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

  1. Génération de données
  2. Préparation du classificateur à utiliser dans l'apprentissage d'ensemble
  3. Mise en œuvre de l'apprentissage d'ensemble
  4. Évaluation
  5. 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.

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.

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.

Picture1.png

step 1

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.

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.

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

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

Kaggle Ensemble Guide

Recommended Posts

Exemple de programme et exemple d'exécution de la généralisation empilée
Apprentissage d'ensemble et analyse de paniers
Différenciation du tri et généralisation du tri
Importance de l'apprentissage automatique et de l'apprentissage par mini-lots
[Apprentissage automatique] Résumé et exécution de l'évaluation / des indicateurs du modèle (avec jeu de données Titanic)
Algorithme d'apprentissage automatique (généralisation de la régression linéaire)
Exemple d'utilisation de variables de classe et de méthodes de classe
Signification des modèles et paramètres d'apprentissage en profondeur
Installez l'API Python du simulateur de conduite automatique LGSVL et exécutez un exemple de programme