Exercice - Créer un modèle Machine Learning

Effectué

Pour créer un modèle Machine Learning, vous avez besoin de deux jeux de données : un pour l’entraînement et un pour les tests. Dans la pratique, vous n’avez souvent qu’un seul jeu de données : vous le divisez donc en deux. Dans cet exercice, vous allez effectuer un fractionnement 80-20 sur le DataFrame que vous avez préparé dans le labo précédent, afin de pouvoir l’utiliser pour entraîner un modèle Machine Learning. Vous allez aussi séparer le DataFrame en colonnes de caractéristiques et en colonnes d’étiquettes. Le premier contient les colonnes utilisées comme entrée pour le modèle (par exemple l’origine et la destination du vol, et l’heure de départ planifiée), tandis que le deuxième contient la colonne que le modèle va essayer de prédire : dans ce cas, la colonne ARR_DEL15, qui indique si un vol arrivera à l’heure.

1. Revenez au notebook Azure que vous avez créé dans la section précédente. Si vous avez fermé le notebook, vous pouvez vous reconnecter au portail Microsoft Azure Notebooks, ouvrir votre notebook et utiliser Cellule –>Exécuter tout pour réexécuter toutes les cellules du notebook après son ouverture.

2. Dans une nouvelle cellule à la fin du notebook, entrez et exécutez les instructions suivantes :

   from sklearn.model_selection import train_test_split
   train_x, test_x, train_y, test_y = train_test_split(df.drop('ARR_DEL15', axis=1), df['ARR_DEL15'], test_size=0.2, random_state=42)
   

   La première instruction importe la fonction d’assistance train_test_split de scikit-learn. La deuxième ligne utilise la fonction pour diviser le DataFrame en jeu d’entraînement contenant 80 % des données d’origine et en jeu de test contenant les 20 % restants. Le paramètre random_state amorce le générateur de nombres aléatoires utilisé pour effectuer le fractionnement, tandis que les premier et deuxième paramètres sont les DataFrames contenant les colonnes de caractéristiques et la colonne d’étiquettes.

3. train_test_split retourne quatre DataFrames. Utilisez la commande suivante pour afficher le nombre de lignes et de colonnes dans le DataFrame contenant les colonnes de caractéristiques utilisées pour l’entraînement :

   train_x.shape
   

4. Utilisez maintenant cette commande pour afficher le nombre de lignes et de colonnes dans le DataFrame contenant les colonnes de caractéristiques utilisées pour le test :

   test_x.shape
   

   En quoi les deux sorties diffèrent-elles et pourquoi ?

Pouvez-vous prédire ce que vous allez voir si vous appelez shape sur les deux autres DataFrames, train_y et test_y ? Si vous n’en êtes pas sûr, essayez et regardez les résultats.

Il existe de nombreux types de modèles Machine Learning. Un des plus courants est le modèle de régression, qui utilise un des nombreux algorithmes de régression pour produire une valeur numérique, par exemple l’âge d’une personne ou la probabilité qu’une transaction de carte de crédit soit frauduleuse. Vous allez entraîner un modèle de classification, qui cherche à résoudre un ensemble d’entrées en un ensemble de sorties connues. Un exemple classique de modèle de classification est un modèle qui examine des e-mails et les classifie comme « spam » ou « non spam ». Votre modèle sera un modèle de classification binaire qui prédit si un vol arrivera à l’heure ou en retard (« binaire », car il n’existe que deux sorties possibles).

Un des avantages de l’utilisation de scikit-learn est que vous n’avez pas à créer ces modèles ni à implémenter les algorithmes qu’ils utilisent manuellement. scikit-learn comprend une variété de classes pour l’implémentation de modèles Machine Learning courants. L’une d’elle est RandomForestClassifier, qui ajuste plusieurs arbres de décision aux données, et utilise la moyenne pour améliorer la précision globale et limiter le surajustement.

1. Exécutez le code suivant dans une nouvelle cellule pour créer un objet RandomForestClassifier et entraînez-le en appelant la méthode fit.

   from sklearn.ensemble import RandomForestClassifier
   
   model = RandomForestClassifier(random_state=13)
   model.fit(train_x, train_y)
   

   La sortie montre les paramètres utilisés dans le classifieur, notamment n_estimators, qui spécifie le nombre d’arbres dans chaque forêt d’arbres de décision, et max_depth, qui spécifie la profondeur maximale des arbres de décision. Les valeurs affichées sont les valeurs par défaut, mais vous pouvez les remplacer lors de la création de l’objet RandomForestClassifier.

   

   Entraînement du modèle

2. Appelez maintenant la méthode predict pour tester le modèle en utilisant les valeurs dans test_x, suivie de la méthode score pour déterminer la précision moyenne du modèle :

   predicted = model.predict(test_x)
   model.score(test_x, test_y)
   

   Vérifiez que vous voyez la sortie suivante :

   

   Test du modèle

La précision moyenne est de 86 %, ce qui semble bon au premier abord. Cependant, la précision moyenne n’est pas toujours un indicateur fiable de la précision d’un modèle de classification. Approfondissons l’analyse et déterminons la précision réelle du modèle, c’est-à-dire son expertise pour déterminer si un vol arrivera à l’heure.

Il existe plusieurs façons de mesurer la précision d’un modèle de classification. Une des meilleures mesures globales pour un modèle de classification binaire est l’Aire sous la courbe de la fonction d’efficacité du récepteur (parfois appelée « Aire sous la courbe ROC »), qui quantifie essentiellement la fréquence à laquelle le modèle fait une prédiction correcte indépendamment du résultat. Dans cette unité, vous allez calculer un score Aire sous la courbe ROC pour le modèle que vous avez créé précédemment, et découvrir les raisons pour lesquelles ce score est inférieur au résultat de la précision moyenne par la méthode score. Vous allez aussi découvrir d’autres façons d’évaluer la précision du modèle.

1. Avant de calculer l’aire sous la courbe ROC, vous devez générer des probabilités de prédiction pour le jeu de test. Ces probabilités sont des estimations pour chacune des classes, ou réponses, que le modèle peut prédire. Par exemple, [0.88199435, 0.11800565] signifie qu’il y a 89 % de chances qu’un vol arrive à l’heure (ARR_DEL15 = 0) et 12 % de chances que ce ne soit pas le cas (ARR_DEL15 = 1). La somme des deux probabilités fait 100 %.

   Exécutez le code suivant pour générer un ensemble de probabilités de prédiction à partir des données de test :

   from sklearn.metrics import roc_auc_score
   probabilities = model.predict_proba(test_x)
   

2. Utilisez maintenant l’instruction suivante pour générer un score d’aire sous la courbe ROC à partir des probabilités avec la méthode roc_auc_score de scikit-learn :

   roc_auc_score(test_y, probabilities[:, 1])
   

   Vérifiez que la sortie indique un score de 67 % :

   

   Génération d’un score d’aire sous la courbe

   Pourquoi le score d’aire sous la courbe est-il inférieur à la précision moyenne calculée dans l’exercice précédent ?

   La sortie de la méthode score reflète le nombre des éléments du jeu de test que le modèle a prédit correctement. Ce score est biaisé par le fait que le jeu de données avec lequel le modèle a été entraîné et testé contient beaucoup plus de lignes représentant des arrivées à l’heure que des lignes représentant des arrivées avec retard. En raison de ce déséquilibre dans les données, vous êtes plus susceptible d’être correct si vous prédisez qu’un vol sera à l’heure que si vous prédisez qu’un vol sera en retard.

   L’aire sous la courbe ROC prend ceci en compte et fournit une indication plus précise de la probabilité qu’une prédiction de vol à l’heure ou avec retard soit correcte.

3. Vous pouvez en savoir plus sur le comportement du modèle en générant une matrice de confusion, également appelée matrice d’erreur. La matrice de confusion quantifie le nombre de fois où chaque réponse a été classifiée correctement ou incorrectement. Plus précisément, elle évalue le nombre de faux positifs, de faux négatifs, de vrais positifs et de vrais négatifs. Ceci est important, car si un modèle de classification binaire entraîné à reconnaître des chats et des chiens a été testé avec un jeu de données constitué à 95 % de chiens, son score peut être de 95 % simplement en devinant « chien » à chaque fois. Mais s’il a toujours échoué à identifier des chats, sa valeur serait très faible.

   Utilisez le code suivant pour produire une matrice de confusion pour votre modèle :

   from sklearn.metrics import confusion_matrix
   confusion_matrix(test_y, predicted)
   

   La première ligne de la sortie représente les vols qui étaient à l’heure. La première colonne de cette ligne montre combien de vols ont été prédits correctement comme étant à l’heure, tandis que la deuxième colonne révèle combien de vols ont été prédits comme étant en retard mais ne l’étaient pas. Au vu de ces données, le modèle semble avoir une expertise pour prédire qu’un vol sera à l’heure.

   

   Génération d’une matrice de confusion

   Regardez cependant la deuxième ligne, qui représente les vols qui ont été en retard. La première colonne montre combien de vols en retard ont été prédits incorrectement comme étant à l’heure. La deuxième colonne montre combien de vols ont été prédits correctement comme étant en retard. Clairement, le modèle n’est pas aussi expert pour prédire qu’un vol sera en retard que pour prédire qu’un vol arrivera à l’heure. Ce que vous voulez dans une matrice de confusion, ce sont des nombres élevés dans les coins supérieur gauche et inférieur droit, et des nombres peu élevés (de préférence des zéros) dans les coins supérieur droit et inférieur gauche.

4. Les autres mesures de précision pour un modèle de classification incluent la précision et le rappel. Supposons que le modèle a prédit trois arrivées à l’heure et trois arrivées avec retard, et qu’il a correctement prédit deux des arrivées à l’heure, mais incorrectement prédit que deux des arrivées avec retard seraient à l’heure. Dans ce cas, la précision est de 50 % (deux des quatre vols classifiées comme étant à l’heure sont effectivement à l’heure), tandis que son rappel est de 67 % (il a correctement identifié deux des trois arrivées à l’heure). Vous pouvez en savoir plus sur la précision et le rappel dans https://en.wikipedia.org/wiki/Precision_and_recall.

   scikit-learn contient une méthode pratique nommée precision_score pour le calcul de la précision. Pour quantifier la précision de votre modèle, exécutez les instructions suivantes :

   from sklearn.metrics import precision_score
   
   train_predictions = model.predict(train_x)
   precision_score(train_y, train_predictions)
   

   Examinez la sortie. Quelle est la précision de votre modèle ?

   

   Mesure de la précision

5. scikit-learn contient également une méthode nommée recall_score pour le calcul du rappel. Pour mesurer le rappel du modèle, exécutez les instructions suivantes :

   from sklearn.metrics import recall_score
   
   recall_score(train_y, train_predictions)
   

   Quel est le rappel du modèle ?

   

   Mesure du rappel

6. Utilisez la commande Fichier – >Enregistrer et effectuer un point de contrôle pour enregistrer le notebook.

Dans le monde réel, un scientifique des données expérimenté rechercherait des moyens de rendre le modèle encore plus précis. Entre autres choses, il essayerait différents algorithmes et prendrait des mesures pour optimiser l’algorithme choisi de façon à trouver la combinaison optimale des paramètres. Une autre étape probable serait d’étendre le jeu de données à des millions de lignes au lieu de quelques milliers, et aussi d’essayer de réduire le déséquilibre entre les arrivées en retard et les arrivées à l’heure. Mais dans notre contexte, le modèle est bon en l’état.