Trois lignes pour un modèle

Cet article est issu de la newsletter IA Comprise et reproduit ici par commodité. Recevez toutes les lettres dans votre boîte mail au fur et à mesure de leur publication en laissant votre adresse dans le cadre à droite !


Chère lectrice, cher lecteur,

Après la dernière lettre, vous avez peut-être installé Python, écrit quelques lignes… et maintenant ? Comment créer un modèle de machine learning, parcouru des cours de statistiques et de programmation, pour assembler petit à petit les briques d’un algorithme prédictif, sans renoncer devant la complexité apparente de la tâche ?

J’ai une bonne et une mauvaise nouvelle.

D’abord la bonne : il n’y a pas besoin de programmer des algorithmes. Ils sont déjà prêts. Cela tient littéralement en trois lignes de code sous Python ! Vous ne me croyez pas ? Voici comment faire, sur l’exemple du célèbre problème du Titanic.

Qui a survécu au naufrage du Titanic ?

Vous le savez certainement, le Titanic est un paquebot qui a fait naufrage en 1912 suite à une collision avec un iceberg. Sur les 2400 passagers (y compris membres de l’équipage), environ 700 ont survécu. On peut se douter que le sort d’un passager n’est pas tout à fait dû au hasard : les femmes et les enfants ont été embarqués en priorité dans les canots de sauvetage, tout comme ceux qui avaient la chance d’être dans une cabine proche de ces canots (généralement les passagers aisés).

Le problème se présente de la manière suivante : peut-on prédire si un passager a survécu à partir de son profil (âge, sexe, s’il voyageait en première classe, etc.) ? Pour cela, le but est de créer et entraîner un modèle à partir de données connues : le profil et l’information de la survie ou non de quelques centaines de passagers. Puis, on fournit au modèle entraîné une autre liste de passagers afin qu’il prédise à partir de leur profil s’ils ont survécu ou non : ce sont les données de test. En comparant le résultat de ce test à la réalité, on peut évaluer la performance du modèle.

Les données se trouvent sur le site de Kaggle [1] ; j’en ai extrait quatre fichiers csv sur lesquels le modèle sera bâti :

  • Titanic_profils1.csv : les profils des passagers dont on connaît le sort, pour entraîner le modèle
  • Titanic_resultats1.csv : le sort des passagers du fichier précédent, pour entraîner le modèle
  • Titanic_profils2.csv : les profils d’un autre groupe de passager dont on cherche à prédire le sort
  • Titanic_resultats2.csv : le sort des passagers du fichier précédent, uniquement pour comparer à ce que donne le modèle

Si vous souhaitez reproduire le code plus loin, vous pouvez cliquer sur les liens pour télécharger les fichiers et les mettre dans votre dossier Python.

Ces fichiers sont de simples tables. Dans les tables de profils, on dispose pour chaque passager de :

  • Son nom
  • Son statut socio-économique (la classe dans laquelle voyage un passager payant, ou une estimation pour les membres de l’équipage : 1 = Aisé, 2 = Moyen, 3 = Bas)
  • Son âge
  • Le nombre de membres de sa famille de même génération (frères, sœurs et époux) à bord
  • Le nombre de membres de sa famille d’une autre génération (parents et enfants) à bord
  • Son sexe (0 = Femme, 1 = Homme)
  • Le port d’embarquement de la personne (1 dans la colonne correspondante)

Dans le fichier de résultat, 0 indique que la personne est décédée et 1 qu’elle a survécu.

Les 5 premières lignes des tables de données à partir desquelles le modèle va être construit

Prêt(e) à passer sous Python ?

Partons par exemple sur un modèle basé sur un algorithme d’arbre de décision. On commence par importer les bibliothèques (pandas et sklearn.tree) et les quatre fichiers sous formes de dataframes, des tables facilement manipulables en Python.

import pandas
import sklearn.tree

titanic_profils1 = pandas.read_csv('Titanic_profils1.csv', index_col=0)
titanic_resultats1 = pandas.read_csv('Titanic_resultats1.csv', index_col=0)
titanic_profils2 = pandas.read_csv('Titanic_profils2.csv', index_col=0)
titanic_resultats2 = pandas.read_csv('Titanic_resultats2.csv', index_col=0)

Ensuite, place à l’algorithme proprement dit. Attention… trois lignes de code !

model = sklearn.tree.DecisionTreeClassifier(max_depth=3)
model.fit(titanic_profils1, titanic_resultats1)
model.predict(titanic_profils2)

La première ligne crée un objet « model » qui est défini comme un arbre de décision (d’une profondeur de 3 nœuds pour rester simple).

La deuxième ligne entraîne le modèle à partir du profil et de la survie de chaque passager de la première liste.

La troisième ligne applique le modèle aux profils de chaque passager de la seconde liste.

C’est tout !

Le résultat est une longue liste de 0 et de 1, indiquant si le modèle prédit un décès ou une survie pour chacun des passagers de la seconde liste, dans l’ordre. On peut rendre ce résultat plus présentable en comparant pour chaque nom de passager la prédiction et la réalité :

pandas.DataFrame(model.predict(titanic_profils2), index=titanic_profils2.index, columns=['Prédiction']).assign(Réel = titanic_resultats2)
Prédictions du modèle pour les 5 premiers passagers. Il a correctement prédit le sort des quatre premiers et incorrectement celui du cinquième.

La précision du modèle peut s’évaluer directement en une ligne, qui nous indique que la prédiction du modèle est correcte pour environ 80% des passagers :

model.score(titanic_profils2, titanic_resultats2)

Et comme nous avons utilisé un algorithme d’arbre de décision, nous pouvons directement l’afficher ! [2]

L’arbre de décision généré par ce code. Si la passagère est une femme (Sexe = 0), aisée ou moyenne, âgée de moins de 27 ans (en suivant les branches tout à gauche), le modèle prédit avec 90% de certitude qu’elle a survécu. Si le passager est un homme, de statut économique moyen ou bas, sans parent ni enfant à bord, le modèle prédit avec 86% de certitude qu’il n’a pas survécu.

Si l’on souhaite utiliser un autre algorithme, rien de plus simple : il suffit d’importer la bibliothèque correspondante.

Scikit-learn inclut de nombreux algorithmes pré-programmés, dont la liste peut se trouver sur son site [3].

Voici ce que cela donnerait en utilisant cette fois un algorithme de régression logistique :

import sklearn.linear_model
model = sklearn.linear_model.LogisticRegression()
model.fit(titanic_profils1, titanic_resultats1)
model.predict(titanic_profils2)

C’est pratiquement la même chose que pour l’arbre de décision, en indiquant que l’objet « model » est cette fois une régression logistique. Construire un modèle basé sur le Machine Learning en Python, c’est aussi simple que cela !

Vraiment ?

Il y a aussi une mauvaise nouvelle…

Si construire un modèle est finalement assez simple, construire un modèle performant l’est moins. Les 80% de précision du modèle ci-dessus sont en réalité très médiocres : on arrive pratiquement au même résultat en se contentant de prédire que tous les hommes décèdent et toutes les femmes survivent !

Avec le recul, optimiser un modèle relève pratiquement plus de l’art que de la science exacte. Triturer les données, les paramètres, les modèles, autant de leviers pour améliorer les résultats… dont je vous parlerai dans une prochaine lettre !

À la prochaine,

Erwan


Inscrivez-vous gratuitement pour ne rater aucune lettre !


[1] https://www.kaggle.com/c/titanic/data?select=train.csv
[2] Le code est un peu plus long et nécessite des bibliothèques supplémentaires. Si besoin, la documentation se trouve ici :
https://scikit-learn.org/stable/modules/tree.html
[3] https://scikit-learn.org/stable/modules/classes.html

Laisser un commentaire

Abonnez-moi à la newsletter