Miglioramento delle prestazioni dei modelli ML

Miglioramento delle prestazioni con gli ensemble

Gli ensemble possono darci una spinta nel risultato dell'apprendimento automatico combinando diversi modelli. Fondamentalmente, i modelli di insieme sono costituiti da diversi modelli di apprendimento supervisionato addestrati individualmente ei loro risultati vengono uniti in vari modi per ottenere migliori prestazioni predittive rispetto a un singolo modello. I metodi dell'insieme possono essere suddivisi nei seguenti due gruppi:

Metodi sequenziali dell'insieme

Come suggerisce il nome, in questo tipo di metodi di insieme, gli studenti di base vengono generati in sequenza. La motivazione di tali metodi è sfruttare la dipendenza tra gli studenti di base.

Metodi di ensemble paralleli

Come suggerisce il nome, in questo tipo di metodi di insieme, gli studenti di base vengono generati in parallelo. La motivazione di tali metodi è sfruttare l'indipendenza tra gli studenti di base.

Metodi di apprendimento dell'insieme

I seguenti sono i metodi di apprendimento d'insieme più popolari, ovvero i metodi per combinare le previsioni da diversi modelli:

Insaccamento

Il termine bagging è anche noto come aggregazione bootstrap. Nei metodi di insaccamento, il modello di insieme cerca di migliorare l'accuratezza della previsione e ridurre la varianza del modello combinando previsioni di modelli individuali addestrati su campioni di addestramento generati casualmente. La previsione finale del modello d'insieme sarà data calcolando la media di tutte le previsioni dai singoli stimatori. Uno dei migliori esempi di metodi di insacco sono le foreste casuali.

Potenziamento

Nel metodo boosting, il principio principale della creazione di un modello di insieme è di costruirlo in modo incrementale addestrando ogni stimatore del modello di base in modo sequenziale. Come suggerisce il nome, fondamentalmente combina diversi studenti di base settimanale, addestrati in modo sequenziale su più iterazioni di dati di formazione, per creare un insieme potente. Durante la formazione degli studenti della base settimanale, vengono assegnati pesi più elevati a quegli studenti che erano stati classificati erroneamente in precedenza. L'esempio del metodo di potenziamento è AdaBoost.

Voto

In questo modello di apprendimento dell'insieme, vengono costruiti più modelli di diversi tipi e alcune semplici statistiche, come il calcolo della media o della mediana, ecc., Vengono utilizzate per combinare le previsioni. Questa previsione servirà come input aggiuntivo per la formazione per fare la previsione finale.

Algoritmi dell'insieme di insaccamento

I seguenti sono tre algoritmi di insiemi di insaccamento:

Albero decisionale in sacchi

Come sappiamo, i metodi dell'insieme di insaccamento funzionano bene con gli algoritmi che hanno un'elevata varianza e, a questo proposito, il migliore è l'algoritmo dell'albero decisionale. Nella seguente ricetta Python, costruiremo un modello di insieme dell'albero decisionale in sacchi utilizzando la funzione BaggingClassifier di sklearn con DecisionTreeClasifier (un algoritmo di classificazione e alberi di regressione) sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come abbiamo fatto negli esempi precedenti -

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]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 7
kfold = KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi -

num_trees = 150

Quindi, costruisci il modello con l'aiuto del seguente script:

model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7733766233766234

L'output sopra mostra che abbiamo ottenuto circa il 77% di precisione del nostro modello di classificatore dell'albero decisionale in sacchi.

Foresta casuale

È un'estensione degli alberi decisionali in sacchi. Per i classificatori individuali, i campioni del set di dati di addestramento vengono presi con la sostituzione, ma gli alberi sono costruiti in modo tale da ridurre la correlazione tra di loro. Inoltre, viene considerato un sottoinsieme casuale di caratteristiche per scegliere ogni punto di divisione piuttosto che scegliere avidamente il miglior punto di divisione nella costruzione di ogni albero.

Nella seguente ricetta Python, costruiremo un modello di insieme di foreste casuali in sacchi utilizzando la classe di sklearn RandomForestClassifier sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

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]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 150
max_features = 5

Quindi, costruisci il modello con l'aiuto del seguente script:

model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7629357484620642

L'output sopra mostra che abbiamo ottenuto circa il 76% di precisione del nostro modello di classificatore di foreste casuali in sacchi.

Alberi extra

È un'altra estensione del metodo dell'insieme dell'albero decisionale in sacchi. In questo metodo, gli alberi casuali vengono costruiti dai campioni del set di dati di addestramento.

Nella seguente ricetta Python, costruiremo un modello di insieme di alberi extra utilizzando la classe di sklearn ExtraTreesClassifier sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

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]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 150
max_features = 5

Quindi, costruisci il modello con l'aiuto del seguente script:

model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7551435406698566

L'output sopra mostra che abbiamo ottenuto circa il 75,5% di precisione del nostro modello di classificatore di alberi extra in sacchi.

Potenziamento degli algoritmi dell'insieme

I seguenti sono i due algoritmi di boosting ensemble più comuni:

AdaBoost

È uno degli algoritmi di potenziamento dell'insieme di maggior successo. La chiave principale di questo algoritmo è nel modo in cui danno i pesi alle istanze nel set di dati. Per questo motivo, l'algoritmo deve prestare meno attenzione alle istanze durante la costruzione dei modelli successivi.

Nella seguente ricetta Python, costruiremo un modello di insieme Ada Boost per la classificazione utilizzando la classe di sklearn AdaBoostClassifier sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

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]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 50

Quindi, costruisci il modello con l'aiuto del seguente script:

model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7539473684210527

L'output sopra mostra che abbiamo ottenuto circa il 75% di precisione del nostro modello di insieme di classificatori AdaBoost.

Aumento del gradiente stocastico

È anche chiamato Gradient Boosting Machines. Nella seguente ricetta Python, costruiremo il modello Stochastic Gradient Boostingensemble per la classificazione utilizzando la classe GradientBoostingClassifier di sklearn sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

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]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 50

Quindi, costruisci il modello con l'aiuto del seguente script:

model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7746582365003418

L'output sopra mostra che abbiamo ottenuto circa il 77,5% di accuratezza del nostro modello di ensemble classificatore Gradient Boosting.

Voting Ensemble Algorithms

Come discusso, la votazione crea prima due o più modelli autonomi dal set di dati di addestramento e quindi un classificatore di voto avvolgerà il modello insieme alla media delle previsioni del sottomodello ogni volta che saranno necessari nuovi dati.

Nella seguente ricetta Python, costruiremo un modello di ensemble di voto per la classificazione utilizzando la classe VotingClassifier di sklearn sul set di dati del diabete degli indiani Pima. Stiamo combinando le previsioni di regressione logistica, classificatore dell'albero decisionale e SVM insieme per un problema di classificazione come segue:

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

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]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

kfold = KFold(n_splits=10, random_state=7)

Successivamente, dobbiamo creare sottomodelli come segue:

estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))

Ora, crea il modello di insieme di voto combinando le previsioni dei sottomodelli creati sopra.

ensemble = VotingClassifier(estimators)
results = cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7382262474367738

L'output sopra mostra che abbiamo ottenuto circa il 74% di precisione del nostro modello di ensemble di classificatori di voto.