0. Introduction

Le flux général de régression / classification utilisant l'apprentissage automatique avec Kaggle, etc. Lecture des données → Traitement des valeurs manquantes → Codage des étiquettes → → EDA → Un encodage à chaud → → Créer un modèle de base → Construire un modèle complexe → → Réglage des paramètres C'est comme ça.

Parmi eux, la régression / classification dans le modèle de base peut être résolue comme un modèle relatif. De plus, il peut être résolu plus rapidement en utilisant le traitement Pipeline. Donc, cette fois, j'ai résumé la construction du modèle de base et le traitement du pipeline.

1. Préparation

L'ensemble de données utilisé cette fois est l'ensemble de données titanesque qui a été déposé dans Kaggle.

Cela ressemble à ceci jusqu'à un encodage à chaud. Les détails à ce jour sont résumés dans l'article précédent.

`In[1]`


%matplotlib inline
import matplotlib as plt
import pandas as pd
import numpy as np
import seaborn as sns
import collections

df = pd.read_csv('./train.csv')
df = df.set_index('PassengerId') #Définir des colonnes uniques à indexer
df = df.drop(['Name', 'Ticket'], axis=1) #Supprimer les colonnes qui ne sont pas nécessaires pour l'analyse
df = df.drop(['Cabin'], axis=1) #Supprimé car il semble difficile à utiliser pour l'analyse
df = df.dropna(subset = ['Embarked']) #La cabine a peu de défauts, supprimez donc la ligne avec dropna
df = df.fillna(method = 'ffill') #D'autres colonnes complètent les données précédentes

from sklearn.preprocessing import LabelEncoder
for column in ['Sex','Embarked']:
    le = LabelEncoder()
    le.fit(df[column])
    df[column] = le.transform(df[column])

df_continuous = df[['Age','SibSp','Parch','Fare']]

df = pd.get_dummies(df, columns = ['Pclass','Embarked'])
df.head()

Ensuite, divisez-le en données de train et de test avec train_test_split.

`In[2]`


from sklearn.model_selection import train_test_split

X = df.drop(['Survived'], axis=1) 
y = df['Survived']

validation_size = 0.20
seed = 42 
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=validation_size,random_state=seed)

2. Création d'un modèle de ligne de base

Thanks: https://www.kaggle.com/mdiqbalbajmi/titanic-survival-prediction-beginner

La bibliothèque requise ressemble à ceci.

`In[3]`


from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier

Cette fois, nous utiliserons ces six algorithmes comme modèle de base.

--Régression logistique

Discrimination linéaire --KNN (méthode de voisinage k) --CART (arbre de décision) --Gaussian Naive Bayes
Machine de vecteur de soutien

Nous utilisons également la validation croisée de KFold pour voir la variance des scores pour chaque modèle.

`In[4]`



# Spot-check Algorithms
models = []

# In LogisticRegression set: solver='lbfgs',multi_class ='auto', max_iter=10000 to overcome warning
models.append(('LR',LogisticRegression(solver='lbfgs',multi_class='auto',max_iter=10000)))
models.append(('LDA',LinearDiscriminantAnalysis()))
models.append(('KNN',KNeighborsClassifier()))
models.append(('CART',DecisionTreeClassifier()))
models.append(('NB',GaussianNB()))
models.append(('SVM',SVC(gamma='scale')))

# evaluate each model in turn
results = []
names = []

for name, model in models:
    # initializing kfold by n_splits=10(no.of K)
    kfold = KFold(n_splits = 10, random_state=seed, shuffle=True) #crossvalidation
    
    # cross validation score of given model using cross-validation=kfold
    cv_results = cross_val_score(model,X_train,y_train,cv=kfold, scoring="accuracy")
    
    # appending cross validation result to results list
    results.append(cv_results)
    
    # appending name of algorithm to names list
    names.append(name)
    
    # printing cross_validation_result's mean and standard_deviation
    print(name, cv_results.mean()*100.0, "(",cv_results.std()*100.0,")")

La sortie ressemble à ceci.

`out[4]`


LR 80.15845070422536 ( 5.042746503951439 )
LDA 79.31533646322379 ( 5.259067356458109 )
KNN 71.1658841940532 ( 3.9044128926316235 )
CART 76.50821596244131 ( 4.1506876372712815 )
NB 77.91471048513301 ( 4.426999157571688 )
SVM 66.9424882629108 ( 6.042153317290744 )

Visualisez cela avec un diagramme de moustaches.

`In[5]`


figure = plt.figure()
figure.suptitle('Algorithm Comparison')
ax = figure.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names);

Voici le graphique de sortie.

3. Traitement du pipeline

Lorsqu'il y a plusieurs processus, il y a de belles choses à faire avec les pipelines de ces processus. Le code peut être simplifié et les hyperparamètres peuvent être facilement recherchés en les combinant avec GridSearch.

Ce que vous pouvez faire avec le traitement Pipeline

Cette fois, je vais essayer de canaliser la mise à l'échelle standard et la classification par modèle.

`In[6]`


# import pipeline to make machine learning pipeline to overcome data leakage problem
from sklearn.pipeline import Pipeline

# import StandardScaler to Column Standardize the data
# many algorithm assumes data to be Standardized
from sklearn.preprocessing import StandardScaler

# test options and evaluation matrix
num_folds=10
seed=42
scoring='accuracy'

# import warnings filter
from warnings import simplefilter
# ignore all future warnings
simplefilter(action='ignore', category=FutureWarning)

Un avertissement apparaîtra, donc nous nous en occupons également.

Créez des pipelines pour chaque modèle de base et stockez-les dans des pipelines.

`In[7]`


# source of code: machinelearningmastery.com
# Standardize the dataset
pipelines = []
pipelines.append(('ScaledLR', Pipeline([('Scaler', StandardScaler()),('LR',LogisticRegression(solver='lbfgs',multi_class='auto',max_iter=10000))])))
pipelines.append(('ScaledLDA', Pipeline([('Scaler', StandardScaler()),('LDA',LinearDiscriminantAnalysis())])))
pipelines.append(('ScaledKNN', Pipeline([('Scaler', StandardScaler()),('KNN',KNeighborsClassifier())])))
pipelines.append(('ScaledCART', Pipeline([('Scaler', StandardScaler()),('CART',DecisionTreeClassifier())])))
pipelines.append(('ScaledNB', Pipeline([('Scaler', StandardScaler()),('NB',GaussianNB())])))
pipelines.append(('ScaledSVM', Pipeline([('Scaler', StandardScaler()),('SVM', SVC(gamma='scale'))])))
results = []
names = []
for name, model in pipelines:
    kfold = KFold(n_splits=num_folds, random_state=seed)
    cv_results = cross_val_score(model, X_train, y_train, cv=kfold, scoring=scoring)
    results.append(cv_results)
    names.append(name)
    msg = "%s: %f (%f)" % (name, cv_results.mean()*100, cv_results.std())
    print(msg)

Voici la sortie.

`out[7]`


ScaledLR: 79.743740 (0.029184)
ScaledLDA: 79.045383 (0.042826)
ScaledKNN: 82.838419 (0.031490)
ScaledCART: 78.761737 (0.028512)
ScaledNB: 77.779734 (0.037019)
ScaledSVM: 82.703443 (0.029366)

Tracez ceci sur un diagramme de moustaches de boîte.

`In[8]`


# Compare Algorithms
fig = plt.figure()
fig.suptitle('Algorithm Comparison')
ax = fig.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names)
plt.show()

Ceci est le graphique de sortie.

4. Résumé

J'ai résumé la construction du modèle de base et le traitement du pipeline. Le traitement du pipeline semble être profond.

Nous sommes toujours à la recherche d'articles, de commentaires, etc.

[PYTHON] [Kaggle] Construction du modèle de base, traitement du pipeline

0. Introduction

1. Préparation

In[1]

In[2]

2. Création d'un modèle de ligne de base

In[3]

In[4]

out[4]

In[5]