Qu'est-ce que l'apprentissage d'ensemble?

** Une technique pour combiner plusieurs apprenants ** pour obtenir de meilleures prédictions. Dans la plupart des cas, vous obtiendrez de meilleurs résultats que d'utiliser un seul modèle seul.
En particulier, combinez les valeurs prédites de plusieurs prédicteurs en traitant comme ** "prendre la valeur moyenne" ** ou ** "prendre la décision majoritaire" **.

―― Ces dernières années, ** «boosting» et «random forest» **, qui ont attiré l'attention dans le domaine de l'analyse des données, sont également un type d'apprentissage d'ensemble.

Ensachage

Il ne sert à rien de combiner des modèles entraînés avec le même algorithme ** en utilisant les mêmes données ** même si vous dites «combiner plusieurs apprenants (prédicteurs)».

Cependant, il n'y a généralement qu'une seule donnée.

Là, j'utilise une technique appelée ** "boostrap" **.

** Boot lap **… Échantillonnage aléatoire de n données (avec duplication) à partir des données d'entraînement.

Générez N ensembles de données bootstrap de taille n à partir des données d'entraînement.

Lorsque N modèles de prédiction sont créés à l'aide de ces données, chaque valeur de prédiction est yn (x).

Par conséquent, la valeur finale prévue du modèle utilisant l'ensachage est la suivante.

Empilement

Pour l'ensachage que j'ai mentionné plus tôt, j'ai considéré une simple moyenne de N valeurs prédites. En d'autres termes, les valeurs prédites ici sont évaluées de manière égale, et ** l'importance de chaque modèle ne peut pas être prise en compte. ** **

Pour l'empilement, la ** moyenne pondérée ** de chaque valeur prédite est utilisée comme valeur prédite finale, et l'importance de chaque modèle est prise en considération.

Par conséquent, la valeur finale prévue est

pompage

Le pompage est une méthode pour ** rechercher le meilleur modèle d'ajustement ** à partir de plusieurs prédicteurs.

--Générer N modèles à l'aide de l'ensemble de données bootstrap, les appliquer aux données d'entraînement d'origine et sélectionner le modèle qui minimise l'erreur de prédiction comme meilleur modèle.

――Il semble qu'il n'y ait aucun mérite à première vue par rapport à l'ensachage et à l'empilage, mais ** Lorsqu'une solution indésirable est obtenue à l'aide de données de mauvaise qualité, il est préférable d'utiliser un ensemble de données bootstrap excluant ces données. Une solution peut être obtenue **.

Forêt aléatoire

-La forêt aléatoire est une méthode qui utilise «l'arbre de décision» comme apprenant de base pour le «bagging» mentionné ci-dessus. L'algorithme spécifique est le suivant (1) Extraire N ensembles de données bootstrap à partir des données d'entraînement. (2) Générer N arbres Tn à partir de ces données.

À ce stade, seules m entités sont sélectionnées au hasard parmi p entités. (3) Prendre la ** moyenne ** dans le cas de la régression et la ** décision à la majorité ** dans le cas de la classification et l'utiliser comme valeur prédite finale.

Pourquoi utiliser un arbre de décision pour l'apprenant de base?

―― L'idée de base de l'ensachage est de réduire les erreurs en combinant plusieurs modèles avec une grande dispersion et un petit biais.

(1) Grande dispersion / petit biais → Modèle complexe (arbre de décision, méthode du plus proche voisin) (2) Petite dispersion / grand biais → Modèle simple (régression linéaire)

--L'arbre de décision est un modèle idéal avec une grande dispersion et un faible biais en tant qu'apprenant de base pour l'ensachage ** (Il peut être corrigé en faisant la moyenne de plusieurs modèles.) **

D'autres mérites tels que "haute vitesse", "quel que soit le type de données variable" et "invariant à la mise à l'échelle".

Pourquoi n'utiliser que certaines fonctionnalités?

―― Dans l'apprentissage d'ensemble, plus la corrélation entre les modèles ** est faible, plus la précision de la valeur prédite finale est élevée. ** **

→ Il est inutile de collecter de nombreux modèles similaires, et les performances sont plus élevées lorsque les modèles appris avec des données différentes sont combinés.

--En plus du tour de démarrage, la corrélation entre les modèles est abaissée en modifiant les variables utilisées pour la formation dans chaque modèle.

Qu'est-ce que le boosting?

"Boosting" est l'une des méthodes d'apprentissage d'ensemble.
Former l'apprenant de base ** séquentiellement **. (Générer l'apprenant suivant en fonction de l'apprenant précédent) Des techniques telles que l'ensachage et l'empilement combinent en fin de compte plusieurs apprenants de base pour produire des valeurs prédictives. (Il n'y a pas de relation entre les apprenants avant et arrière)
** Deux méthodes appelées "Ada Boost" ** et ** "gradient boosting" ** sont typiques.
** Un algorithme réalisé par une bibliothèque appelée "Xgboost" **, qui est assez populaire dans Kaggle **.

Ada Boost

--Un ensemble de données pondérées ** est utilisé dans la formation de chaque apprenant.

L'apprenant précédent donne ** plus de poids ** aux points de données mal classés.
Dans un premier temps, accordez un poids égal à tous.
Les valeurs prédites de ces apprenants de base sont finalement combinées pour obtenir la valeur prédite finale.

Qu'est-ce que le boosting de gradient?

Ajuster au ** «résiduel» ** de l'apprenant précédent.
En tant qu'apprenant de base, un «arbre de décision» est souvent utilisé. -L'algorithme implémenté par ** xgboost **

Expérience ①

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()

Analyse d'arbre de décision

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier #(scikit-Déterminé par l'analyse de l'arbre d'apprentissage(Méthode CART))

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

tree_clf=DecisionTreeClassifier().fit(X_train,y_train) #par défaut pas de limite supérieure

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

Forêt aléatoire

from sklearn.ensemble import RandomForestClassifier

random_forest=RandomForestClassifier(n_estimators=100,random_state=0).fit(X_train,y_train)
#La valeur par défaut est 10. Spécifiez le nombre d'arbres de décision utilisés pour l'ensachage.

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

Expérience ②

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)

#Quelle est l'importance de chaque fonctionnalité
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()

Expérience ③

L'ensemble de données utilisait le Titanic de 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])#Valeur la plus fréquente

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))

Formulaire de soumission (sortie comme submisson.csv)

#Formulaire de soumission
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])#Valeur la plus fréquente

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)