Exemple de programme et exemple d'exécution de la généralisation empilée
introduction
Cet article utilise Python 2.7, numpy 1.11, scipy 0.17, scikit-learn 0.18, matplotlib 1.5, seaborn 0.7, pandas 0.17. Il a été confirmé qu'il fonctionne sur le notebook jupyter.
Pour résoudre des problèmes de classification simples avec Kaggle, j'utilise souvent le guide Ansembling de ML Wave. Je n'avais pas beaucoup de sites en japonais, alors je l'ai écrit avec un exemple de programme.
table des matières
- Génération de données
- Préparation du classificateur à utiliser dans l'apprentissage d'ensemble
- Mise en œuvre de l'apprentissage d'ensemble
- Évaluation
- Référence
1. Génération de données
Si vous avez vos propres données, veuillez les ignorer.
Utilisez make_classification of here pour créer 2000 échantillons de données de classe 3D 2. Make_classification (flip_y = 0) est utilisé pour aligner le rapport de données d'étiquette sur 1: 1.
Après cela, les données générées sont divisées en train et test en deux.
make_classification.py
from sklearn.datasets import make_classification
import pandas as pd
import numpy as np
n_features = 3
n_samples = 2000
data = np.c_[make_classification(n_samples=n_samples, n_features=n_features, n_redundant=1, n_informative=2,n_clusters_per_class=2, n_classes=2, flip_y=0)]
train = test = np.empty((0,n_features+1), float)
for d in [data[data[:, n_features]==0], data[data[:, n_features]==1]]:
np.random.shuffle(d)
train = np.append(train, d[:(n_samples/4)], axis=0)
test = np.append(test, d[(n_samples/4):], axis=0)
map(lambda x: np.random.shuffle(x), [train, test])
Le contenu du train et du test ressemble à ceci.
array([[-0.96155185, -0.49879683, 0.65487916, 1. ],
[-0.95225926, -1.00853786, -0.97598077, 0. ],
[-0.11578056, 2.51579129, -1.23724233, 0. ],
...,
[-0.93715662, 0.41894292, -1.56002152, 0. ],
[-0.69759832, -0.20810317, -0.01283087, 0. ],
[ 0.31519506, -1.75498218, 0.89115054, 1. ]])
Vous avez maintenant 3 données numériques et des données d'étiquette.
2. Préparation du classificateur à utiliser dans l'apprentissage d'ensemble
Préparez un algorithme d'apprentissage automatique. Six types sont utilisés cette fois: RandomForest, KNN, ExtraTree, GradientBoosting, NaiveBays et XGBoost. Autre que XGBoost, scikit-learn est utilisé et vous pouvez simplement l'importer. XGBoost peut être construit avec pip install ou git.
Créez une liste de classificateurs à utiliser dans l'apprentissage d'ensemble.
- Puisque n_jobs = -1, un calcul parallèle est effectué. Veuillez corriger si nécessaire
- Non utilisé cette fois, mais le paramètre eval_matrix est manquant dans XGBoost 0.6 et versions ultérieures
set_clfs.py
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.naive_bayes import GaussianNB
from xgboost import XGBClassifier
from sklearn.neighbors import KNeighborsClassifier
clfs = [RandomForestClassifier(n_estimators=100, n_jobs=-1, criterion='gini'),
ExtraTreesClassifier(n_estimators=100, n_jobs=-1, criterion='gini'),
GradientBoostingClassifier(learning_rate=0.05, subsample=0.5, max_depth=6, n_estimators=50),
KNeighborsClassifier(n_neighbors=10, n_jobs=-1),
GaussianNB(),
XGBClassifier(learning_rate =0.1, n_estimators=1000, max_depth=5, min_child_weight=1,
gamma=0, subsample=0.8, colsample_bytree=0.5, objective= 'binary:logistic',
scale_pos_weight=1, seed=0
)
]
Essayons la classification binaire avec KNN.
knn.py
from sklearn.metrics import accuracy_score
nbrs = KNeighborsClassifier().fit(train[:, :-1], train[:, -1])
print "Acc: ", accuracy_score(test[:, -1], nbrs.predict(test[:, :-1]))
Acc: 0.90
La précision est de 90%. Nous comparerons comment cette précision change à la suite de l'apprentissage d'ensemble.
3. Mise en œuvre de l'apprentissage d'ensemble
Lorsqu'il s'agit de problèmes de classification simples (sans image ou à valeur continue) dans des compétitions telles que Kaggle, il est rare d'utiliser un seul apprenant. L'apprentissage d'ensemble qui combine l'apprentissage automatique multiple est utilisé. Autant que je sache, le site qui explique le plus en détail l'apprentissage d'ensemble est celui de MLWave cet article.
- Voting
- Averaging
- Rank averaging
- Stacked generalization & blending
Ces quatre sont le principal apprentissage d'ensemble. L'article lié détaille les cas d'utilisation réels dans Kaggle. Très gentiment, j'ai publié Framework pour les utiliser sur github. Cette fois, je présenterai la généralisation et le mélange empilés. (Sur github, c'est un programme appelé blend_proba.py)
3.1 Exemple d'utilisation de blend_proba ()
Cette fonction est un cadre pour résoudre la classification binaire par apprentissage d'ensemble. Le contenu est très simple, donc si vous avez le temps, consultez le code. Ici, nous allons apprendre par la méthode suivante.
step 1
- Tout d'abord, nous entraînerons les données générées avec RandomForest, KNN, ExtraTree, NaiveBays, GradientBoosting et XGBoost.
- En utilisant le classificateur appris à partir des données d'entraînement, les données de test sont évaluées en même temps.
Après avoir importé blend_proba, exécutez le programme suivant.
step1.py
import blend_proba as bp
[bp.blend_proba(clf, X_train=train[:, :-1], y=train[:, -1], X_test=test[:, :-1], save_preds="1", nfolds=3) for clf in clfs]
Après exécution, un fichier npy est généré dans le répertoire exécuté.
1GB_0.303855837305_16482164617e7c9d188bc75bafc06a08_test.npy
1GB_0.303855837305_16482164617e7c9d188bc75bafc06a08_train.npy
1Ne_0.455167671362_cddd24af66706c9fa26f6601910c92c5_test.npy
1Ne_0.455167671362_cddd24af66706c9fa26f6601910c92c5_train.npy
1an_0.249015612417_825e1ad5956801c2225da656822caebb_test.npy
1an_0.249015612417_825e1ad5956801c2225da656822caebb_train.npy
1au_0.22545173232_4b57dac04bbc037494cb592143a1c09c_test.npy
1au_0.22545173232_4b57dac04bbc037494cb592143a1c09c_train.npy
1ra_0.207753858339_a0cb35c894f0ad378f6bb824e1019748_test.npy
1ra_0.207753858339_a0cb35c894f0ad378f6bb824e1019748_train.npy
1xt_0.270981174382_e130a295809821efc1db2f64c228169c_test.npy
1xt_0.270981174382_e130a295809821efc1db2f64c228169c_train.npy
En définissant save_preds = "?", Le résultat de la prédiction nommé "? + 2ème à 3ème caractères du nom du classificateur + valeur de hachage + test (ou train) .npy" est généré par probabilité. Dans ce cas, puisqu'il y a 6 classificateurs, 12 fichiers npy seront générés.
step 2 Tout d'abord, créez une fonction pour lire le fichier généré à l'étape 1.
- __ Ici, on suppose que le fichier npy généré à l'étape 1 se trouve dans './ first / train /','./ first / test /'. __
- Entrez le résultat de la prédiction de la classification binaire (valeur continue de 0 à 1) obtenu à l'étape 1.
read_first_stage.py
import sys,os
def read_npy(tr_p, te_p):
train_file_names = map(lambda x: tr_p + x, os.listdir(tr_p))
test_file_names = map(lambda x: te_p + x, os.listdir(te_p))
list_train, list_test = [], []
for path_train, path_test in zip(train_file_names, test_file_names):
frame_train, frame_test = np.load(path_train), np.load(path_test)
list_train.append(frame_train)
list_test.append(frame_test)
l_train, l_test = list_train[0], list_test[0]
for train_, test_ in zip(list_train[1:], list_test[1:]):
l_train = np.concatenate([l_train, train_], axis=1)
l_test = np.concatenate([l_test, test_], axis=1)
return l_train, l_test
first_train, first_test = read_npy('./first/train/', './first/test/')
print first_train
Voici le résultat de la lecture du fichier npy des données du train et de sa concaténation. Le résultat de la prédiction de la classification binaire est inclus pour chaque apprenant, et la formation et le test contiennent 12 variables.
array([[ 1.07884407e-04, 9.99892116e-01, 0.00000000e+00, ...,
9.93333333e-01, 2.50875433e-04, 9.99749125e-01],
[ 9.96784627e-01, 3.21540073e-03, 9.76666667e-01, ...,
2.00000000e-02, 9.53099981e-01, 4.69000190e-02],
[ 5.11407852e-05, 9.99948859e-01, 5.33333333e-02, ...,
9.06666667e-01, 1.66652470e-06, 9.99998333e-01],
...,
[ 4.93575096e-01, 5.06424904e-01, 6.30000000e-01, ...,
4.03333333e-01, 9.49199952e-01, 5.08000478e-02],
[ 3.96782160e-03, 9.96032178e-01, 2.66666667e-02, ...,
9.46666667e-01, 2.46422552e-06, 9.99997536e-01],
[ 9.99466836e-01, 5.33185899e-04, 9.03333333e-01, ...,
8.00000000e-02, 9.54109081e-01, 4.58909185e-02]])
Le résultat de l'évaluation de l'étape 1 est utilisé pour apprendre l'étape 2.
step2.py
[bp.blend_proba(clf, X_train=first_train, y=train[:, -1], X_test=first_test, save_preds="2", nfolds=3) for clf in clfs]
Après exécution, 12 fichiers npy seront générés.
2GB_0.37311622448_16482164617e7c9d188bc75bafc06a08_test.npy
2GB_0.37311622448_16482164617e7c9d188bc75bafc06a08_train.npy
2Ne_0.784523345103_cddd24af66706c9fa26f6601910c92c5_test.npy
2Ne_0.784523345103_cddd24af66706c9fa26f6601910c92c5_train.npy
2an_0.421335902473_825e1ad5956801c2225da656822caebb_test.npy
2an_0.421335902473_825e1ad5956801c2225da656822caebb_train.npy
2au_1.9348828025_4b57dac04bbc037494cb592143a1c09c_test.npy
2au_1.9348828025_4b57dac04bbc037494cb592143a1c09c_train.npy
2ra_0.292331269114_a0cb35c894f0ad378f6bb824e1019748_test.npy
2ra_0.292331269114_a0cb35c894f0ad378f6bb824e1019748_train.npy
2xt_0.451990280749_e130a295809821efc1db2f64c228169c_test.npy
2xt_0.451990280749_e130a295809821efc1db2f64c228169c_train.npy
step 3 Lisez les données générées à l'étape 2 et apprenez avec XGBoost.
- __ Ici, on suppose que le fichier npy généré à l'étape 2 se trouve dans './ second / train /','./ second / test /'. __
- En utilisant blend_proba (save_test_only = "3") au lieu de save_preds, une sortie de fichier avec 0, 1 au lieu de probabilité est générée.
step3.py
second_train, second_test = read_data('./second/train/', './second/test/')
clf = XGBClassifier(learning_rate =0.1, n_estimators=1000, max_depth=5, min_child_weight=1,
gamma=0, subsample=0.8, colsample_bytree=0.5, objective= 'binary:logistic',
scale_pos_weight=1, seed=0
)
bp.blend_proba(clf, X_train=second_train, y=second_train[:, -1], X_test=second_test, save_test_only="3", nfolds=3)
Un fichier appelé 3 + Go + valeur de hachage + _test.txt a été généré. 3GB_0.338917307945_16482164617e7c9d188bc75bafc06a08_test.txt
check_ans.py
ans = np.loadtxt('./3GB_0.338917307945_16482164617e7c9d188bc75bafc06a08_test.txt')
print "Acc: ", accuracy_score(test[:, -1], ans)
La précision est la suivante.
Acc: 0.90
Il semble que la précision ne se soit pas améliorée en particulier.
4. Évaluation
À la suite de plusieurs essais, la précision n'a pas changé (ou diminué) par rapport à KNN. Il est possible que les données générées étaient petites au départ et qu'il y ait eu un problème avec les données générées artificiellement elles-mêmes. Comme introduit dans MLWave, la précision est souvent améliorée de quelques pour cent lorsqu'il y a un grand nombre de variables dans les données de Kaggle.
À propos de Kaggle-Ensemble-Guide / correlations.py
Dans l'exemple de code, il existe un fichier appelé correlations.py. En regardant à l'intérieur, le coefficient de corrélation du résultat de la prédiction est calculé à partir de chaque résultat de classification. Comme mentionné dans l'article MLWave, plus vous combinez les classificateurs avec moins de corrélation, meilleure est la précision de la prédiction. (Cela peut être une évidence) En vérifiant le coefficient de corrélation de cette manière
- Combinaison d'algorithmes
- Préparation des données originales
- Ajustement de la fonction de score du classificateur
Je vais essayer diverses choses pour améliorer la précision.
À propos de la classification multi-classes
MLWave introduit également la classification multi-classes en utilisant l'apprentissage d'ensemble. Dans l'article, l'apprentissage d'ensemble est implémenté pour chaque classe et la classification multi-classes est implémentée en résumant les résultats de prédiction de chacune. (One-vs-the-rest)
5. Référence
Recommended Posts