[PYTHON] Comment assembler de nombreux pipelines et les ranger en même temps

1.Tout d'abord

Pipeline est pratique car vous pouvez écrire du code de manière concise lorsque vous connectez divers pré-processus, mais cette fois, ** une méthode pour combiner plusieurs pipelines en un seul et le ranger en même temps ** est très bonne. C'était pratique, je vais donc le laisser sous forme de mémorandum.

2. Préparation

Téléchargez l'ensemble de données de démonstration de kaggle ** HR Analytics **.

Préparez ** dossier d'entrée, dossier de sortie, dossier de modèle ** dans le répertoire actuel et enregistrez l'ensemble de données téléchargé ** HR_comma_sep.csv ** dans ** dossier d'entrée **.

HR_comma_sep.csv est un ensemble de données qui prédit si une personne quittera l'entreprise (colonne de gauche) en fonction des caractéristiques de 9 éléments, et a un total de 14 999 lignes.

Comme dans la compétition kaggle, supposons que 10 000 lignes sont des trains et que les 4 999 lignes restantes sont des tests, et un modèle d'entraînement est créé avec des trains pour prédire les résultats des tests.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

# -------------Créer un jeu de données------------------
#Lire l'ensemble de données
df = pd.read_csv('./input/HR_comma_sep.csv')

#Mélanger les lignes, réinitialiser les index, ajouter des ID
df = df.sample(frac=1, random_state=1)  
df = df.reset_index(drop=True) 
df = df.reset_index()  
df = df.rename(columns={'index':'ID'})

#Train par nombre de lignes,Diviser en test
train = df[0:10000]
valid = df[10000:]

#Un encodage à chaud des variables de catégorie
df_train = pd.get_dummies(train)
df_valid = pd.get_dummies(valid)

#Divisé en étiquette correcte et quantité de fonction
y = df_train['left']
X = df_train.drop(['ID','left'], axis=1)
y_valid = df_valid['left']
X_valid = df_valid.drop(['ID','left'], axis=1)

#Divisé en train et test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)    

print('X_train.shape = ', X_train.shape)
print('y_train.shape =  ', y_train.shape)
print('X_test.shape = ', X_test.shape)
print('y_test.shape = ', y_test.shape)
print('X_valid.shape = ', X_valid.shape)
print('y_valid.shape = ', y_valid.shape)
print()

Après avoir mélangé les lignes de l'ensemble de données, il est divisé en train et test, et chaque variable catégorielle est encodée à chaud et séparée en étiquette correcte (y, y_valid) et en quantité d'entités (X, X_valid).

De plus, X et y pour créer un modèle d'apprentissage sont ** train_test_split **, qui sont divisés en entraînement (X_train, y_train) et évaluation (X_test, y_test). Ceci termine la préparation.

3. Paramètres du pipeline

Cette fois, ** préparez 8 pipelines de modèles de formation avec prétraitement ** et combinez-les en un seul gros pipeline **. En faisant cela, vous pouvez déplacer les huit pipelines dans l'ordre.

# --------Paramètres du pipeline-------- 
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.pipeline import Pipeline

pipelines = {    
    'KNN':
        Pipeline([('scl',StandardScaler()),
                  ('est',KNeighborsClassifier())]), 
    'Logistic':
        Pipeline([('scl',StandardScaler()),
                  ('est',LogisticRegression(solver='lbfgs', random_state=1))]), 
    'SVM':
        Pipeline([('scl',StandardScaler()),
                  ('est',SVC(C=1.0, kernel='linear', class_weight='balanced', random_state=1, probability=True))]),
    'K-SVM':
        Pipeline([('scl',StandardScaler()),
                  ('est',SVC(C=1.0, kernel='rbf', class_weight='balanced', random_state=1, probability=True))]),
    'Tree':
        Pipeline([('scl',StandardScaler()),
                  ('est',DecisionTreeClassifier(random_state=1))]),
    'RandomF':
        Pipeline([('scl',StandardScaler()),
                  ('est',RandomForestClassifier(n_estimators=100, random_state=1))]), 
    'GBoost':
        Pipeline([('scl',StandardScaler()),
                  ('est',GradientBoostingClassifier(random_state=1))]),    
    'MLP':
        Pipeline([('scl',StandardScaler()),
                  ('est',MLPClassifier(hidden_layer_sizes=(3,3),
                                       max_iter=1000,
                                       random_state=1))]), 
    }

5. Traitement des pipelines

Après cela, si vous faites ** pour pipe_name, pipeline dans pipelines.items (): **, la chaîne de caractères au début de chaque pipeline (par exemple, 'KNN') sera ** pipe_name **, respectivement. Les instances de pipeline sont entrées séquentiellement dans ** pipeline **. En d'autres termes

** Créez un modèle d'entraînement avec pipeline.fit (X_train, y_train) ** ** pipeline.predict (X_test) ** prédit avec le modèle d'entraînement ** Enregistrez le modèle d'entraînement avec pickle.dump (pipeline, open (file_name, 'wb')) **

Il peut être utilisé comme ça et est très pratique.

# -------Traitement du pipeline------
from sklearn.metrics import accuracy_score
from sklearn.metrics import log_loss
import pickle

scores = {}
for pipe_name, pipeline in pipelines.items():
    
    #Apprentissage
    pipeline.fit(X_train, y_train)
    
    #Calcul des indicateurs
    scores[(pipe_name,'test_log')] = log_loss(y_test, pipeline.predict_proba(X_test))
    scores[(pipe_name,'valid_log')] = log_loss(y_valid, pipeline.predict_proba(X_valid))
    scores[(pipe_name,'test_acc')] = accuracy_score(y_test, pipeline.predict(X_test))
    scores[(pipe_name,'valid_acc')] = accuracy_score(y_valid, pipeline.predict(X_valid))
    
    #Soumettre enregistrer(dossier de sortie)　
    ID=df_valid['ID']
    preds = pipeline.predict_proba(X_valid)  #Probabilité de prédiction
    submission = pd.DataFrame({'ID': ID, 'left':preds[:, 1]})  
    submission.to_csv('./output/'+pipe_name+'.csv', index=False) 
    
    #Enregistrer le modèle(dossier de modèle)
    file_name = './model/'+pipe_name+'.pkl'
    pickle.dump(pipeline, open(file_name, 'wb'))

#Affichage des indicateurs
df = pd.Series(scores).unstack()
df = df.sort_values('test_acc', ascending=False)
print(df)

Ici, ** l'apprentissage, le calcul de l'indice (précision, perte de log), l'enregistrement de soumission (probabilité de prédiction) et l'enregistrement du modèle ** sont effectués pour chacun des huit pipelines. ** pipeline ** est très pratique lorsque vous souhaitez effectuer un traitement similaire en même temps.

Au fait, dans le cas de kaggle, y_valid est un secret (ou plutôt, c'est kaggle à deviner), donc valid_acc et valid_loss ne peuvent pas être calculés, mais cette fois je le sais, donc je l'ajoute. ^^