Dans ce tutoriel, nous allons parcourir le jeu de données Titanic, l’analyser et soumettre les résultats à la compétition officielle. Vous avez déjà appris à récupérer les données et à les importer dans votre Notebook Kaggle dans ce tutoriel. Nous allons maintenant utiliser DataLab comme notebook de data science. Vous apprendrez à utiliser les deux outils sur différentes plateformes afin de choisir celui qui vous convient le mieux.
Commencez par vous rendre dans la section « Competitions » sur Kaggle et recherchez Titanic (figure 5.4). Avant d’entrer directement dans le notebook, prenez le temps de lire toutes les informations des sections « Description » et « Rules ». Il est également utile de consulter les notebooks des autres utilisateurs : vous y trouverez souvent des pistes pour améliorer votre solution.
La compétition consiste à utiliser l’apprentissage automatique pour créer un modèle qui prédit quels passagers auraient survécu au naufrage du Titanic. Nous utiliserons un jeu de données contenant des informations sur les passagers : nom, sexe, âge, etc. Deux jeux de données distincts sont fournis. Le premier, « train.csv », contient en plus des informations passagers les valeurs de vérité terrain, comme « survived » ou « not survived ». Le second, « test.csv », ne comporte aucune vérité terrain, puisqu’il vous est demandé de prédire ces valeurs et de soumettre vos résultats.
Le fichier de soumission doit comporter exactement 2 colonnes : PassengerId et Survived. Le système refusera un fichier contenant plus de 2 colonnes. Notez que vous pouvez réaliser jusqu’à 10 soumissions par jour.
À partir des informations de la section « Competition Description », l’étape suivante consiste à récupérer les données dans notre DataLab et à les analyser.
Commencez par télécharger le jeu de données dans Data Explorer via l’onglet Data (figure 5.5). Téléchargez à la fois « train.csv » et « test.csv ».
Après le téléchargement, rendez-vous sur DataLab. Veuillez noter qu’il faut d’abord créer un compte. La création d’un compte et l’utilisation de DataLab sont gratuites.
Vous pouvez facilement glisser-déposer les fichiers dans la colonne de gauche du notebook (figure 5.6).
Vérifiez ensuite le dictionnaire des données dans la description du jeu de données. Cela vous aidera à décider quelles colonnes visualiser.
- survival : survie
- pclass : classe du billet
- sex : sexe
- Age : âge en années
- sibsp : nombre de frères/sœurs et conjoints à bord du Titanic
- parch : nombre de parents et enfants à bord du Titanic
- ticket : numéro de billet
- fare : prix du billet
- cabin : numéro de cabine
- embarked : port d’embarquement
Importation des données
Vous pouvez exécuter des commandes bash dans un notebook Jupyter en plaçant un point d’exclamation au début de la cellule. Nous allons vérifier l’emplacement des fichiers importés avec les commandes pwd et ls.
!pwd; ls
/work/files/workspace
notebook.ipynb test.csv train.csv
Pandas est une bibliothèque Python utilisée pour la manipulation et l’analyse de données. Nous avons supprimé les colonnes Ticket, Name et PassengerId car elles n’apportent pas d’information numérique ou catégorielle pertinente. Vous pouvez maintenant voir les autres variables utilisables.
Dans les lignes suivantes, les fichiers d’entraînement et de test sont lus via la méthode read_csv de Pandas. Notez que les colonnes Survived et PassengerId sont ajoutées respectivement aux dataframes d’entraînement et de test. Nous alimenterons le modèle séparément avec les caractéristiques de columns_to_be_added_as_features et les étiquettes dans la colonne Survived. Pour simplifier le prétraitement, nous pouvons toutefois les combiner pour l’instant. La variable test_df_matcher inclut également PassengerId. Nous l’utiliserons pour associer PassengerId aux prédictions du test et générer le fichier CSV à téléverser sur Kaggle comme résultat.
import pandas as pd
columns_to_be_added_as_features = ['Sex','Age','SibSp','Parch','Pclass','Fare','Embarked']
train_df = pd.read_csv('train.csv', usecols=columns_to_be_added_as_features + ['Survived'])
test_df_matcher = pd.read_csv('test.csv', usecols=columns_to_be_added_as_features + ['PassengerId'])
test_df = test_df[columns_to_be_added_as_features]
Avec la méthode head(), nous pouvons afficher les 5 premières lignes et leurs noms de colonnes. Vous pouvez définir le nombre de lignes à afficher en paramètre de head(). Le nombre de lignes des jeux d’entraînement et de test est ensuite affiché dans la cellule suivante.
print(train_df.head())
print("Number of rows in training set: {}".format(len(train_df)))
print("Number of rows in test set: {}".format(len(test_df)))
Number of rows in training set: 891 Number of rows in test set: 418
Prétraitement
Nous devons convertir en float les valeurs qui serviront de caractéristiques dans le modèle. Cette conversion permettra d’effectuer des opérations numériques lors de la normalisation des données.
for column_title in columns_to_be_added_as_features:
if column_title in ['Embarked', "Sex"]:
continue
train_df[column_title] = pd.to_numeric(train_df[column_title], downcast="float")
test_df[column_title] = pd.to_numeric(test_df[column_title], downcast="float")
train_df["Survived"] = pd.to_numeric(train_df["Survived"], downcast="float")
Le modèle doit être alimenté avec des valeurs numériques. Dans le code ci-dessous, les chaînes sont converties en valeurs numériques.
train_df['Embarked'].replace('Q', 0,inplace=True)
train_df['Embarked'].replace('S', 1,inplace=True)
train_df['Embarked'].replace('C', 2,inplace=True)
test_df['Embarked'].replace('Q', 0,inplace=True)
test_df['Embarked'].replace('S', 1,inplace=True)
test_df['Embarked'].replace('C', 2,inplace=True)
train_df['Sex'].replace('male', 0,inplace=True)
train_df['Sex'].replace('female', 1,inplace=True)
test_df['Sex'].replace('male', 0,inplace=True)
test_df['Sex'].replace('female', 1,inplace=True)
print(train_df.head())
Ci-dessous, toutes les caractéristiques sont normalisées, c’est‑à‑dire mises à l’échelle entre 0 et 1 dans notre cas.
#Credit: Michael Aquilina,
#https://stackoverflow.com/questions/26414913/normalize-columns-of-pandas-data-frame
def normalize(df):
result = df.copy()
for feature_name in df.columns:
max_value = df[feature_name].max()
min_value = df[feature_name].min()
result[feature_name] = (df[feature_name] - min_value) / (max_value - min_value)
return result
train_df = normalize(train_df)
test_df = normalize(test_df)
print(train_df.head())
Comme le jeu de données sera divisé en entraînement et validation, nous allons d’abord le mélanger pour éviter que des groupes ne se retrouvent dans un seul des deux ensembles.
#Credit: Kris, https://stackoverflow.com/questions/29576430/shuffle-dataframe-rows
train_df = train_df.sample(frac=1).reset_index(drop=True)
Toutes les valeurs manquantes seront remplacées par 0 ; ce choix vise à gagner du temps. Pour aller plus loin sur le traitement des valeurs manquantes en apprentissage automatique, consultez ce tutoriel.
train_df = train_df.fillna(0)
test_df = test_df.fillna(0)
Ci-dessous, le ratio de validation est fixé à 0,2, ce qui signifie que 20 % des données serviront à la validation. Pour séparer entraînement et validation, nous utiliserons la méthode train_test_split de Sklearn. Nous séparons ensuite caractéristiques et étiquettes comme dans les 4 dernières lignes du code.
validation_set_ratio = 0.2
validation_set_size = int(len(train_df)*validation_set_ratio)
training_set_size = len(train_df) - validation_set_size
print("Total set size: {}".format(len(train_df)))
print("Training set size: {}".format(training_set_size))
print("Validation set size: {}".format(validation_set_size))
from sklearn.model_selection import train_test_split
train, val = train_test_split(train_df, test_size=validation_set_ratio)
train_X = train[columns_to_be_added_as_features]
train_Label = train[['Survived']]
val_X = val[columns_to_be_added_as_features]
val_Label = val[['Survived']]
Entraînement
Les machines à vecteurs de support (SVM) sont des modèles d’apprentissage supervisé utilisés pour la classification et la régression. Nous avons choisi ce modèle avec les paramètres ci-dessous. Vous devriez tester d’autres modèles avec différentes combinaisons d’hyperparamètres. Inutile de relancer le code à chaque modification : vous pouvez automatiser ce processus. Si les SVM vous intéressent, consultez le tutoriel Support Vector Machines with Scikit-learn sur DataCamp.
from sklearn.svm import SVC
SVM_KERNEL = "linear"
SVM_C = 10
SVM_GAMMA = 0.00001
svm_model = SVC(kernel = SVM_KERNEL, C = SVM_C, gamma = SVM_GAMMA)
svm_model.fit(train_X, train_Label)
Obtenir les prédictions sur l’ensemble de validation
Ici, nous alimentons le modèle avec les caractéristiques de validation pour obtenir les prédictions, puis nous les comparons aux valeurs de vérité terrain. La méthode metrics.accuracy_score de Sklearn facilite le calcul de la précision. La précision sur l’ensemble de validation est de 0,799 — un bon début.
from sklearn import metrics
y_pred = svm_model.predict(val_X)
print("Accuracy:",metrics.accuracy_score(val_Label, y_pred))
Accuracy: 0.7988826815642458
Obtenir les prédictions sur l’ensemble de test
Passons maintenant aux prédictions sur le jeu de test réel. Comme il n’y a pas de vérité terrain pour ce jeu, nous ne connaîtrons la précision qu’après avoir téléversé le fichier de prédictions sur Kaggle.
test_pred = svm_model.predict(test_df)
Générer le dataframe de sortie
La colonne PassengerId est extraite du dataframe test_df_matcher. Renvoyée telle quelle, elle est de type Series. Nous allons donc la convertir en DataFrame Pandas, puis insérer la colonne de prédictions du test en deuxième position.
result = pd.DataFrame(test_df_matcher['PassengerId'])
print(result.head(10))
result.insert(1, "Survived", test_pred, True)
result["Survived"] = pd.to_numeric(result["Survived"], downcast="integer")
print(result.head(10))
Générer le fichier de sortie
Le format de sortie est prêt. Pour finir, nous supprimons l’index en passant False au paramètre index. Vous pouvez maintenant télécharger le fichier généré et l’envoyer sur Kaggle. Vous obtiendrez ainsi la précision sur le jeu de test et serez classé au tableau des scores.
result.to_csv("out.csv", index=False)
Retournez sur la page de la compétition, cliquez sur « Submit Predictions », puis téléversez le fichier de prédictions. Après quelques secondes, vous verrez votre précision sur le test (figure 5.12).
Conclusion
Dans ce tutoriel, vous avez appris à analyser un jeu de données et à soumettre vos résultats à une compétition Kaggle. Si vous aimez les compétitions de data science, découvrez-en plus sur DataCamp Competitions ici.