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.

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.

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.

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.

Data Dictionary

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)

parch (nombre de parents / enfants sur le Titanic)

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

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

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)

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

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

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

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

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

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