Amélioration des performances des modèles ML

Amélioration des performances avec des ensembles

Les ensembles peuvent nous donner un coup de pouce dans le résultat de l'apprentissage automatique en combinant plusieurs modèles. Fondamentalement, les modèles d'ensemble se composent de plusieurs modèles d'apprentissage supervisé formés individuellement et leurs résultats sont fusionnés de diverses manières pour obtenir de meilleures performances prédictives par rapport à un modèle unique. Les méthodes d'ensemble peuvent être divisées en deux groupes suivants -

Méthodes d'ensemble séquentielles

Comme son nom l'indique, dans ce type de méthodes d'ensemble, les apprenants de base sont générés séquentiellement. La motivation de telles méthodes est d'exploiter la dépendance parmi les apprenants de base.

Méthodes d'ensemble parallèles

Comme son nom l'indique, dans ce type de méthodes d'ensemble, les apprenants de base sont générés en parallèle. La motivation de telles méthodes est d'exploiter l'indépendance des apprenants de base.

Méthodes d'apprentissage d'ensemble

Voici les méthodes d'apprentissage d'ensemble les plus populaires, c'est-à-dire les méthodes pour combiner les prédictions de différents modèles -

Ensachage

Le terme ensachage est également connu sous le nom d'agrégation bootstrap. Dans les méthodes d'ensachage, le modèle d'ensemble tente d'améliorer la précision de la prédiction et de réduire la variance du modèle en combinant les prédictions de modèles individuels entraînés sur des échantillons d'apprentissage générés aléatoirement. La prédiction finale du modèle d'ensemble sera donnée en calculant la moyenne de toutes les prédictions à partir des estimateurs individuels. Les forêts aléatoires sont l'un des meilleurs exemples de méthodes d'ensachage.

Booster

Dans la méthode d'amplification, le principe principal de la construction d'un modèle d'ensemble est de le construire de manière incrémentielle en entraînant chaque estimateur de modèle de base séquentiellement. Comme son nom l'indique, il combine essentiellement plusieurs apprenants de base d'une semaine, formés séquentiellement sur plusieurs itérations de données d'entraînement, pour créer un ensemble puissant. Au cours de la formation des apprenants de base hebdomadaire, des poids plus élevés sont attribués aux apprenants qui ont été mal classés auparavant. L'exemple de méthode de boosting est AdaBoost.

Vote

Dans ce modèle d'apprentissage d'ensemble, plusieurs modèles de différents types sont construits et quelques statistiques simples, comme le calcul de la moyenne ou de la médiane, etc., sont utilisées pour combiner les prédictions. Cette prédiction servira d'entrée supplémentaire pour l'entraînement pour faire la prédiction finale.

Algorithmes d'ensemble d'ensachage

Voici trois algorithmes d'ensemble d'ensachage -

Arbre de décision en sac

Comme nous savons que les méthodes d'ensemble de bagging fonctionnent bien avec les algorithmes qui ont une variance élevée et, dans ce cas, le meilleur est l'algorithme d'arbre de décision. Dans la recette Python suivante, nous allons créer un modèle d'ensemble d'arbre de décision en sac en utilisant la fonction BaggingClassifier de sklearn avec DecisionTreeClasifier (un algorithme d'arbres de classification et de régression) sur l'ensemble de données sur le diabète des Indiens Pima.

Tout d'abord, importez les packages requis comme suit -

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

Maintenant, nous devons charger l'ensemble de données sur le diabète Pima comme nous l'avons fait dans les exemples précédents -

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]

Ensuite, donnez l'entrée pour la validation croisée par 10 comme suit -

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

Nous devons fournir le nombre d'arbres que nous allons construire. Ici, nous construisons 150 arbres -

num_trees = 150

Ensuite, construisez le modèle à l'aide du script suivant -

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

Calculez et imprimez le résultat comme suit -

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

Production

0.7733766233766234

La sortie ci-dessus montre que nous avons obtenu une précision d'environ 77% de notre modèle de classificateur d'arbre de décision en sac.

Forêt aléatoire

C'est une extension des arbres de décision ensachés. Pour les classificateurs individuels, les échantillons de l'ensemble de données d'apprentissage sont prélevés avec remplacement, mais les arbres sont construits de manière à réduire la corrélation entre eux. En outre, un sous-ensemble aléatoire d'entités est considéré pour choisir chaque point de partage plutôt que de choisir avidement le meilleur point de partage dans la construction de chaque arbre.

Dans la recette Python suivante, nous allons créer un modèle d'ensemble de forêts aléatoires en sac en utilisant la classe RandomForestClassifier de sklearn sur l'ensemble de données sur le diabète des Indiens Pima.

Tout d'abord, importez les packages requis comme suit -

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

Maintenant, nous devons charger l'ensemble de données sur le diabète Pima comme dans les exemples précédents -

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]

Ensuite, donnez l'entrée pour la validation croisée par 10 comme suit -

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

Nous devons fournir le nombre d'arbres que nous allons construire. Ici, nous construisons 150 arbres avec des points de partage choisis parmi 5 fonctionnalités -

num_trees = 150
max_features = 5

Ensuite, construisez le modèle à l'aide du script suivant -

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

Calculez et imprimez le résultat comme suit -

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

Production

0.7629357484620642

La sortie ci-dessus montre que nous avons obtenu une précision d'environ 76% de notre modèle de classificateur de forêt aléatoire en sac.

Arbres supplémentaires

C'est une autre extension de la méthode d'ensemble d'arbres de décision en sac. Dans cette méthode, les arbres aléatoires sont construits à partir des échantillons de l'ensemble de données d'apprentissage.

Dans la recette Python suivante, nous allons créer un modèle d'ensemble d'arbres supplémentaire en utilisant la classe ExtraTreesClassifier de sklearn sur l'ensemble de données sur le diabète des Indiens Pima.

Tout d'abord, importez les packages requis comme suit -

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

Maintenant, nous devons charger l'ensemble de données sur le diabète Pima comme dans les exemples précédents -

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]

Ensuite, donnez l'entrée pour la validation croisée par 10 comme suit -

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

Nous devons fournir le nombre d'arbres que nous allons construire. Ici, nous construisons 150 arbres avec des points de partage choisis parmi 5 fonctionnalités -

num_trees = 150
max_features = 5

Ensuite, construisez le modèle à l'aide du script suivant -

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

Calculez et imprimez le résultat comme suit -

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

Production

0.7551435406698566

La sortie ci-dessus montre que nous avons obtenu une précision d'environ 75,5% de notre modèle de classificateur d'arbres supplémentaires en sacs.

Booster les algorithmes d'ensemble

Voici les deux algorithmes d'ensemble d'amplification les plus courants:

AdaBoost

C'est l'un des algorithmes d'ensemble d'amplification les plus réussis. La clé principale de cet algorithme réside dans la manière dont ils attribuent des pondérations aux instances de l'ensemble de données. Pour cette raison, l'algorithme doit accorder moins d'attention aux instances lors de la construction des modèles suivants.

Dans la recette Python suivante, nous allons créer un modèle d'ensemble Ada Boost pour la classification en utilisant la classe AdaBoostClassifier de sklearn sur l'ensemble de données sur le diabète des Indiens Pima.

Tout d'abord, importez les packages requis comme suit -

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

Maintenant, nous devons charger l'ensemble de données sur le diabète Pima comme dans les exemples précédents -

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]

Ensuite, donnez l'entrée pour la validation croisée par 10 comme suit -

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

Nous devons fournir le nombre d'arbres que nous allons construire. Ici, nous construisons 150 arbres avec des points de partage choisis parmi 5 fonctionnalités -

num_trees = 50

Ensuite, construisez le modèle à l'aide du script suivant -

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

Calculez et imprimez le résultat comme suit -

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

Production

0.7539473684210527

La sortie ci-dessus montre que nous avons obtenu une précision d'environ 75% de notre modèle d'ensemble de classificateurs AdaBoost.

Augmentation du gradient stochastique

Il est également appelé Gradient Boosting Machines. Dans la recette Python suivante, nous allons créer un modèle Stochastic Gradient Boostingensemble pour la classification en utilisant la classe GradientBoostingClassifier de sklearn sur l'ensemble de données sur le diabète des Indiens Pima.

Tout d'abord, importez les packages requis comme suit -

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

Maintenant, nous devons charger l'ensemble de données sur le diabète Pima comme dans les exemples précédents -

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]

Ensuite, donnez l'entrée pour la validation croisée par 10 comme suit -

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

Nous devons fournir le nombre d'arbres que nous allons construire. Ici, nous construisons 150 arbres avec des points de partage choisis parmi 5 fonctionnalités -

num_trees = 50

Ensuite, construisez le modèle à l'aide du script suivant -

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

Calculez et imprimez le résultat comme suit -

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

Production

0.7746582365003418

La sortie ci-dessus montre que nous avons obtenu une précision d'environ 77,5% de notre modèle d'ensemble de classificateurs Gradient Boosting.

Algorithmes d'ensemble de vote

Comme indiqué, le vote crée d'abord deux modèles autonomes ou plus à partir de l'ensemble de données de formation, puis un classificateur de vote encapsule le modèle en prenant la moyenne des prédictions du sous-modèle chaque fois que de nouvelles données sont nécessaires.

Dans la recette Python suivante, nous allons créer un modèle d'ensemble de vote pour la classification en utilisant la classe VotingClassifier de sklearn sur l'ensemble de données sur le diabète des Indiens Pima. Nous combinons les prédictions de la régression logistique, du classificateur d'arbre de décision et du SVM ensemble pour un problème de classification comme suit -

Tout d'abord, importez les packages requis comme suit -

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

Maintenant, nous devons charger l'ensemble de données sur le diabète Pima comme dans les exemples précédents -

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]

Ensuite, donnez l'entrée pour la validation croisée par 10 comme suit -

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

Ensuite, nous devons créer des sous-modèles comme suit -

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

Maintenant, créez le modèle d'ensemble de vote en combinant les prédictions des sous-modèles créés ci-dessus.

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

Production

0.7382262474367738

La sortie ci-dessus montre que nous avons obtenu une précision d'environ 74% de notre modèle d'ensemble de classificateurs de vote.