Il modo migliore per comprendere l’apprendimento automatico è costruire un modello da soli. È molto meno intimidatorio di quanto possa sembrare: con Python e la libreria giusta, il vostro primo modello funzionante richiede circa 20 righe di codice. Questo tutorial illustra ogni singolo passaggio, spiegando non solo cosa digitare, ma anche perché.
Punti chiave
- Userete Python e scikit-learn — la libreria standard per principianti nel campo del machine learning.
- Il flusso di lavoro tipico è il seguente: caricare i dati → suddividerli → addestrare un modello → valutarlo → effettuare previsioni.
- La regola d’oro: testare sempre il modello su dati che non ha mai visto durante l’addestramento.
- Non è richiesta alcuna conoscenza avanzata di matematica — scikit-learn si occupa delle parti più complesse.
Cosa realizzerete
Realizzerete un classificatore — un modello in grado di assegnare elementi a categorie specifiche. Useremo il classico dataset per principianti, il dataset Iris: misurazioni di fiori di iris (lunghezza e larghezza del petalo e del sepalo), dove l’obiettivo è prevedere la specie del fiore. È un dataset piccolo, pulito e integrato direttamente in scikit-learn, quindi ideale per il primo modello.
Gli stessi cinque passaggi illustrati qui sono applicabili alla stragrande maggioranza dei progetti di machine learning, indipendentemente dalle loro dimensioni.
Passo 1: Configurare gli strumenti
Avete bisogno di Python e di due librerie. scikit-learn è la libreria principale: fornisce dataset, algoritmi e strumenti di valutazione attraverso un’interfaccia coerente e accessibile ai principianti.
Installatele dal terminale:
pip install scikit-learn pandas
Potete scrivere il codice in un semplice file .py ma un notebook Jupyter (o un notebook cloud gratuito come Google Colab) è l’opzione ideale per imparare: potrete eseguire il codice in piccole porzioni e visualizzare immediatamente ogni risultato.
Passo 2: Caricare i dati
Ogni progetto di machine learning inizia con i dati. Qui carichiamo il dataset Iris integrato:
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data # the measurements (the inputs / features)
y = iris.target # the species (the labels / answers)
print("Shape of X:", X.shape) # (150, 4) — 150 flowers, 4 measurements each
print("Classes:", iris.target_names)
Due variabili sono fondamentali qui, e la convenzione di denominazione è universale:
Xcontiene le caratteristiche — gli input dai quali il modello apprende (le quattro misurazioni).ycontiene le etichette — le risposte corrette (la specie).
Poiché disponiamo delle risposte, si tratta di apprendimento supervisionato.
Passo 3: Suddividere i dati
Questo è il passo più importante per ottenere un risultato onesto. È necessario suddividere i dati in due parti:
- A insieme di addestramento dal quale il modello apprende.
- A insieme di test che il modello non vede mai durante l’addestramento — utilizzato esclusivamente per la sua valutazione.
Se eseguissi il test sugli stessi dati utilizzati per l’addestramento, misureresti semplicemente la capacità di memorizzazione, non un vero apprendimento. (È così che si individua il overfitting.)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
test_size=0.2 riserva il 20% dei dati per il test e utilizza l’80% rimanente per l’addestramento. random_state=42 garantisce che la suddivisione casuale sia riproducibile, fornendo lo stesso risultato a ogni esecuzione.
Passo 4: Scegliere e addestrare un modello
Ora entra in gioco l’apprendimento automatico vero e proprio. Useremo una foresta casuale — un algoritmo accurato, affidabile e adatto ai principianti (vedi la nostra guida agli algoritmi).
In scikit-learn, addestrare un modello richiede due sole righe:
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
La chiamata .fit() effettua è l’addestramento. Il modello analizza le caratteristiche di addestramento e le relative etichette, imparando i pattern che collegano le misurazioni alla specie. scikit-learn gestisce tutta la matematica sottostante con questa singola riga.
Passo 5: Valutare il modello
Verifichiamo ora quanto bene il modello abbia appreso — utilizzando l’insieme di test che non ha mai visto:
from sklearn.metrics import accuracy_score
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"Accuratezza: {accuracy:.2%}")
.predict() chiede al modello di classificare i fiori di test; accuracy_score confronta le sue previsioni con le risposte effettive. Sul dataset Iris otterrai tipicamente un’accuratezza compresa tra il 95% e il 100% — il modello identifica correttamente quasi tutti i fiori che non aveva mai visto prima.
Passo 6: Effettuare una previsione su nuovi dati
Il vero vantaggio: utilizzare il modello su dati completamente nuovi. Forniscigli un insieme di misurazioni e predirà la specie corrispondente:
new_flower = [[5.1, 3.5, 1.4, 0.2]] # sepal & petal measurements
prediction = model.predict(new_flower)
print("Predicted species:", iris.target_names[prediction[0]])
Questo è un modello completo di machine learning: addestrato, testato e in grado di effettuare previsioni su dati mai incontrati in precedenza.
Il flusso di lavoro completo
Questi cinque passi non sono solo un esercizio — costituiscono lo scheletro di praticamente ogni progetto di ML supervisionato:
| Passo | A cosa serve |
|---|---|
| 1. Caricare i dati | Ottenere le caratteristiche (X) e le etichette (y) |
| 2. Suddividere i dati | Separare l’insieme di addestramento da quello di test |
| 3. Addestrare | model.fit() apprende il pattern |
| 4. Valutare | Misurare l’accuratezza sui dati di test mai visti |
| 5. Prevedere | model.predict() su nuovi input |
Progetti più complessi prevedono ulteriori fasi come la pulizia dei dati, la preparazione delle caratteristiche e l’ottimizzazione del modello — ma questo ciclo fondamentale rimane immutato.
Dove andare avanti
Per continuare a costruire:
- Provare altri algoritmi — sostituire
RandomForestClassifierperLogisticRegressionoSVCe confrontarli. L'interfaccia coerente di scikit-learn rende questa operazione banale. - Prova altri dataset — esercitati su quelli che dataset gratuiti ti interessano.
- Impara la preparazione dei dati — i dati reali sono disordinati; la loro pulizia e preparazione costituisce la maggior parte del lavoro.
- Esplora le metriche di valutazione — l'accuratezza è solo una delle metriche; impara a utilizzare precisione, richiamo (recall) e convalida incrociata (cross-validation).
Errori comuni che compromettono silenziosamente il tuo primo modello
Il tuo modello è stato addestrato e ha stampato un punteggio di accuratezza — ma un numero che sembra buono non equivale necessariamente a un modello funzionante. Queste sono le trappole in cui cadono più spesso i principianti, e tutte sono facilmente evitabili non appena se ne conosce l’esistenza.
- Valutare il modello sui dati su cui è già stato addestrato. Se misuri l’accuratezza sui dati di addestramento, stai valutando il modello in base alle risposte che ha semplicemente memorizzato. Un punteggio del 100% in questo caso non significa nulla. Valuta sempre il modello sull’insieme di test tenuto da parte durante la suddivisione dei dati: è l’unico valore che stima le prestazioni nel mondo reale.
- Data leakage (perdita di dati): permettere ai dati di test di influenzare l’addestramento. Questo è l’errore più dannoso e meno evidente. Se applichi scalatura, normalizzazione o riempimento dei valori mancanti prima di prima della suddivisione, statistiche provenienti dall’insieme di test (come la media di una colonna) vengono 'fatte filtrare' nell’insieme di addestramento, gonfiando artificialmente il punteggio. La soluzione consiste nell’applicare un ordine rigoroso: suddividi prima i dati, quindi adatta (fit) ogni trasformatore esclusivamente sull’insieme di addestramento e semplicemente applica (apply) tale trasformazione all’insieme di test. La documentazione di scikit-learn indica questo errore come uno dei più comuni 'pitfall' nel machine learning.
- Dimenticare di scalare i dati quando l’algoritmo lo richiede. Modelli basati su distanza o sul gradiente (k-nearest neighbors, SVM, regressione logistica) risultano distorti se una caratteristica varia tra 0 e 1 mentre un’altra varia tra 0 e 100.000. I modelli basati su alberi decisionali, come le random forest, non ne risentono. Conosci bene a quale categoria appartiene l’algoritmo che stai utilizzando.
- Affidarsi ciecamente all’accuratezza su dati sbilanciati. Se il 95% dei tuoi esempi appartiene a una sola classe, un modello che predice sempre quella classe otterrà un’accuratezza del 95%, pur essendo del tutto inutile. Quando le classi sono fortemente sbilanciate, consulta precisione, richiamo (recall) e punteggio F1 forniti da
classification_reportanziché basarti esclusivamente sull’accuratezza.
La difesa più efficace contro il data leakage è una Pipelinepipeline.
from sklearn.pipeline import make_pipelinemodel = make_pipeline(StandardScaler(), LogisticRegression())- Poi chiama
model.fit(X_train, y_train)esattamente come prima.
Un'ultima abitudine utile da acquisire fin dall'inizio: una singola suddivisione train/test è una stima rumorosa. Eseguire nuovamente il processo con una suddivisione casuale diversa può far variare il punteggio di diversi punti. Una volta che ti senti a tuo agio, sostituisci la suddivisione singola con cross_val_score, che esegue l'addestramento e la valutazione su più fold e restituisce la media — una stima molto più onesta dell'effettiva capacità del modello di aver appreso qualcosa.
Domande frequenti
Come costruisco un modello di machine learning in Python?
Usa la libreria scikit-learn. Il flusso di lavoro è il seguente: carica i tuoi dati nelle variabili di input (X) e nelle etichette (y), suddividili in insiemi di addestramento e di test, crea un modello e chiama .fit() per addestrarlo, valutalo sull’insieme di test e usa .predict() per effettuare previsioni su nuovi dati. Un primo modello richiede circa 20 righe di codice.
Quale libreria dovrebbero usare i principianti per il machine learning?
scikit-learn. Offre un’ampia gamma di algoritmi, dataset integrati e strumenti di valutazione attraverso un’unica interfaccia semplice e coerente, gestendo per te la matematica sottostante. È il punto di partenza standard prima di passare a framework per il deep learning.
Devo essere bravo in matematica per costruire un modello ML?
No. Per costruire modelli con scikit-learn ti servono soltanto conoscenze basilari di Python e una comprensione del flusso di lavoro. La libreria si occupa della matematica. Una conoscenza più approfondita diventa utile in seguito, se desideri ottimizzare i modelli in modo esperto o condurre ricerche.
Perché devo suddividere i dati in insiemi di addestramento e di test?
Per misurare in modo affidabile le prestazioni reali. Se testi un modello sugli stessi dati su cui è stato addestrato, misuri soltanto la sua capacità di memorizzazione. Un insieme di test separato, mai visto dal modello, mostra se quest’ultimo ha davvero appreso il pattern e riesce a generalizzare su dati nuovi.
Cosa fa model.fit()?
.fit() è il passaggio di addestramento. Fornisce algoritmo con i dati di input e le etichette di addestramento, che ne aggiusta i parametri interni per apprendere i legami tra gli input e le risposte corrette. Dopo .fit(), il modello è addestrato ed è pronto a effettuare previsioni.
Il mio modello ha ottenuto un'alta accuratezza: significa che è buono?
Non necessariamente. Un'alta accuratezza è significativa solo se è stata misurata sul set di test tenuto da parte, non sui dati di addestramento, e solo se le classi sono ragionevolmente bilanciate. Su un dataset in cui una classe domina nettamente, un punteggio elevato potrebbe derivare semplicemente dal fatto che il modello indovina sempre la classe maggioritaria. Verifica precisione, recall e F1-score con classification_report, assicurandoti che il valore riportato provenga da dati sui quali il modello non è mai stato addestrato.
Come salvo il mio modello addestrato e lo utilizzo in seguito?
Usa la libreria Python joblib , inclusa in scikit-learn. Chiama joblib.dump(modello, "modello.joblib") per salvare il modello addestrato su disco, e joblib.load("modello.joblib") per caricarlo in un altro script — senza doverlo riaddestrare. Salva l'intera Pipeline, non solo l'ultimo estimatore, in modo che scalatura e preprocessing viaggino insieme al modello e i nuovi input vengano elaborati in modo identico.
Come passo da un dataset integrato ai miei dati personali?
Carica i tuoi dati con pandas — pandas.read_csv("tuo_file.csv") — quindi separa le colonne di input (caratteristiche, generalmente chiamate X) dalla colonna che desideri prevedere (l'obiettivo, y). Da quel punto in poi il flusso di lavoro è identico: suddivisione, addestramento, valutazione. Il nuovo lavoro consiste principalmente nella pulizia dei dati: gestione dei valori mancanti, codifica delle categorie testuali in numeri e selezione delle colonne effettivamente utili. È proprio in questa fase di preparazione dei dati che viene spesa la maggior parte del tempo reale nell’ambito dell’ML.
Conclusione
Costruire il tuo primo modello di machine learning è davvero un progetto breve e raggiungibile: installa scikit-learn, quindi carica i dati, suddividili, addestra il modello, valutalo e infine effettua previsioni. Questi cinque passaggi costituiscono la base di quasi ogni progetto di machine learning supervisionato che realizzerai.
Non limitarti a leggere questo articolo — apri un notebook ed esegui il codice. Cambia l’algoritmo, prova un dataset diverso, provoca errori e risolvili. I concetti di machine learning diventano molto più chiari non appena avrai addestrato un modello con le tue mani. Quando sarai pronto per proseguire, scarica un dataset gratuito e costruisci qualcosa di tuo.
