Scikit-learn da Zero: Classificazione, Regressione e Clustering con Python — Guida Operativa

Se hai mai provato a fare machine learning con Python e ti sei perso tra DataFrame, array e parametri, non sei solo. Noi di Meteora Web lo vediamo spesso: sviluppatori che saltano da un tutorial all'altro, ma quando arriva un dataset reale, non sanno da che parte iniziare. Partiamo da un problema concreto: hai un CSV di clienti e vuoi prevedere chi comprerà, oppure raggruppare prodotti simili. Scikit-learn è la risposta. In questa guida vediamo come si fa, perché funziona e quanto costa in termini di risorse.

Perché scikit-learn e non un altro framework?

Non è una moda. Noi di Meteora Web scegliamo scikit-learn per progetti reali perché ha un ecosistema maturo, stabile e ben testato. PyTorch e TensorFlow sono per deep learning: se hai 1000 righe di dati tabellari, porti una pressa idraulica per schiacciare una noce. Scikit-learn ti dà modelli classici (regressione logistica, random forest, SVM, KMeans) con un'interfaccia uniforme, documentazione eccellente e integrazione nativa con pandas e numpy. In più, il costo computazionale è contenuto: puoi addestrare un modello su un portatile senza GPU. Per la maggior parte dei problemi di business, è la scelta giusta.

Classificazione: dal preprocessing al modello

La classificazione assegna una categoria a un'osservazione. Esempio: un cliente compra (1) o non compra (0). Il flusso è sempre lo stesso: carica dati, separa features e target, suddividi in training e test, preprocessa, addestra, valuta.

Caricamento e preparazione dei dati

Usiamo pandas per leggere il CSV e numpy per manipolare array. Supponiamo di avere un dataset con colonne: età, reddito, spesa_precedente, acquistato. Le prime tre sono feature, l'ultima è il target binario.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# Carica dati
df = pd.read_csv('clienti.csv')
X = df[['età', 'reddito', 'spesa_precedente']]
y = df['acquistato']
# Divisione train/test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Errore comune: dimenticare di scalare le feature. Se reddito è 50000 e età è 30, modelli come SVM o regressione logistica danno più peso al reddito. Lo scaler standard (media=0, dev.std=1) risolve.

Modelli di classificazione

Proviamo tre modelli: Regressione Logistica (lineare, veloce, interpretabile), Random Forest (non lineare, robusto), SVM con kernel RBF (potente ma più lento). Scikit-learn li ha tutti con .fit() e .predict().

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
# Pipeline con scaling
from sklearn.pipeline import make_pipeline
models = {
    'LogisticRegression': make_pipeline(StandardScaler(), LogisticRegression()),
    'RandomForest': RandomForestClassifier(n_estimators=100, random_state=42),
    'SVM': make_pipeline(StandardScaler(), SVC(kernel='rbf'))
}
for name, model in models.items():
    model.fit(X_train, y_train)
    acc = model.score(X_test, y_test)
    print(f'{name}: {acc:.3f}')

Metriche che contano: l'accuratezza va bene se le classi sono bilanciate. Con dati sbilanciati (es. 95% non compra), guarda precision, recall, F1-score. Usa classification_report e confusion_matrix.

Validazione incrociata per evitare overfitting

Un singolo split può ingannare. Scikit-learn ha cross_val_score per valutare su più fold.

from sklearn.model_selection import cross_val_score
scores = cross_val_score(RandomForestClassifier(), X_train, y_train, cv=5)
print(f'Accuracy media: {scores.mean():.3f} (+/- {scores.std():.3f})')

Regressione: prevedere valori continui

Se invece vuoi prevedere il prezzo di una casa o il fatturato del prossimo mese, usi la regressione. Il flusso è identico: split, scaling, addestramento, valutazione con errore quadratico medio (MSE) o R².

Regressione lineare e varianti

La regressione lineare è il punto di partenza. Ma attenzione: se hai molte feature correlate (multicollinearità) o poche osservazioni, usa Ridge o Lasso (regolarizzazione L2 o L1).

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.metrics import mean_squared_error, r2_score
model = make_pipeline(StandardScaler(), LinearRegression())
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(f'MSE: {mean_squared_error(y_test, y_pred):.2f}')
print(f'R²: {r2_score(y_test, y_pred):.2f}')

Consiglio pratico: usa RidgeCV e LassoCV per trovare automaticamente il miglior parametro di regolarizzazione con cross-validation. Scikit-learn ti dà tutto integrato.

Valutazione della regressione

R² si legge come percentuale di varianza spiegata. Un R² di 0.8 significa che il modello spiega l'80% della variabilità. MSE è nella stessa unità del target. Per confronti, usa anche MAE (Mean Absolute Error) che è meno sensibile agli outlier.

Clustering: raggruppare senza etichette

Quando non hai etichette (apprendimento non supervisionato), vuoi trovare gruppi naturali nei dati. Esempi: segmentare clienti, raggruppare articoli simili, rilevare anomalie.

K-Means: semplice e veloce

K-Means è il pilastro: scegli k (numero di cluster), assegna ogni punto al centro più vicino, ricalcola i centri, ripeti. Scikit-learn fa tutto con una riga.

from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(X)  # X scalate!
labels = kmeans.labels_
centers = kmeans.cluster_centers_

Come scegliere k? Usa il metodo del gomito: addestra con k da 1 a 10 e calcola l'inertia (somma delle distanze quadrate interne). Il punto dove la curva si appiattisce è il k ottimale. Scikit-learn ha KMeans.inertia_.

inertias = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X_scaled)
    inertias.append(kmeans.inertia_)

In alternativa, usa il silhouette score (più alto=cluster più separati). Scikit-learn: from sklearn.metrics import silhouette_score.

DBSCAN: cluster basati sulla densità

DBSCAN non richiede di specificare k e gestisce outlier. Identifica regioni dense e le separa. I parametri sono eps (raggio) e min_samples (punti minimi per formare un nucleo). È ottimo per dati con forma irregolare.

from sklearn.cluster import DBSCAN
db = DBSCAN(eps=0.5, min_samples=5)
db.fit(X_scaled)
labels = db.labels_  # -1 = rumore (outlier)

Attenzione: DBSCAN non scala bene con tanti punti (complessità O(n²)). Su dataset grandi usa HDBSCAN o campiona.

Messe in produzione: pipeline, salvare modelli e scalare

Un modello in un notebook non serve a nessuno. Per usarlo in produzione, crea una pipeline completa (scaling + modello) e salvala con joblib. Noi di Meteora Web lo facciamo per clienti che hanno dashboard Django o API FastAPI.

import joblib
from sklearn.pipeline import Pipeline
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', RandomForestClassifier())
])
pipeline.fit(X_train, y_train)
# Salva su disco
joblib.dump(pipeline, 'modello_cliente.pkl')
# Ricarica altrove
loaded_pipe = joblib.load('modello_cliente.pkl')
nuova_predizione = loaded_pipe.predict(nuovi_dati)

Scalabilità: scikit-learn non è pensato per streaming di dati enormi. Per dataset oltre la RAM, considera IncrementalPCA, SGDClassifier (stocastico) o passa a framework distribuiti. Ma per la maggior parte delle PMI, 100k righe sono gestibili.

In sintesi — cosa fare adesso

1. Installa scikit-learn: pip install scikit-learn pandas numpy. Fine.
2. Scegli un dataset piccolo (es. Iris, Boston housing da sklearn.datasets) e applica il flusso: carica, split, scala, addestra, valuta.
3. Non dimenticare lo scaling per tutti i modelli basati su distanze o gradienti. Le metriche come MSE o accuratezza vanno interpretate nel contesto di business.
4. Usa cross-validation per ogni scelta importante (parametri, selezione modello).
5. Metti in produzione con pipeline e joblib. Un modello è utile solo quando qualcuno lo interroga.

Noi di Meteora Web usiamo scikit-learn ogni giorno per progetti di analisi dati e automazione. Vuoi approfondire? Leggi la nostra guida su Chain of Thought Prompting per capire come l'AI ragiona, oppure scarica il codice completo di questo articolo dal nostro repository. Ma ricordati: il modello perfetto è inutile se non risolve un problema reale. Parti dai dati, misura il ritorno e solo dopo ottimizza.