Was ist Ensemble-Lernen?

** Eine Technik, um mehrere Lernende zu kombinieren **, um bessere Vorhersagen zu erhalten. In den meisten Fällen erzielen Sie bessere Ergebnisse als wenn Sie nur ein einzelnes Modell verwenden.
Kombinieren Sie insbesondere die vorhergesagten Werte mehrerer Prädiktoren durch Verarbeitung wie ** "Durchschnittswert nehmen" ** oder ** "Mehrheitsentscheidung treffen" **.

――In den letzten Jahren sind ** "Boosting" und "Random Forest" **, die im Bereich der Datenanalyse Aufmerksamkeit erregt haben, auch eine Art Ensemble-Lernen.

Absacken

Es macht keinen Sinn, Modelle zu kombinieren, die mit demselben Algorithmus ** unter Verwendung derselben Daten ** trainiert wurden, selbst wenn Sie "mehrere Lernende (Prädiktoren) kombinieren" sagen.

Es gibt jedoch normalerweise nur eine Daten.

Dort verwende ich eine Technik namens ** "Boostrap" **.

** Bootrunde **… Zufällig (mit Duplizierung) werden n Daten aus den Trainingsdaten abgetastet.

Generieren Sie aus den Trainingsdaten N Bootstrap-Datensätze der Größe n.

Wenn N Vorhersagemodelle unter Verwendung dieser Daten erstellt werden, ist jeder Vorhersagewert yn (x).

Daher ist der endgültige vorhergesagte Wert des Modells unter Verwendung des Absackens wie folgt.

Stapeln

Für das zuvor erwähnte Absacken habe ich einen einfachen Durchschnitt von N vorhergesagten Werten berücksichtigt. Mit anderen Worten, die vorhergesagten Werte werden hier gleich bewertet, und ** die Wichtigkeit jedes Modells kann nicht berücksichtigt werden. ** **.

Beim Stapeln wird der ** gewichtete Durchschnitt ** jedes vorhergesagten Werts als endgültiger vorhergesagter Wert verwendet und die Wichtigkeit jedes Modells berücksichtigt.

Daher ist der endgültige vorhergesagte Wert

Pumpen

--Pumping ist eine Methode zur ** Suche nach dem am besten passenden Modell ** aus mehreren Prädiktoren.

Generieren Sie N Modelle mit dem Bootstrap-Datensatz, wenden Sie sie auf die ursprünglichen Trainingsdaten an und wählen Sie das Modell aus, das den Vorhersagefehler als bestes Modell minimiert.

――Es scheint auf den ersten Blick keinen Vorteil im Vergleich zum Absacken und Stapeln zu geben, aber ** Wenn eine unerwünschte Lösung mit Daten von schlechter Qualität erhalten wird, ist es besser, einen Bootstrap-Datensatz zu verwenden, der diese Daten ausschließt. Eine Lösung kann erhalten werden **.

Zufälliger Wald

Zufälliger Wald ist eine Methode, die den "Entscheidungsbaum" als Basislerner für das oben erwähnte "Absacken" verwendet. Der spezifische Algorithmus ist wie folgt (1) Extrahieren Sie N Bootstrap-Datensätze aus den Trainingsdaten. (2) Erzeugen Sie N Bäume Tn unter Verwendung dieser Daten.
Zu diesem Zeitpunkt werden nur m Merkmale zufällig aus p Merkmalen ausgewählt. (3) Nehmen Sie im Falle einer Regression einen ** Durchschnitt ** und im Falle einer Klassifizierung eine ** Mehrheitsentscheidung ** und verwenden Sie ihn als endgültigen vorhergesagten Wert.

Warum einen Entscheidungsbaum für den Basislerner verwenden?

Die Grundidee des Absackens besteht darin, Fehler zu reduzieren, indem mehrere Modelle mit großer Streuung und geringer Vorspannung kombiniert werden.

(1) Große Streuung / kleine Verzerrung → Komplexes Modell (Entscheidungsbaum, Methode des nächsten Nachbarn) (2) Kleine Streuung / große Verzerrung → Einfaches Modell (lineare Regression)

Der Entscheidungsbaum ist ein ideales Modell mit großer Streuung und geringer Verzerrung als Basislerner für das Absacken ** (Er kann durch Mittelung mehrerer Modelle korrigiert werden.) **
Andere Vorteile wie "hohe Geschwindigkeit", "unabhängig vom variablen Datentyp" und "unveränderlich für die Skalierung".

Warum nur einige Funktionen verwenden?

―― Beim Lernen im Ensemble ist die Genauigkeit des endgültigen vorhergesagten Werts umso höher, je geringer die Korrelation zwischen ** Modellen ist. ** **.

→ Es ist sinnlos, viele ähnliche Modelle zu sammeln, und die Leistung ist höher, wenn die mit unterschiedlichen Daten gelernten Modelle kombiniert werden.

Zusätzlich zu den Boost-Runden wird die Korrelation zwischen den Modellen verringert, indem die für das Training in jedem Modell verwendeten Variablen geändert werden.

Was steigert?

"Boosting" ist eine der Lernmethoden des Ensembles.
Trainieren Sie den Basisschüler ** nacheinander **. (Generieren Sie den nächsten Lernenden basierend auf dem vorherigen Lernenden.) Techniken wie Absacken und Stapeln kombinieren letztendlich mehrere Basislerner, um Vorhersagewerte zu erzeugen. (Es gibt keine Beziehung zwischen den vorderen und hinteren Lernenden)
** Zwei Methoden namens "Ada Boost" ** und ** "Gradient Boosting" ** sind typisch.
** Ein Algorithmus, der von einer Bibliothek namens "Xgboost" ** realisiert wurde, die in Kaggle sehr beliebt ist **.

Ada Boost

Ein gewichteter Datensatz ** wird für das Training jedes Lernenden verwendet.
Der vorherige Lernende misst den falsch klassifizierten Datenpunkten ** mehr Gewicht ** bei.
Geben Sie zuerst allen das gleiche Gewicht.
Die vorhergesagten Werte dieser Basislerner werden schließlich kombiniert, um den endgültigen vorhergesagten Wert zu erhalten.

Was ist Gradientenverstärkung?

Passen Sie zum ** "Rest" ** des vorherigen Lernenden.
Als Basislerner wird häufig ein "Entscheidungsbaum" verwendet. -Der von ** xgboost ** implementierte Algorithmus

Experiment ①

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons

moons=make_moons(n_samples=200,noise=0.2,random_state=0)

X=moons[0]
y=moons[1]

from matplotlib.colors import ListedColormap

def plot_decision_boundary(model,X,y):
    _x1 = np.linspace(X[:,0].min()-0.5,X[:,0].max()+0.5,100)
    _x2 = np.linspace(X[:,1].min()-0.5,X[:,1].max()+0.5,100)
    x1,x2 = np.meshgrid(_x1,_x2)
    X_new=np.c_[x1.ravel(),x2.ravel()]
    y_pred=model.predict(X_new).reshape(x1.shape)
    custom_cmap=ListedColormap(["mediumblue","orangered"])
    plt.contourf(x1,x2,y_pred,cmap=custom_cmap,alpha=0.3)
    
def plot_dataset(X,y):
    plt.plot(X[:,0][y==0],X[:,1][y==0],"bo",ms=15)
    plt.plot(X[:,0][y==1],X[:,1][y==1],"r^",ms=15)
    plt.xlabel("$x_1$",fontsize=30)
    plt.ylabel("$x_2$",fontsize=30,rotation=0)

plt.figure(figsize=(12,8))
plot_dataset(X,y)
plt.show()

Entscheidungsbaumanalyse

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier #(scikit-Bestimmt durch Learn Tree-Analyse(CART-Methode))

X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0)

tree_clf=DecisionTreeClassifier().fit(X_train,y_train) #Standardmäßig keine Obergrenze

plt.figure(figsize=(12,8))
plot_decision_boundary(tree_clf,X,y)
plot_dataset(X,y)
plt.show()

Zufälliger Wald

from sklearn.ensemble import RandomForestClassifier

random_forest=RandomForestClassifier(n_estimators=100,random_state=0).fit(X_train,y_train)
#Der Standardwert ist 10. Geben Sie die Anzahl der Entscheidungsbäume an, die zum Absacken verwendet werden.

plt.figure(figsize=(12,8))
plot_decision_boundary(random_forest,X,y)
plot_dataset(X,y)
plt.show()

Experiment ②

from sklearn.datasets import load_iris

iris=load_iris()
X_iris=iris.data
y_iris=iris.target

random_forest_iris=RandomForestClassifier(random_state=0).fit(X_iris,y_iris)

#Wie wichtig jedes Feature ist
random_forest_iris.feature_importances_

plt.figure(figsize=(12,8))
plt.barh(range(iris.data.shape[1]),random_forest_iris.feature_importances_,height=0.5)
plt.yticks(range(iris.data.shape[1]),iris.feature_names,fontsize=20)
plt.xlabel("Feature importance",fontsize=30)
plt.show()

Experiment ③

Der Datensatz verwendete die Titanic von Kaggle. https://www.kaggle.com/c/titanic

import pandas as pd

df=pd.read_csv("train.csv")
df["Age"]=df["Age"].fillna(df["Age"].mean())
df["Embarked"]=df["Embarked"].fillna(df["Embarked"].mode()[0])#Häufigster Wert

from sklearn.preprocessing import LabelEncoder

cat_features=["Sex","Embarked"]

for col in cat_features:
    lbl = LabelEncoder()
    df[col]=lbl.fit_transform(list(df[col].values))

X=df.drop(columns=["PassengerId","Survived","Name","Ticket","Cabin"])
y=df["Survived"]

X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0)

tree=DecisionTreeClassifier().fit(X_train,y_train)
print(tree.score(X_test,y_test))

rnd_forest=RandomForestClassifier(n_estimators=500,max_depth=5,random_state=0).fit(X_train,y_train)

print(rnd_forest.score(X_test,y_test))

Anmeldeformular (Ausgabe als submisson.csv)

#Anmeldeformular
test_df=pd.read_csv("test.csv")
test_df["Age"]=test_df["Age"].fillna(test_df["Age"].mean())
test_df["Fare"]=test_df["Fare"].fillna(test_df["Fare"].mean())
test_df["Embarked"]=test_df["Embarked"].fillna(test_df["Embarked"].mode()[0])#Häufigster Wert

for col in cat_features:
    lbl = LabelEncoder()
    test_df[col]=lbl.fit_transform(list(test_df[col].values))

X_pred=test_df.drop(columns=["PassengerId","Name","Ticket","Cabin"])
ID=test_df["PassengerId"]

prediction=rnd_forest.predict(X_pred)

submisson=pd.DataFrame({
    "PassengerId":ID,
    "Survived":prediction
})

submisson.to_csv("submisson.csv",index=False)

[PYTHON] Was ist Ensemble-Lernen?

Was ist Ensemble-Lernen?

Absacken

Stapeln

Pumpen

Zufälliger Wald

Warum einen Entscheidungsbaum für den Basislerner verwenden?

Warum nur einige Funktionen verwenden?

Was steigert?

Ada Boost

Was ist Gradientenverstärkung?

Experiment ①

Entscheidungsbaumanalyse

Zufälliger Wald

Experiment ②

Experiment ③

Anmeldeformular (Ausgabe als submisson.csv)