Algoritmi di Machine Learning Spiegati: Guida Completa per i Colloqui Tecnici

Gli algoritmi di machine learning costituiscono il nucleo di ogni colloquio tecnico in data science nel 2026. Che il ruolo sia rivolto a un data scientist junior o a un ML engineer senior, i selezionatori si aspettano che i candidati sappiano spiegare, implementare e confrontare le principali famiglie di algoritmi — dai modelli lineari ai metodi ensemble, fino alle tecniche non supervisionate. Questa guida approfondita copre ogni categoria principale con implementazioni in Python tramite scikit-learn 1.8, strategie di valutazione e i trade-off esatti che distinguono i candidati forti dagli altri.

Apprendimento Supervisionato: Fondamenti di Regressione e Classificazione

Gli algoritmi di apprendimento supervisionato apprendono da dati etichettati — ogni esempio di addestramento include un input e l'output atteso. La regressione predice valori continui (prezzi delle abitazioni, temperature), mentre la classificazione assegna etichette discrete (spam/non spam, diagnosi medica). La comprensione di entrambi i paradigmi è imprescindibile nei colloqui di data science.

La regressione lineare rappresenta il punto di partenza per qualsiasi task di regressione. Modella la relazione tra le feature e la variabile target come una somma pesata. I selezionatori chiedono frequentemente ai candidati di implementarla, spiegare la funzione di costo e illustrare in quali scenari presenta limitazioni.

# linear_regression_demo.py
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Generate synthetic housing data: square footage -> price
np.random.seed(42)
sqft = np.random.uniform(500, 3000, size=200).reshape(-1, 1)
price = 150 * sqft.flatten() + np.random.normal(0, 20000, size=200)

X_train, X_test, y_train, y_test = train_test_split(sqft, price, test_size=0.2)

model = LinearRegression()
model.fit(X_train, y_train)                    # Fit on training data
predictions = model.predict(X_test)            # Predict on unseen data

print(f"Coefficient: {model.coef_[0]:.2f}")    # Weight per sqft
print(f"R2 Score: {r2_score(y_test, predictions):.4f}")
print(f"RMSE: {np.sqrt(mean_squared_error(y_test, predictions)):.2f}")

Il coefficiente rivela quanto ogni metro quadro aggiuntivo contribuisce al prezzo. Il punteggio R2 e il RMSE quantificano la qualità delle previsioni — due metriche che i selezionatori si aspettano vengano interpretate senza esitazioni.

Per la classificazione, la regressione logistica applica una funzione sigmoid per produrre probabilità. Nonostante il nome, risolve problemi di classificazione. Il decision boundary, il parametro di regolarizzazione C e la differenza tra contesti binari e multiclasse sono tutti argomenti frequenti nei colloqui tecnici.

# logistic_classification.py
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

data = load_breast_cancer()                    # Binary classification dataset
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

clf = LogisticRegression(max_iter=5000, C=1.0) # C controls regularization strength
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred, target_names=data.target_names))

Il report di classificazione mostra precisione, recall e F1-score per classe — le metriche esatte di cui si discute nella sezione successiva. Saper leggere questi report con scioltezza è essenziale: i selezionatori notano subito quando un candidato fatica a interpretarli.

Alberi Decisionali e Metodi Ensemble al Centro dei Colloqui

Gli alberi decisionali suddividono i dati in modo ricorsivo sulla base di soglie sulle feature. Da soli tendono all'overfitting. I metodi ensemble — Random Forest e Gradient Boosting — risolvono questo problema combinando più alberi. Questi algoritmi compaiono in quasi ogni colloquio di ML perché bilanciano interpretabilità e performance.

Random Forest costruisce molti alberi indipendenti su campioni bootstrap e ne media le previsioni. Questo riduce la varianza senza aumentare il bias.

# ensemble_comparison.py
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score

data = load_wine()                             # 3-class classification
X, y = data.data, data.target

# Random Forest: parallel trees, reduces variance
rf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
rf_scores = cross_val_score(rf, X, y, cv=5, scoring='accuracy')

# Gradient Boosting: sequential trees, reduces bias
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)
gb_scores = cross_val_score(gb, X, y, cv=5, scoring='accuracy')

print(f"Random Forest:     {rf_scores.mean():.4f} +/- {rf_scores.std():.4f}")
print(f"Gradient Boosting: {gb_scores.mean():.4f} +/- {gb_scores.std():.4f}")

Random Forest eccelle quando l'obiettivo è la stabilità e un basso sforzo di tuning. Gradient Boosting raggiunge spesso un'accuratezza superiore, ma richiede una selezione attenta degli iperparametri — learning rate, numero di estimatori e profondità degli alberi interagiscono tra loro in modo non banale. I selezionatori verificano che i candidati comprendano questo trade-off, non solo quale numero sia più alto.

| Criterio | Random Forest | Gradient Boosting | |-----------|--------------|-------------------| | Velocità di addestramento | Alta (parallelo) | Inferiore (sequenziale) | | Rischio di overfitting | Basso | Più alto senza tuning | | Sensibilità agli iperparametri | Bassa | Alta | | Feature importance | Integrata (impurity-based) | Integrata (gain-based) | | Utilizzo ideale | Modelli baseline, dati rumorosi | Competizioni, dati tabulari |

Apprendimento Non Supervisionato: Clustering e Riduzione della Dimensionalità

Gli algoritmi non supervisionati trovano struttura in dati privi di etichette. K-Means clustering e PCA (Principal Component Analysis) sono le due tecniche su cui i selezionatori si soffermano maggiormente.

K-Means suddivide i dati in k cluster minimizzando la varianza intra-cluster. L'algoritmo itera tra l'assegnazione dei punti al centroide più vicino e l'aggiornamento dei centroidi. Due domande critiche nei colloqui: come scegliere k (metodo del gomito, silhouette score) e cosa accade con cluster non sferici.

# kmeans_clustering.py
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.datasets import load_iris

data = load_iris()
X = StandardScaler().fit_transform(data.data)  # Scale features first

# Test multiple values of k to find optimal cluster count
for k in [2, 3, 4, 5]:
    kmeans = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = kmeans.fit_predict(X)
    sil = silhouette_score(X, labels)          # Higher = better-defined clusters
    inertia = kmeans.inertia_                  # Within-cluster sum of squares
    print(f"k={k}: silhouette={sil:.3f}, inertia={inertia:.1f}")

Scalare le feature prima del clustering è obbligatorio — K-Means utilizza la distanza euclidea, quindi feature non normalizzate con intervalli ampi dominano la metrica distorcendo i risultati.

La PCA riduce la dimensionalità proiettando i dati nelle direzioni di massima varianza. Serve a due scopi: visualizzazione (proiezione in 2D/3D) e preprocessing (rimozione del rumore, accelerazione dei modelli a valle).

Metriche di Valutazione del Modello che Ogni Candidato Deve Padroneggiare

Scegliere la metrica di valutazione corretta è più importante che scegliere l'algoritmo giusto. Un modello con il 99% di accuratezza su dati sbilanciati (tasso di frode dell'1%) può essere del tutto inutile — si limita a predire sempre "non frode".

Per la classificazione, quattro metriche dominano i colloqui:

• Precisione: tra tutte le predizioni positive, quante sono corrette? Fondamentale quando i falsi positivi sono costosi (filtro antispam)
• Recall: tra tutti i positivi reali, quanti vengono individuati? Fondamentale quando i falsi negativi sono costosi (screening medico)
• F1-Score: media armonica di precisione e recall — la scelta bilanciata quando nessun tipo di errore prevale chiaramente sull'altro
• AUC-ROC: misura la qualità del ranking su tutte le soglie di classificazione — essenziale per confrontare modelli tra loro

# evaluation_metrics.py
from sklearn.metrics import (
    precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix
)
import numpy as np

# Simulated predictions on imbalanced data (5% positive class)
np.random.seed(42)
y_true = np.array([1]*50 + [0]*950)
y_pred = np.array([1]*40 + [0]*10 + [1]*30 + [0]*920)  # Some errors

print(f"Precision: {precision_score(y_true, y_pred):.3f}")  # 40/(40+30) = 0.571
print(f"Recall:    {recall_score(y_true, y_pred):.3f}")     # 40/(40+10) = 0.800
print(f"F1-Score:  {f1_score(y_true, y_pred):.3f}")         # Harmonic mean

cm = confusion_matrix(y_true, y_pred)
print(f"\nConfusion Matrix:\n{cm}")
# [[920, 30],   -> TN=920, FP=30
#  [10,  40]]   -> FN=10,  TP=40

La matrice di confusione offre una visione completa degli errori del modello. Un candidato in grado di leggere e commentare rapidamente una confusion matrix dimostra una comprensione pratica che va oltre la semplice conoscenza teorica.

Trade-off Bias-Varianza e Strategie di Regolarizzazione

Il trade-off bias-varianza è il concetto teorico più importante nel machine learning. Un bias elevato indica che il modello è troppo semplice e produce underfitting. Una varianza elevata indica che il modello è troppo complesso e produce overfitting.

La regolarizzazione controlla la complessità del modello penalizzando i coefficienti di grandi dimensioni. La regressione Ridge (L2) riduce i coefficienti verso zero ma li mantiene tutti. La regressione Lasso (L1) porta alcuni coefficienti esattamente a zero, eseguendo una selezione implicita delle feature. Elastic Net combina entrambi gli approcci.

# regularization_comparison.py
from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True)

models = {
    "Ridge (L2)":      make_pipeline(StandardScaler(), Ridge(alpha=1.0)),
    "Lasso (L1)":      make_pipeline(StandardScaler(), Lasso(alpha=0.1)),
    "ElasticNet (L1+L2)": make_pipeline(StandardScaler(), ElasticNet(alpha=0.1, l1_ratio=0.5)),
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring='r2')
    print(f"{name:25s}  R2: {scores.mean():.4f} +/- {scores.std():.4f}")

L'utilizzo di make_pipeline garantisce che lo StandardScaler venga applicato correttamente durante la cross-validazione, evitando la data leakage — un dettaglio che distingue un candidato esperto da uno inesperto.

Prepararsi alle Domande sugli Algoritmi ML nel 2026

La preparazione ai colloqui di machine learning nel 2026 va ben oltre la memorizzazione di formule. I team di selezione valutano tre dimensioni: comprensione teorica, implementazione pratica e capacità di giudizio.

Sulla comprensione teorica, il candidato deve essere in grado di spiegare perché un algoritmo funziona, non solo come si chiama. Per Random Forest, la risposta attesa non è "combina più alberi", ma "il bagging su campioni bootstrap riduce la varianza mantenendo il bias, mentre la randomizzazione delle feature alla suddivisione decorrela gli alberi". Questo livello di profondità è ciò che distingue i candidati selezionati.

Sull'implementazione pratica, i selezionatori richiedono spesso di scrivere codice in tempo reale. Saper impostare rapidamente una pipeline con StandardScaler, scegliere le metriche appropriate e interpretare i risultati senza supporto esterno è una competenza verificabile sul momento. I candidati che conoscono scikit-learn in modo fluente completano questo tipo di esercizio con sicurezza.

Sulla capacità di giudizio, le domande più discriminanti sono del tipo "quando non useresti questo algoritmo?". Per K-Means: quando i cluster hanno forme non sferiche o densità molto diverse. Per la regressione logistica: quando la relazione tra feature e target è altamente non lineare. Per il Gradient Boosting: quando il dataset ha meno di qualche centinaio di campioni e il rischio di overfitting è elevato. Articolare questi limiti con chiarezza segnala una maturità tecnica reale.

Una strategia di preparazione efficace prevede tre fasi. Prima fase: padronanza delle basi, implementando ogni algoritmo su dataset standard senza guardare la documentazione. Seconda fase: comprensione comparativa, costruendo tabelle di confronto personali su bias, varianza, scalabilità e interpretabilità per ogni famiglia di algoritmi. Terza fase: esposizione a scenari reali, analizzando casi aziendali pubblici in cui la scelta dell'algoritmo ha avuto un impatto misurabile sui risultati.

Conclusione

• I modelli lineari (regressione lineare, regressione logistica) costituiscono il fondamento su cui si costruisce ogni conoscenza successiva
• Gli alberi decisionali tendono all'overfitting da soli; Random Forest e Gradient Boosting risolvono questo problema attraverso bagging e boosting rispettivamente
• K-Means e PCA coprono le basi del non supervisionato, ma le feature devono sempre essere scalate prima dell'applicazione
• Le metriche di valutazione devono essere allineate al problema di business — l'accuratezza da sola non ha significato su dati sbilanciati
• La regolarizzazione controlla l'overfitting, ma funziona correttamente solo su feature standardizzate all'interno di una pipeline
• Il successo nei colloqui nel 2026 richiede di dimostrare la capacità di selezionare l'algoritmo giusto per il contesto, non soltanto di saperlo implementare