Scikit Learn - กระบวนการสร้างแบบจำลอง

บทนี้เกี่ยวข้องกับกระบวนการสร้างแบบจำลองที่เกี่ยวข้องกับ Sklearn ให้เราเข้าใจในรายละเอียดเกี่ยวกับเรื่องเดียวกันและเริ่มต้นด้วยการโหลดชุดข้อมูล

กำลังโหลดชุดข้อมูล

การรวบรวมข้อมูลเรียกว่าชุดข้อมูล มีสององค์ประกอบต่อไปนี้ -

Features- ตัวแปรของข้อมูลเรียกว่าคุณลักษณะ พวกเขาเรียกอีกอย่างว่าตัวทำนายอินพุตหรือแอตทริบิวต์

• Feature matrix - เป็นชุดของคุณสมบัติในกรณีที่มีมากกว่าหนึ่ง

• Feature Names - เป็นรายชื่อคุณสมบัติทั้งหมด

Response- เป็นตัวแปรเอาต์พุตที่โดยพื้นฐานแล้วขึ้นอยู่กับตัวแปรคุณลักษณะ พวกเขาเรียกอีกอย่างว่าเป้าหมายฉลากหรือผลลัพธ์

• Response Vector- ใช้เพื่อแสดงคอลัมน์ตอบกลับ โดยทั่วไปเรามีคอลัมน์คำตอบเพียงคอลัมน์เดียว

• Target Names - แสดงถึงค่าที่เป็นไปได้ที่นำมาจากเวกเตอร์การตอบสนอง

Scikit-learn มีชุดข้อมูลตัวอย่างเช่น iris และ digits สำหรับการจำแนกประเภทและ Boston house prices สำหรับการถดถอย

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างในการโหลด iris ชุดข้อมูล -

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names
print("Feature names:", feature_names)
print("Target names:", target_names)
print("\nFirst 10 rows of X:\n", X[:10])

เอาต์พุต

Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Target names: ['setosa' 'versicolor' 'virginica']
First 10 rows of X:
[
   [5.1 3.5 1.4 0.2]
   [4.9 3. 1.4 0.2]
   [4.7 3.2 1.3 0.2]
   [4.6 3.1 1.5 0.2]
   [5. 3.6 1.4 0.2]
   [5.4 3.9 1.7 0.4]
   [4.6 3.4 1.4 0.3]
   [5. 3.4 1.5 0.2]
   [4.4 2.9 1.4 0.2]
   [4.9 3.1 1.5 0.1]
]

การแยกชุดข้อมูล

เพื่อตรวจสอบความถูกต้องของแบบจำลองของเราเราสามารถแบ่งชุดข้อมูลออกเป็นสองส่วน -a training set และ a testing set. ใช้ชุดฝึกในการฝึกโมเดลและชุดทดสอบเพื่อทดสอบแบบจำลอง หลังจากนั้นเราสามารถประเมินได้ว่าโมเดลของเราทำได้ดีเพียงใด

ตัวอย่าง

ตัวอย่างต่อไปนี้จะแบ่งข้อมูลออกเป็นอัตราส่วน 70:30 กล่าวคือข้อมูล 70% จะใช้เป็นข้อมูลการฝึกอบรมและ 30% จะใช้เป็นข้อมูลการทดสอบ ชุดข้อมูลคือชุดข้อมูลม่านตาตามตัวอย่างข้างต้น

from sklearn.datasets import load_iris
iris = load_iris()

X = iris.data
y = iris.target

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
   X, y, test_size = 0.3, random_state = 1
)

print(X_train.shape)
print(X_test.shape)

print(y_train.shape)
print(y_test.shape)

เอาต์พุต

(105, 4)
(45, 4)
(105,)
(45,)

ดังที่เห็นในตัวอย่างด้านบนจะใช้ train_test_split()ฟังก์ชั่นของ scikit-learn เพื่อแยกชุดข้อมูล ฟังก์ชันนี้มีอาร์กิวเมนต์ดังนี้ -

• X, y - ที่นี่ X คือ feature matrix และ y คือ response vectorซึ่งจำเป็นต้องแยก

• test_size- แสดงถึงอัตราส่วนของข้อมูลทดสอบต่อข้อมูลทั้งหมดที่ระบุ ดังตัวอย่างข้างต้นเรากำลังตั้งค่าtest_data = 0.3 สำหรับ 150 แถวของ X จะให้ข้อมูลการทดสอบ 150 * 0.3 = 45 แถว

• random_size- ใช้เพื่อรับประกันว่าการแบ่งจะเหมือนกันเสมอ สิ่งนี้มีประโยชน์ในสถานการณ์ที่คุณต้องการผลลัพธ์ที่ทำซ้ำได้

ฝึกโมเดล

ต่อไปเราสามารถใช้ชุดข้อมูลของเราเพื่อฝึกโมเดลการคาดคะเน ตามที่กล่าวไว้ scikit-learn มีหลากหลายMachine Learning (ML) algorithms ซึ่งมีอินเทอร์เฟซที่สอดคล้องกันสำหรับการปรับความแม่นยำการคาดการณ์การเรียกคืน ฯลฯ

ตัวอย่าง

ในตัวอย่างด้านล่างเราจะใช้ตัวแยกประเภท KNN (K เพื่อนบ้านที่ใกล้ที่สุด) อย่าเข้าไปดูรายละเอียดของอัลกอริทึม KNN เพราะจะมีบทแยกต่างหาก ตัวอย่างนี้ใช้เพื่อให้คุณเข้าใจส่วนการนำไปใช้งานเท่านั้น

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
   X, y, test_size = 0.4, random_state=1
)
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
classifier_knn = KNeighborsClassifier(n_neighbors = 3)
classifier_knn.fit(X_train, y_train)
y_pred = classifier_knn.predict(X_test)
# Finding accuracy by comparing actual response values(y_test)with predicted response value(y_pred)
print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
# Providing sample data and the model will make prediction out of that data

sample = [[5, 5, 3, 2], [2, 4, 3, 5]]
preds = classifier_knn.predict(sample)
pred_species = [iris.target_names[p] for p in preds] print("Predictions:", pred_species)

เอาต์พุต

Accuracy: 0.9833333333333333
Predictions: ['versicolor', 'virginica']

ความคงอยู่ของโมเดล

เมื่อคุณฝึกโมเดลแล้วเป็นที่พึงปรารถนาว่าโมเดลควรจะคงอยู่เพื่อใช้ในอนาคตเพื่อที่เราจะได้ไม่ต้องฝึกซ้ำแล้วซ้ำอีก สามารถทำได้ด้วยความช่วยเหลือของdump และ load คุณสมบัติของ joblib แพ็คเกจ

ลองพิจารณาตัวอย่างด้านล่างซึ่งเราจะบันทึกโมเดลที่ได้รับการฝึกฝนข้างต้น (classifier_knn) เพื่อใช้ในอนาคต -

from sklearn.externals import joblib
joblib.dump(classifier_knn, 'iris_classifier_knn.joblib')

โค้ดด้านบนจะบันทึกโมเดลลงในไฟล์ชื่อ iris_classifier_knn.joblib ตอนนี้วัตถุสามารถโหลดซ้ำได้จากไฟล์ด้วยความช่วยเหลือของรหัสต่อไปนี้ -

joblib.load('iris_classifier_knn.joblib')

การประมวลผลข้อมูลล่วงหน้า

เนื่องจากเรากำลังจัดการกับข้อมูลจำนวนมากและข้อมูลนั้นอยู่ในรูปแบบดิบก่อนที่จะป้อนข้อมูลนั้นไปยังอัลกอริทึมการเรียนรู้ของเครื่องเราจำเป็นต้องแปลงข้อมูลนั้นให้เป็นข้อมูลที่มีความหมาย กระบวนการนี้เรียกว่าการประมวลผลข้อมูลล่วงหน้า Scikit-learn มีชื่อแพคเกจpreprocessingเพื่อจุดประสงค์นี้. preprocessing package มีเทคนิคดังนี้ -

Binarisation

เทคนิคก่อนการประมวลผลนี้ใช้เมื่อเราต้องการแปลงค่าตัวเลขเป็นค่าบูลีน

ตัวอย่าง

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [2.1, -1.9, 5.5],
   [-1.5, 2.4, 3.5],
   [0.5, -7.9, 5.6],
   [5.9, 2.3, -5.8]]
)
data_binarized = preprocessing.Binarizer(threshold=0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)

ในตัวอย่างข้างต้นเราใช้ threshold value = 0.5 และนั่นคือเหตุผลที่ค่าทั้งหมดที่สูงกว่า 0.5 จะถูกแปลงเป็น 1 และค่าทั้งหมดที่ต่ำกว่า 0.5 จะถูกแปลงเป็น 0

เอาต์พุต

Binarized data:
[
   [ 1. 0. 1.]
   [ 0. 1. 1.]
   [ 0. 0. 1.]
   [ 1. 1. 0.]
]

หมายถึงการกำจัด

เทคนิคนี้ใช้เพื่อกำจัดค่าเฉลี่ยจากเวกเตอร์คุณลักษณะเพื่อให้ทุกคุณลักษณะมีศูนย์กลางอยู่ที่ศูนย์

ตัวอย่าง

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [2.1, -1.9, 5.5],
   [-1.5, 2.4, 3.5],
   [0.5, -7.9, 5.6],
   [5.9, 2.3, -5.8]]
)

#displaying the mean and the standard deviation of the input data
print("Mean =", input_data.mean(axis=0))
print("Stddeviation = ", input_data.std(axis=0))
#Removing the mean and the standard deviation of the input data

data_scaled = preprocessing.scale(input_data)
print("Mean_removed =", data_scaled.mean(axis=0))
print("Stddeviation_removed =", data_scaled.std(axis=0))

เอาต์พุต

Mean = [ 1.75 -1.275 2.2 ]
Stddeviation = [ 2.71431391 4.20022321 4.69414529]
Mean_removed = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Stddeviation_removed = [ 1. 1. 1.]

การปรับขนาด

เราใช้เทคนิคก่อนการประมวลผลนี้ในการปรับขนาดเวกเตอร์คุณลักษณะ การปรับขนาดของเวกเตอร์คุณลักษณะมีความสำคัญเนื่องจากคุณสมบัติไม่ควรสังเคราะห์มากหรือน้อย

ตัวอย่าง

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [
      [2.1, -1.9, 5.5],
      [-1.5, 2.4, 3.5],
      [0.5, -7.9, 5.6],
      [5.9, 2.3, -5.8]
   ]
)
data_scaler_minmax = preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)

เอาต์พุต

Min max scaled data:
[
   [ 0.48648649 0.58252427 0.99122807]
   [ 0. 1. 0.81578947]
   [ 0.27027027 0. 1. ]
   [ 1. 0.99029126 0. ]
]

Normalization

เราใช้เทคนิคก่อนการประมวลผลนี้เพื่อแก้ไขเวกเตอร์คุณลักษณะ การทำให้ปกติของเวกเตอร์คุณลักษณะเป็นสิ่งที่จำเป็นเพื่อให้สามารถวัดเวกเตอร์คุณลักษณะในระดับทั่วไปได้ การทำให้เป็นมาตรฐานมีสองประเภทดังนี้ -

L1 Normalization

เรียกอีกอย่างว่า Least Absolute Deviation มันปรับเปลี่ยนค่าในลักษณะที่ผลรวมของค่าสัมบูรณ์ยังคงเป็น 1 เสมอในแต่ละแถว ตัวอย่างต่อไปนี้แสดงการปรับใช้ L1 normalization กับข้อมูลอินพุต

ตัวอย่าง

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [
      [2.1, -1.9, 5.5],
      [-1.5, 2.4, 3.5],
      [0.5, -7.9, 5.6],
      [5.9, 2.3, -5.8]
   ]
)
data_normalized_l1 = preprocessing.normalize(input_data, norm='l1')
print("\nL1 normalized data:\n", data_normalized_l1)

เอาต์พุต

L1 normalized data:
[
   [ 0.22105263 -0.2 0.57894737]
   [-0.2027027 0.32432432 0.47297297]
   [ 0.03571429 -0.56428571 0.4 ]
   [ 0.42142857 0.16428571 -0.41428571]
]

L2 Normalization

เรียกอีกอย่างว่า Least Squares มันปรับเปลี่ยนค่าในลักษณะที่ผลรวมของกำลังสองยังคงเป็น 1 เสมอในแต่ละแถว ตัวอย่างต่อไปนี้แสดงการปรับใช้ L2 normalization กับข้อมูลอินพุต

ตัวอย่าง

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [
      [2.1, -1.9, 5.5],
      [-1.5, 2.4, 3.5],
      [0.5, -7.9, 5.6],
      [5.9, 2.3, -5.8]
   ]
)
data_normalized_l2 = preprocessing.normalize(input_data, norm='l2')
print("\nL1 normalized data:\n", data_normalized_l2)

เอาต์พุต

L2 normalized data:
[
   [ 0.33946114 -0.30713151 0.88906489]
   [-0.33325106 0.53320169 0.7775858 ]
   [ 0.05156558 -0.81473612 0.57753446]
   [ 0.68706914 0.26784051 -0.6754239 ]
]