Scikit Learn - Processus de modélisation
Ce chapitre traite du processus de modélisation impliqué dans Sklearn. Comprenons la même chose en détail et commençons par le chargement de l'ensemble de données.
Chargement de l'ensemble de données
Une collection de données est appelée ensemble de données. Il a les deux composants suivants -
Features- Les variables de données sont appelées ses caractéristiques. Ils sont également appelés prédicteurs, entrées ou attributs.
Feature matrix - C'est la collection de fonctionnalités, au cas où il y en aurait plus d'une.
Feature Names - C'est la liste de tous les noms des fonctionnalités.
Response- C'est la variable de sortie qui dépend essentiellement des variables de fonction. Ils sont également appelés cible, étiquette ou sortie.
Response Vector- Il est utilisé pour représenter la colonne de réponse. En général, nous n'avons qu'une seule colonne de réponse.
Target Names - Il représente les valeurs possibles prises par un vecteur de réponse.
Scikit-learn a quelques exemples d'ensembles de données comme iris et digits pour la classification et le Boston house prices pour la régression.
Exemple
Voici un exemple de chargement iris ensemble de données -
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])Production
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]
]Fractionner l'ensemble de données
Pour vérifier l'exactitude de notre modèle, nous pouvons diviser l'ensemble de données en deux parties -a training set et a testing set. Utilisez l'ensemble d'entraînement pour entraîner le modèle et l'ensemble de test pour tester le modèle. Après cela, nous pouvons évaluer les performances de notre modèle.
Exemple
L'exemple suivant divisera les données en un rapport de 70:30, c'est-à-dire que 70% des données seront utilisées comme données d'entraînement et 30% seront utilisées comme données de test. L'ensemble de données est l'ensemble de données iris comme dans l'exemple ci-dessus.
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)Production
(105, 4)
(45, 4)
(105,)
(45,)Comme le montre l'exemple ci-dessus, il utilise train_test_split()fonction de scikit-learn pour diviser l'ensemble de données. Cette fonction a les arguments suivants -
X, y - Ici, X est le feature matrix et y est le response vector, qui doivent être divisés.
test_size- Ceci représente le rapport entre les données de test et le total des données données. Comme dans l'exemple ci-dessus, nous définissonstest_data = 0.3 pour 150 lignes de X. Cela produira des données de test de 150 * 0,3 = 45 lignes.
random_size- Il est utilisé pour garantir que la répartition sera toujours la même. Ceci est utile dans les situations où vous souhaitez des résultats reproductibles.
Former le modèle
Ensuite, nous pouvons utiliser notre ensemble de données pour entraîner un modèle de prédiction. Comme discuté, scikit-learn propose une large gamme deMachine Learning (ML) algorithms qui ont une interface cohérente pour l'ajustement, la prédiction de la précision, le rappel, etc.
Exemple
Dans l'exemple ci-dessous, nous allons utiliser le classificateur KNN (K plus proches voisins). N'allez pas dans les détails des algorithmes KNN, car il y aura un chapitre séparé pour cela. Cet exemple est utilisé pour vous faire comprendre uniquement la partie implémentation.
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)Production
Accuracy: 0.9833333333333333
Predictions: ['versicolor', 'virginica']Persistance du modèle
Une fois que vous avez entraîné le modèle, il est souhaitable que le modèle soit conservé pour une utilisation future afin que nous n'ayons pas besoin de le recycler encore et encore. Cela peut être fait avec l'aide dedump et load les caractéristiques de joblib paquet.
Prenons l'exemple ci-dessous dans lequel nous enregistrerons le modèle formé ci-dessus (classifier_knn) pour une utilisation future -
from sklearn.externals import joblib
joblib.dump(classifier_knn, 'iris_classifier_knn.joblib')Le code ci-dessus enregistrera le modèle dans le fichier nommé iris_classifier_knn.joblib. Maintenant, l'objet peut être rechargé à partir du fichier à l'aide du code suivant -
joblib.load('iris_classifier_knn.joblib')Prétraitement des données
Comme nous traitons beaucoup de données et que ces données sont sous forme brute, avant de les saisir dans des algorithmes d'apprentissage automatique, nous devons les convertir en données significatives. Ce processus s'appelle le prétraitement des données. Scikit-learn a un package nommépreprocessingdans ce but. lepreprocessing package a les techniques suivantes -
Binarisation
Cette technique de prétraitement est utilisée lorsque nous devons convertir nos valeurs numériques en valeurs booléennes.
Exemple
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)Dans l'exemple ci-dessus, nous avons utilisé threshold value = 0,5 et c'est pourquoi, toutes les valeurs supérieures à 0,5 seraient converties en 1, et toutes les valeurs inférieures à 0,5 seraient converties en 0.
Production
Binarized data:
[
[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]
]Élimination moyenne
Cette technique est utilisée pour éliminer la moyenne du vecteur d'entités de sorte que chaque entité soit centrée sur zéro.
Exemple
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))Production
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.]Mise à l'échelle
Nous utilisons cette technique de prétraitement pour mettre à l'échelle les vecteurs de caractéristiques. La mise à l'échelle des vecteurs de caractéristiques est importante, car les caractéristiques ne doivent pas être synthétiquement grandes ou petites.
Exemple
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)Production
Min max scaled data:
[
[ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0.99029126 0. ]
]Normalisation
Nous utilisons cette technique de prétraitement pour modifier les vecteurs de caractéristiques. La normalisation des vecteurs de caractéristiques est nécessaire pour que les vecteurs de caractéristiques puissent être mesurés à une échelle commune. Il existe deux types de normalisation comme suit -
Normalisation L1
Il est également appelé écarts les moins absolus. Il modifie la valeur de telle manière que la somme des valeurs absolues reste toujours jusqu'à 1 dans chaque ligne. L'exemple suivant montre l'implémentation de la normalisation L1 sur les données d'entrée.
Exemple
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)Production
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]
]Normalisation L2
Aussi appelé moindres carrés. Il modifie la valeur de telle sorte que la somme des carrés reste toujours jusqu'à 1 dans chaque ligne. L'exemple suivant montre l'implémentation de la normalisation L2 sur les données d'entrée.
Exemple
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)Production
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 ]
]