Scikit Learn - proces modelowania

Ten rozdział dotyczy procesu modelowania związanego ze Sklearn. Rozumiemy szczegółowo to samo i zacznijmy od załadowania zbioru danych.

Ładowanie zestawu danych

Zbiór danych nosi nazwę zbioru danych. Składa się z dwóch następujących elementów -

Features- Zmienne danych nazywane są jego cechami. Znane są również jako predyktory, dane wejściowe lub atrybuty.

Feature matrix - Jest to zbiór funkcji, na wypadek gdyby było ich więcej.
Feature Names - To jest lista wszystkich nazw funkcji.

Response- Jest to zmienna wyjściowa, która zasadniczo zależy od zmiennych cech. Są również znane jako cel, etykieta lub wynik.

Response Vector- Służy do reprezentowania kolumny odpowiedzi. Ogólnie mamy tylko jedną kolumnę odpowiedzi.
Target Names - Reprezentuje możliwe wartości przyjęte przez wektor odpowiedzi.

Scikit-learn ma kilka przykładowych zestawów danych, takich jak iris i digits do klasyfikacji i Boston house prices do regresji.

Przykład

Poniżej znajduje się przykład do załadowania iris zbiór danych -

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])

Wynik

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]
]

Dzielenie zbioru danych

Aby sprawdzić dokładność naszego modelu, możemy podzielić zbiór danych na dwie części:a training set i a testing set. Użyj zestawu uczącego, aby wytrenować model i zestaw testowy, aby przetestować model. Następnie możemy ocenić, jak dobrze radził sobie nasz model.

Przykład

Poniższy przykład podzieli dane na stosunek 70:30, tj. 70% danych zostanie wykorzystanych jako dane treningowe, a 30% jako dane testowe. Zbiór danych to zbiór danych tęczówki, jak w powyższym przykładzie.

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)

Wynik

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

Jak widać w powyższym przykładzie, używa train_test_split()funkcja scikit-Learn do dzielenia zbioru danych. Ta funkcja ma następujące argumenty -

X, y - Tutaj, X jest feature matrix a y to response vector, które należy podzielić.
test_size- Przedstawia stosunek danych testowych do wszystkich podanych danych. Jak w powyższym przykładzie ustawiamytest_data = 0.3 dla 150 rzędów X. Wytworzy dane testowe 150 * 0,3 = 45 rzędów.
random_size- Służy do zagwarantowania, że podział będzie zawsze taki sam. Jest to przydatne w sytuacjach, w których chcesz uzyskać powtarzalne wyniki.

Trenuj model

Następnie możemy użyć naszego zestawu danych, aby wytrenować model predykcyjny. Jak już wspomniano, scikit-learn ma szeroki zakresMachine Learning (ML) algorithms które mają spójny interfejs do dopasowania, przewidywania dokładności, przypominania itp.

Przykład

W poniższym przykładzie użyjemy klasyfikatora KNN (K najbliższych sąsiadów). Nie wchodź w szczegóły algorytmów KNN, ponieważ będzie to osobny rozdział. Ten przykład służy wyłącznie do zrozumienia części dotyczącej implementacji.

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)

Wynik

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

Trwałość modelu

Po wytrenowaniu modelu pożądane jest, aby został on utrwalony do wykorzystania w przyszłości, aby nie trzeba było go ponownie uczyć. Można to zrobić za pomocądump i load cechy joblib pakiet.

Rozważ poniższy przykład, w którym będziemy zapisywać powyższy wytrenowany model (classifier_knn) do wykorzystania w przyszłości -

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

Powyższy kod zapisze model do pliku o nazwie iris_classifier_knn.joblib. Teraz obiekt można przeładować z pliku za pomocą następującego kodu -

joblib.load('iris_classifier_knn.joblib')

Wstępne przetwarzanie danych

Ponieważ mamy do czynienia z dużą ilością danych, a dane są w postaci surowej, przed wprowadzeniem tych danych do algorytmów uczenia maszynowego, musimy je przekształcić w znaczące dane. Ten proces nazywa się przetwarzaniem wstępnym danych. Scikit-learn ma pakiet o nazwiepreprocessingw tym celu. Plikpreprocessing pakiet ma następujące techniki -

Binaryzacja

Ta technika przetwarzania wstępnego jest używana, gdy musimy przekonwertować nasze wartości liczbowe na wartości logiczne.

Przykład

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)

W powyższym przykładzie użyliśmy threshold value = 0,5 i dlatego wszystkie wartości powyżej 0,5 zostaną zamienione na 1, a wszystkie wartości poniżej 0,5 zostaną zamienione na 0.

Wynik

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

Średnie usuwanie

Technika ta służy do eliminacji średniej z wektora cech, tak aby każda cecha była wyśrodkowana na zero.

Przykład

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))

Wynik

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.]

skalowanie

Używamy tej techniki przetwarzania wstępnego do skalowania wektorów cech. Skalowanie wektorów cech jest ważne, ponieważ cechy nie powinny być syntetycznie duże ani małe.

Przykład

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)

Wynik

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

Normalizacja

Używamy tej techniki przetwarzania wstępnego do modyfikowania wektorów cech. Normalizacja wektorów cech jest konieczna, aby wektory cech mogły być mierzone we wspólnej skali. Istnieją dwa rodzaje normalizacji w następujący sposób -

Normalizacja L1

Nazywa się to również najmniejszymi odchyleniami bezwzględnymi. Modyfikuje wartość w taki sposób, że suma wartości bezwzględnych pozostaje zawsze do 1 w każdym wierszu. Poniższy przykład pokazuje implementację normalizacji L1 na danych wejściowych.

Przykład

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)

Wynik

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]
]

Normalizacja L2

Nazywany również najmniejszymi kwadratami. Modyfikuje wartość w taki sposób, że suma kwadratów pozostaje zawsze do 1 w każdym wierszu. Poniższy przykład pokazuje implementację normalizacji L2 na danych wejściowych.

Przykład

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)

Wynik

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 ]
]