Verbesserung der Leistung von ML-Modellen

Leistungsverbesserung mit Ensembles

Ensembles können das Ergebnis des maschinellen Lernens verbessern, indem sie mehrere Modelle kombinieren. Grundsätzlich bestehen Ensemblemodelle aus mehreren individuell trainierten überwachten Lernmodellen, und ihre Ergebnisse werden auf verschiedene Weise zusammengeführt, um eine bessere Vorhersageleistung im Vergleich zu einem einzelnen Modell zu erzielen. Ensemble-Methoden können in folgende zwei Gruppen unterteilt werden:

Sequentielle Ensemble-Methoden

Wie der Name schon sagt, werden bei solchen Ensemble-Methoden die Basislerner nacheinander generiert. Die Motivation solcher Methoden besteht darin, die Abhängigkeit zwischen Basislernenden auszunutzen.

Parallele Ensemblemethoden

Wie der Name schon sagt, werden bei solchen Ensemble-Methoden die Basislerner parallel generiert. Die Motivation solcher Methoden besteht darin, die Unabhängigkeit unter den Basislernenden auszunutzen.

Ensemble-Lernmethoden

Das Folgende sind die beliebtesten Ensemble-Lernmethoden, dh die Methoden zum Kombinieren der Vorhersagen aus verschiedenen Modellen -

Absacken

Der Begriff Bagging wird auch als Bootstrap-Aggregation bezeichnet. Bei Absackmethoden versucht das Ensemble-Modell, die Vorhersagegenauigkeit zu verbessern und die Modellvarianz zu verringern, indem Vorhersagen einzelner Modelle kombiniert werden, die über zufällig generierte Trainingsmuster trainiert wurden. Die endgültige Vorhersage des Ensemblemodells erfolgt durch Berechnung des Durchschnitts aller Vorhersagen aus den einzelnen Schätzern. Eines der besten Beispiele für Absackmethoden sind zufällige Wälder.

Erhöhen

Bei der Boosting-Methode besteht das Hauptprinzip beim Erstellen eines Ensemble-Modells darin, es schrittweise zu erstellen, indem jeder Basismodellschätzer nacheinander trainiert wird. Wie der Name schon sagt, kombiniert es im Grunde mehrere Wochenbasis-Lernende, die nacheinander über mehrere Iterationen von Trainingsdaten trainiert werden, um ein leistungsstarkes Ensemble aufzubauen. Während des Trainings von Wochenbasislernern werden den zuvor falsch klassifizierten Lernenden höhere Gewichte zugewiesen. Das Beispiel für eine Boosting-Methode ist AdaBoost.

Wählen

In diesem Ensemble-Lernmodell werden mehrere Modelle unterschiedlicher Typen erstellt und einige einfache Statistiken wie die Berechnung des Mittelwerts oder Medians usw. verwendet, um die Vorhersagen zu kombinieren. Diese Vorhersage dient als zusätzliche Eingabe für das Training, um die endgültige Vorhersage zu treffen.

Bagging Ensemble-Algorithmen

Das Folgende sind drei Bagging-Ensemble-Algorithmen -

Eingesackter Entscheidungsbaum

Wie wir wissen, funktionieren Bagging-Ensemble-Methoden gut mit Algorithmen mit hoher Varianz, und in diesem Zusammenhang ist der Entscheidungsbaum-Algorithmus der beste. Im folgenden Python-Rezept werden wir ein Bagged Decision Tree Ensemble-Modell erstellen, indem wir die BaggingClassifier-Funktion von sklearn mit DecisionTreeClasifier (einem Algorithmus für Klassifizierungs- und Regressionsbäume) für den Diabetes-Datensatz von Pima Indians verwenden.

Importieren Sie zunächst die erforderlichen Pakete wie folgt:

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

Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -

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]

Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:

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

Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume -

num_trees = 150

Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:

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

Berechnen und drucken Sie das Ergebnis wie folgt:

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

Ausgabe

0.7733766233766234

Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 77% unseres Bagged Decision Tree Classifier-Modells erhalten haben.

Zufälliger Wald

Es ist eine Erweiterung von eingesackten Entscheidungsbäumen. Für einzelne Klassifikatoren werden die Stichproben des Trainingsdatensatzes mit Ersatz entnommen, aber die Bäume sind so konstruiert, dass die Korrelation zwischen ihnen verringert wird. Außerdem wird eine zufällige Teilmenge von Merkmalen berücksichtigt, um jeden Teilungspunkt auszuwählen, anstatt gierig den besten Teilungspunkt bei der Konstruktion jedes Baums auszuwählen.

Im folgenden Python-Rezept werden wir ein Modell eines zufälligen Waldensembles in Säcken erstellen, indem wir die RandomForestClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima Indians verwenden.

Importieren Sie zunächst die erforderlichen Pakete wie folgt:

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

Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -

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]

Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:

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

Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -

num_trees = 150
max_features = 5

Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:

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

Berechnen und drucken Sie das Ergebnis wie folgt:

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

Ausgabe

0.7629357484620642

Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 76% unseres eingesackten zufälligen Waldklassifikatormodells erhalten haben.

Zusätzliche Bäume

Es ist eine weitere Erweiterung der Methode des Bagged Decision Tree Ensembles. Bei dieser Methode werden die Zufallsbäume aus den Stichproben des Trainingsdatensatzes erstellt.

Im folgenden Python-Rezept werden wir ein zusätzliches Baumensemble-Modell erstellen, indem wir die ExtraTreesClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima Indians verwenden.

Importieren Sie zunächst die erforderlichen Pakete wie folgt:

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

Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -

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]

Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:

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

Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -

num_trees = 150
max_features = 5

Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:

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

Berechnen und drucken Sie das Ergebnis wie folgt:

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

Ausgabe

0.7551435406698566

Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 75,5% für unser klassifiziertes Modell mit zusätzlichen Bäumen erhalten haben.

Boosten von Ensemble-Algorithmen

Das Folgende sind die beiden am häufigsten verwendeten Boosting-Ensemble-Algorithmen:

AdaBoost

Es ist einer der erfolgreichsten Boosting-Ensemble-Algorithmen. Der Hauptschlüssel dieses Algorithmus liegt in der Art und Weise, wie die Instanzen im Datensatz gewichtet werden. Aus diesem Grund muss der Algorithmus beim Erstellen nachfolgender Modelle den Instanzen weniger Aufmerksamkeit schenken.

Im folgenden Python-Rezept erstellen wir ein Ada Boost-Ensemble-Modell für die Klassifizierung unter Verwendung der AdaBoostClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima Indians.

Importieren Sie zunächst die erforderlichen Pakete wie folgt:

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

Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -

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]

Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:

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

Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -

num_trees = 50

Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:

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

Berechnen und drucken Sie das Ergebnis wie folgt:

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

Ausgabe

0.7539473684210527

Die obige Ausgabe zeigt, dass wir eine Genauigkeit von ca. 75% unseres AdaBoost-Klassifikator-Ensemble-Modells erhalten haben.

Stochastische Gradientenverstärkung

Es wird auch als Gradientenverstärkungsmaschine bezeichnet. Im folgenden Python-Rezept erstellen wir ein stochastisches Gradienten-Boostingensemble-Modell für die Klassifizierung unter Verwendung der GradientBoostingClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima-Indianern.

Importieren Sie zunächst die erforderlichen Pakete wie folgt:

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

Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -

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]

Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:

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

Wir müssen die Anzahl der Bäume angeben, die wir bauen werden. Hier bauen wir 150 Bäume mit Teilungspunkten, die aus 5 Merkmalen ausgewählt wurden -

num_trees = 50

Erstellen Sie als Nächstes das Modell mithilfe des folgenden Skripts:

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

Berechnen und drucken Sie das Ergebnis wie folgt:

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

Ausgabe

0.7746582365003418

Die obige Ausgabe zeigt, dass wir mit unserem Gradienten-Boosting-Klassifikator-Ensemble-Modell eine Genauigkeit von ca. 77,5% erreicht haben.

Voting Ensemble-Algorithmen

Wie bereits erwähnt, werden bei der Abstimmung zunächst zwei oder mehr eigenständige Modelle aus dem Trainingsdatensatz erstellt. Anschließend wird das Modell von einem Abstimmungsklassifizierer umschlossen und der Durchschnitt der Vorhersagen des Untermodells ermittelt, wann immer neue Daten benötigt werden.

Im folgenden Python-Rezept erstellen wir ein Voting-Ensemble-Modell für die Klassifizierung unter Verwendung der VotingClassifier-Klasse von sklearn für den Diabetes-Datensatz von Pima Indians. Wir kombinieren die Vorhersagen der logistischen Regression, des Entscheidungsbaumklassifikators und der SVM für ein Klassifizierungsproblem wie folgt:

Importieren Sie zunächst die erforderlichen Pakete wie folgt:

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

Jetzt müssen wir den Pima-Diabetes-Datensatz wie in den vorherigen Beispielen laden -

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]

Geben Sie als Nächstes die Eingabe für die 10-fache Kreuzvalidierung wie folgt ein:

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

Als nächstes müssen wir Untermodelle wie folgt erstellen:

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

Erstellen Sie nun das Voting-Ensemble-Modell, indem Sie die Vorhersagen der oben erstellten Untermodelle kombinieren.

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

Ausgabe

0.7382262474367738

Die obige Ausgabe zeigt, dass wir eine Genauigkeit von rund 74% unseres Voting-Klassifikator-Ensemble-Modells haben.