Scikit Learn - Processo di modellazione
Questo capitolo tratta del processo di modellazione coinvolto in Sklearn. Cerchiamo di capire lo stesso in dettaglio e iniziare con il caricamento del set di dati.
Caricamento del set di dati
Una raccolta di dati è chiamata dataset. Ha i seguenti due componenti:
Features- Le variabili dei dati sono chiamate le sue caratteristiche. Sono anche noti come predittori, input o attributi.
Feature matrix - È la raccolta di funzionalità, nel caso ce ne siano più di una.
Feature Names - È l'elenco di tutti i nomi delle funzionalità.
Response- È la variabile di output che dipende fondamentalmente dalle variabili delle caratteristiche. Sono anche conosciuti come destinazione, etichetta o output.
Response Vector- Viene utilizzato per rappresentare la colonna di risposta. In genere, abbiamo solo una colonna di risposta.
Target Names - Rappresenta i possibili valori assunti da un vettore di risposta.
Scikit-learn ha pochi set di dati di esempio come iris e digits per la classificazione e il Boston house prices per la regressione.
Esempio
Di seguito è riportato un esempio da caricare iris set di dati -
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])Produzione
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]
]Divisione del set di dati
Per verificare l'accuratezza del nostro modello, possiamo dividere il set di dati in due parti:a training set e a testing set. Utilizzare il set di addestramento per addestrare il modello e il set di test per testare il modello. Dopodiché, possiamo valutare il rendimento del nostro modello.
Esempio
L'esempio seguente suddividerà i dati in un rapporto 70:30, ovvero il 70% dei dati verrà utilizzato come dati di addestramento e il 30% verrà utilizzato come dati di test. Il set di dati è il set di dati dell'iride come nell'esempio precedente.
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)Produzione
(105, 4)
(45, 4)
(105,)
(45,)Come si vede nell'esempio sopra, utilizza train_test_split()funzione di scikit-learn per dividere il set di dati. Questa funzione ha i seguenti argomenti:
X, y - Qui, X è il feature matrix e y è il response vector, che devono essere divisi.
test_size- Questo rappresenta il rapporto tra i dati del test e il totale dei dati forniti. Come nell'esempio sopra, stiamo impostandotest_data = 0.3 per 150 righe di X. Produrrà dati di test di 150 * 0,3 = 45 righe.
random_size- Viene utilizzato per garantire che la divisione sarà sempre la stessa. Ciò è utile nelle situazioni in cui si desiderano risultati riproducibili.
Addestra il modello
Successivamente, possiamo utilizzare il nostro set di dati per addestrare alcuni modelli di previsione. Come discusso, scikit-learn ha un'ampia gamma di fileMachine Learning (ML) algorithms che hanno un'interfaccia coerente per l'adattamento, la previsione dell'accuratezza, il richiamo, ecc.
Esempio
Nell'esempio seguente, utilizzeremo il classificatore KNN (K vicini più vicini). Non entrare nei dettagli degli algoritmi KNN, poiché ci sarà un capitolo separato per questo. Questo esempio viene utilizzato per farti capire solo la parte di implementazione.
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)Produzione
Accuracy: 0.9833333333333333
Predictions: ['versicolor', 'virginica']Persistenza del modello
Una volta addestrato il modello, è auspicabile che il modello sia persistente per un utilizzo futuro in modo da non doverlo riaddestrare più e più volte. Può essere fatto con l'aiuto didump e load caratteristiche di joblib pacchetto.
Considera l'esempio seguente in cui salveremo il modello addestrato sopra (classifier_knn) per un uso futuro -
from sklearn.externals import joblib
joblib.dump(classifier_knn, 'iris_classifier_knn.joblib')Il codice precedente salverà il modello in un file denominato iris_classifier_knn.joblib. Ora l'oggetto può essere ricaricato dal file con l'aiuto del seguente codice:
joblib.load('iris_classifier_knn.joblib')Pre-elaborazione dei dati
Poiché abbiamo a che fare con molti dati e tali dati sono in forma grezza, prima di immettere tali dati in algoritmi di apprendimento automatico, dobbiamo convertirli in dati significativi. Questo processo è chiamato pre-elaborazione dei dati. Scikit-learn ha il pacchetto denominatopreprocessingper questo scopo. Ilpreprocessing pacchetto ha le seguenti tecniche:
Binarizzazione
Questa tecnica di pre-elaborazione viene utilizzata quando è necessario convertire i nostri valori numerici in valori booleani.
Esempio
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)Nell'esempio sopra, abbiamo usato threshold value = 0,5 ed è per questo che tutti i valori superiori a 0,5 verranno convertiti in 1 e tutti i valori inferiori a 0,5 verranno convertiti in 0.
Produzione
Binarized data:
[
[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]
]Rimozione media
Questa tecnica viene utilizzata per eliminare la media dal vettore delle caratteristiche in modo che ogni caratteristica sia centrata sullo zero.
Esempio
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))Produzione
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.]Ridimensionamento
Usiamo questa tecnica di pre-elaborazione per ridimensionare i vettori delle caratteristiche. Il ridimensionamento dei vettori delle caratteristiche è importante, perché le caratteristiche non dovrebbero essere sinteticamente grandi o piccole.
Esempio
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)Produzione
Min max scaled data:
[
[ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0.99029126 0. ]
]Normalizzazione
Usiamo questa tecnica di pre-elaborazione per modificare i vettori delle caratteristiche. La normalizzazione dei vettori di caratteristiche è necessaria in modo che i vettori di caratteristiche possano essere misurati su scala comune. Esistono due tipi di normalizzazione come segue:
Normalizzazione L1
È anche chiamato Deviazioni Minime Assolute. Modifica il valore in modo tale che la somma dei valori assoluti rimanga sempre fino a 1 in ogni riga. L'esempio seguente mostra l'implementazione della normalizzazione L1 sui dati di input.
Esempio
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)Produzione
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]
]Normalizzazione L2
Chiamato anche minimi quadrati. Modifica il valore in modo tale che la somma dei quadrati rimanga sempre fino a 1 in ogni riga. L'esempio seguente mostra l'implementazione della normalizzazione L2 sui dati di input.
Esempio
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)Produzione
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 ]
]