0. Einleitung

Der allgemeine Fluss der Regression / Klassifizierung durch maschinelles Lernen mit Kaggle usw. Daten lesen → Verarbeitung fehlender Werte → Etikettencodierung → → EDA → Eine Hot-Codierung → → Erstellen Sie ein Basismodell → Erstellen Sie ein komplexes Modell → → Parametereinstellung Es ist wie es ist.

Unter diesen kann die Regression / Klassifizierung im Basismodell als relativ Muster gelöst werden. Darüber hinaus kann es durch die dortige Pipeline-Verarbeitung schneller gelöst werden. Dieses Mal habe ich die Konstruktion des Basismodells und die Pipeline-Verarbeitung zusammengefasst.

1. Vorbereitung

Der diesmal verwendete Datensatz ist der Titan-Datensatz, der in Kaggle abgelegt wurde.

Es sieht so aus, bis eine heiße Codierung. Die bisherigen Details sind im vorherigen Artikel zusammengefasst.

`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') #Setzen Sie eindeutige Spalten auf Index
df = df.drop(['Name', 'Ticket'], axis=1) #Löschen Sie Spalten, die für die Analyse nicht benötigt werden
df = df.drop(['Cabin'], axis=1) #Gelöscht, da die Analyse schwierig zu sein scheint
df = df.dropna(subset = ['Embarked']) #Die Kabine weist nur wenige Mängel auf. Löschen Sie daher die Zeile mit dropna
df = df.fillna(method = 'ffill') #Andere Spalten ergänzen frühere Daten

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()

Teilen Sie es dann mit train_test_split in Zug- und Testdaten auf.

`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. Erstellen eines Basismodells

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

Die erforderliche Bibliothek sieht folgendermaßen aus.

`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

Dieses Mal werden wir diese sechs Algorithmen als Basismodell verwenden.

--Logistische Regression

Lineare Diskriminierung --KNN (k Nachbarschaftsmethode) --CART (Entscheidungsbaum)
Gaußsche naive Bayes --Unterstützungsvektormaschine

Wir verwenden auch die KFold-Kreuzvalidierung, um die Varianz der Scores für jedes Modell zu ermitteln.

`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,")")

Die Ausgabe sieht so aus.

`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 )

Visualisieren Sie dies mit einem Box-Whisker-Diagramm.

`In[5]`


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

Hier ist das Ausgabediagramm.

3. Pipeline-Verarbeitung

Wenn es mehrere Prozesse gibt, gibt es einige nette Dinge, die mit Pipelines dieser Prozesse zu tun haben. Der Code kann vereinfacht werden, und Hyperparameter können durch Kombination mit GridSearch leicht durchsucht werden.

Was Sie mit der Pipeline-Verarbeitung tun können

Dieses Mal werde ich versuchen, die Standardskalierung und Klassifizierung nach Modell zu leiten.

`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)

Eine Warnung wird angezeigt, daher beschäftigen wir uns auch damit.

Erstellen Sie Pipelines für jedes Basismodell und speichern Sie sie in 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)

Hier ist die Ausgabe.

`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)

Zeichnen Sie dies in ein Box-Whisker-Diagramm.

`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()

Dies ist das Ausgabediagramm.

4. Zusammenfassung

Ich habe den Aufbau des Basismodells und die Pipeline-Verarbeitung zusammengefasst. Die Pipeline-Verarbeitung scheint tief zu sein.

Wir sind immer auf der Suche nach Artikeln, Kommentaren usw.

[PYTHON] [Kaggle] Basismodellkonstruktion, Pipeline-Verarbeitung

0. Einleitung

1. Vorbereitung

In[1]

In[2]

2. Erstellen eines Basismodells

In[3]

In[4]

out[4]

In[5]