Hai un dataset con migliaia di righe. Clienti da classificare, vendite da prevedere, prodotti da raggruppare senza sapere le categorie. Ogni problema ha un approccio diverso. Noi di Meteora Web abbiamo visto aziende buttare tempo su algoritmi sbagliati perché non capivano la differenza tra supervised, unsupervised e reinforcement learning. In questa guida ti spieghiamo come funzionano, con codice che puoi eseguire subito sul tuo computer.
Supervised Learning — quando hai le risposte giuste
Il supervised learning parte da dati etichettati: per ogni esempio conosci la risposta (es. prezzo di una casa, categoria di un'email). L'algoritmo impara a mappare gli input in output. Due macro-categorie: regressione (valori continui) e classificazione (valori discreti).
Regressione: prevedere un numero
Immagina di dover stimare il prezzo di un'abitazione basandoti su metratura, camere, anno di costruzione. Usiamo un modello lineare. Con scikit-learn bastano poche righe:
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import numpy as np
# Dati fittizi: metratura (mq) e prezzo (€)
X = np.array([[50], [80], [120], [150], [200]])
y = np.array([100000, 160000, 240000, 300000, 400000])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = LinearRegression()
model.fit(X_train, y_train)
print(f'Prezzo stimato per 100 mq: {model.predict([[100]])[0]:.2f} €')
Errore comune: usare la regressione lineare quando la relazione non è lineare. Controlla sempre i residui e prova modelli polinomiali se necessario. Metrica chiave: Mean Absolute Error (MAE) o R². Non ti fidare solo dell'R², guarda la distribuzione degli errori.
Classificazione: assegnare una categoria
Un caso tipico: classificare email in spam o non spam. Un Random Forest è robusto e tollera bene i dati mancanti. Ecco un esempio su un dataset sintetico:
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.metrics import classification_report
X, y = make_classification(n_samples=1000, n_features=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))
Attenzione allo sbilanciamento delle classi: se hai 95% di 'non spam' e 5% 'spam', una baseline stupida indovina al 95%. Usa sempre matrice di confusione e metriche come precision, recall, F1-score.
Cosa fare subito: Prendi un dataset piccolo sul tuo dominio (es. vendite del tuo e-commerce) e prova una regressione lineare. Valuta l'errore medio. Poi passa a un modello più complesso (Random Forest) e confronta.
Unsupervised Learning — quando non hai etichette
Il dato non ha una risposta predefinita. Vuoi scoprire pattern nascosti: segmenti di clienti, anomalie, raggruppamenti di prodotti. Due tecniche fondamentali: clustering e riduzione della dimensionalità.
Clustering: raggruppare senza sapere i gruppi
K-means è l'algoritmo più noto, ma attento: devi specificare il numero di cluster (k) a priori. Un errore classico è fissare k troppo alto o basso. Usa il metodo del gomito (Elbow method) per trovare il k ottimale. Ecco il codice:
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
X, _ = make_blobs(n_samples=300, centers=4, random_state=42)
inertias = []
for k in range(1, 11):
kmeans = KMeans(n_clusters=k, random_state=42)
kmeans.fit(X)
inertias.append(kmeans.inertia_)
plt.plot(range(1, 11), inertias, marker='o')
plt.title('Metodo del gomito')
plt.xlabel('Numero di cluster')
plt.ylabel('Inerzia')
plt.show()
Se i tuoi dati non hanno cluster sferici, K-means fallisce. Prova DBSCAN che non richiede k e gestisce outlier. Per dati ad alta dimensionalità, riduci prima la dimensione con PCA.
Riduzione della dimensionalità: vedere il bosco
La PCA (Principal Component Analysis) trasforma le feature in componenti che catturano la varianza massima. Utile per visualizzare dati in 2D/3D o come pre-processing per altri modelli.
from sklearn.decomposition import PCA
import numpy as np
X = np.random.rand(100, 10) # 100 campioni, 10 feature
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
print(f'Varianza spiegata: {pca.explained_variance_ratio_.sum():.2%}')
Cosa fare subito: Raccogli un insieme di dati non etichettati (es. log di navigazione del sito) e applica K-means con il metodo del gomito. Interpreta i cluster: rappresentano segmenti di utenti? Se sì, puoi personalizzare l'esperienza.
Reinforcement Learning — quando l'agente impara dagli errori
Nell'apprendimento per rinforzo un agente interagisce con un ambiente, riceve ricompense (reward) e impara una politica (policy) per massimizzare la ricompensa cumulativa. È diverso: non hai dati statici, ma un processo di trial-and-error. Usato per robotica, giochi, ottimizzazione di processi.
Q-learning: la base tabellare
Per spazi di stato e azione discreti e piccoli, il Q-learning è semplice ed efficace. Ecco un esempio su un ambiente 'Gridworld' 3x3 dove l'agente parte dall'alto a sinistra e deve raggiungere l'obiettivo in basso a destra evitando trappole:
import numpy as np
# Ambiente 3x3, stati 0..8, azioni 0=su,1=giù,2=sx,3=dx
n_stati = 9
n_azioni = 4
Q = np.zeros((n_stati, n_azioni))
# Reward: -1 per passo, -10 per trappola (stato 4), +10 per obiettivo (stato 8)
reward = np.full(n_stati, -1)
reward[4] = -10
reward[8] = 10
done_stati = [8]
# Transizioni (semplificato, con pareti che rimandano allo stesso stato)
def next_stato(s, a):
riga, col = divmod(s, 3)
if a == 0: riga = max(0, riga-1)
elif a == 1: riga = min(2, riga+1)
elif a == 2: col = max(0, col-1)
elif a == 3: col = min(2, col+1)
return riga*3 + col
alpha = 0.1
gamma = 0.9
epsilon = 0.1
for episodio in range(500):
stato = 0
while stato not in done_stati:
if np.random.rand() < epsilon:
azione = np.random.randint(n_azioni)
else:
azione = np.argmax(Q[stato])
nuovo = next_stato(stato, azione)
Q[stato][azione] += alpha * (reward[nuovo] + gamma * np.max(Q[nuovo]) - Q[stato][azione])
stato = nuovo
print(Q.round(2))
Attenzione: Funziona solo se lo spazio degli stati è piccolo. Per problemi più grandi (immagini, sensori continui) servono reti neurali profonde (Deep Q-Networks) o metodi policy gradient.
Cosa fare subito: Non hai bisogno di un robot. Simula un problema di scheduling (es. ordini da processare) come un ambiente RL. Anche un semplice Q-learning ti aiuta a capire la dinamica.
In sintesi — cosa fare adesso
Abbiamo visto tre paradigmi. Ogni problema ha una strada: se hai etichette usa supervised; se non hai etichette prova unsupervised; se l'agente interagisce con l'ambiente usa reinforcement learning.
- Identifica il tipo di problema: Che dati hai? Qual è l'obiettivo? Vuoi prevedere (supervised), scoprire pattern (unsupervised) o ottimizzare decisioni in sequenza (RL)?
- Scegli l'algoritmo giusto: Per supervised inizia con modelli lineari o alberi decisionali. Per unsupervised prova K-means e PCA. Per RL parti con Q-learning tabellare su un ambiente semplice.
- Valuta le metriche: Non fermarti all'accuratezza. Usa MAE per regressione, F1 per classificazione, silhouette score per clustering, reward totale per RL.
- Verifica la complessità computazionale: Se il dataset è enorme (milioni di righe), scikit-learn potrebbe non bastare. Considera PyTorch/TensorFlow o frameworks distribuiti.
Ricorda: il modello migliore è quello che risolve il problema al costo giusto. Noi di Meteora Web lo vediamo ogni giorno: un'alta percentuale di fallimento nei progetti ML deriva dalla scelta errata del paradigma. Parti da qui.
Per approfondire tecniche avanzate applicate all'AI, leggi la nostra guida su Gemini 2.5 Pro vs Flash o il confronto tra Claude Opus, Sonnet e Haiku. Se vuoi capire come le tecniche di prompting si applichino ai modelli linguistici, leggi Zero-shot, One-shot, Few-shot Prompting.
Sponsored Protocol
