Scikit Learn - Alberi decisionali randomizzati

Questo capitolo ti aiuterà a comprendere gli alberi decisionali casuali in Sklearn.

Algoritmi di albero decisionale randomizzato

Poiché sappiamo che un DT viene solitamente addestrato suddividendo in modo ricorsivo i dati, ma essendo inclini all'overfit, sono stati trasformati in foreste casuali addestrando molti alberi su vari sottocampioni di dati. Ilsklearn.ensemble il modulo sta avendo i seguenti due algoritmi basati su alberi decisionali randomizzati:

L'algoritmo Random Forest

Per ogni caratteristica in esame, calcola la combinazione caratteristica / suddivisione ottimale a livello locale. Nella foresta casuale, ogni albero decisionale nell'insieme è costruito da un campione estratto con sostituzione dal set di addestramento e quindi ottiene la previsione da ciascuno di essi e infine seleziona la soluzione migliore mediante il voto. Può essere utilizzato sia per la classificazione che per le attività di regressione.

Classificazione con Random Forest

Per creare un classificatore di foresta casuale, il modulo Scikit-learn fornisce sklearn.ensemble.RandomForestClassifier. Durante la creazione di classificatori di foreste casuali, i parametri principali utilizzati da questo modulo sono‘max_features’ e ‘n_estimators’.

Qui, ‘max_features’è la dimensione dei sottoinsiemi casuali di funzionalità da considerare quando si divide un nodo. Se scegliamo il valore di questo parametro su nessuno, considererà tutte le caratteristiche piuttosto che un sottoinsieme casuale. D'altra parte,n_estimatorssono il numero di alberi nella foresta. Maggiore è il numero di alberi, migliore sarà il risultato. Ma ci vorrà anche più tempo per calcolare.

Esempio di implementazione

Nell'esempio seguente, stiamo creando un classificatore di foresta casuale utilizzando sklearn.ensemble.RandomForestClassifier e verificandone l'accuratezza anche utilizzando cross_val_score modulo.

from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_blobs
from sklearn.ensemble import RandomForestClassifier
X, y = make_blobs(n_samples = 10000, n_features = 10, centers = 100,random_state = 0) RFclf = RandomForestClassifier(n_estimators = 10,max_depth = None,min_samples_split = 2, random_state = 0)
scores = cross_val_score(RFclf, X, y, cv = 5)
scores.mean()

Produzione

0.9997

Esempio

Possiamo anche utilizzare il set di dati sklearn per creare un classificatore di foresta casuale. Come nell'esempio seguente, stiamo usando il set di dati iris. Troveremo anche il suo punteggio di accuratezza e la matrice di confusione.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

path = "https://archive.ics.uci.edu/ml/machine-learning-database
s/iris/iris.data"
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']
dataset = pd.read_csv(path, names = headernames)
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)
RFclf = RandomForestClassifier(n_estimators = 50)
RFclf.fit(X_train, y_train)
y_pred = RFclf.predict(X_test)
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Produzione

Confusion Matrix:
[[14 0 0]
[ 0 18 1]
[ 0 0 12]]
Classification Report:
                  precision recall f1-score support
Iris-setosa       1.00        1.00  1.00     14
Iris-versicolor   1.00        0.95  0.97     19
Iris-virginica    0.92        1.00  0.96     12

micro avg         0.98        0.98  0.98     45
macro avg         0.97        0.98  0.98     45
weighted avg      0.98        0.98  0.98     45

Accuracy: 0.9777777777777777

Regressione con foresta casuale

Per creare una regressione della foresta casuale, il modulo Scikit-learn fornisce sklearn.ensemble.RandomForestRegressor. Durante la creazione di un regressore forestale casuale, utilizzerà gli stessi parametri utilizzati dasklearn.ensemble.RandomForestClassifier.

Esempio di implementazione

Nell'esempio seguente, stiamo costruendo un regressore di foresta casuale utilizzando sklearn.ensemble.RandomForestregressor e anche prevedere nuovi valori utilizzando il metodo prediction ().

from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
X, y = make_regression(n_features = 10, n_informative = 2,random_state = 0, shuffle = False)
RFregr = RandomForestRegressor(max_depth = 10,random_state = 0,n_estimators = 100)
RFregr.fit(X, y)

Produzione

RandomForestRegressor(
   bootstrap = True, criterion = 'mse', max_depth = 10,
   max_features = 'auto', max_leaf_nodes = None,
   min_impurity_decrease = 0.0, min_impurity_split = None,
   min_samples_leaf = 1, min_samples_split = 2,
   min_weight_fraction_leaf = 0.0, n_estimators = 100, n_jobs = None,
   oob_score = False, random_state = 0, verbose = 0, warm_start = False
)

Una volta adattato, possiamo prevedere dal modello di regressione come segue:

print(RFregr.predict([[0, 2, 3, 0, 1, 1, 1, 1, 2, 2]]))

Produzione

[98.47729198]

Metodi extra-albero

Per ogni caratteristica in esame, seleziona un valore casuale per la divisione. Il vantaggio di utilizzare metodi albero aggiuntivi è che consente di ridurre un po 'di più la varianza del modello. Lo svantaggio dell'utilizzo di questi metodi è che aumenta leggermente il bias.

Classificazione con metodo Extra-Tree

Per creare un classificatore utilizzando il metodo Extra-tree, il modulo Scikit-learn fornisce sklearn.ensemble.ExtraTreesClassifier. Utilizza gli stessi parametri utilizzati dasklearn.ensemble.RandomForestClassifier. L'unica differenza è nel modo in cui, discusso sopra, costruiscono gli alberi.

Esempio di implementazione

Nell'esempio seguente, stiamo creando un classificatore di foresta casuale utilizzando sklearn.ensemble.ExtraTreeClassifier e anche verificandone l'accuratezza utilizzando cross_val_score modulo.

from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_blobs
from sklearn.ensemble import ExtraTreesClassifier
X, y = make_blobs(n_samples = 10000, n_features = 10, centers=100,random_state = 0)
ETclf = ExtraTreesClassifier(n_estimators = 10,max_depth = None,min_samples_split = 10, random_state = 0)
scores = cross_val_score(ETclf, X, y, cv = 5)
scores.mean()

Produzione

1.0

Esempio

Possiamo anche utilizzare il set di dati sklearn per creare un classificatore utilizzando il metodo Extra-Tree. Come nell'esempio seguente, stiamo utilizzando il set di dati Pima-Indian.

from pandas import read_csv

from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
seed = 7
kfold = KFold(n_splits=10, random_state=seed)
num_trees = 150
max_features = 5
ETclf = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)
results = cross_val_score(ETclf, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7551435406698566

Regressione con metodo Extra-Tree

Per creare un file Extra-Tree regressione, fornisce il modulo Scikit-learn sklearn.ensemble.ExtraTreesRegressor. Durante la creazione di un regressore forestale casuale, utilizzerà gli stessi parametri utilizzati dasklearn.ensemble.ExtraTreesClassifier.

Esempio di implementazione

Nell'esempio seguente, stiamo applicando sklearn.ensemble.ExtraTreesregressore sugli stessi dati che abbiamo usato durante la creazione di un regressore forestale casuale. Vediamo la differenza nell'output

from sklearn.ensemble import ExtraTreesRegressor
from sklearn.datasets import make_regression
X, y = make_regression(n_features = 10, n_informative = 2,random_state = 0, shuffle = False)
ETregr = ExtraTreesRegressor(max_depth = 10,random_state = 0,n_estimators = 100)
ETregr.fit(X, y)

Produzione

ExtraTreesRegressor(bootstrap = False, criterion = 'mse', max_depth = 10,
   max_features = 'auto', max_leaf_nodes = None,
   min_impurity_decrease = 0.0, min_impurity_split = None,
   min_samples_leaf = 1, min_samples_split = 2,
   min_weight_fraction_leaf = 0.0, n_estimators = 100, n_jobs = None,
   oob_score = False, random_state = 0, verbose = 0, warm_start = False)

Esempio

Una volta adattato, possiamo prevedere dal modello di regressione come segue:

print(ETregr.predict([[0, 2, 3, 0, 1, 1, 1, 1, 2, 2]]))

Produzione

[85.50955817]