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 :
Accédez à votre espace de travail dans Azure Machine Learning studio, sélectionnez Notebooks, puis sélectionnez l’onglet Exemples.
Dans la liste des notebooks, développez le nœud Samples>SDK v1>tutorials>regression-automl-nyc-taxi-data.
Sélectionnez le notebook regression-automated-ml.ipynb.
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 :
Exécutez la commande
pip install azureml-opendatasets azureml-widgetssur 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 :
| vendorID | lpepPickupDatetime | lpepDropoffDatetime | passengerCount | tripDistance | puLocationId | doLocationId | pickupLongitude | pickupLatitude | dropoffLongitude | ... | paymentType | fareAmount | extra | mtaTax | improvementSurcharge | tipAmount | tollsAmount | ehailFee | totalAmount | tripType |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2 | 2015-01-30 18:38:09 | 2015-01-30 19:01:49 | 1 | 1.88 | None | None | -73.996155 | 40.690903 | -73.964287 | ... | 1 | 15.0 | 1.0 | 0,5 | 0.3 | 4.00 | 0.0 | Aucune | 20.80 | 1.0 |
| 1 | 2015-01-17 23:21:39 | 2015-01-17 23:35:16 | 1 | 2.70 | None | None | -73.978508 | 40.687984 | -73.955116 | ... | 1 | 11.5 | 0.5 | 0,5 | 0.3 | 2.55 | 0.0 | Aucune | 15.35 | 1.0 |
| 2 | 2015-01-16 01:38:40 | 2015-01-16 01:52:55 | 1 | 3.54 | None | None | -73.957787 | 40.721779 | -73.963005 | ... | 1 | 13,5 | 0.5 | 0,5 | 0.3 | 2.80 | 0.0 | Aucune | 17.60 | 1.0 |
| 2 | 2015-01-04 17:09:26 | 2015-01-04 17:16:12 | 1 | 1,00 | None | None | -73.919914 | 40.826023 | -73.904839 | ... | 2 | 6.5 | 0.0 | 0,5 | 0.3 | 0.00 | 0.0 | Aucune | 7.30 | 1.0 |
| 1 | 2015-01-14 10:10:57 | 2015-01-14 10:33:30 | 1 | 5.10 | None | None | -73.943710 | 40.825439 | -73.982964 | ... | 1 | 18.5 | 0.0 | 0,5 | 0.3 | 3.85 | 0.0 | Aucune | 23.15 | 1.0 |
| 2 | 2015-01-19 18:10:41 | 2015-01-19 18:32:20 | 1 | 7.41 | None | None | -73.940918 | 40.839714 | -73.994339 | ... | 1 | 24.0 | 0.0 | 0,5 | 0.3 | 4,80 | 0.0 | Aucune | 29.60 | 1.0 |
| 2 | 2015-01-01 15:44:21 | 2015-01-01 15:50:16 | 1 | 1,03 | None | None | -73.985718 | 40.685646 | -73.996773 | ... | 1 | 6.5 | 0.0 | 0,5 | 0.3 | 1.30 | 0.0 | Aucune | 8.60 | 1.0 |
| 2 | 2015-01-12 08:01:21 | 2015-01-12 08:14:52 | 5 | 2.94 | None | None | -73.939865 | 40.789822 | -73.952957 | ... | 2 | 12.5 | 0.0 | 0,5 | 0.3 | 0.00 | 0.0 | Aucune | 13.30 | 1.0 |
| 1 | 2015-01-16 21:54:26 | 2015-01-16 22:12:39 | 1 | 3.00 | None | None | -73.957939 | 40.721928 | -73.926247 | ... | 1 | 14,0 | 0.5 | 0,5 | 0.3 | 2,00 | 0.0 | Aucune | 17.30 | 1.0 |
| 2 | 2015-01-06 06:34:53 | 2015-01-06 06:44:23 | 1 | 2,31 | None | None | -73.943825 | 40.810257 | -73.943062 | ... | 1 | 10.0 | 0.0 | 0,5 | 0.3 | 2,00 | 0.0 | Aucune | 12,80 | 1.0 |
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 :
| vendorID | passengerCount | tripDistance | pickupLongitude | pickupLatitude | dropoffLongitude | dropoffLatitude | totalAmount | |
|---|---|---|---|---|---|---|---|---|
| count | 24000.00 | 24000.00 | 24000.00 | 24000.00 | 24000.00 | 24000.00 | 24000.00 | 24000.00 |
| mean | 1.777625 | 1.373625 | 2.893981 | -73.827403 | 40.689730 | -73.819670 | 40.684436 | 14.892744 |
| std | 0.415850 | 1.046180 | 3.072343 | 2.821767 | 1.556082 | 2.901199 | 1.599776 | 12.339749 |
| min | 1.00 | 0,00 | 0.00 | -74.357101 | 0.00 | -74.342766 | 0.00 | -120.80 |
| 25% | 2,00 | 1,00 | 1.05 | -73.959175 | 40.699127 | -73.966476 | 40.699459 | 8,00 |
| 50% | 2,00 | 1,00 | 1.93 | -73.945049 | 40.746754 | -73.944221 | 40.747536 | 11,30 |
| 75 % | 2,00 | 1,00 | 3.70 | -73.917089 | 40.803060 | -73.909061 | 40.791526 | 17,80 |
| max | 2,00 | 8,00 | 154.28 | 0.00 | 41.109089 | 0.00 | 40.982826 | 425.00 |
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 :
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.
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.
| Propriété | Valeur dans ce didacticiel | Description |
|---|---|---|
iteration_timeout_minutes |
10 | Limite de temps (en minutes) pour chaque itération. Augmentez cette valeur pour les jeux de données plus volumineux qui ont besoin de plus de temps pour chaque itération. |
experiment_timeout_hours |
0.3 | Durée maximale en heures pendant laquelle toutes les itérations combinées peuvent être effectuées avant que l’expérience ne se termine. |
enable_early_stopping |
True | Indicateur activant la fin anticipée si le score ne s’améliore pas à court-terme. |
primary_metric |
spearman_correlation | Métrique que vous souhaitez optimiser. Le modèle le mieux adapté est choisi en fonction de cette métrique. |
featurization |
auto | La valeur auto permet à l’expérience de prétraiter les données d’entrée, notamment de gérer les données manquantes, de convertir du texte en caractères numériques, etc. |
verbosity |
logging.INFO | Contrôle le niveau de journalisation. |
n_cross_validations |
5 | Nombre de divisions de validation croisée à effectuer quand les données de validation ne sont pas spécifiées. |
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)
Remarque
Les étapes de prétraitement du ML automatisé (normalisation des caractéristiques, gestion des données manquantes, conversion de texte en valeurs numériques, et ainsi de suite) font partie du modèle sous-jacent. Lorsque vous utilisez le modèle pour des prédictions, les étapes de prétraitement qui sont appliquées pendant l’entraînement sont appliquées automatiquement à vos données d’entrée.
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 :
Accédez à votre espace de travail dans Azure Machine Learning studio, et sélectionnez Calcul.
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 :
Sur le portail Azure, accédez Groupes de ressources.
Dans la liste, sélectionnez le groupe de ressources que vous avez créé dans ce tutoriel, puis sélectionnez Supprimer le groupe de ressources.
À 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 :
Dans le portail Azure, accédez au groupe de ressources qui contient l’espace de travail à supprimer.
Sélectionnez l’espace de travail, sélectionnez Propriétés, puis Supprimer.
Étape suivante
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour