J'ai essayé d'apprendre avec le Titanic de Kaggle (kaggle②)

introduction

Voici l’histoire de votre première participation au concours Kaggle </ b>. Dans Last "First Kaggle", ・ Comment participer à Kaggle ・ Comment participer au concours ・ Jusqu'à ce que vous rejoignez et écrivez le code ・ Comment soumettre les résultats J'ai principalement écrit. Cette fois, je voudrais passer au point d'étudier au "Titanic competition". Le taux de précision de l'échantillon de code peut-il dépasser "76%"?

table des matières

  1. Connaissances préalables
  2. Flux d'apprentissage
  3. Organiser les données 3.1. Extraire les éléments requis 3.2. Gérer les valeurs manquantes 3.3. Numériser les étiquettes 3.4. Normaliser les nombres
  4. Construisez un modèle
  5. Apprenez avec les données d'entraînement
  6. Prédire les résultats avec les données de test
  7. Résultat soumis
  8. Résumé Histoire

1. Connaissances préalables

C'est à partir du point de savoir à quel point une personne qui connaît l'apprentissage automatique le décrit. Il y a environ six mois (avril 2019), je me suis intéressé à l'apprentissage automatique et j'ai principalement appris des livres suivants. ・ [Théorie et pratique par un spécialiste de la programmation de l'apprentissage automatique Python](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) ・ [Explication détaillée Apprentissage en profondeur ~ Traitement des données de séries temporelles par TensorFlow ・ Keras ~](https://www.amazon.co.jp/%E8%A9%B3%E8%A7%A3-%E3%83%87%E3 % 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0-TensorFlow% E3 % 83% BBKeras% E3% 81% AB% E3% 82% 88% E3% 82% 8B% E6% 99% 82% E7% B3% BB% E5% 88% 97% E3% 83% 87% E3% 83 % BC% E3% 82% BF% E5% 87% A6% E7% 90% 86-% E5% B7% A3% E7% B1% A0-% E6% 82% A0% E8% BC% 94 / dp / 4839962510 / ref = sr_1_2? __mk_ja_JP =% E3% 82% AB% E3% 82% BF% E3% 82% AB% E3% 83% 8A & mots-clés =% E8% A9% B3% E8% A7% A3 +% E3% 83% 87 % E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0 +% 7ETensorFlow % E3% 83% BBKeras% E3% 81% AB% E3% 82% 88% E3% 82% 8B% E6% 99% 82% E7% B3% BB% E5% 88% 97% E3% 83% 87% E3 % 83% BC% E3% 82% BF% E5% 87% A6% E7% 90% 86 & qid = 1575853564 & s = livres & sr = 1-2)

C'est une situation où vous ne savez pas ce que sont "scikit-learn", "tensorflow" et "keras".

L'image que je comprends est la suivante.

  • scikit-learn a peu de paramètres et peut être appris facilement (la vitesse de traitement est rapide)
  • keras est un groupe de bibliothèques d'apprentissage automatique qui s'exécutent sur tensorflow. Il peut être défini plus finement que scikit-learn. (Keras semble fonctionner en dehors de tensorflow, mais je ne connais pas les détails. Theano?)
  • tensorflow est un groupe de bibliothèques pour l'apprentissage automatique, mais cette bibliothèque est proche d'un conteneur. Vous pouvez gérer des «constantes», des «variables» et des «espaces réservés» qui sont pratiques pour l'apprentissage automatique, mais si vous n'utilisez que tensorflow, vous devez créer vos propres «fonction d'activation» et «fonction d'évaluation».

À mon niveau, je me demande si je peux écrire du code d'apprentissage en utilisant scicit-learn ou keras.

2. Flux d'apprentissage

Le flux de l'apprentissage automatique est le suivant.

  1. Organisez les données
  2. Construisez un modèle
  3. Apprenez avec les données d'entraînement
  4. Prédire les résultats avec les données de test

3. Organiser les données

Vérifiez et gérez les données.

20191209_01.png

Tout d'abord, puisque nous allons commencer avec un nouveau Notebook différent du précédent, cliquez sur "New Notebook" et sélectionnez la langue "Paython" et tapez "Notebook" comme avant.

20191209_02.png

Vérifiez train.csv. Puisque vous pouvez écrire le code, vous pouvez afficher les données avec la commande pandas.head (), mais vous pouvez également le télécharger, alors téléchargeons-le. Cliquez sur train.csv et vous verrez 100 lignes de données à l'écran. Vous pouvez le télécharger avec le bouton de téléchargement.

PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
1 0 3 Braund, male 22 1 0 A/5 21171 7.25 S
2 1 1 Cumings, female 38 1 0 PC 17599 71.2833 C85 C
3 1 3 Heikkinen, female 26 0 0 STON/O2. 3101282 7.925 S
4 1 1 Futrelle, female 35 1 0 113803 53.1 C123 S
5 0 3 Allen, male 35 0 0 373450 8.05 S
6 0 3 Moran, male 0 0 330877 8.4583 Q
7 0 1 McCarthy male 54 0 0 17463 51.8625 E46 S
8 0 3 Palsson, male 2 3 1 349909 21.075 S
9 1 3 Johnson, female 27 0 2 347742 11.1333 S
10 1 2 Nasser, female 14 1 0 237736 30.0708 C

Vérifiez CSV avec Excel, etc. Il y a certains éléments que je ne comprends pas, mais il y a une description dans les données du concours. En aparté, comme expliqué dans OverView, l'échantillon "gender_submission.csv" semble considérer "seules les femmes ont survécu". Certes, les valeurs de "Sex" dans "test.csv" et "Survived" dans "gender_submission.csv" correspondent. C'est pourquoi le taux de réponse correcte de «76%» est tout à fait formidable.

20191209_03.png Data Dictionary

Variable Definition Traduction Key
survival Survival Survie 0 = No, 1 = Yes
pclass Ticket class Classe de billet 1 = 1st, 2 = 2nd, 3 = 3rd
sex Sex sexe
Age Age in years âge
sibsp # of siblings / spouses aboard the Titanic Frères chevauchant le Titanic/Nombre de conjoints
parch # of parents / children aboard the Titanic Parents chevauchant le Titanic/Nombre d'enfants
ticket Ticket number Numéro de billet
fare Passenger fare Tarif passager
cabin Cabin number Numéro de chambre
embarked Port of Embarkation Port d'embarquement C = Cherbourg, Q = Queenstown, S = Southampton

Réfléchissez aux éléments à utiliser pour l'apprentissage. Puisque "Survival" est la partie qui est demandée, je vais l'utiliser comme réponse d'apprentissage. Étant donné que les femmes et les enfants sont plus susceptibles de monter sur l'embarcation de sauvetage en priorité, les termes «sexe» et «âge» sont utilisés. De plus, selon la situation, la richesse peut avoir eu un effet. Utilisons également «classe de billet» et «tarif passager». «Nom», «numéro de billet» et «port d'embarquement» ne semblent pas liés, ils sont donc exclus. Le problème est "sibsp" et "parch". Lorsque "sibsp" et "parch" sont agrégés par Excel, etc., c'est comme suit. Cela semble être lié, mais cette fois je l'ai exclu par souci de simplicité.

sibsp (nombre de frères / conjoints sur le Titanic)

valeur de sibsp Survival=1 Survival=0 Taux de survie
0 210 608 26%
1 112 209 35%
2 13 28 32%
3 4 16 20%
4 3 18 14%
5 0 5 0%
8 0 7 0%

parch (nombre de parents / enfants sur le Titanic)

valeur du parchemin Survival=1 Survival=0 Taux de survie
0 233 678 26%
1 65 118 36%
2 40 80 33%
3 3 5 38%
4 0 4 0%
5 1 5 17%
6 0 1 0%

3.1. Extraire les éléments requis

Supprimez l'exemple de code et écrivez le code suivant. Chargez train.csv et extrayez uniquement les éléments requis ('Survived', 'Pclass', 'Sex', 'Age', 'Fare').

import numpy 
import pandas 

##############################
#Prétraitement des données 1
#Extraire les éléments requis
##############################

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

df_train = df_train.loc[:, ['Survived', 'Pclass', 'Sex', 'Age', 'Fare']]
df_train.head()
index Survived Pclass Sex Age Fare
0 0 3 male 22 7.25
1 1 1 female 38 71.2833
2 1 3 female 26 7.925
3 1 1 female 35 53.1
4 0 3 male 35 8.05

J'ai pu extraire uniquement les éléments requis.

3.2. Gérer les valeurs manquantes

Vérifiez les valeurs manquantes.

##############################
#Prétraitement des données 2
#Gérer les valeurs manquantes
##############################

#Vérifiez les valeurs manquantes
df_train.isnull().sum()
Colonne compter
Survived 0
Pclass 0
Sex 0
Age 177
Fare 0

Il existe de nombreuses données sans âge. Si possible, remplissez les valeurs manquantes, mais cette fois supprimez-les.

#Supprimer les lignes avec un âge nul
# Delete rows with null age
df_train = df_train.dropna(subset=['Age']).reset_index(drop=True)
len(df_train)
compter
714

Les lignes dont l'âge est nul ont été supprimées.

3.3. Numériser les étiquettes

Les genres «masculin» et «féminin» sont difficiles à gérer tels quels, alors numérisez-les. Comme il n'y a que deux types, masculin et féminin, vous pouvez les convertir vous-même, mais scikit-learn a une classe pratique appelée LabelEncoder </ b>, alors utilisons-la. LabelEncoder: la méthode fit et la méthode fit_transform remplacent la chaîne de caractères par un entier de 0 à N-1 lorsqu'il y a N types de chaînes de caractères apparaissant dans l'entrée.

##############################
#Prétraitement des données 3
#Quantifier l'étiquette (nom)
##############################
from sklearn.preprocessing import LabelEncoder

#Quantifier le sexe à l'aide de Label Encoder
encoder = LabelEncoder()
df_train['Sex'] = encoder.fit_transform(df_train['Sex'].values)
df_train.head()
index Survived Pclass Sex Age Fare
0 0 3 1 22 7.25
1 1 1 0 38 71.2833
2 1 3 0 26 7.925
3 1 1 0 35 53.1
4 0 3 1 35 8.05

Le «sexe» a été quantifié. Cet encodeur sera également utilisé plus tard lors de la quantification du sexe dans test.csv.

3.4. Normaliser les nombres

Il semble qu'il existe de nombreux cas où il est possible de mieux apprendre en ajustant l'échelle (standardisation) plutôt qu'en entrant les valeurs numériques comme des données d'apprentissage telles qu'elles sont. Par exemple, lors de l'analyse des résultats de tests, est-il plus facile à comprendre en utilisant des valeurs d'écart qu'en utilisant des points (sur 100 ou 200)? Standardisons «âge» et «tarif». Comme pour le codage d'étiquettes, la normalisation a une classe utile dans scicit-learn. Scaler standard </ b>.

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

#Standardisation
# Standardize numbers
standard = StandardScaler()
df_train_std = pandas.DataFrame(standard.fit_transform(df_train.loc[:, ['Age', 'Fare']]), columns=['Age', 'Fare'])

#Standardiser l'âge
# Standardize Age
df_train['Age'] = df_train_std['Age']

#Tarif standard
# Standardize Fare
df_train['Fare'] = df_train_std['Fare']

df_train.head()
index Survived Pclass Sex Age Fare
0 0 3 1 -0.530376641 -0.518977865
1 1 1 0 0.571830994 0.69189675
2 1 3 0 -0.254824732 -0.506213563
3 1 1 0 0.365167062 0.348049152
4 0 3 1 0.365167062 -0.503849804

L'âge et le tarif ont été standardisés. À ce stade, la maintenance des données est terminée.

4. Construisez un modèle

Une fois que les données sont prêtes, il est temps de créer le modèle. Pour le moment, construisons-le avec scicit-learn. Vous trouverez ci-dessous un organigramme de la sélection d'algorithmes sur le site sckit-learn.

ml_map.png

Choisissons un modèle selon cet organigramme. "Catégorie" OUI ⇒ "Avec données d'étiquette" Oui, passez à "classification" en haut à gauche. Je pense que cela correspond à «l'apprentissage supervisé par classification». Il est devenu "SVC linéaire" sur le graphique.

Lors de l'apprentissage, les données à apprendre (= x_train) et la réponse (= y_train) sont transmises au modèle séparément. L'image est la suivante.

y_train x_train
index Survived Pclass Sex Age Fare
0 0 3 1 -0.530376641 -0.518977865
1 1 1 0 0.571830994 0.69189675
2 1 3 0 -0.254824732 -0.506213563
3 1 1 0 0.365167062 0.348049152
4 0 3 1 0.365167062 -0.503849804

Le code est ci-dessous.

##############################
#Construire un modèle
##############################
from sklearn.svm import LinearSVC

#Préparer les données d'entraînement
x_train = df_train.loc[:, ['Pclass', 'Sex', 'Age', 'Fare']].values
y_train = df_train.loc[:, ['Survived']].values

# y_Supprimer la cote du train
y_train = numpy.reshape(y_train,(-1))

#Générer un modèle
model = LinearSVC(random_state=1)

5. Apprenez avec les données d'entraînement

L'entraînement transmet simplement les données d'entraînement au modèle.

##############################
#Apprentissage
##############################
model.fit(x_train, y_train)

6. Prédire les résultats avec les données de test

Voyons le résultat de l'apprentissage avec les données de test. test.csv doit être similaire aux données d'entraînement (x_train). Il y a un manque d'âge et de tarif, mais même s'il est insuffisant, le résultat doit être prédit. S'il s'agit de données de test, elles seront converties en "0" sans être supprimées.

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

# 'PassengerId'Extraire(À combiner avec le résultat)
df_test_index = df_test.loc[:, ['PassengerId']]

# 'Survived', 'Pclass', 'Sex', 'Age', 'Fare'Extraire
# Extract 'Survived', 'Pclass', 'Sex', 'Age', 'Fare'
df_test = df_test.loc[:, ['Pclass', 'Sex', 'Age', 'Fare']]

#Quantifier le sexe à l'aide de Label Encoder
# Digitize gender using LabelEncoder
df_test['Sex'] = encoder.transform(df_test['Sex'].values)

df_test_std = pandas.DataFrame(standard.transform(df_test.loc[:, ['Age', 'Fare']]), columns=['Age', 'Fare'])

#Standardiser l'âge
# Standardize Age
df_test['Age'] = df_test_std['Age']

#Tarif standard
# Standardize Fare
df_test['Fare'] = df_test_std['Fare']

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

df_test.head()
Index Pclass Sex Age Fare
0 3 1 0.298549339 -0.497810518
1 3 0 1.181327932 -0.512659955
2 2 1 2.240662243 -0.464531805
3 3 1 -0.231117817 -0.482887658
4 3 0 -0.584229254 -0.417970618

J'ai pu convertir les données de test de la même manière. Prédisez le résultat. Transmettez simplement les données de test et prédisez.

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

Le résultat est dans y_test. Enregistrez le résultat dans le même format que gender_submission.csv.

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

Avec ce qui précède, nous avons pu obtenir les résultats. J'essaierai de l'exécuter avec "Commit" comme avant. Une fois l'exécution terminée, cliquez sur "Ouvrir Viersion". Vous pouvez voir que result.csv a été créé.

20191209_04.png

Cliquez sur «Soumettre au concours» pour soumettre. Que va-t-il se passer ...

7. Résultat soumis

20191210_01.png

Le résultat était "0,75119". 75%. C'est pire que les exemples de données ^^;

8. Résumé

Comment était-ce. Je n'ai pas ajusté du tout les paramètres d'apprentissage, mais j'ai compris le flux d'apprentissage. La prochaine fois examinera les données et examinera les paramètres d'apprentissage afin que le score soit un peu meilleur.

Histoire

2019/12/11 Première édition publiée 2019/12/26 Installation du lien suivant 2020/01/03 Commentaires corrigés sur la source 2020/03/26 Partiellement révisé le code source de "6. Prédire le résultat avec les données de test"

Recommended Posts