Tutoriel Kaggle : votre premier modèle de machine learning

Créez votre premier modèle d'apprentissage automatique

Avec l'Exploratory Data Analysis (EDA) et le modèle de référence sous la main, vous pouvez vous lancer dans votre premier vrai modèle de machine learning.

Remarque : ce tutoriel est basé sur une session de code en direct Facebook Live ; vous pouvez la revoir ici :

Avant de commencer, importez toutes les bibliothèques nécessaires :

# Import modules\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport re\nimport numpy as np\nfrom sklearn import tree\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.model_selection import GridSearchCV\n\n# Figures inline and set visualization style\n%matplotlib inline\nsns.set()\n\n# Import data\ndf_train = pd.read_csv('data/train.csv')\ndf_test = pd.read_csv('data/test.csv')\n

\n
• Ci-dessous, vous allez supprimer la cible \"Survived\" du jeu d'entraînement et créer un nouveau DataFrame data qui combine entraînement et test. Vous le faites pour prétraiter l’ensemble et garantir que toutes les opérations effectuées sur le train le sont aussi sur le test.
\n
• Mais d'abord, conservez la variable cible de l'ensemble d'entraînement en lieu sûr.
\n

# Store target variable of training data in a safe place\nsurvived_train = df_train.Survived\n\n# Concatenate training and test sets\ndata = pd.concat([df_train.drop(['Survived'], axis=1), df_test])\n

\n
• Examinez votre nouveau DataFrame data avec la méthode info().
\n

data.info()\n

<class 'pandas.core.frame.DataFrame'>\nInt64Index: 1309 entries, 0 to 417\nData columns (total 11 columns):\nPassengerId    1309 non-null int64\nPclass         1309 non-null int64\nName           1309 non-null object\nSex            1309 non-null object\nAge            1046 non-null float64\nSibSp          1309 non-null int64\nParch          1309 non-null int64\nTicket         1309 non-null object\nFare           1308 non-null float64\nCabin          295 non-null object\nEmbarked       1307 non-null object\ndtypes: float64(2), int64(4), object(5)\nmemory usage: 122.7+ KB\n

Deux variables numériques présentent des valeurs manquantes.

Lesquelles ?

Exact, il manque des valeurs dans les colonnes \'Age\' et \'Fare\' ! Le résultat de .info() ci-dessus montre 263 valeurs manquantes pour la première, avec seulement 1046 valeurs non nulles sur 1309 lignes. Idéalement, on voudrait 1309 valeurs non nulles ; ce n'est pas le cas ici.

Heureusement, il n'en manque qu'une pour Fare. Notez aussi que \'Cabin\' et \'Embarked\' ont des valeurs manquantes, qu'il faudra traiter à un moment.

Concentrons-nous désormais sur les variables numériques : vous allez imputer, c'est-à-dire renseigner, les valeurs manquantes de \'Age\' et \'Fare\' en utilisant la médiane des variables lorsque connue.

Remarque : ici, on utilise la médiane car elle gère bien les valeurs extrêmes. En d'autres termes, elle est utile lorsque la distribution est asymétrique. D'autres stratégies d'imputation incluent la moyenne (somme des points divisée par leur nombre) ou la mode (valeur la plus fréquente).

# Impute missing numerical variables\ndata['Age'] = data.Age.fillna(data.Age.median())\ndata['Fare'] = data.Fare.fillna(data.Fare.median())\n\n# Check out info of data\ndata.info()\n

<class 'pandas.core.frame.DataFrame'>\nInt64Index: 1309 entries, 0 to 417\nData columns (total 11 columns):\nPassengerId    1309 non-null int64\nPclass         1309 non-null int64\nName           1309 non-null object\nSex            1309 non-null object\nAge            1309 non-null float64\nSibSp          1309 non-null int64\nParch          1309 non-null int64\nTicket         1309 non-null object\nFare           1309 non-null float64\nCabin          295 non-null object\nEmbarked       1307 non-null object\ndtypes: float64(2), int64(4), object(5)\nmemory usage: 122.7+ KB\n

C'est déjà bien mieux, n'est-ce pas ?

Notez aussi que, dans le tutoriel précédent et le notebook, vous avez identifié plusieurs variables prédictives importantes pour \'Survived\' : \'Fare\', mais aussi \'Age\' et \'Sex\' !

Comme les modèles de machine learning prennent généralement des entrées numériques, vous devez encoder les catégories : transformer \"male\" et \"female\" en nombres. Utilisez pour cela la fonction pandas .get_dummies() :

data = pd.get_dummies(data, columns=['Sex'], drop_first=True)\ndata.head()\n

.get_dummies() crée une nouvelle colonne pour chaque modalité de \'Sex\'. Il génère donc une colonne pour female, nommée \'Sex_female\', et une pour \'Sex_male\', qui encode le sexe de la ligne.

Comme vous avez ajouté l'argument drop_first, \'Sex_female\' est supprimée : ces deux colonnes encodent la même information.

Résultat : une nouvelle colonne \'Sex_male\' vaut 1 si la personne est un homme, 0 sinon.

.get_dummies() deviendra l'un de vos meilleurs alliés pour la préparation de données en machine learning !

\n
• Sélectionnez maintenant les colonnes ['Sex_male', 'Fare', 'Age','Pclass', 'SibSp'] pour construire votre premier modèle :
\n

# Select columns and view head\ndata = data[['Sex_male', 'Fare', 'Age','Pclass', 'SibSp']]\ndata.head()\n

\n
• Utilisez .info() pour vérifier data :
\n

data.info()\n

<class 'pandas.core.frame.DataFrame'>\nInt64Index: 1309 entries, 0 to 417\nData columns (total 5 columns):\nSex_male    1309 non-null uint8\nFare        1309 non-null float64\nAge         1309 non-null float64\nPclass      1309 non-null int64\nSibSp       1309 non-null int64\ndtypes: float64(2), int64(2), uint8(1)\nmemory usage: 52.4 KB\n

Toutes les entrées sont désormais non nulles. Parfait !

Jusqu'ici, vous avez préparé vos données pour construire un premier modèle de machine learning. Vous pouvez enfin passer à la modélisation !

Pour aller plus loin avec pandas, découvrez notre parcours Data Manipulation with Python.

Construire un classifieur par arbre de décision

Qu'est-ce qu'un classifieur par arbre de décision ? C'est un arbre qui permet de classer des observations (variables cibles) à partir de variables explicatives.

Par exemple, l'arbre ci-dessous possède une racine qui impose une première décision : \"\'Sex_male\' est-il inférieur à 0,5 ?\" Autrement dit, s'agit-il d'une femme ? Si la réponse est True, on part à gauche et la prédiction est \'Survived\'. Si False, on part à droite et on obtient \'Dead\'.

Pour l'instant, inutile de vous attarder sur les autres informations dans les nœuds (gini, samples, value). Vous y reviendrez plus tard.

\n
• Commencez par ajuster un tel modèle sur vos données d'entraînement : il s'agit de déterminer, à chaque embranchement, la règle de séparation la plus pertinente d'après les données (par exemple, séparer d'abord sur \"Male\" ou non, et prédire \'Dead\' pour \"Male\").
\n

Remarque : ces décisions reposent sur le coefficient de Gini. Nous n'entrons pas dans les détails ici.

\n
• Avant d'ajuster un modèle sur data, redivisez-la en jeux d'entraînement et de test :
\n

data_train = data.iloc[:891]\ndata_test = data.iloc[891:]\n

\n
• Vous allez utiliser scikit-learn, qui attend des tableaux (arrays) et non des DataFrames : transformez-les donc :
\n

X = data_train.values\ntest = data_test.values\ny = survived_train.values\n

\n
• Créez maintenant votre classifieur par arbre de décision ! Instanciez-le avec max_depth=3 puis ajustez-le aux données. Remarque : on nomme le modèle clf pour \"Classifier\".
\n

# Instantiate model and fit to data\nclf = tree.DecisionTreeClassifier(max_depth=3)\nclf.fit(X, y)\n

DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=3,\n            max_features=None, max_leaf_nodes=None,\n            min_impurity_decrease=0.0, min_impurity_split=None,\n            min_samples_leaf=1, min_samples_split=2,\n            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n            splitter='best')\n

Les variables explicatives X sont le premier argument passé à .fit(), la variable cible y est le second.

La sortie résume la configuration de votre classifieur : on y voit par exemple une profondeur maximale fixée à 3.

\n
• Faites désormais des prédictions sur votre jeu de test, créez une nouvelle colonne \'Survived\' et stockez-y ces prédictions. Enregistrez les colonnes \"PassengerId\" et \"Survived\" de df_test en .csv et soumettez sur Kaggle.
\n

# Make predictions and store in 'Survived' column of df_test\nY_pred = clf.predict(test)\ndf_test['Survived'] = Y_pred\n

df_test[['PassengerId', 'Survived']].to_csv('data/predictions/1st_dec_tree.csv', index=False)\n

\n
• Quelle est la précision de votre modèle, telle que rapportée par Kaggle ?
\n

La précision est de 78 %. Vous avez gagné plus de 2 000 places !

Félicitations : vous avez préparé vos données et construit votre premier modèle de machine learning : un arbre de décision.

Passons maintenant à l'argument max_depth : pourquoi ce choix ? Et explorons train_test_split.

Pour en savoir plus sur scikit-learn, consultez notre cours Supervised Learning with scikit-learn.

Qu'est-ce qu'un classifieur par arbre de décision ?

Le classifieur que vous venez de bâtir avait max_depth=3 et ressemble à ceci :

La distance maximale entre la première et la dernière décision est 3 : d'où max_depth=3.

Remarque : vous pouvez utiliser graphviz pour générer ce type de figure. Voir la documentation scikit-learn ici pour plus de détails.

En construisant ce modèle, vous définissez en réalité une frontière de décision dans l'espace des variables explicatives, par exemple (image tirée d'ici) :

Pourquoi choisir max_depth=3 ?

La profondeur de l'arbre est un hyperparamètre : un paramètre à fixer avant l'ajustement. Plus max_depth est grand, plus la frontière de décision est complexe.

\n
• Si la frontière est trop complexe, vous risquez le surapprentissage : le modèle capte le bruit autant que le signal.
\n
• Si max_depth est trop faible, vous risquez le sous-apprentissage : le modèle ne capte pas assez le signal.
\n

Comment savoir si vous surapprenez ou sous-apprenez ?

Remarque : on parle aussi de compromis biais-variance ; nous n'entrons pas dans les détails ici.

Une approche consiste à écarter un jeu de test depuis l'entraînement, à ajuster le modèle sur le train puis à évaluer la précision des prédictions sur le test.

\n
• Faisons-le : scindez vos données d'entraînement en entraînement et test :
\n

X_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.33, random_state=42, stratify=y)\n

\n
• Itérez à présent sur des valeurs de max_depth allant de 1 à 9 et tracez la précision sur les jeux d'entraînement et de test :
\n

# Setup arrays to store train and test accuracies\ndep = np.arange(1, 9)\ntrain_accuracy = np.empty(len(dep))\ntest_accuracy = np.empty(len(dep))\n\n# Loop over different values of k\nfor i, k in enumerate(dep):\n    # Setup a Decision Tree Classifier\n    clf = tree.DecisionTreeClassifier(max_depth=k)\n\n    # Fit the classifier to the training data\n    clf.fit(X_train, y_train)\n\n    #Compute accuracy on the training set\n    train_accuracy[i] = clf.score(X_train, y_train)\n\n    #Compute accuracy on the testing set\n    test_accuracy[i] = clf.score(X_test, y_test)\n\n# Generate plot\nplt.title('clf: Varying depth of tree')\nplt.plot(dep, test_accuracy, label = 'Testing Accuracy')\nplt.plot(dep, train_accuracy, label = 'Training Accuracy')\nplt.legend()\nplt.xlabel('Depth of tree')\nplt.ylabel('Accuracy')\nplt.show()\n

Plus vous augmentez max_depth, mieux le modèle s'ajuste aux données d'entraînement : la précision sur le train grimpe. Ce n'est pas le cas sur le test : vous surapprenez.

C'est pourquoi vous avez retenu max_depth=3.

Conclusion

Dans ce tutoriel, vous avez préparé vos données pour construire un premier modèle de machine learning. Ensuite, vous avez bâti votre premier modèle : un classifieur par arbre de décision. Enfin, vous avez découvert train_test_split et comment cet outil aide à choisir les hyperparamètres d'un modèle de ML.

Dans le prochain tutoriel, publié sur la DataCamp Community le 10 janvier 2018, vous apprendrez à créer de nouvelles features et à entraîner d'autres modèles !

En attendant, pour approfondir scikit-learn, consultez le cours de DataCamp Supervised Learning with scikit-learn.