Per Iniziare

Per Iniziare con il Machine Learning in Python

Questo capitolo introduce il machine learning con Python. Imparerai cos'è il machine learning, perché Python è il linguaggio dominante in questo campo, come configurare un ambiente di lavoro e come si articola il flusso di lavoro ML end-to-end — dai dati grezzi a un modello addestrato e valutato.

Al termine avrai eseguito un esempio completo di classificazione utilizzando le tre librerie principali: NumPy, pandas e scikit-learn.

Cos'è il Machine Learning?

Il machine learning (ML) è un ramo dell'intelligenza artificiale in cui un programma apprende i pattern dai dati anziché seguire regole scritte a mano. Fornisci degli esempi (i dati), specifichi cosa vuoi predire o scoprire, e un algoritmo ML elabora la mappatura corrispondente.

Esistono tre grandi categorie:

Questa serie si concentra sull'apprendimento supervisionato perché è la categoria più utilizzata nella pratica.

Perché Python per il Machine Learning?

Python è diventato il linguaggio predefinito per ML per diversi motivi:

• Sintassi leggibile — gli algoritmi possono essere prototipati rapidamente senza codice ripetitivo.
• Ecosistema ricco — scikit-learn, TensorFlow, PyTorch e Keras hanno tutti API Python di prima classe.
• Strumenti per i dati — NumPy e pandas rendono la manipolazione dei dati semplice.
• Community — la più grande community ML, che significa abbondanza di tutorial, risposte su Stack Overflow e modelli pre-addestrati.

Configurare l'Ambiente

Installare Python

Scarica Python 3.10 o versione successiva da python.org. Verifica l'installazione:

python3 --version

Dovresti vedere un output come Python 3.10.15 (o versione più recente).

Creare un Ambiente Virtuale

Un ambiente virtuale isola i pacchetti del tuo progetto dall'installazione Python di sistema. Questo previene conflitti di versione tra i progetti.

python3 -m venv ml-env

Attivalo:

# macOS / Linux
source ml-env/bin/activate

# Windows (Command Prompt)
ml-env\Scripts\activate.bat

Il tuo prompt mostrerà ora (ml-env) per confermare che l'ambiente è attivo.

Installare le Librerie Principali

Con l'ambiente virtuale attivo, installa le tre librerie che utilizzerai in tutta questa serie:

pip install numpy pandas scikit-learn

Salva le versioni esatte per la riproducibilità:

pip freeze > requirements.txt

Chiunque cloni il tuo progetto potrà riprodurre il tuo ambiente con pip install -r requirements.txt.

Il Flusso di Lavoro del Machine Learning

Ogni progetto ML supervisionato segue la stessa pipeline in cinque fasi:

Raw data → Clean & prepare → Split → Train model → Evaluate

Comprendere questa pipeline è più importante che memorizzare un singolo algoritmo. Le sezioni seguenti illustrano ogni fase con del codice.

Fase 1 — Comprendere i Dati con NumPy e pandas

Prima di addestrare qualsiasi cosa è necessario sapere com'è fatto il tuo dataset. NumPy fornisce operazioni aritmetiche veloci su array; pandas aggiunge tabelle con etichette (DataFrame) che rendono semplice l'esplorazione.

NumPy: ispezione di un array numerico

import numpy as np

data = np.array([2.1, 3.4, 1.8, 5.0, 2.7])
print('Mean:', data.mean())   # 3.0
print('Std: ', round(data.std(), 4))  # 1.1402
print('Max: ', data.max())    # 5.0

pandas: costruire un piccolo dataset

import pandas as pd

df = pd.DataFrame({
    'age':    [25, 30, 22, 35, 28],
    'income': [40000, 55000, 32000, 70000, 48000],
    'bought': [0,     1,     0,     1,     0],
})

print(df.shape)             # (5, 3)
print(df['income'].mean())  # 49000.0
print(df.isnull().sum())    # 0 missing values in each column

df.shape indica il numero di righe e colonne. isnull().sum() conta i valori mancanti per colonna — verificalo sempre prima di modellare.

Fase 2 — Pulire e Preparare i Dati

I dataset reali hanno quasi sempre valori mancanti, formati inconsistenti o feature su scale molto diverse. È necessario affrontare questi problemi prima dell'addestramento.

Gestire i Valori Mancanti

Sostituisci i numeri mancanti con la mediana della colonna (robusta agli outlier) o con la media:

import pandas as pd

df = pd.DataFrame({
    'age':    [25, None, 22, 35, 28],
    'income': [40000, 55000, None, 70000, 48000],
})

df['age']    = df['age'].fillna(df['age'].median())
df['income'] = df['income'].fillna(df['income'].mean())

print(df.isnull().sum())
# age       0
# income    0

Scalare le Feature

Molti algoritmi (k-nearest neighbours, SVM, reti neurali) sono sensibili alla scala delle feature. Una colonna con valori nell'ordine delle migliaia dominerà una colonna con valori singoli se non le normalizzi. StandardScaler sottrae la media e divide per la deviazione standard, così ogni feature avrà media 0 e deviazione standard 1:

from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[1.0, 200.0], [2.0, 400.0], [3.0, 300.0]])
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
print(X_scaled.round(2))
# [[-1.22 -1.22]
#  [ 0.    1.22]
#  [ 1.22  0.  ]]

Consulta Feature Scaling per maggiori dettagli.

Fase 3 — Dividere in Set di Addestramento e Test

Non valutare mai un modello sui dati su cui è stato addestrato — sarebbe come correggere il proprio esame con il foglio delle risposte aperto. Dividi i dati in modo che il modello si addestri su una parte e venga valutato su una parte separata che non ha mai visto.

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. random_state=42 rende la divisione riproducibile. Consulta il capitolo Train/Test Split per strategie come la divisione stratificata e la cross-validation.

Fase 4 — Addestrare un Modello

Con dati puliti e divisi puoi addestrare il tuo primo modello. L'esempio seguente usa il dataset Iris — un classico benchmark con 150 campioni, 4 feature numeriche e 3 specie di fiori da classificare.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 1. Load
iris = load_iris()

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# 3. Train
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 4. Predict & evaluate
predictions = model.predict(X_test)
print(f'Test samples: {len(X_test)}')   # 30
print(f'Accuracy: {accuracy_score(y_test, predictions):.2f}')  # 1.00

Un RandomForestClassifier addestra molti alberi decisionali su sottoinsiemi casuali dei dati e combina i loro voti. Gestisce bene le relazioni non lineari ed è un'ottima baseline per i compiti di classificazione. n_estimators=100 specifica il numero di alberi.

Fase 5 — Valutare il Modello

L'accuracy (la proporzione di predizioni corrette) è facile da comprendere ma può essere fuorviante quando una classe è molto più rara delle altre. scikit-learn fornisce una suite completa di metriche:

Per un'analisi più approfondita della valutazione, consulta il capitolo Confusion Matrix.

Scegliere l'Algoritmo Giusto

Problemi diversi richiedono algoritmi diversi. Ecco un orientamento rapido:

Esplorerai la maggior parte di questi nel resto di questa serie. Buoni punti di partenza sono K-Nearest Neighbors, Decision Tree e Linear Regression.

Errori Comuni per i Principianti

• Data leakage — addestrare lo scaler sull'intero dataset (prima della divisione) fa trapelare le statistiche del set di test nell'addestramento. Addestra sempre i trasformatori solo sul set di addestramento, poi applicali al set di test.
• Overfitting — un modello che memorizza i dati di addestramento funziona male sui nuovi dati. Usa la Cross-Validation per rilevarlo precocemente.
• Ignorare lo sbilanciamento delle classi — se il 95% delle etichette è "negativo", un modello che predice sempre "negativo" ottiene il 95% di accuracy ma è inutile. Controlla la distribuzione delle classi prima di scegliere una metrica.
• Saltare l'esplorazione — guarda sempre i tuoi dati prima di modellare. Controlla intervalli, distribuzioni e conteggi di valori mancanti.

Conclusione

Ora disponi di un ambiente Python ML funzionante e comprendi l'intera pipeline di apprendimento supervisionato: caricare i dati, pulirli, dividerli, addestrare un modello e valutarlo su dati separati. I capitoli successivi approfondiscono ogni fase — a partire dalla preparazione dei dati, passando attraverso i singoli algoritmi e concludendo con argomenti avanzati come la cross-validation e il tuning degli iperparametri.