Foreste casuali

Le foreste casuali sono un tipo di algoritmo di machine learning che sfrutta il concetto di ensemble learning, ovvero l'aggregazione di più modelli per migliorare le prestazioni predittive.

Le foreste casuali sono un modello di apprendimento automatico supervisionato.
Questo significa che richiedono un insieme di dati di addestramento etichettati, dove ogni esempio nel set di addestramento è associato a una risposta nota o a un valore target. Le foreste casuali utilizzano questi dati di addestramento per imparare a fare previsioni su nuovi dati non etichettati.

Ecco le principali differenze con gli alberi decisionali e quando è consigliabile utilizzare le foreste casuali:

Differenze tra Foreste Casuali e Alberi Decisionali

• Complessità del Modello: Gli alberi decisionali tendono ad avere una maggiore complessità, il che li rende soggetti all'overfitting, mentre le foreste casuali aggregano diversi alberi decisionali per ridurre l'overfitting.
• Processo di Addestramento: Gli alberi decisionali vengono addestrati su tutto il dataset, mentre le foreste casuali vengono addestrate su sottoinsiemi casuali del dataset, garantendo una maggiore varietà nei modelli.
• Stabilità: Le foreste casuali sono generalmente più stabili e meno sensibili ai piccoli cambiamenti nel dataset rispetto agli alberi decisionali.

Quando Usare le Foreste Casuali

• Le foreste casuali sono particolarmente utili quando si desidera migliorare le prestazioni predittive di un modello senza dover ottimizzare troppo i parametri dell'albero decisionale.
• Sono adatte per una vasta gamma di problemi di classificazione e regressione e spesso producono risultati più robusti rispetto agli alberi decisionali singoli.

Confronto tra i metodi

Di seguito sono riportati due esempi distinti, uno utilizzando un albero decisionale e l'altro una foresta casuale, con la convalida incrociata a 5 fold per valutare le prestazioni dei modelli e calcolare l'errore medio RMSE per ciascuna profondità dell'albero.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

# Caricamento del dataset Iris
iris = load_iris()
X = iris.data
y = iris.target

# Definizione del range di profondità dell'albero
depth_range = range(1, 22)

# Lista per salvare l'errore medio RMSE per ciascuna profondità
decision_tree_rmse = []
random_forest_rmse = []

# Calcolo dell'errore medio RMSE per ogni profondità dell'albero decisionale e della foresta casuale
for depth in depth_range:
    # Albero decisionale
    dt = DecisionTreeRegressor(max_depth=depth, random_state=42)
    dt_scores = cross_val_score(dt, X, y, cv=5, scoring='neg_mean_squared_error')
    dt_rmse = np.sqrt(-dt_scores.mean())
    decision_tree_rmse.append(dt_rmse)

    # Foresta casuale
    rf = RandomForestRegressor(max_depth=depth, n_estimators=100, random_state=42)
    rf_scores = cross_val_score(rf, X, y, cv=5, scoring='neg_mean_squared_error')
    rf_rmse = np.sqrt(-rf_scores.mean())
    random_forest_rmse.append(rf_rmse)

# Plot dell'errore medio RMSE per ogni profondità dell'albero decisionale e della foresta casuale
plt.figure(figsize=(10, 6))
plt.plot(depth_range, decision_tree_rmse, label='Albero Decisionale', marker='o')
plt.plot(depth_range, random_forest_rmse, label='Foresta Casuale', marker='o')
plt.xlabel('Profondità dell\'Albero')
plt.ylabel('RMSE Medio')
plt.title('RMSE Medio in Funzione della Profondità dell\'Albero')
plt.legend()
plt.grid(True)
plt.show()

Questo codice calcola l'errore medio RMSE per ogni profondità dell'albero decisionale e della foresta casuale utilizzando la convalida incrociata a 5 fold.
Visualizza i risultati in un grafico.

Importanza delle caratteristiche

Ecco del codice utilizza il dataset Iris, addestra un modello di foreste casuali su di esso e quindi calcola l'importanza delle caratteristiche.
Infine, mostra un grafico che rappresenta l'importanza delle caratteristiche nel modello addestrato.

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import numpy as np
import matplotlib.pyplot as plt

# Carica il dataset Iris
iris = load_iris()
X = iris.data
y = iris.target

# Crea il modello di foreste casuali
forest = RandomForestClassifier(n_estimators=100, random_state=42)
forest.fit(X, y)

# Calcola l'importanza delle caratteristiche
importances = forest.feature_importances_

# Ordina le caratteristiche per importanza
sorted_indices = np.argsort(importances)[::-1]

# Visualizza l'importanza delle caratteristiche
plt.figure(figsize=(10, 5))
plt.title("Feature Importance")
plt.bar(range(X.shape[1]), importances[sorted_indices], align="center")
plt.xticks(range(X.shape[1]), np.array(iris.feature_names)[sorted_indices], rotation=90)
plt.xlabel("Feature")
plt.ylabel("Importance")
plt.show()