Corso
Apprendimento non supervisionato in Python
4 h
179.3K
Il machine learning è un sottoinsieme dell'intelligenza artificiale dedicato a comprendere e costruire metodi per imitare il modo in cui gli esseri umani imparano. Questi metodi includono l'uso di algoritmi e dati per migliorare le prestazioni su un insieme di compiti e spesso rientrano in uno dei tre tipi di apprendimento più comuni:
- Apprendimento supervisionato: un tipo di machine learning che apprende la relazione tra input e output.
- Apprendimento non supervisionato: un tipo di machine learning che apprende la struttura sottostante di un dataset non etichettato.
- Apprendimento per rinforzo: un metodo di machine learning in cui l'agente software impara a eseguire determinate azioni in un ambiente che lo portano alla ricompensa massima.
Scikit-learn, noto anche come sklearn, è una libreria open source e robusta per il machine learning in Python. È stata creata per semplificare l'implementazione di modelli di machine learning e statistici in Python.
La libreria consente di implementare rapidamente un'ampia gamma di algoritmi di machine learning supervisionati e non supervisionati tramite un'interfaccia coerente. Sklearn è costruita sopra SciPy e funziona con tutti i tipi di dati numerici memorizzati come array NumPy, matrici sparse SciPy e tutti gli altri tipi di dati che possono essere convertiti in array numerici, come i DataFrame di Pandas.
In questo tutorial pratico su sklearn, tratteremo vari aspetti del ciclo di vita del machine learning, come l'elaborazione dei dati, l'addestramento del modello e la valutazione del modello.
Dai un'occhiata a questo workspace di DataCamp per seguire il codice.
Dati
Il primo aspetto di sklearn che esploreremo sono i dati; Scikit-learn include alcuni dataset standard per il machine learning, il che significa che non sei obbligato a scaricarli da un sito web o database esterno.
Esempi di toy dataset disponibili in sklearn includono il dataset iris per la classificazione e il dataset diabetes per la regressione. Per il nostro esempio useremo il dataset del vino.
Carichiamolo in memoria:
from sklearn.datasets import load_wine
wine_data = load_wine() L'esecuzione del codice sopra restituisce un oggetto simile a un dizionario che contiene i dati insieme ai metadati relativi al contenuto.
I dati che ci servono sono nell'attributo .data restituito da load_wine(). Possiamo accedervi come attributo dell'istanza wine_data come segue:
wine_data.dataQuesto restituisce una matrice N x M dove N è il numero di campioni e M è il numero di feature.
Usiamo queste informazioni per caricare i nostri dati in un DataFrame di pandas, molto più semplice da manipolare e analizzare.
import pandas as pd
from sklearn.datasets import load_wine
wine_data = load_wine()
# Converti i dati in un dataframe pandas
wine_df = pd.DataFrame(wine_data.data, columns=wine_data.feature_names)
# Aggiungi l'etichetta target
wine_df["target"] = wine_data.target
# Anteprima
wine_df.head()
Ora sei pronto per un po' di esplorazione dei dati.
Esplorazione dei dati
I DataFrame di Pandas sono strutture di dati etichettate bidimensionali composte da colonne, che possono contenere tipi di dati diversi. Il modo più semplice per concettualizzare un DataFrame è pensarlo come tre componenti uniti insieme: 1) i dati, 2) un indice e 3) le colonne.
L'esplorazione dei dati non è l'obiettivo principale di questo articolo, ma è un passaggio estremamente importante in qualsiasi progetto sui dati: puoi saperne di più nel nostro tutorial su Python per l'Exploratory Data Analysis. Faremo una breve esplorazione per avere un'idea migliore di cosa contiene il nostro dataset; questo ci darà indicazioni su come processare i dati.
La prima cosa che faremo è chiamare il metodo info() sul nostro DataFrame di pandas; stamperà un riepilogo conciso dei dati del vino contenuti nel DataFrame.
wine_df.info()
"""
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 178 entries, 0 to 177
Data columns (total 14 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 alcohol 178 non-null float64
1 malic_acid 178 non-null float64
2 ash 178 non-null float64
3 alcalinity_of_ash 178 non-null float64
4 magnesium 178 non-null float64
5 total_phenols 178 non-null float64
6 flavanoids 178 non-null float64
7 nonflavanoid_phenols 178 non-null float64
8 proanthocyanins 178 non-null float64
9 color_intensity 178 non-null float64
10 hue 178 non-null float64
11 od280/od315_of_diluted_wines 178 non-null float64
12 proline 178 non-null float64
13 target 178 non-null int64
dtypes: float64(13), int64(1)
memory usage: 19.6 KB
"""Dopo aver eseguito questa cella, scoprirai:
- Il dataset contiene 178 campioni
- Ci sono 14 colonne totali, inclusa la colonna target (ciò che vogliamo prevedere)
- Ci sono 0 colonne con valori mancanti; puoi dedurlo dalla colonna “Non-Null Count”.
- Tutte le feature sono di tipo float64, mentre l'etichetta target è un int64.
- I dati occupano 19,6 KB di memoria.
Possiamo anche chiamare il metodo describe() sul nostro DataFrame per ottenere statistiche descrittive su ciascuna feature del dataset.
Per esempio:
wine_df.describe() 
Vuoi anche farti un'idea del tipo di valori contenuti in ogni feature. Il modo più rapido per scoprirlo è usare il metodo head() per visualizzare le prime cinque righe di dati o il metodo tail() per vedere le ultime cinque righe di dati.
wine_df.tail()
L'esecuzione di questo codice ci mostra che le nostre feature sono su scale diverse, il che può causare problemi quando si utilizzano algoritmi basati sulla discesa del gradiente come la regressione logistica e quando si utilizzano algoritmi basati sulla distanza come le support vector machine. Questo perché sono sensibili all'intervallo dei punti dati.
In un normale workflow di machine learning, questo processo sarebbe molto più approfondito, ma passeremo direttamente al processamento dei dati per tornare al focus principale di questo tutorial, Scikit-learn.
Puoi imparare di più su Pandas nel Python Pandas Tutorial: The Ultimate Guide for Beginners.
Esempio con Scikit-learn: preprocessing dei dati
Abbiamo una discreta comprensione di come sono fatti i nostri dati. Quando arrivi a questo punto, di solito significa che sei pronto per iniziare a preparare i dati da dare in pasto a un modello di machine learning.
Il processamento dei dati è un passaggio fondamentale nel workflow di machine learning perché i dati del mondo reale sono disordinati. Possono contenere:
- Valori mancanti,
- Valori ridondanti
- Outlier
- Errori
- Rumore
Devi occuparti di tutto questo prima di fornire i dati a un modello di machine learning; altrimenti, il modello incorporerà questi errori nella sua funzione di approssimazione: imparerà a commettere errori su nuovi casi. È da qui che nasce il famoso detto nel machine learning: “Garbage in, garbage out”.
Un altro motivo è che i modelli di machine learning richiedono in genere dati numerici.
A parte il fatto che i nostri dati sono su scale diverse, a prima vista non c'è molto altro di problematico. Per risolvere questo problema, standardizziamo le feature usando la classe StandardScaler di sklearn; questo renderà le feature con media 0 e deviazione standard 1.
Ecco il codice:
from sklearn.preprocessing import StandardScaler
# Suddividi i dati in feature ed etichetta
X = wine_df[wine_data.feature_names].copy()
y = wine_df["target"].copy()
# Istanzia lo scaler e adatta sulle feature
scaler = StandardScaler()
scaler.fit(X)
# Trasforma le feature
X_scaled = scaler.transform(X.values)
# Visualizza la prima istanza
print(X_scaled[0])
"""
[ 1.51861254 -0.5622498 0.23205254 -1.16959318 1.91390522 0.80899739
1.03481896 -0.65956311 1.22488398 0.25171685 0.36217728 1.84791957
1.01300893]
"""Passiamo all'addestramento del modello.
Esempio con Scikit-learn: addestramento del modello
Prima che un modello di machine learning possa fare previsioni, deve essere addestrato su un set di dati per apprendere una funzione di approssimazione.
Ma come sapremo se il modello si comporta bene su dati che non ha mai visto? Non lo sapremo, a meno di testarlo.
Un modo per testare un modello di machine learning prima di metterlo in un ambiente in cui ha impatto sugli altri è suddividere i dati in un set di addestramento e uno di test e usare il set di test per valutare ciò che il modello ha imparato; questo è noto come valutazione offline.
Ci sono diversi modi per suddividere i dati in train e test, ma scikit-learn ha una funzione integrata che lo fa per noi, chiamata train_test_split().
Useremo questa funzione per suddividere i nostri dati in modo che il 70% venga usato per addestrare il modello e il 30% per valutarne la capacità di generalizzare a istanze mai viste.
from sklearn.model_selection import train_test_split
# Suddividi i dati in train e test
X_train_scaled, X_test_scaled, y_train, y_test = train_test_split(X_scaled,
y,
train_size=.7,
random_state=25)
# Verifica che le suddivisioni siano corrette
print(f"Train size: {round(len(X_train_scaled) / len(X) * 100)}% \n\
Test size: {round(len(X_test_scaled) / len(X) * 100)}%")
"""
Train size: 70%
Test size: 30%
Ora costruiamo alcuni modelli.
Costruire il modello
Grazie a sklearn, costruire un modello di machine learning è estremamente semplice.
Costruiremo tre modelli per prevedere la classe del vino:
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
# Istanziamento dei modelli
logistic_regression = LogisticRegression()
svm = SVC()
tree = DecisionTreeClassifier()
# Addestramento dei modelli
logistic_regression.fit(X_train_scaled, y_train)
svm.fit(X_train_scaled, y_train)
tree.fit(X_train_scaled, y_train)
# Predizioni con ciascun modello
log_reg_preds = logistic_regression.predict(X_test_scaled)
svm_preds = svm.predict(X_test_scaled)
tree_preds = tree.predict(X_test_scaled)Il passaggio successivo è valutare come i modelli generalizzano a istanze mai viste.
Esempio con Scikit-learn: valutazione del modello
La valutazione del modello serve a testare quanto bene il modello generalizza a istanze mai viste. Scikit-learn fornisce una serie di metriche di classificazione e regressione per valutare le prestazioni di un modello addestrato.
Per il nostro caso d'uso, utilizzeremo classification_report() dal modulo metrics per costruire un report testuale che mostri le principali metriche di classificazione come precision, recall, f1_score, accuracy, ecc.
Ecco come appare in codice:
from sklearn.metrics import classification_report
# Memorizza le predizioni dei modelli in un dizionario
# questo rende più semplice iterare su ciascun modello
# e stampare i risultati.
model_preds = {
"Logistic Regression": log_reg_preds,
"Support Vector Machine": svm_preds,
"Decision Tree": tree_preds
}
for model, preds in model_preds.items():
print(f"{model} Results:\n{classification_report(y_test, preds)}", sep="\n\n")
"""
Logistic Regression Results:
precision recall f1-score support
0 1.00 1.00 1.00 17
1 1.00 0.92 0.96 25
2 0.86 1.00 0.92 12
accuracy 0.96 54
macro avg 0.95 0.97 0.96 54
weighted avg 0.97 0.96 0.96 54
Support Vector Machine Results:
precision recall f1-score support
0 1.00 1.00 1.00 17
1 1.00 1.00 1.00 25
2 1.00 1.00 1.00 12
accuracy 1.00 54
macro avg 1.00 1.00 1.00 54
weighted avg 1.00 1.00 1.00 54
Decision Tree Results:
precision recall f1-score support
0 0.94 0.94 0.94 17
1 0.96 0.88 0.92 25
2 0.86 1.00 0.92 12
accuracy 0.93 54
macro avg 0.92 0.94 0.93 54
weighted avg 0.93 0.93 0.93 54
"""A prima vista, sembra che la support vector machine sia il modello migliore. In un workflow tipico, questo susciterebbe curiosità sul modello: è davvero così buono come sembra, o abbiamo commesso un errore da qualche parte? Dovresti essere stimolato a conoscere meglio i tuoi modelli e ciò che stanno imparando, perché questo ti darà maggiore consapevolezza dei loro punti di forza e di debolezza.
Conoscere queste informazioni è estremamente utile per gli stakeholder, perché consente loro di trovare soluzioni per compensare dove il modello è carente.
Conclusione
La libreria scikit-learn è composta da diversi moduli che rendono semplice l'implementazione di modelli di machine learning. Questi moduli spaziano dagli strumenti di preprocessing per preparare i dati da fornire a un modello di machine learning, ai modelli che puoi usare per trovare pattern nei tuoi dati, fino alle metriche di valutazione con cui misurare le prestazioni del tuo modello.
In questo tutorial abbiamo appena scalfito la superficie delle capacità di sklearn. Per approfondire ciò che puoi fare con la libreria, abbiamo diverse risorse per metterti sulla strada giusta. Eccone alcune per iniziare:
Argomenti
