Entraîner un modèle de régression avec le ML automatisé et Python (SDK v1)

S’APPLIQUE À : SDK Python azureml v1

Dans cet article, vous allez découvrir comment effectuer l’entraînement d’un modèle de régression avec le kit SDK Python Azure Machine Learning au moyen du ML automatisé Azure Machine Learning. Le modèle de régression prédit les tarifs pour les taxis qui opèrent à New York (NYC). Vous allez écrire du code avec le SDK Python pour configurer un espace de travail avec des données préparées, entraîner le modèle localement avec des paramètres personnalisés et explorer les résultats.

Le processus accepte les données d’entraînement et les paramètres de configuration. Il itère automatiquement des combinaisons de différentes méthodes de normalisation/standardisation des caractéristiques, de modèles et de paramètres d’hyperparamètres afin d’obtenir le meilleur modèle. Le diagramme suivant illustre le flux de processus pour l’entraînement du modèle de régression :

Prérequis

• Un abonnement Azure. Vous pouvez créer un compte gratuit ou payant d’Azure Machine Learning.

• Un espace de travail Azure Machine Learning ou une instance de calcul. Pour préparer ces ressources, consultez Démarrage rapide : Bien démarrer avec Azure Machine Learning.

• Obtenez les exemples de données préparés pour les exercices du tutoriel en chargeant un notebook dans votre espace de travail :

  1. Accédez à votre espace de travail dans Azure Machine Learning studio, sélectionnez Notebooks, puis sélectionnez l’onglet Exemples.

  2. Dans la liste des notebooks, développez le nœud Samples>SDK v1>tutorials>regression-automl-nyc-taxi-data.

  3. Sélectionnez le notebook regression-automated-ml.ipynb.

  4. Pour exécuter chaque cellule de notebook dans le cadre de ce tutoriel, sélectionnez Cloner ce fichier.

  Autre approche : si vous préférez, vous pouvez exécuter les exercices du tutoriel dans un environnement local. Le tutoriel est disponible dans le dépôt de notebooks Azure Machine Learning sur GitHub. Pour cette approche, effectuez ces étapes afin d’obtenir les packages requis :

  1. Installez le client automl complet.

  2. Exécutez la commande pip install azureml-opendatasets azureml-widgets sur votre ordinateur local pour obtenir les packages requis.

Télécharger et préparer les données

Le package Open Datasets contient une classe qui représente chaque source de données (telle que NycTlcGreen) afin de filtrer facilement les paramètres de date avant le téléchargement.

Le code suivant importe les packages nécessaires :

from azureml.opendatasets import NycTlcGreen
import pandas as pd
from datetime import datetime
from dateutil.relativedelta import relativedelta

La première étape consiste à créer un DataFrame pour les données des taxis. Quand vous travaillez dans un environnement autre que Spark, le package Open Datasets autorise le téléchargement d’un seul mois de données à la fois avec certaines classes. Cette approche permet d’éviter le problème MemoryError qui peut se produire avec des jeux de données volumineux.

Pour télécharger les données des taxis, récupérez de manière itérative un mois à la fois. Avant d’ajouter le jeu de données suivant au DataFrame green_taxi_df, échantillonnez de façon aléatoire 2 000 enregistrements de chaque mois, puis affichez un aperçu des données. Cette approche permet d’éviter le ballonnement du DataFrame.

Le code suivant crée le DataFrame, extrait les données et les charge dans le DataFrame :

green_taxi_df = pd.DataFrame([])
start = datetime.strptime("1/1/2015","%m/%d/%Y")
end = datetime.strptime("1/31/2015","%m/%d/%Y")

for sample_month in range(12):
   temp_df_green = NycTlcGreen(start + relativedelta(months=sample_month), end + relativedelta(months=sample_month)) \
      .to_pandas_dataframe()
   green_taxi_df = green_taxi_df.append(temp_df_green.sample(2000))

green_taxi_df.head(10)

Le tableau suivant présente les nombreuses colonnes de valeurs de l’exemple de données de taxis :

Il peut être utile de supprimer certaines colonnes dont vous n’avez pas besoin pour l’entraînement ou la création de caractéristiques supplémentaires. Par exemple, vous pouvez supprimer la colonne lpepPickupDatetime, car le ML automatisé gère automatiquement les caractéristiques basées sur le temps.

Le code suivant supprime 14 colonnes de l’exemple de données :

columns_to_remove = ["lpepDropoffDatetime", "puLocationId", "doLocationId", "extra", "mtaTax",
                "improvementSurcharge", "tollsAmount", "ehailFee", "tripType", "rateCodeID",
                "storeAndFwdFlag", "paymentType", "fareAmount", "tipAmount"
               ]
for col in columns_to_remove:
   green_taxi_df.pop(col)

green_taxi_df.head(5)

Nettoyer les données

L’étape suivante consiste à nettoyer les données.

Le code suivant exécute la fonction describe() sur le nouveau DataFrame pour générer des statistiques récapitulatives pour chaque champ :

green_taxi_df.describe()

Le tableau suivant présente des statistiques récapitulatives pour les champs restants dans les exemples de données :

Les statistiques récapitulatives révèlent que plusieurs champs ont des valeurs hors norme, à savoir des valeurs qui réduisent la précision du modèle. Pour résoudre ce problème, filtrez les champs de latitude/longitude (lat/long) afin que les valeurs se trouvent dans les limites de Manhattan. Cette approche masque les courses de taxi plus longues ou les trajets hors norme par rapport à leur relation avec les autres caractéristiques.

Ensuite, filtrez le champ tripDistance afin d’afficher les valeurs supérieures à zéro, mais inférieur à 31 miles (distance Haversine entre les deux paires de latitude/longitude). Cette technique élimine les longs trajets hors norme qui présentent un coût de trajet inégal.

Pour finir, le champ totalAmount présente des valeurs de prix des courses négatives, ce qui n’est pas logique dans le contexte de notre modèle. Le champ passengerCount contient également des données incorrectes où la valeur minimale est égale à zéro.

Le code suivant filtre ces anomalies de valeurs à l’aide de fonctions de requête. Le code supprime ensuite les quelques dernières colonnes qui ne sont pas nécessaires pour l’entraînement :

final_df = green_taxi_df.query("pickupLatitude>=40.53 and pickupLatitude<=40.88")
final_df = final_df.query("pickupLongitude>=-74.09 and pickupLongitude<=-73.72")
final_df = final_df.query("tripDistance>=0.25 and tripDistance<31")
final_df = final_df.query("passengerCount>0 and totalAmount>0")

columns_to_remove_for_training = ["pickupLongitude", "pickupLatitude", "dropoffLongitude", "dropoffLatitude"]
for col in columns_to_remove_for_training:
   final_df.pop(col)

La dernière étape de cette séquence consiste à appeler à nouveau la fonction describe() sur les données afin de s’assurer que le nettoyage a fonctionné comme prévu. Vous disposez maintenant d’un jeu préparé et nettoyé de données de taxis, congés et météorologiques à des fins d’entraînement du modèle Machine Learning :

final_df.describe()

Configurer l’espace de travail

Créez un objet d’espace de travail à partir de l’espace de travail existant. Un espace de travail est une classe qui accepte les informations concernant vos abonnements et vos ressources Azure. Il crée également une ressource cloud pour superviser et suivre les exécutions de votre modèle.

Le code suivant appelle la fonction Workspace.from_config() pour lire le fichier config.json et charger les détails de l’authentification dans un objet nommé ws.

from azureml.core.workspace import Workspace
ws = Workspace.from_config()

L’objet ws est utilisé dans tout le reste du code de ce tutoriel.

Diviser les données entre un jeu d’entraînement et un jeu de test

Divisez les données en jeu d’entraînement et en jeu de test à l’aide de la fonction train_test_split de la bibliothèque scikit-learn. Cette fonction sépare les données entre le jeu de données x (caractéristiques) pour l’entraînement du modèle, et le jeu de données y (valeurs à prédire) pour les tests.

Le paramètre test_size détermine le pourcentage de données à allouer pour les tests. Le paramètre random_state définit une valeur initiale pour le générateur aléatoire, afin que les deux jeux de données soient déterministes.

Le code suivant appelle la fonction train_test_split pour charger les jeux de données x et y :

from sklearn.model_selection import train_test_split

x_train, x_test = train_test_split(final_df, test_size=0.2, random_state=223)

L’objectif de cette étape est de préparer des points de données qui n’ont pas été utilisées pour l’apprentissage du modèle, afin de tester le modèle fini. Ces points sont utilisés pour mesurer la précision réelle. Un modèle bien formé est un modèle qui peut effectuer des prédictions précises à partir de données jamais rencontrées. Vous disposez maintenant de données préparées pour l’entraînement automatique d’un modèle Machine Learning.

Entraîner automatiquement un modèle

Pour entraîner automatiquement un modèle, effectuez les étapes suivantes :

1. Définissez des paramètres pour l’exécution de l’expérience. Attachez vos données d’entraînement à la configuration et modifiez les paramètres qui contrôlent le processus d’entraînement.

2. Soumettez l’expérience pour l’optimisation du modèle. Une fois l’expérience envoyée, le processus parcourt différents algorithmes et paramètres d’hyperparamètres de Machine Learning tout en respectant vos contraintes définies. Il choisit le modèle le mieux adapté en optimisant une métrique de précision.

Définir les paramètres d’entraînement

Définissez les paramètres du modèle et de l’expérience pour l’entraînement. Affichez la liste complète des paramètres. L’envoi de l’expérience avec ces paramètres par défaut prend environ cinq à 20 minutes. Pour réduire la durée d’exécution, réduisez le paramètre experiment_timeout_hours.

Le code suivant envoie l’expérience :

import logging

automl_settings = {
   "iteration_timeout_minutes": 10,
   "experiment_timeout_hours": 0.3,
   "enable_early_stopping": True,
   "primary_metric": 'spearman_correlation',
   "featurization": 'auto',
   "verbosity": logging.INFO,
   "n_cross_validations": 5
}

Le code suivant vous permet d’utiliser vos paramètres d’entraînement définis en tant que paramètre **kwargs sur un objet AutoMLConfig. De plus, vous spécifiez vos données d’entraînement et le type de modèle, en l’occurrence regression.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task='regression',
                      debug_log='automated_ml_errors.log',
                      training_data=x_train,
                      label_column_name="totalAmount",
                      **automl_settings)

Entraîner un modèle de régression automatique

Créez un objet d’expérience dans votre espace de travail. Une expérience fait office de conteneur pour vos travaux individuels. Transmettez l’objet automl_config défini à l’expérience et définissez la sortie sur True pour suivre la progression du travail.

Une fois l’expérience démarrée, la sortie affichée est mise à jour en temps réel à mesure que l’expérience s’exécute. Pour chaque itération, vous voyez le type de modèle, la durée d’exécution et la précision de l’entraînement. Le champ BEST effectue un suivi du meilleur score d’entraînement en cours d’exécution, en fonction de votre type de métrique :

from azureml.core.experiment import Experiment
experiment = Experiment(ws, "Tutorial-NYCTaxi")
local_run = experiment.submit(automl_config, show_output=True)

Voici la sortie :

Running on local machine
Parent Run ID: AutoML_1766cdf7-56cf-4b28-a340-c4aeee15b12b
Current status: DatasetFeaturization. Beginning to featurize the dataset.
Current status: DatasetEvaluation. Gathering dataset statistics.
Current status: FeaturesGeneration. Generating features for the dataset.
Current status: DatasetFeaturizationCompleted. Completed featurizing the dataset.
Current status: DatasetCrossValidationSplit. Generating individually featurized CV splits.
Current status: ModelSelection. Beginning model selection.

****************************************************************************************************
ITERATION: The iteration being evaluated.
PIPELINE: A summary description of the pipeline being evaluated.
DURATION: Time taken for the current iteration.
METRIC: The result of computing score on the fitted pipeline.
BEST: The best observed score thus far.
****************************************************************************************************

 ITERATION   PIPELINE                              DURATION     METRIC     BEST
       0   StandardScalerWrapper RandomForest          0:00:16      0.8746   0.8746
       1   MinMaxScaler RandomForest                 0:00:15      0.9468   0.9468
       2   StandardScalerWrapper ExtremeRandomTrees      0:00:09      0.9303   0.9468
       3   StandardScalerWrapper LightGBM             0:00:10      0.9424   0.9468
       4   RobustScaler DecisionTree                 0:00:09      0.9449   0.9468
       5   StandardScalerWrapper LassoLars            0:00:09      0.9440   0.9468
       6   StandardScalerWrapper LightGBM             0:00:10      0.9282   0.9468
       7   StandardScalerWrapper RandomForest          0:00:12      0.8946   0.9468
       8   StandardScalerWrapper LassoLars            0:00:16      0.9439   0.9468
       9   MinMaxScaler ExtremeRandomTrees            0:00:35      0.9199   0.9468
      10   RobustScaler ExtremeRandomTrees            0:00:19      0.9411   0.9468
      11   StandardScalerWrapper ExtremeRandomTrees      0:00:13      0.9077   0.9468
      12   StandardScalerWrapper LassoLars            0:00:15      0.9433   0.9468
      13   MinMaxScaler ExtremeRandomTrees            0:00:14      0.9186   0.9468
      14   RobustScaler RandomForest                 0:00:10      0.8810   0.9468
      15   StandardScalerWrapper LassoLars            0:00:55      0.9433   0.9468
      16   StandardScalerWrapper ExtremeRandomTrees      0:00:13      0.9026   0.9468
      17   StandardScalerWrapper RandomForest          0:00:13      0.9140   0.9468
      18   VotingEnsemble                         0:00:23      0.9471   0.9471
      19   StackEnsemble                          0:00:27      0.9463   0.9471

Explorer les résultats

Explorez les résultats de l’entraînement automatique à l’aide d’un widget Jupyter. Le widget vous permet d’afficher un graphique et un tableau de toutes les itérations de travaux individuels, ainsi que des métriques et des métadonnées sur la précision de l’apprentissage. Vous pouvez aussi filtrer sur des métriques de précision différentes de votre métrique principale avec le sélecteur de liste déroulante.

Le code suivant produit un graphique pour explorer les résultats :

from azureml.widgets import RunDetails
RunDetails(local_run).show()

Détails de l’exécution pour le widget Jupyter :

Graphique pour le widget Jupyter :

Récupérer le meilleur modèle

Le code suivant vous permet de sélectionner le meilleur modèle à partir de vos itérations. La fonction get_output retourne la meilleure exécution ainsi que le modèle ajusté pour le dernier appel d’ajustement. En utilisant des surcharges sur la fonction get_output, vous pouvez récupérer la meilleure exécution et le modèle ajusté pour toute métrique consignée ou itération.

best_run, fitted_model = local_run.get_output()
print(best_run)
print(fitted_model)

Tester la précision du meilleur modèle

Utilisez le meilleur modèle pour exécuter des prédictions sur le jeu de données de test et prédire les tarifs des courses de taxi. La fonction predict utilise le meilleur modèle et prédit les valeurs de y, coût du trajet, à partir du jeu de données x_test.

Le code suivant imprime les dix premières valeurs de coût prédites à partir du jeu de données y_predict :

y_test = x_test.pop("totalAmount")

y_predict = fitted_model.predict(x_test)
print(y_predict[:10])

Calculez le(la) root mean squared error des résultats. Convertissez le DataFrame y_test en liste et comparez-la aux valeurs prédites. La fonction mean_squared_error accepte deux tableaux de valeurs, et calcule l’erreur au carré moyenne entre ces tableaux. En prenant la racine carrée du résultat, vous obtenez une erreur dans les mêmes unités que la variable y, cost. Elle indique l’écart approximatif entre les prédictions de tarifs de taxi et les tarifs réels.

from sklearn.metrics import mean_squared_error
from math import sqrt

y_actual = y_test.values.flatten().tolist()
rmse = sqrt(mean_squared_error(y_actual, y_predict))
rmse

Exécutez le code suivant pour calculer le pourcentage d’erreur absolue moyenne (MAPE) à l’aide des jeux de données y_actual et y_predict complets. Cette métrique calcule une différence absolue entre chaque valeur prédite et réelle et additionne toutes les différences. Ensuite, elle exprime cette somme sous forme de pourcentage du total des valeurs réelles.

sum_actuals = sum_errors = 0

for actual_val, predict_val in zip(y_actual, y_predict):
   abs_error = actual_val - predict_val
   if abs_error < 0:
      abs_error = abs_error * -1

   sum_errors = sum_errors + abs_error
   sum_actuals = sum_actuals + actual_val

mean_abs_percent_error = sum_errors / sum_actuals
print("Model MAPE:")
print(mean_abs_percent_error)
print()
print("Model Accuracy:")
print(1 - mean_abs_percent_error)

Voici la sortie :

Model MAPE:
0.14353867606052823

Model Accuracy:
0.8564613239394718

Les deux métriques de précision de la prédiction montrent que le modèle est assez bon pour prédire les tarifs de taxi à partir des caractéristiques du jeu de données, en général à ± 4,00 dollars US et environ 15 % d’erreur.

Le processus de développement de modèle Machine Learning traditionnel est très gourmand en ressources. Il nécessite un investissement important en temps et en connaissances de domaine pour exécuter et comparer les résultats de dizaines de modèles. Le machine learning automatisé se révèle un excellent moyen de tester rapidement de nombreux modèles pour votre scénario.

Nettoyer les ressources

Si vous ne prévoyez pas de travailler sur d’autres tutoriels Azure Machine Learning, effectuez les étapes suivantes pour supprimer les ressources dont vous n’avez plus besoin.

Arrêter l’instance de calcul

Si vous avez utilisé un calcul, vous pouvez arrêter la machine virtuelle lorsque vous ne l’utilisez pas afin de réduire les coûts :

1. Accédez à votre espace de travail dans Azure Machine Learning studio, et sélectionnez Calcul.

2. Dans la liste, sélectionnez le calcul à arrêter, puis sélectionnez Arrêter.

Lorsque vous êtes à nouveau prêt à utiliser le calcul, vous pouvez redémarrer la machine virtuelle.

Supprimer les autres ressources

Si vous n’envisagez pas d’utiliser les ressources que vous avez créées dans ce tutoriel, vous pouvez les supprimer et éviter d’encourir d’autres frais.

Effectuez ces étapes pour supprimer le groupe de ressources et toutes les ressources :

1. Sur le portail Azure, accédez Groupes de ressources.

2. Dans la liste, sélectionnez le groupe de ressources que vous avez créé dans ce tutoriel, puis sélectionnez Supprimer le groupe de ressources.

3. À l’invite de confirmation, entrez le nom du groupe de ressources, puis sélectionnez Supprimer.

Si vous souhaitez conserver le groupe de ressources et supprimer uniquement un seul espace de travail, effectuez ces étapes :

1. Dans le portail Azure, accédez au groupe de ressources qui contient l’espace de travail à supprimer.

2. Sélectionnez l’espace de travail, sélectionnez Propriétés, puis Supprimer.

Étape suivante