Certains modèles de Kaggle's Titanic (kaggle ④)

introduction

Voici l’histoire de la participation au concours Kaggle </ b> pour la première fois. Dans le précédent «Vérification de la corrélation avec le Titanic de Kaggle» [https://qiita.com/sudominoru/items/840e87cc77de29f10ca2), nous avons examiné la corrélation et examiné Pclass (classe de billet), le sexe (sexe), le tarif. J'ai décidé d'utiliser trois données d'entrée de (tarif). Cette fois, j'aimerais essayer quelques modèles.

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

yx
SurvivedPclassSexFare
103male7.25
211female71.2833
313female7.925
411female53.1
503male8.05
603male8.4583
701male51.8625
803male21.075
913female11.1333
1012female30.0708

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

y_trainx_train
SurvivedPclassSexFare
103male7.25
211female71.2833
411female53.1
503male8.05
603male8.4583
803male21.075
1012female30.0708

〇 Test des données après division

y_testx_test
SurvivedPclassSexFare
313female7.925
701male51.8625
913female11.1333

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.

modèle score
sklearn.svm.LinearSVC 0.753
sklearn.svm.SVC 0.783
sklearn.ensemble.RandomForestClassifier 0.805
sklearn.linear_model.LogisticRegression 0.753
sklearn.linear_model.SGDClassifier 0.753

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:

Paramètres modèle
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 Ture / False

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». 20191229_01.png

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

Recommended Posts

Certains modèles de Kaggle's Titanic (kaggle ④)
Prédire le Titanic de Kaggle avec Keras (Kaggle ⑦)
Vérifiez les données brutes avec Kaggle's Titanic (Kaggle ⑥)
J'ai essayé d'apprendre avec le Titanic de Kaggle (kaggle②)
Vérifiez la corrélation avec le Titanic de Kaggle (kaggle③)
Essayez tous les modèles de scikit-learn avec le Titanic de Kaggle (kaggle ⑤)
Défiez Kaggle Titanic
Essayez le didacticiel Titanic de Kaggle
Prédisons les survivants du Hello World de Kaggle, Titanic par régression logistique-Modélisation-
J'ai essayé de prédire et de soumettre les survivants du Titanic avec Kaggle
Prédisons les survivants de Hello World, Titanic de Kaggle par régression logistique-Prédiction / Évaluation-
Kaggle Tutorial Titanic Précision 80.9% (Top 7% 0.80861)
[Pour les débutants de Kaggle] Titanic (LightGBM)
Essayez le machine learning à la légère avec Kaggle