[PYTHON] Wie man viele Pipelines zusammenbaut und sofort weglegt

1. Zuallererst

Pipeline ist praktisch, da Sie Code präzise schreiben können, wenn Sie verschiedene Vorverarbeitungsvorgänge verbinden. Diesmal ist ** eine Methode, um viele Pipelines zu einer zu kombinieren und gleichzeitig zu entfernen **, sehr gut. Es war praktisch, also werde ich es als Memorandum belassen.

2. Vorbereitung

Laden Sie den Demo-Datensatz von kaggles ** [HR Analytics] herunter (https://www.kaggle.com/giripujar/hr-analytics) **.

Bereiten Sie ** Eingabeordner, Ausgabeordner, Modellordner ** im aktuellen Verzeichnis vor und speichern Sie den heruntergeladenen Datensatz ** HR_comma_sep.csv ** im ** Eingabeordner **.

HR_comma_sep.csv ist ein Datensatz, der anhand der Merkmale von 9 Elementen vorhersagt, ob eine Person das Unternehmen verlässt (linke Spalte), und der insgesamt 14.999 Zeilen enthält.

Nehmen wir wie beim Kaggle-Wettbewerb an, dass 10.000 Linien Züge und die restlichen 4.999 Linien Tests sind und ein Trainingsmodell mit Zügen erstellt wird, um die Testergebnisse vorherzusagen.

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

# -------------Erstellen eines Datensatzes------------------
#Lesen Sie den Datensatz
df = pd.read_csv('./input/HR_comma_sep.csv')

#Zeilen mischen, Indizes zurücksetzen, IDs hinzufügen
df = df.sample(frac=1, random_state=1)  
df = df.reset_index(drop=True) 
df = df.reset_index()  
df = df.rename(columns={'index':'ID'})

#Zug nach Anzahl der Linien,In Test aufteilen
train = df[0:10000]
valid = df[10000:]

#Eine Hot-Codierung von Kategorievariablen
df_train = pd.get_dummies(train)
df_valid = pd.get_dummies(valid)

#Aufgeteilt in richtige Etiketten- und Merkmalsmenge
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)

#Aufgeteilt in Zug und 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()

Nach dem Mischen der Zeilen des Datensatzes wird dieser in Zug und Test aufgeteilt, und jede Kategorievariable wird einmalig codiert und in die richtige Bezeichnung (y, y_valid) und Merkmalsmenge (X, X_valid) getrennt.

Darüber hinaus sind X und y zum Erstellen eines Trainingsmodells ** train_test_split **, die in Training (X_train, y_train) und Bewertung (X_test, y_test) unterteilt sind. Damit ist die Vorbereitung abgeschlossen.

3. Pipeline-Einstellungen

Dieses Mal ** bereiten Sie 8 Pipelines von Trainingsmodellen mit Vorverarbeitung ** vor und kombinieren Sie sie zu einer großen Pipeline **. Auf diese Weise können Sie die acht Pipelines nacheinander verschieben.

# --------Pipeline-Einstellungen-------- 
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. Pipeline-Verarbeitung

Wenn Sie danach ** für Pipe-Name, Pipeline in pipelines.items (): ** ausführen, lautet die Zeichenfolge am Anfang jeder Pipeline (z. B. 'KNN') ** Pipe-Name **. Die Pipeline-Instanzen werden nacheinander in ** Pipeline ** eingegeben. Mit anderen Worten

** Erstellen Sie ein Trainingsmodell mit Pipeline.fit (X_train, y_train) ** ** Pipeline.predict (X_test) ** sagt mit Trainingsmodell voraus ** Speichern Sie das Trainingsmodell mit pickle.dump (Pipeline, open (Dateiname, wb))

Es kann so verwendet werden und ist sehr praktisch.

# -------Pipeline-Verarbeitung------
from sklearn.metrics import accuracy_score
from sklearn.metrics import log_loss
import pickle

scores = {}
for pipe_name, pipeline in pipelines.items():
    
    #Lernen
    pipeline.fit(X_train, y_train)
    
    #Indikatorberechnung
    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))
    
    #Senden speichern(Ausgabeordner)　
    ID=df_valid['ID']
    preds = pipeline.predict_proba(X_valid)  #Vorhersagewahrscheinlichkeit
    submission = pd.DataFrame({'ID': ID, 'left':preds[:, 1]})  
    submission.to_csv('./output/'+pipe_name+'.csv', index=False) 
    
    #Modell speichern(Modellordner)
    file_name = './model/'+pipe_name+'.pkl'
    pickle.dump(pipeline, open(file_name, 'wb'))

#Anzeige von Indikatoren
df = pd.Series(scores).unstack()
df = df.sort_values('test_acc', ascending=False)
print(df)

Hier werden für jede der acht Pipelines ** Lernen, Indexberechnung (Genauigkeit, Protokollverlust), Übermittlungsspeicherung (Vorhersagewahrscheinlichkeit) und Modellspeicherung ** durchgeführt. ** Pipeline ** ist sehr praktisch, wenn Sie eine ähnliche Verarbeitung auf einmal durchführen möchten.

Übrigens ist im Fall von kaggle y_valid ein Geheimnis (oder besser gesagt, es ist kaggle zu erraten), so dass valid_acc und valid_loss nicht berechnet werden können, aber diesmal weiß ich es, also füge ich es hinzu. ^^