[PYTHON] Résumé de Kaggle: Redhat (partie 2)

introduction

Nous mettrons à jour les informations de Kaggle qui a participé dans le passé. Ici, nous reprendrons l'introduction des données sur Prédire la valeur commerciale de Red Hat et la discussion de premier plan dans le forum. L'introduction des données et l'analyse de base sont résumées dans Kaggle Summary: Red Hat (Part 1), qui est un résumé de code pratique. ..

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. (Veuillez modifier correctement% matplotlib inline) Si vous trouvez des erreurs lors de l'exécution de l'exemple de script, il serait utile que vous puissiez commenter.

Aperçu

Comme expliqué dans Partie 1, les données d'origine contiennent suffisamment de fonctionnalités. Même si vous n'utilisez pas de méthodes élaborées, vous pouvez obtenir un score de 95% ou plus, donc au contraire, diverses solutions sont essayées en fonction de la façon d'emballer les quelques% restants. Des codes qui utilisent des méthodes très polyvalentes et un apprentissage en profondeur pour les problèmes de classification sont également apparus, de sorte que cet article présente les quatre suivants.

1. 1st solution
2. 2nd solution
3. Prédiction à l'aide de XGBoost
4. Apprentissage en profondeur avec Keras

Il n'existe aucun exemple de script dans 1 et 2, et 3 et 4 sont des exemples de code de référence.

1. 1st solution

Description du gagnant Je vais le poster. Veuillez consulter ici pour la visualisation de la structure et de la distribution des données. En outre, Sites autour d'ici est également affiché. C'est facile à comprendre.

Comme vous pouvez le voir en lisant le japonais, la longue histoire se poursuit sans fin et aucun code concret n'en sort. La traduction japonaise devient de plus en plus compliquée à mesure que vous descendez, donc si vous êtes confus, veuillez vérifier le texte anglais ou le site de référence. La différence avec les trois premiers groupes n'est pas close et il est clair que Radder a passé des journées assez stressantes.

Ce modèle est très simple. Il est très important de créer un ensemble de validation croisée approprié et de créer un ensemble de CV par la méthode suivante.

1. Supprimez group_1 = 17304 du train et des données de test. Les données de ce groupe occupent 30% des données d'entraînement et ont toutes un résultat = 0.
2. Utilisez un autre opérateur pour le groupe1. En effet, ce groupe contient plus de 3 000 données. (C'est important)
3. Créez aléatoirement des CV non stratifiés en cinq pour les fichiers de personnes.

Mon concept de modélisation est assez simple. Réduisez le problème d'origine à quelques problèmes plus petits et combinez-les dans un modèle de second niveau. J'ai fait quelques modèles selon ce qui suit. a) Sélectionnez une activité dans la chronologie du groupe_1 (cette fois, j'ai utilisé la première / dernière activité de la chronologie) b) Collectez toutes les activités des groupes avec des résultats similaires c) Compressez la quantité de fonctions. tf-idf est particulièrement utile. Les caractéristiques de chaque variable ont été calculées. (Pour les personnes ayant les mêmes attributs dans chaque groupe ou partout) d) Ajouter des fonctionnalités simples et non simples. (La valeur de l'identifiant du groupe_1, l'activité dans le groupe, les personnes dans le groupe, la date maximum / minimum, etc.) Cette fois, nous n'avons pas utilisé l'interrelation entre les quantités de caractéristiques ou les informations de probabilité. e) Créez un classificateur. ** Cette fois, je n'ai utilisé que XGBoost. ** Il a pu atteindre 0,84 AUC par lui-même. (Aucune donnée de fuite n'est utilisée)

Afin d'exécuter correctement la méthode ci-dessus, il est nécessaire d'envisager une approche CV moins courante. Cette méthode de décomposition est basée sur people_id, des données compressées. Ce CV est basé sur plusieurs schémas de répartition des CV agrégés. Cette technique fonctionne bien, mais vous devez créer jusqu'à 15 XGBoosts, et vous devez créer deux niveaux. Cette façon de penser le CV est importante, mais je vais omettre l'explication ici.

Ici, nous présentons quatre modèles de 1er niveau qui fonctionnent bien. (Deux d'entre eux fonctionnent bien en LB public, les deux autres donnent le meilleur score CV dans le modèle de 2e niveau) [Le modèle de 2e couche nécessite des compétences de script très soignées](http: / /qiita.com/TomHortons/items/2a05b72be180eb83a204). De plus, comme la version comprenant Leaked release est implémentée dans CV, la prédiction au sein du groupe de résultats est-elle apprise en ML? .. Le modèle de 2e niveau résout deux problèmes. La probabilité de prédiction liée aux informations de fuite et la probabilité de prédiction sans rapport avec les informations de fuite. Le modèle lui-même est simple, mais certaines fonctionnalités intelligentes ont été introduites pour capturer les changements de temps dans le groupe / la population.

Dans l'état ci-dessus (en utilisant un modèle de prédiction décent), j'étais classé 4e au milieu de la compétition. J'ai vu des participants à la 3e place et au-dessus améliorer leurs scores de jour en jour. Par conséquent, j'ai pensé à ce qu'ils développaient manuellement dans la LB publique pour augmenter les fuites (omissions de prédiction?). La partition de données publique / privée (lors de l'essai du modèle) est aléatoire. Certaines personnes ont fait une soumission de groupe de test à la main et ont utilisé le non affecté par des fuites dans un groupe particulier pour obtenir un score. Ensuite, nous avons déterminé quelle était la probabilité de résultat pour l'ensemble du groupe. (???) Pour y parvenir, nous avons soumis un grand nombre de soumissions pour obtenir le plus grand groupe_1 possible, et avons trouvé certains groupes avec une précision de prédiction médiocre du modèle d'apprentissage automatique. Dans cet esprit, j'ai créé d'excellents modèles. (Autrement dit, avez-vous apporté des ajustements précis au modèle et à la méthode CV pour créer de nouveaux modèles, et soumettez-vous à plusieurs reprises afin que des groupes pratiques soient inclus au hasard dans les données de test?)

Et dans la soumission finale, nous avons simplement fait la moyenne des modèles les plus performants pour LB et CV jusqu'à présent. Étonnamment, cela a donné le meilleur score jamais enregistré.

2. 2nd solution

Peut-être parce que Radder (vainqueur) a remporté le championnat avec rebondissements, les discussions à la deuxième place et en dessous qui proposaient des solutions plus intelligentes sont plus populaires dans les entretiens du forum. Ici, Interview à la 2ème place est décrit.

step 1 Nous avons créé des modèles de complément de probabilité pour les groupes apparaissant dans l'échantillon de formation. La figure suivante montre la probabilité de prédiction du groupe 7 tracée par ordre chronologique.

Dans l'échantillon d'apprentissage, la probabilité est de 1 et un autre jour, la probabilité diminue. La figure suivante montre des résultats de prédiction similaires, mais trace la totalité de la plage de données.

step 2 Cette fois, il y a 34224 groupes différents dans les données. Ce nombre est la taille réelle de l'échantillon (?) Parce que le groupe n'est qu'un objet d'un point de vue statistique. Le problème est la quantité de caractéristiques qui prend différentes valeurs au sein du groupe. Nous avons calculé l'histogramme pour tous les groupes et toutes les fonctionnalités. Les bacs de l'histogramme sont de nouvelles fonctionnalités. C'est ce qu'on appelle la version "floue" du codage binaire (?). Il existe trois modèles de prédiction comme suit.

A) Logistic regression B) KNN C) XGBoost based public scripts

step 3 Sur la base de ce qui précède, nous l'améliorerons en faisant référence aux commentaires de LB.

3. Prédiction à l'aide de XGBoost

Présentation de la méthode la plus efficace et la plus générale utilisant XGBoost. Code de code auteur (Abriosi) Veuillez vous référer au code de ici. C'est très simple, il encode les données de catégorie et les prédit avec XGBoost.

Je n'expliquerai que les principaux points. Après avoir fait pd.read (), supprimez char_10. (Parce qu'il y a beaucoup de valeurs manquantes?)

act_train_data=act_train_data.drop('char_10',axis=1)
act_test_data=act_test_data.drop('char_10',axis=1)

Exécutez la fonction act_data_treatment sur act_train_data et d'autres données d'entrée dont char_10 a été supprimé.

act_train_data  = act_data_treatment(act_train_data)
act_test_data   = act_data_treatment(act_test_data)
people_data = act_data_treatment(people_data)

La fonction act_data_treatment est définie comme suit.

def act_data_treatment(dsname):
    dataset = dsname
    
    for col in list(dataset.columns):
        if col not in ['people_id', 'activity_id', 'date', 'char_38', 'outcome']:
            if dataset[col].dtype == 'object':
                dataset[col].fillna('type 0', inplace=True)
                dataset[col] = dataset[col].apply(lambda x: x.split(' ')[1]).astype(np.int32)
            elif dataset[col].dtype == 'bool':
                dataset[col] = dataset[col].astype(np.int8)
    
    dataset['year'] = dataset['date'].dt.year
    dataset['month'] = dataset['date'].dt.month
    dataset['day'] = dataset['date'].dt.day
    dataset['isweekend'] = (dataset['date'].dt.weekday >= 5).astype(int)
    dataset = dataset.drop('date', axis = 1)
    
    return dataset

En bref, toutes les données de catégorie sauf ['people_id', 'activity_id', 'date', 'char_38', 'result'] sont encodées et ['date'] est divisée en année, mois, jour et semaine. Ensuite, exécutez la fonction reduction_dimen sur les données concaténées du train et du test.

whole=pd.concat([train,test],ignore_index=True)
categorical=['group_1','activity_category','char_1_x','char_2_x','char_3_x','char_4_x','char_5_x','char_6_x','char_7_x','char_8_x','char_9_x','char_2_y','char_3_y','char_4_y','char_5_y','char_6_y','char_7_y','char_8_y','char_9_y']
for category in categorical:
    whole=reduce_dimen(whole,category,9999999)
    
X=whole[:len(train)]
X_test=whole[len(train):]

del train
del whole

La fonction reduction_dimen est la suivante.

def reduce_dimen(dataset,column,toreplace):
    for index,i in dataset[column].duplicated(keep=False).iteritems():
        if i==False:
            dataset.set_value(index,column,toreplace)
    return dataset

Encodez les données de catégorie de l'entrée X avec OneHotEncoder. Ceci termine les matrices creuses 0 et 1 X_sparse.

enc = OneHotEncoder(handle_unknown='ignore')
enc=enc.fit(pd.concat([X[categorical],X_test[categorical]]))
X_cat_sparse=enc.transform(X[categorical])
X_test_cat_sparse=enc.transform(X_test[categorical])
from scipy.sparse import hstack
X_sparse=hstack((X[not_categorical], X_cat_sparse))
X_test_sparse=hstack((X_test[not_categorical], X_test_cat_sparse))

Convertissez X_sparse en DMatrix et définissez les paramètres. Comme il existe de nombreux sites qui présentent le contenu de chaque paramètre en détail, les explications sont omises ici. Il existe quatre types principaux: {'max_depth': 10, 'eta': 0.02, 'silent': 1, 'objective': 'binary: logistic'}.

print("Training data: " + format(X_sparse.shape))
print("Test data: " + format(X_test_sparse.shape))
print("###########")
print("One Hot enconded Test Dataset Script")

dtrain = xgb.DMatrix(X_sparse,label=y)
dtest = xgb.DMatrix(X_test_sparse)

param = {'max_depth':10, 'eta':0.02, 'silent':1, 'objective':'binary:logistic' }
param['nthread'] = 4
param['eval_metric'] = 'auc'
param['subsample'] = 0.7
param['colsample_bytree']= 0.7
param['min_child_weight'] = 0
param['booster'] = "gblinear"

Apprenez avec XGBoost, faites des prédictions et vous avez terminé.

watchlist  = [(dtrain,'train')]
num_round = 300
early_stopping_rounds=10
bst = xgb.train(param, dtrain, num_round, watchlist,early_stopping_rounds=early_stopping_rounds)

ypred = bst.predict(dtest)
output = pd.DataFrame({ 'activity_id' : test['activity_id'], 'outcome': ypred })
output.head()

Cela vous donnera un score proche de 98%.

4. Apprentissage en profondeur avec Keras

Il y a pas mal de gens qui ont essayé l'approche neurale pour le moment. Fondamentalement, l'apprentissage en profondeur est rarement le meilleur modèle autre que les données d'image, mais probablement parce que la corrélation entre XGBoost et RandomForest et le résultat de la prédiction est faible, il est souvent utilisé pour renforcer XGBoost dans l'apprentissage d'ensemble. Je le sens.

Chez Kaggle en 2016, la majeure partie de l'apprentissage profond était Keras. Ici, la classification de classe est effectuée à l'aide de Keras.

4.1. Jusqu'à la conception du modèle

Tout d'abord, importez la bibliothèque.

import pandas as pd
import numpy as np
from scipy import sparse as ssp
import pylab as plt
from sklearn.preprocessing import LabelEncoder,LabelBinarizer,MinMaxScaler,OneHotEncoder
from sklearn.feature_extraction.text import TfidfVectorizer,CountVectorizer
from sklearn.decomposition import TruncatedSVD,NMF,PCA,FactorAnalysis
from sklearn.feature_selection import SelectFromModel,SelectPercentile,f_classif
from sklearn.decomposition import TruncatedSVD
from sklearn.metrics import log_loss,roc_auc_score
from sklearn.pipeline import Pipeline,make_pipeline
from sklearn.cross_validation import StratifiedKFold,KFold
from keras.preprocessing import sequence
from keras.callbacks import ModelCheckpoint,Callback
from keras import backend as K
from keras.layers import Input, Embedding, LSTM, Dense,Flatten, Dropout, merge,Convolution1D,MaxPooling1D,Lambda,AveragePooling1D
from keras.layers.normalization import BatchNormalization
from keras.optimizers import SGD
from keras.layers.advanced_activations import PReLU,LeakyReLU,ELU,SReLU
from keras.models import Model

Veuillez installer Keras et tensorflow (theano) à l'avance. Il existe également de nombreux sites écrits en japonais.

Vient ensuite le chemin des données et les paramètres de départ.

seed = 1
np.random.seed(seed)
dim = 32
hidden=64

path = "../input/"

Lisez les données de train, de test, de personnes et laissez les données concaténées être des données. data est une variable utilisée pour créer des couches d'entrée, intermédiaire et de sortie et qui est supprimée une fois la modélisation terminée.

train = pd.read_csv(path+'act_train.csv')
test = pd.read_csv(path+'act_test.csv')
people = pd.read_csv(path+'people.csv')
columns = people.columns
test['outcome'] = np.nan
data = pd.concat([train,test])
    
data = pd.merge(data,people,how='left',on='people_id').fillna('missing')
train = data[:train.shape[0]]
test = data[train.shape[0]:]

Jusqu'à ce point, la forme des données est (2695978, 55), qui est un DataFrame comprenant people_id et activity_id.

Ensuite, définissez les informations de colonne en tant que colonnes et encodez la valeur des données avec LabelEncoder de sklearn. Comme les données manquantes sont incluses dans les données, elles sont également codées de la même manière que les données numériques normales. Il semble que le programme soit écrit assez soigneusement, donc le programme est long. Notez s'il vous plaît.

columns = train.columns.tolist()
columns.remove('activity_id')
columns.remove('outcome')
data = pd.concat([train,test])
for c in columns:
    data[c] = LabelEncoder().fit_transform(data[c].values)

train = data[:train.shape[0]]
test = data[train.shape[0]:]
data = pd.concat([train,test])
columns = train.columns.tolist()
columns.remove('activity_id')
columns.remove('outcome')

Lorsque la préparation des données est terminée, commencez à définir le calque. Préparez la couche d'entrée et la couche d'incorporation de Keras, et préparez les couches en fonction des colonnes créées. Les détails de chaque couche sont décrits dans «Input (Embedding + Flatten) + Layer + Dropout + Output» dans Keras Case Study. Est omis. Voici une visualisation du modèle finalement terminé.

4.2. De la préparation des données d'entrée à model.fit

Étant donné que les données utilisées précédemment étaient destinées à la création du modèle, préparez X et y pour l'entrée. Classez les données d'entraînement / test avec skf et créez X_train et X_test.

X = train[columns].values
X_t = test[columns].values
y = train["outcome"].values
people_id = train["people_id"].values
activity_id = test['activity_id']
del train
del test

skf = StratifiedKFold(y, n_folds=4, shuffle=True, random_state=seed)
for ind_tr, ind_te in skf:
    X_train = X[ind_tr]
    X_test = X[ind_te]

    y_train = y[ind_tr]
    y_test = y[ind_te]
    break

X_train = [X_train[:,i] for i in range(X.shape[1])]
X_test = [X_test[:,i] for i in range(X.shape[1])]

del X

Dans le code d'origine, le modèle est ensuite enregistré à l'aide de ModelCheckpoint. Cependant, après tout, le point de contrôle n'est pas défini dans model.fit, donc une explication détaillée est omise ici.

Enfin, faites model.fit et model.predict et vous avez terminé.

model.fit(
    X_train, 
    y_train,
    batch_size=batch_size, 
    nb_epoch=nb_epoch, 
    verbose=1, 
    shuffle=True,
    validation_data=[X_test,y_test],
    callbacks = [
        model_checkpoint,
        auc_callback,
        ],
    )

Le score maximal de précision des prévisions est de 0,98. L'apprentissage en profondeur n'est pas particulièrement bon car les données d'origine sont faciles à prévoir.