table des matières

1. Résultat
2. À propos du modèle à utiliser
3. Comment évaluer le modèle
4. Essayez le modèle
5. Réglage des paramètres
6. Soumettre à Kaggle
7. Résumé

Histoire

1. Résultat

A partir du résultat, le score a un peu augmenté et est devenu "0,77511". Le résultat est le top 58% (au 29 décembre 2019). J'aimerais voir le déroulement jusqu'à la nouvelle soumission.

2. À propos du modèle à utiliser

La dernière fois, j'ai utilisé "Linear SVC" selon la feuille d'algorithme scikit-learn. J'ai d'abord appris l'apprentissage automatique [ce livre](https://www.amazon.co.jp/Python-%E6%A9%9F%E6%A2%B0%E5%AD%A6%E7%BF % 92% E3% 83% 97% E3% 83% AD% E3% 82% B0% E3% 83% A9% E3% 83% 9F% E3% 83% B3% E3% 82% B0-% E9% 81% 94% E4% BA% BA% E3% 83% 87% E3% 83% BC% E3% 82% BF% E3% 82% B5% E3% 82% A4% E3% 82% A8% E3% 83% B3% E3% 83% 86% E3% 82% A3% E3% 82% B9% E3% 83% 88% E3% 81% AB% E3% 82% 88% E3% 82% 8B% E7% 90% 86% E8% AB% 96% E3% 81% A8% E5% AE% 9F% E8% B7% B5-impress-gear / dp / 4295003379 / ref = dp_ob_title_bk) reprend le modèle suivant de scikit-learn sur le problème de classification. Je suis. ・ Sklearn.svm.LinearSVC ・ Sklearn.svm.SVC ・ Sklearn.ensemble.RandomForestClassifier ・ Sklearn.linear_model.LogisticRegression ・ Sklearn.linear_model.SGDClassifier

Cette fois, j'aimerais essayer le modèle ci-dessus.

3. Comment évaluer le modèle

La procédure d'évaluation du modèle est la suivante.

1. Apprenez à utiliser les données d'entraînement
2. Prédire à l'aide des données de test
3. Vérifiez si le résultat prévu est correct

Dans Titanic de Kaggle, il y a des données d'entraînement [train.csv](données qui montrent le résultat) et des données de test [test.csv](données qui ne connaissent pas le résultat). Si vous utilisez test.csv pour 2 "prédire" et 3 "confirmer", c'est inefficace car vous devez valider et soumettre le résultat à chaque fois. Les données de formation [train.csv] avec des résultats connus peuvent être évaluées efficacement en les divisant en données de formation et données de test. scikit-learn fournit une fonction "train_test_split" qui divise les données d'entraînement et les données de test.

from sklearn.model_selection import train_test_split

######################################
#Séparez les données d'entraînement et les données de test
# Split training data and test data
######################################
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=1, shuffle=True)

L'image est la suivante. Si test_size = 0.3, les données d'entraînement et les données de test seront divisées par "7: 3".

〇Données avant division

〇 Données d'entraînement après division

〇 Test des données après division

Viennent ensuite l'apprentissage et la prédiction.

Le modèle scikit-learn fournit une méthode «fit» pour l'apprentissage et une méthode «score» pour évaluer les prédictions. Ils sont «en forme» et «marqués».

from sklearn.svm import LinearSVC
model = LinearSVC(random_state=1)

######################################
#apprendre
# training
######################################
model.fit(x_train, y_train)

######################################
#Évaluer les résultats prévus
# Evaluate predicted results
######################################
score = model.score(x_test, y_test)

«Fit», c'est apprendre. "Score" prédit le résultat avec "x_test", correspond au résultat avec "y_test" et renvoie le taux de réponse correct. Dans le cas ci-dessus, le score serait "0,753731343283582". Le résultat est un taux de réponse correcte de 75%.

4. Essayez le modèle

Vous pouvez évaluer les performances d'un modèle en essayant différents modèles et en comparant leurs scores. Essayez le modèle dans "2. A propos du modèle à utiliser".

Le code global est ci-dessous.

Préparation

import numpy 
import pandas

# train.Charger csv
# Load train.csv
df = pandas.read_csv('/kaggle/input/titanic/train.csv')

##############################
#Prétraitement des données
#Extraire les éléments requis
# Data preprocessing 
# Extract necessary items
##############################
# 'Survived', 'Pclass', 'Sex', 'Fare'Extraire
# Extract 'Survived', 'Pclass', 'Age', 'Fare'
df = df[['Survived', 'Pclass', 'Sex', 'Fare']]

##############################
#Prétraitement des données
#Quantifier l'étiquette (nom)
# Data preprocessing 
# Digitize labels
##############################
from sklearn.preprocessing import LabelEncoder
#Quantifier le sexe à l'aide de Label Encoder
# Digitize gender using LabelEncoder
encoder_sex = LabelEncoder()
df['Sex'] = encoder_sex.fit_transform(df['Sex'].values)

##############################
#Prétraitement des données
#Normaliser les nombres
# Data preprocessing
# Standardize numbers
##############################
from sklearn.preprocessing import StandardScaler

#Standardisation
# Standardize numbers
standard = StandardScaler()
df_std = pandas.DataFrame(standard.fit_transform(df[['Pclass', 'Fare']]), columns=['Pclass', 'Fare'])

#Tarif standard
# Standardize Fare
df['Pclass'] = df_std['Pclass']
df['Fare'] = df_std['Fare']

from sklearn.model_selection import train_test_split

x = df.drop(columns='Survived')
y = df[['Survived']]

Données d'entraînement, création de données de test

#######################################
#Séparez les données d'entraînement et les données de test
# Split training data and test data
#######################################
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=1, shuffle=True)
y_train = numpy.ravel(y_train)
y_test = numpy.ravel(y_test)

Évaluation du modèle

#######################################
#Évaluer le modèle
# Evaluate the model
#######################################
from sklearn.svm import LinearSVC
model = LinearSVC(random_state=1)
model.fit(x_train, y_train)
score = model.score(x_test, y_test)
score

En remplaçant la partie de définition de modèle de «Évaluation du modèle», vous pouvez évaluer avec différents modèles. Essayez le modèle décrit dans "2. A propos du modèle à utiliser". Le résultat est le suivant.

Le résultat est que la forêt aléatoire est la meilleure. Ensuite, ajustons les paramètres du modèle de forêt aléatoire.

5. Réglage des paramètres

Utilisez la recherche de grille (GridSearchCV) dans scikit-learn pour ajuster les paramètres. La recherche de grille évalue les paramètres spécifiés dans tous les modèles et trouve la combinaison optimale de paramètres. Cependant, puisque tous les modèles sont évalués, plus vous avez de paramètres, plus le processus prendra du temps. Consultez la documentation Random Forest (https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html) et décidez d'ajuster les paramètres suivants:

Vous pouvez effectuer une recherche dans la grille en remplaçant «Évaluation du modèle» par la «Recherche en grille» suivante.

Recherche de grille

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
###############################################
#Essayez les paramètres LogisticRegression avec la recherche de grille
# Tuning LogisticRegression parameters with grid search
###############################################
pipe_svc = RandomForestClassifier(random_state=1)

param_grid = {'criterion':['gini','entropy'],
			  'n_estimators':[25, 100, 500, 1000, 2000],
			  'min_samples_split':[0.5, 2,4,10],
			  'min_samples_leaf':[1,2,4,10],
			  'bootstrap':[True, False]
			  }

grid = GridSearchCV(estimator=RandomForestClassifier(random_state=1), param_grid=param_grid)
grid = grid.fit(x_train, y_train)

print(grid.best_score_)
print(grid.best_params_)

Le résultat est le suivant. Dans mon environnement, il a fallu environ 10 minutes pour exécuter la recherche de grille.

Résultats de la recherche dans la grille

0.8105939004815409
{'bootstrap': False, 'criterion': 'entropy', 'min_samples_leaf': 10, 'min_samples_split': 2, 'n_estimators': 100}

6. Soumettre à Kaggle

Spécifions les paramètres réglés par la recherche de grille, apprenons et prédisons. Réécrivez le code «Données de formation, création de données de test» et «Recherche de grille» comme suit pour effectuer l'apprentissage et la prédiction.

Apprentissage, anticipation

##############################
#Construire un modèle
# Model building
##############################
from sklearn.ensemble import RandomForestClassifier

#Générer un modèle
# Generate a model
model = RandomForestClassifier(n_estimators=100, \
                               criterion='entropy', \
                               min_samples_split=2, \
                               min_samples_leaf=10, \
                               bootstrap=False, \
                               random_state=1)

##############################
#Apprentissage
# Trainig
##############################
y = numpy.ravel(y)
model.fit(x, y)

# test.Convertir csv
# convert test.csv
##############################
# test.Charger csv
# Load test.csv
df_test = pandas.read_csv('/kaggle/input/titanic/test.csv')

#Convertir Fare Nan
# Convert Fare Nan to 0 
df_test = df_test.fillna({'Fare':0})

# 'PassengerId'Extraire(À combiner avec le résultat)
# Extract 'PassengerId'(To combine with the result)
df_test_index = df_test[['PassengerId']]

# 'Pclass', 'Sex', 'Fare'Extraire
# Extract 'Pclass', 'Sex', 'Fare'
df_test = df_test[['Pclass', 'Sex', 'Fare']]

#Standardisation
# Standardize
df_test_std = pandas.DataFrame(standard.transform(df_test[['Pclass', 'Fare']]), columns=['Pclass', 'Fare'])
df_test['Pclass'] = df_test_std['Pclass']
df_test['Fare'] = df_test_std['Fare']

#Encodage des étiquettes
# Label Encoding
df_test ['Sex'] = encoder_sex.transform(df_test ['Sex'].values)

##############################
#Prédire les résultats
# Predict results
##############################
x_test = df_test.values
y_test = model.predict(x_test)

#Combinez le résultat avec le DataFrame du PassengerId
# Combine the data frame of PassengerId and the result
df_output = pandas.concat([df_test_index, pandas.DataFrame(y_test, columns=['Survived'])], axis=1)

# result.Ecrire csv dans le répertoire courant
# Write result.csv to the current directory
df_output.to_csv('result.csv', index=False)

Décrivez ce qui précède dans l'environnement Kaggle. Exécutez "Tout exécuter" et vérifiez que result.csv est créé.

Soumettez en sélectionnant «Commit» ⇒ «Open Version» ⇒ «Submit to Competition».

Le score est désormais de "0.77511".

7. Résumé

Cette fois, j'ai pu augmenter un peu le score en comparant 5 types de modèles et en ajustant les paramètres. La prochaine fois aimerait trouver un modèle plus approprié parmi divers modèles de scikit-learn.

Histoire

2019/12/29 Première édition publiée 01/01/2020 Ajouter le lien suivant 2020/01/03 Commentaires corrigés sur la source