Appunti personali sul linguaggio Python

Come fare machine learning con scikit-learn di Python

In questi appunti uso il modulo sklearn della libreria scikit-learn di Python per sviluppare ed eseguire un semplice algoritmo di apprendimento automatico.

Nota. Questo tutorial richiede la presenza della libreria scikit-learn nell'interprete Python. Se non è presente, occorre prima installare la libreria scikit-learn.

Un esempio pratico

Questo codice è uno dei primi esempi pratici di machine learning con il linguaggio python.

Lo script elabora un modello previsionale tramite la libreria scikit-learn.

  1. import numpy as np
  2. from sklearn import datasets
  3. from sklearn.linear_model import Perceptron
  4. from sklearn.metrics import accuracy_score
  5. from sklearn.model_selection import train_test_split
  6. iris = datasets.load_iris()
  7. X = iris.data[:, [2, 3]]
  8. y = iris.target
  9. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
  10. ppn = Perceptron(max_iter=40, tol=0.001, eta0=0.01, random_state=0)
  11. ppn.fit(X_train, y_train)
  12. y_pred = ppn.predict(X_test)
  13. print(accuracy_score(y_test, y_pred))

Nei prossimi paragrafi fornisco una spiegazione per ogni singolo passaggio.

L'algoritmo è suddiviso in tre fasi:

  • preparazione dei dati
  • creazione del modello previsionale ( addestramento )
  • verifica del modello

le fasi del processo di learning

La preparazione dei dati

Per cominciare utilizzo il dataset Iris.

Il modulo Sklearn ha il vantaggio di incorporare diversi dataset di default. Pertanto, non devo caricare il file dall'esterno.

>>> from sklearn import datasets
>>> iris = datasets.load_iris()

Nella prima riga carico la funzionalità datasets di sklearn.

Poi, nella seconda riga, assegno alla variabile iris il dataset con il metodo load_iris().

A questo punto nella variabile iris c'è tutto il dataset iris.

Cos'è il dataset iris? E' un insieme di addestramento composto da 130 esempi che misurano la lunghezza e la larghezza del petalo e del sepalo delle classi di fiori Iris-Setosa, Iris-Versicolor, Iris-Virginica. Analizzando il dataset la macchina impara a classificare correttamente i tre fiori, ossia crea da sé un modello previsionale senza che nessuno l'abbia programmata appositamente per farlo.
le 4 caratteristiche delle 3 specie di fiori Iris

Gli esempi del training set si trovano con il metodo data.

Ogni riga contiene un esempio e ogni esempio è composto da 4 attributi che misurano la lunghezza e la larghezza del petalo e del setalo in centimetri.

il metodo iris.data

Le risposte corrette degli esempi, invece, sono memorizzate sotto il metodo target

Il vettore è composto da 130 etichette zero, uno e due:

  • 0 = Iris-Setosa
  • 1 = Iris-Versicolor
  • 2 = Iris-Virginica

il contenuto del metodo target

Nota. Gli esempi sono registrati sotto forma di vettori e matrici. E' quindi necessario trattarli con le funzioni di python predisposte per elaborare le matrici e i vettori ( es. numpy ).

Ora carico in memoria la libreria numpy di python per poter eseguire funzioni di calcolo vettoriale e matriciale.

>>> import numpy as np

Nota. Se la libreria numpy non è stata installata, l'interprete python va in errore. In questi casi è sufficiente installare numpy sul PC. Poi chiudere e riaprire python.

Per semplificità assegno gli esempi ( iris.data ) alla variabile X prendendo soltanto due misure, la colonna 2 e 3.

Le colonne 0 e 1 (le prime due) sono invece eliminate.

>>> X = iris.data[:, [2, 3]]

In questo modo riduco la matrice di 130 esempi da 4 attributi a 2 attributi.

riduco la dimensione del dataset a due attributi

Poi assegno le etichette ( iris.target ) alla variabile y.

>>> y = iris.target

Ora devo dividere il dataset in training set ( insieme di addestramento ) e test set ( insieme di test ).

Per farlo utilizzo la funzione train_test_split

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

La funzione train_test_split ha quattro parametri in input

  1. Data. Il dataset degli esempi (X)
  2. Target. Il dataset delle etichette (y)
  3. Testize. Indica la percentuale di esempi da usare per l'insieme di test. In questo caso è 0.3 ossia il 30%.
  4. Random_state. E' l'indicatore di randomizzazione che per il momento lascio a zero.

come funziona train_test_split

Restituisce in output quattro insieme di dati:

  1. L'insieme di addestramento (X_train)
  2. L'insieme di test (X_test)
  3. Le etichette dell'insieme di addestramento (y_train)
  4. Le etichette dell'insieme di test (y_test)

Nota. In pratica, la funzione ha diviso l'insieme degli esempi in due insiemi distinti, uno destinato all'addestramento (X.train) e l'altro destinato alla verifica finale (X.test). Poi, ha fatto lo stesso con l'insieme delle etichette (risultati).

I dati sono pronti per essere elaborati.

La creazione del modello previsionale

Per creare un modello previsionale devo scegliere un algoritmo di apprendimento.

Opto per il vecchio perceptron, uno dei primi algoritmi di classificazione della storia.

Fortunatamente la libreria scikit-learn include diversi algoritmi di learning, tra cui c'è anche il perceptron.

Lo carico in memoria.

from sklearn.linear_model import Perceptron

Poi definisco gli iperparametri del processo di learning ( max_iter , tol, eta ).

Dove n_iter indica il numero di cicli ( epoch ) da elaborare mentre il parametro eta0 è il tasso di apprendimento del perceptron.

ppn = Perceptron(max_iter=40, tol=0.001, eta0=0.01, eta0=0.1, random_state=0)

L'attributo max_iter fissa il numero massimo di iterazioni.

L'attributo tol indica la tolleranza sufficiente per l'uscita dal ciclo.

A questo punto eseguo il process learning tramite il metodo fit per cominciare l'addestramento.

ppn.fit(X_train, y_train)

L'algoritmo legge il training set e crea il modello previsionale.

la preparazione del modello previsionale

Non resta altro da fare che verificare l'accuratezza del modello, se riesce a formulare una previsione corretta sugli esempi del test set.

La verifica del modello previsionale

Per verificare il modello previsionale, lo applico sugli esempi dell'insieme di test ( X.test ).

Nella libreria scikit-learn c'è un'apposita metodo per verificare il modello. Si tratta del metodo predict().

y_pred = ppn.predict(X_test)

Le risposte del modello sono registrate nella variabile y_pred.

la verifica del modello previsionale

A questo punto devo controllare se le risposte del modello ( y_pred ) coincidono con le etichette corrette ( Y.test ).

Per fare questo utilizzo la funzione accuracy_score di scikit-learn.

la verifica del modello previsionale

La carico in memoria

from sklearn.metrics import accuracy_score

Poi confronto i dati y_test e y_pred tra loro.

accuracy_score(y_test, y_pred)

La funzione restituisce in output il seguente valore:

0.5777777777777777

Vuol dire che il modello ha un'accuratezza del 57%.

E' decisamente migliorabile ma è soltanto il primo passo utile per cominciare a fare machine learning con il linguaggio python.

Esempio. A parità di altri fattori posso portare l'accuratezza del modello previsionale oltre il 97% tramite la standardizzazione del training set ( vedi esempio ).

La libreria scikit-learn ha molti altri strumenti utili per perfezionare l'accuratezza.

Come usare il modello di classificazione

Una volta ottenuto un modello di classificazione affidabile, posso usarlo per classificare qualsiasi query senza doverlo ricostruire.

Esempio

Digito le caratteristiche dell query nella funzione ppn.predict().

Poi do invio.

ppn.predict([[5.8, 1.8, 4.1, 2.4]])

Il sistema consulta il modello statistico e mi restituisce la classificazione più probabile.

In questo caso è la classe 2 ( Iris Virginica ) .

array([2])

E così via



Segnalami un errore, un refuso o un suggerimento per migliorare gli appunti

Questo sito utilizza cookie tecnici. Sono presenti alcuni cookie di terzi ( Gooogle, Facebook ) per la personalizzazione degli annunci pubblicitari. Cliccando su OK, scorrendo la pagina o proseguendo la navigazione in altra maniera acconsenti all’uso dei cookie.

Per ulteriori informazioni o per revocare il consenso fai riferimento alla Privacy del sito.
knowledge base

Libri di approfondimento

Scikit-learn

  1. Cos'è sklearn
  2. Come installare sklearn
  3. Un esempio di machine learning
  4. Come usare i datasets didattici di scikit-learn
  5. Come rappresentare le regioni decisionali
  6. La vettorizzazione delle categorie
  7. StandardScaler ( riduzione di scala )
  8. L'analisi degli errori del classificatore
  9. L'analisi degli errori del regressore
  10. Perceptron
  11. La regressione lineare
  12. Decision Tree Classifier
  13. k-NN (k Nearest Neighbors)
  14. MLPClassifier