Scikit Learn - Modellierungsprozess
Dieses Kapitel befasst sich mit dem Modellierungsprozess von Sklearn. Lassen Sie uns dies im Detail verstehen und mit dem Laden des Datensatzes beginnen.
Laden des Datensatzes
Eine Datensammlung wird als Datensatz bezeichnet. Es hat die folgenden zwei Komponenten -
Features- Die Variablen der Daten werden als ihre Merkmale bezeichnet. Sie werden auch als Prädiktoren, Eingaben oder Attribute bezeichnet.
Feature matrix - Es ist die Sammlung von Funktionen, falls es mehr als eine gibt.
Feature Names - Es ist die Liste aller Namen der Funktionen.
Response- Es ist die Ausgabevariable, die im Wesentlichen von den Feature-Variablen abhängt. Sie werden auch als Ziel, Label oder Ausgabe bezeichnet.
Response Vector- Es wird verwendet, um die Antwortspalte darzustellen. Im Allgemeinen haben wir nur eine Antwortspalte.
Target Names - Es stellt die möglichen Werte dar, die von einem Antwortvektor angenommen werden.
Scikit-learn hat nur wenige Beispieldatensätze wie iris und digits für die Klassifizierung und die Boston house prices für die Regression.
Beispiel
Es folgt ein Beispiel zum Laden iris Datensatz -
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])Ausgabe
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]
]Datensatz aufteilen
Um die Genauigkeit unseres Modells zu überprüfen, können wir den Datensatz in zwei Teile aufteilen.a training set und a testing set. Verwenden Sie das Trainingsset, um das Modell zu trainieren, und das Testset, um das Modell zu testen. Danach können wir bewerten, wie gut unser Modell war.
Beispiel
Im folgenden Beispiel werden die Daten in ein Verhältnis von 70:30 aufgeteilt, dh 70% werden als Trainingsdaten und 30% als Testdaten verwendet. Der Datensatz ist ein Iris-Datensatz wie im obigen Beispiel.
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)Ausgabe
(105, 4)
(45, 4)
(105,)
(45,)Wie im obigen Beispiel zu sehen, wird es verwendet train_test_split()Funktion von scikit-learn, um den Datensatz zu teilen. Diese Funktion hat die folgenden Argumente:
X, y - Hier, X ist der feature matrix und y ist das response vector, die aufgeteilt werden müssen.
test_size- Dies ist das Verhältnis der Testdaten zu den insgesamt angegebenen Daten. Wie im obigen Beispiel stellen wir eintest_data = 0.3 für 150 Zeilen X. Es werden Testdaten von 150 * 0,3 = 45 Zeilen erzeugt.
random_size- Es wird verwendet, um sicherzustellen, dass die Aufteilung immer gleich ist. Dies ist in Situationen nützlich, in denen Sie reproduzierbare Ergebnisse erzielen möchten.
Trainiere das Modell
Als nächstes können wir unseren Datensatz verwenden, um ein Vorhersagemodell zu trainieren. Wie bereits erwähnt, hat Scikit-Learn eine breite Palette vonMachine Learning (ML) algorithms die eine konsistente Schnittstelle zum Anpassen, Vorhersagen der Genauigkeit, Abrufen usw. haben.
Beispiel
Im folgenden Beispiel verwenden wir den Klassifikator KNN (K nächste Nachbarn). Gehen Sie nicht auf die Details der KNN-Algorithmen ein, da es dafür ein separates Kapitel geben wird. Dieses Beispiel dient nur dazu, den Implementierungsteil zu verstehen.
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)Ausgabe
Accuracy: 0.9833333333333333
Predictions: ['versicolor', 'virginica']Modellpersistenz
Sobald Sie das Modell trainiert haben, ist es wünschenswert, dass das Modell für die zukünftige Verwendung erhalten bleibt, damit wir es nicht immer wieder neu trainieren müssen. Dies kann mit Hilfe von erfolgendump und load Merkmale joblib Paket.
Betrachten Sie das folgende Beispiel, in dem wir das oben trainierte Modell (classifier_knn) für die zukünftige Verwendung speichern werden -
from sklearn.externals import joblib
joblib.dump(classifier_knn, 'iris_classifier_knn.joblib')Der obige Code speichert das Modell in der Datei iris_classifier_knn.joblib. Jetzt kann das Objekt mit Hilfe des folgenden Codes aus der Datei neu geladen werden:
joblib.load('iris_classifier_knn.joblib')Vorverarbeitung der Daten
Da es sich um viele Daten handelt und diese Daten in Rohform vorliegen, müssen wir sie vor der Eingabe in Algorithmen für maschinelles Lernen in aussagekräftige Daten konvertieren. Dieser Vorgang wird als Vorverarbeitung der Daten bezeichnet. Scikit-learn hat das Paket benanntpreprocessingfür diesen Zweck. Daspreprocessing Paket hat die folgenden Techniken -
Binarisierung
Diese Vorverarbeitungstechnik wird verwendet, wenn wir unsere numerischen Werte in Boolesche Werte konvertieren müssen.
Beispiel
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)Im obigen Beispiel haben wir verwendet threshold value = 0,5 und deshalb würden alle Werte über 0,5 in 1 und alle Werte unter 0,5 in 0 umgewandelt.
Ausgabe
Binarized data:
[
[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]
]Mittlere Entfernung
Diese Technik wird verwendet, um den Mittelwert aus dem Merkmalsvektor zu eliminieren, so dass jedes Merkmal auf Null zentriert ist.
Beispiel
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))Ausgabe
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.]Skalierung
Wir verwenden diese Vorverarbeitungstechnik zum Skalieren der Merkmalsvektoren. Die Skalierung von Merkmalsvektoren ist wichtig, da die Merkmale nicht synthetisch groß oder klein sein sollten.
Beispiel
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)Ausgabe
Min max scaled data:
[
[ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0.99029126 0. ]
]Normalisierung
Wir verwenden diese Vorverarbeitungstechnik zum Modifizieren der Merkmalsvektoren. Eine Normalisierung der Merkmalsvektoren ist erforderlich, damit die Merkmalsvektoren im gemeinsamen Maßstab gemessen werden können. Es gibt zwei Arten der Normalisierung:
L1 Normalisierung
Es wird auch als geringste absolute Abweichung bezeichnet. Der Wert wird so geändert, dass die Summe der Absolutwerte in jeder Zeile immer bis zu 1 bleibt. Das folgende Beispiel zeigt die Implementierung der L1-Normalisierung für Eingabedaten.
Beispiel
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)Ausgabe
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 Normalisierung
Auch als kleinste Quadrate bezeichnet. Der Wert wird so geändert, dass die Summe der Quadrate in jeder Zeile immer bis zu 1 bleibt. Das folgende Beispiel zeigt die Implementierung der L2-Normalisierung für Eingabedaten.
Beispiel
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)Ausgabe
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 ]
]