Le mélange a été utilisé pour décrire des modèles de traitement par lots qui ont mis en commun plusieurs centaines de modèles dans le concours d'apprentissage automatique Netflix à 1000000 $, et en tant que tel, le mélange reste une méthode et un nom populaires pour le traitement par lots dans les concours d'apprentissage automatique tels que Kaggle. ... Surtout pour le début d'un nouveau flux du cours "Machine Learning"Partagez un tutoriel sur la façon de développer et d'évaluer un ensemble mixte en python. Après avoir terminé ce tutoriel, vous saurez:
- Les ensembles mixtes sont un type d'empaquetage de modèle dans lequel le métamodèle est entraîné à l'aide de prédictions sur un ensemble de données de validation de test indépendant au lieu de prédictions lors de la validation croisée de k fois.
- Comment développer un ensemble mixte, y compris la formation de modèles et des fonctions de prédiction basées sur de nouvelles données.
- Comment évaluer des ensembles mixtes pour des problèmes de classification et de modélisation de régression prédictive.
Présentation du didacticiel
Ce tutoriel est divisé en quatre parties. Les voici:
- Ensemble mixte.
- Création d'un ensemble mixte.
- Ensemble mixte dans un problème de classification.
- Ensemble mixte dans un problème de régression.
Ensemble mixte
Le mélange est une technique d'apprentissage automatique d'ensemble qui utilise un modèle d'apprentissage automatique pour apprendre à combiner au mieux les prédictions de plusieurs modèles de membres d'ensemble.
Le mélange est donc identique à la généralisation de l'empilement connue sous le nom d'empilement. Le mélange et le dosage sont souvent utilisés de manière interchangeable dans le même article ou la même description de modèle.
De nombreux praticiens de l'apprentissage automatique ont réussi à utiliser le traitement par lots et les techniques associées pour améliorer la précision des prévisions sur l'un des modèles individuels. Dans certains contextes, le traitement par lots est également appelé mélange. Nous allons également échanger les termes ici.
Empilement linéaire pondéré en fonction des caractéristiques , 2009.
Une architecture de modèle par lots contient au moins deux modèles de référence, souvent appelés modèles de niveau zéro, et un métamodèle qui combine les prédictions du modèle de base en tant que modèle de niveau un. Le métamodèle est formé sur la base des prédictions faites par les modèles de base sur des données hors échantillon.
- Les modèles de niveau zéro ( modèles de référence ) sont des modèles formés sur des données d'entraînement dont les prévisions sont collectées.
- Le modèle de premier niveau ( métamodèle ) est un modèle qui apprend à combiner au mieux les prévisions des modèles sous-jacents.
Cependant, le mélange a certaines connotations pour construire un modèle d'ensemble packagé. Le mélange peut offrir le développement d'un ensemble de piles, où les modèles de base sont n'importe quel type de modèle d'apprentissage automatique, et le métamodèle est un modèle linéaire qui «mélange» les prédictions des modèles de base. Par exemple, un modèle de régression linéaire lors de la prédiction d'une valeur numérique, ou un modèle de régression logistique lors de la prédiction d'une étiquette de classe, calcule la somme pondérée des prédictions faites par les modèles de base et sera traité comme des prédictions mixtes.
- Ensemble mixte : utilisez un modèle linéaire, tel que la régression linéaire ou la régression logistique, comme métamodèle dans un ensemble de modèles par lots.
Le mélange était un terme couramment utilisé pour un ensemble packagé lors du concours Netflix 2009. Le concours impliquait des équipes à la recherche de modèles prédictifs plus performants que l'algorithme natif de Netflix, avec un prix de 1 000 000 $ attribué à l'équipe qui a obtenu une amélioration de 10% des performances.
Notre solution avec RMSE = 0,8643 ^ 2 est un mélange linéaire de plus de 100 résultats. […] Tout au long de la description des méthodes, nous mettons en évidence les prédicteurs spécifiques qui ont participé à la solution mixte finale.
La solution BellKor 2008 au prix Netflix , 2008.
Ainsi, le mélange est un terme familier pour l'apprentissage d'ensemble avec une architecture modèle telle que le traitement par lots. Il est rarement, voire jamais, utilisé dans des manuels ou des articles académiques autres que ceux liés à l'apprentissage automatique en compétition. Le plus souvent, le terme mélange est utilisé pour décrire une application spécifique du traitement par lots où un métamodèle est formé sur des prédictions faites par des modèles de base avec un ensemble de données de validation indépendant. Dans ce contexte, le packaging est réservé au métamodèle formé aux prédictions lors de la procédure de validation croisée.
- Mélange : un ensemble de type batch dans lequel un métamodèle est formé sur des prédictions faites sur un ensemble de données indépendant.
- Batching : Un ensemble de type batch dans lequel le métamodèle est entraîné sur les prédictions faites lors de la validation croisée de k fois.
Cette distinction est courante dans la communauté des compétitions d'apprentissage automatique de Kaggle.
Le mixage est le mot inventé par les gagnants de Netflix. C'est très proche de la généralisation, mais un peu plus simple et le risque de fuite d'informations est moindre. […] En mélangeant, au lieu de générer des prédictions lors de la validation croisée pour l'ensemble d'apprentissage, vous créez un petit ensemble indépendant de, disons, 10% de l'ensemble d'apprentissage. Le modèle de dosage est ensuite entraîné uniquement sur ce petit ensemble.
Guide de l'ensemble Kaggle , MLWave, 2015.
Nous utilisons la dernière définition du mélange. Voyons comment il est mis en œuvre.
Développement d'ensembles mixtes
La bibliothèque scikit-learn ne prend pas en charge le mixage prêt à l'emploi au moment de la rédaction de cet article. Mais nous pouvons l'implémenter nous-mêmes en utilisant des modèles scikit-learn. Tout d'abord, vous devez créer un ensemble de modèles de base. Il peut s'agir de tous les modèles que nous aimons pour un problème de régression ou de classification. Nous pouvons définir une fonction get_models () qui retourne une liste de modèles, où chaque modèle est défini comme un tuple avec un nom et un classificateur personnalisé ou un objet de régression. Par exemple, pour un problème de classification, nous pourrions utiliser la régression logistique, kNN, arbre de décision, SVM et modèle bayésien naïf.
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
Ensuite, nous devons former le modèle de mixage. Rappelez-vous que les modèles de base sont entraînés sur l'ensemble de données d'entraînement. Le métamodèle est formé sur les prédictions faites par chaque modèle de base sur un jeu de données indépendant.
Tout d'abord, nous pouvons parcourir les modèles dans une liste et former chacun à son tour sur l'ensemble de données d'entraînement. De plus, dans ce cycle, nous pouvons utiliser un modèle entraîné pour faire une prédiction sur un ensemble de données indépendant (validation) et stocker des prédictions pour l'avenir.
...
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
Nous avons maintenant un "meta_X *" représentant l'entrée qui peut être utilisée pour entraîner le métamodèle. Chaque colonne ou objet représente la sortie d'un modèle de base. Chaque ligne représente un échantillon d'un ensemble de données indépendant. Nous pouvons utiliser la fonction hstack () pour nous assurer que cet ensemble de données est un tableau numpy à deux dimensions, comme prévu par le modèle d'apprentissage automatique.
...
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
Nous pouvons maintenant former notre méta-modèle. Il peut s'agir de n'importe quel modèle d'apprentissage automatique que nous aimons, comme la régression logistique pour un problème de classification.
...
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
Vous pouvez regrouper tout cela dans une fonction appelée fit_ensemble () qui entraîne le modèle de fusion à l'aide d'un ensemble de données d'entraînement et de validation indépendant.
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
L'étape suivante consiste à utiliser un ensemble de mixage pour prédire de nouvelles données. Il s'agit d'un processus en deux étapes. La première étape consiste à utiliser chaque modèle de base pour la prévision. Les prédictions sont ensuite rassemblées et utilisées comme entrée dans le modèle de mélange pour faire la prédiction finale.
Nous pouvons utiliser le même cycle que lors de la formation du modèle. Autrement dit, collectez les prédictions de chaque modèle de base dans un ensemble de données d'entraînement, ajoutez les prédictions ensemble et appelez prédict () sur le modèle de mélange avec cet ensemble de données méta-niveau. Predict_ensemble () fonctionci-dessous met en œuvre ces actions. Étant donné la formation d'une liste de modèles de base, la formation d'un mélangeur d'ensemble et d'un ensemble de données (tel qu'un ensemble de données de test ou de nouvelles données), pour l'ensemble de données, il renverra un ensemble de prédictions.
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
Nous disposons désormais de tous les éléments nécessaires pour mettre en œuvre un ensemble mixte pour des problèmes de classification ou de modélisation de régression prédictive.
Ensemble mixte pour problème de classification
Dans cette section, nous examinerons l'utilisation du mélange pour la tâche de classification. Tout d'abord, nous pouvons utiliser la fonction make_classification () pour créer un problème de classification binaire synthétique avec 10 000 exemples et 20 fonctionnalités d'entrée. L'exemple complet est présenté ci-dessous.
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
# summarize the dataset
print(X.shape, y.shape)
L'exécution de l'exemple crée un ensemble de données et résume les entrées et les sorties.
(10000, 20) (10000,)
Ensuite, nous devons d'abord diviser l'ensemble de données en ensembles d'entraînement et de test, puis l'ensemble d'apprentissage en un sous-ensemble utilisé pour entraîner les modèles de base et un sous-ensemble utilisé pour entraîner le métamodèle. Dans ce cas, nous utiliserons une répartition 50-50 pour les ensembles de formation et de test, puis une répartition 67-33 pour les ensembles de formation et de validation.
...
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
Vous pouvez ensuite utiliser la fonction get_models () de la section précédente pour créer les modèles de classification utilisés dans l'ensemble. La fonction fit_ensemble () peut alors être appelée pour entraîner l'ensemble mixte sur ces ensembles de données, et la fonction prédire_ensemble () peut être utilisée pour faire des prédictions sur un ensemble de données indépendant.
...
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
Enfin, nous pouvons mesurer les performances du modèle de fusion en rapportant la précision de classification sur l'ensemble de données de test.
...
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % score)
Un exemple complet d'estimation d'un ensemble mixte dans un problème de classification binaire synthétique est donné ci-dessous.
# blending ensemble for classification using hard voting
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC()))
models.append(('bayes', GaussianNB()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % (score*100))
L'exécution de l'exemple rapporte d'abord un résumé de tous les ensembles de données, puis la précision de l'ensemble dans l'ensemble de données de test.
Remarque: vos résultats peuvent varier en raison de la nature stochastique de l'algorithme ou de la procédure d'estimation, ou des différences de précision numérique. Envisagez d'exécuter l'exemple plusieurs fois et de comparer la moyenne.
Nous voyons ici que l'ensemble mixte a atteint une précision de classification d'environ 97,900%.
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20) Blending Accuracy: 97.900
Dans l'exemple précédent, la prédiction d'étiquettes de classe claires a été combinée à l'aide d'un modèle de fusion. C'est un type de vote difficile . Une alternative est une méthode où chaque modèle prédit les probabilités de classe et utilise un métamodèle pour mélanger les probabilités. C'est une sorte de vote doux qui peut parfois conduire à de meilleures performances. Tout d'abord, nous devons configurer des modèles qui renvoient des probabilités, comme le modèle SVM.
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
Ensuite, les modèles sous-jacents doivent être modifiés pour prédire les probabilités au lieu d'étiquettes de classe claires. Ceci peut être réalisé en appelant predict_proba () dans fit_ensemble () tout en entraînant les modèles sous-jacents.
...
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict_proba(X_val)
# store predictions as input for blending
meta_X.append(yhat)
Cela signifie que le méta-jeu de données utilisé pour entraîner le méta-modèle aura n colonnes par classificateur, où n est le nombre de classes dans le problème de prévision, dans notre cas, il y a deux classes. Nous devons également modifier les prédictions faites par les modèles de base lors de l'utilisation du modèle de mélange pour prédire de nouvelles données.
...
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict_proba(X_test)
# store prediction
meta_X.append(yhat)
L'exemple complet de l'utilisation du mélange sur des probabilités de classe prédites pour un problème de classification binaire synthétique est donné ci-dessous.
# blending ensemble for classification using soft voting
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict_proba(X_val)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict_proba(X_test)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = accuracy_score(y_test, yhat)
print('Blending Accuracy: %.3f' % (score*100))
L'exécution de l'exemple rapporte d'abord un résumé de tous les ensembles de données, puis la précision de l'ensemble dans l'ensemble de test.
Remarque: vos résultats peuvent varier en raison de la nature stochastique de l'algorithme ou de la procédure d'estimation, ou des différences de précision numérique. Essayez plusieurs fois l'exemple et comparez le résultat moyen.
Ici, nous voyons que le mélange des probabilités de classe a conduit à une augmentation de la précision de classification jusqu'à environ 98,240%.
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20) Blending Accuracy: 98.240
Un ensemble mixte n'est efficace que s'il est capable de surpasser l'un des modèles individuels qu'il contient. Nous pouvons le confirmer en évaluant chacun des modèles de base séparément. Chaque modèle de ligne de base peut être entraîné sur l'ensemble de données d'apprentissage (par opposition à l'ensemble de mélange) et évalué sur l'ensemble de données de test (tout comme dans l'ensemble de mélange). L'exemple ci-dessous le démontre en évaluant chaque modèle de base individuellement.
# evaluate base models on the entire training dataset
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# summarize data split
print('Train: %s, Test: %s' % (X_train_full.shape, X_test.shape))
# create the base models
models = get_models()
# evaluate standalone model
for name, model in models:
# fit the model on the training dataset
model.fit(X_train_full, y_train_full)
# make a prediction on the test dataset
yhat = model.predict(X_test)
# evaluate the predictions
score = accuracy_score(y_test, yhat)
# report the score
print('>%s Accuracy: %.3f' % (name, score*100))
L'exécution de l'exemple rapporte d'abord un résumé des trois ensembles de données, puis la précision de chaque modèle de base dans l'ensemble de test.
Remarque: vos résultats peuvent différer en raison de la nature stochastique de l'algorithme, de la procédure d'estimation ou des différences de précision numérique. Essayez plusieurs fois l'exemple et comparez le résultat moyen.
Dans ce cas, nous voyons que tous les modèles fonctionnent moins bien que l'ensemble mixte. La chose intéressante est que nous pouvons voir que le SVM est très proche d'atteindre une précision de 98 200%, contre une précision de 98 240% obtenue avec l'ensemble mixte.
Train: (5000, 20), Test: (5000, 20) >lr Accuracy: 87.800 >knn Accuracy: 97.380 >cart Accuracy: 88.200 >svm Accuracy: 98.200 >bayes Accuracy: 87.300
Nous pouvons choisir un ensemble mixte comme modèle final. Cela comprend la formation de l'ensemble sur l'ensemble de données d'entraînement et la réalisation de prédictions à l'aide de nouveaux exemples. En particulier, l'ensemble de l'apprentissage entier est divisé en ensembles d'apprentissage et de validation pour l'apprentissage de la base et des métamodèles, respectivement, puis l'ensemble peut être utilisé dans la prévision. Voici un exemple complet de prévision de nouvelles données à l'aide d'un ensemble mixte pour la classification:
# example of making a prediction with a blending ensemble for classification
from numpy import hstack
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
# get the dataset
def get_dataset():
X, y = make_classification(n_samples=10000, n_features=20, n_informative=15, n_redundant=5, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LogisticRegression()))
models.append(('knn', KNeighborsClassifier()))
models.append(('cart', DecisionTreeClassifier()))
models.append(('svm', SVC(probability=True)))
models.append(('bayes', GaussianNB()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for _, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict_proba(X_val)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LogisticRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for _, model in models:
# predict with base model
yhat = model.predict_proba(X_test)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s' % (X_train.shape, X_val.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make a prediction on a new row of data
row = [-0.30335011, 2.68066314, 2.07794281, 1.15253537, -2.0583897, -2.51936601, 0.67513028, -3.20651939, -1.60345385, 3.68820714, 0.05370913, 1.35804433, 0.42011397, 1.4732839, 2.89997622, 1.61119399, 7.72630965, -2.84089477, -1.83977415, 1.34381989]
yhat = predict_ensemble(models, blender, [row])
# summarize prediction
print('Predicted Class: %d' % (yhat))
L'exécution de l'exemple entraîne un modèle d'ensemble mixte sur un ensemble de données, puis l'utilise pour prédire une nouvelle ligne de données, comme il le ferait si vous utilisiez le modèle dans une application.
Train: (6700, 20), Val: (3300, 20) Predicted Class: 1
Voyons comment nous pourrions évaluer l'ensemble mixte pour la régression.
Ensemble mixte pour problème de régression
Dans cette section, nous examinerons l'utilisation du batching pour un problème de régression. Tout d'abord, nous pouvons utiliser la fonction make_regression () pour créer un problème de régression synthétique avec 10 000 échantillons et 20 caractéristiques d'entrée. L'exemple complet est présenté ci-dessous.
# test regression dataset
from sklearn.datasets import make_regression
# define dataset
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
# summarize the dataset
print(X.shape, y.shape)
L'exécution de l'exemple crée un ensemble de données et récapitule les composants d'entrée et de sortie.
(10000, 20) (10000,)
Ensuite, vous pouvez définir une liste de modèles de régression à utiliser comme référence. Dans ce cas, nous utilisons des modèles de régression linéaire, kNN, arbre de décision et SVM.
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
La fonction fit_ensemble () utilisée pour entraîner l'ensemble ne change pas, sauf que le modèle utilisé pour le mixage doit être changé en régression. Ici, nous utilisons un modèle de régression linéaire.
...
# define blending model
blender = LinearRegression()
Étant donné qu'il s'agit d'un problème de régression, nous évaluerons les performances du modèle en utilisant la métrique d'erreur, dans ce cas l'erreur absolue moyenne, ou MAE (abrégée).
...
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Blending MAE: %.3f' % score)
L'exemple complet d'un ensemble mixte pour un problème de modélisation prédictive de régression synthétique est présenté ci-dessous:
# evaluate blending ensemble for regression
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
# get the dataset
def get_dataset():
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for name, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LinearRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for name, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# split training set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s, Test: %s' % (X_train.shape, X_val.shape, X_test.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make predictions on test set
yhat = predict_ensemble(models, blender, X_test)
# evaluate predictions
score = mean_absolute_error(y_test, yhat)
print('Blending MAE: %.3f' % score)
L'exemple imprime d'abord un résumé des trois ensembles de données, puis le MAE sur l'ensemble de test.
Remarque: vos résultats peuvent varier en raison de la nature stochastique de l'algorithme ou de la procédure d'estimation, ou des différences de précision numérique. Essayez plusieurs fois l'exemple et comparez le résultat moyen.
Ici, nous voyons que l'ensemble a atteint un MAE d'environ 0,237 sur l'ensemble de données de test.
Train: (3350, 20), Val: (1650, 20), Test: (5000, 20) Blending MAE: 0.237
Comme pour la classification, un ensemble mixte n'est utile que s'il fonctionne mieux que n'importe lequel des modèles d'ensemble de base.
Nous pouvons tester cela en évaluant chaque modèle de base de manière isolée, en l'entraînant d'abord sur l'ensemble d'apprentissage complet (par opposition à un ensemble) et en faisant des prédictions sur l'ensemble de données de test (comme dans un ensemble). Dans l'exemple ci-dessous, chacun des modèles de référence est estimé isolément par rapport à un ensemble de données de modélisation de régression prédictive synthétique.
# evaluate base models in isolation on the regression dataset
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
# get the dataset
def get_dataset():
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
# define dataset
X, y = get_dataset()
# split dataset into train and test sets
X_train_full, X_test, y_train_full, y_test = train_test_split(X, y, test_size=0.5, random_state=1)
# summarize data split
print('Train: %s, Test: %s' % (X_train_full.shape, X_test.shape))
# create the base models
models = get_models()
# evaluate standalone model
for name, model in models:
# fit the model on the training dataset
model.fit(X_train_full, y_train_full)
# make a prediction on the test dataset
yhat = model.predict(X_test)
# evaluate the predictions
score = mean_absolute_error(y_test, yhat)
# report the score
print('>%s MAE: %.3f' % (name, score))
L'exécution de l'exemple résume d'abord les ensembles d'entraînement et de test, puis le MAE de chaque modèle de base dans l'ensemble de données de test.
Remarque: vos résultats peuvent varier en raison de la nature stochastique de l'algorithme ou de la procédure d'estimation, ou des différences de précision numérique. Essayez plusieurs fois l'exemple et comparez le résultat moyen.
Ici, vous pouvez voir qu'en fait, le modèle de régression linéaire a légèrement mieux performé que l'ensemble mixte, atteignant un MAE de 0,236 par rapport à 0,237. Cela peut avoir à voir avec la façon dont le jeu de données synthétiques a été construit.
Cependant, dans ce cas, nous préférerions utiliser un modèle de régression linéaire pour exactement cette tâche. Cette situation souligne l'importance de valider la performance des modèles contributifs avant d'accepter le modèle d'ensemble comme final.
Train: (5000, 20), Test: (5000, 20) >lr MAE: 0.236 >knn MAE: 100.169 >cart MAE: 133.744 >svm MAE: 138.195
Là encore, vous pouvez appliquer l'ensemble mixte comme modèle de régression final. L'approche consiste à diviser l'ensemble de données en ensembles d'apprentissage et de test afin de former respectivement la ligne de base et les métamodèles sur eux, puis l'ensemble peut être utilisé pour prédire une nouvelle ligne de données. Un exemple complet de prédiction de nouvelles données à l'aide d'un ensemble mixte pour un problème de régression est donné ci-dessous.
# example of making a prediction with a blending ensemble for regression
from numpy import hstack
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
# get the dataset
def get_dataset():
X, y = make_regression(n_samples=10000, n_features=20, n_informative=10, noise=0.3, random_state=7)
return X, y
# get a list of base models
def get_models():
models = list()
models.append(('lr', LinearRegression()))
models.append(('knn', KNeighborsRegressor()))
models.append(('cart', DecisionTreeRegressor()))
models.append(('svm', SVR()))
return models
# fit the blending ensemble
def fit_ensemble(models, X_train, X_val, y_train, y_val):
# fit all models on the training set and predict on hold out set
meta_X = list()
for _, model in models:
# fit in training set
model.fit(X_train, y_train)
# predict on hold out set
yhat = model.predict(X_val)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store predictions as input for blending
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# define blending model
blender = LinearRegression()
# fit on predictions from base models
blender.fit(meta_X, y_val)
return blender
# make a prediction with the blending ensemble
def predict_ensemble(models, blender, X_test):
# make predictions with base models
meta_X = list()
for _, model in models:
# predict with base model
yhat = model.predict(X_test)
# reshape predictions into a matrix with one column
yhat = yhat.reshape(len(yhat), 1)
# store prediction
meta_X.append(yhat)
# create 2d array from predictions, each set is an input feature
meta_X = hstack(meta_X)
# predict
return blender.predict(meta_X)
# define dataset
X, y = get_dataset()
# split dataset set into train and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.33, random_state=1)
# summarize data split
print('Train: %s, Val: %s' % (X_train.shape, X_val.shape))
# create the base models
models = get_models()
# train the blending ensemble
blender = fit_ensemble(models, X_train, X_val, y_train, y_val)
# make a prediction on a new row of data
row = [-0.24038754, 0.55423865, -0.48979221, 1.56074459, -1.16007611, 1.10049103, 1.18385406, -1.57344162, 0.97862519, -0.03166643, 1.77099821, 1.98645499, 0.86780193, 2.01534177, 2.51509494, -1.04609004, -0.19428148, -0.05967386, -2.67168985, 1.07182911]
yhat = predict_ensemble(models, blender, [row])
# summarize prediction
print('Predicted: %.3f' % (yhat[0]))
L'exécution de l'exemple entraîne un modèle d'ensemble sur un ensemble de données et est ensuite utilisé pour prédire une nouvelle ligne de données, comme si le modèle était utilisé dans une application.
Train: (6700, 20), Val: (3300, 20) Predicted: 359.986
Cette section contient des ressources sur ce sujet si vous souhaitez approfondir le sujet.
- Stacking Ensemble Machine Learning With Python
- How to Implement Stacked Generalization (Stacking) From Scratch With Python
- Feature-Weighted Linear Stacking, 2009.
- The BellKor 2008 Solution to the Netflix Prize, 2008.
- Kaggle Ensemble Guide, MLWave, 2015.
- Netflix, Wikipedia.
Et n'oubliez pas le code promo HABR , qui ajoute 10% à la réduction de la bannière.
- Cours d'apprentissage automatique
- Cours avancé "Machine Learning Pro + Deep Learning"
- Cours "Mathématiques et apprentissage automatique pour la science des données"
Plus de cours
- Data Science
- Data Analyst
- «Python -»
- Unity
- JavaScript
- -
- Java-
- C++
- DevOps
- iOS-
- Android-
Articles recommandés
- Combien gagne un data scientist: un aperçu des salaires et des emplois en 2020
- Combien gagne un analyste de données: un aperçu des salaires et des emplois en 2020
- Comment devenir Data Scientist sans cours en ligne
- 450 cours gratuits de l'Ivy League
- Comment apprendre le Machine Learning 5 jours par semaine pendant 9 mois consécutifs
- Apprentissage automatique et vision par ordinateur dans l'industrie minière
- Apprentissage automatique et vision par ordinateur dans les usines d'enrichissement