Configurer AutoML pour entraîner des modèles de vision par ordinateur avec Python (v1)

Article
09/04/2024

S’APPLIQUE À : SDK Python azureml v1

Important

Certaines des commandes Azure CLI de cet article utilisent l’extension azure-cli-ml, ou v1, pour Azure Machine Learning. La prise en charge de l’extension v1 se termine le 30 septembre 2025. Vous pourrez installer et utiliser l’extension v1 jusqu’à cette date.

Nous vous recommandons de passer à l’extension ml, ou v2, avant le 30 septembre 2025. Pour plus d’informations sur l’extension v2, consultez Extension Azure ML CLI et le SDK Python v2.

Important

Cette fonctionnalité est actuellement disponible en préversion publique. Cette préversion est fournie sans contrat de niveau de service. Certaines fonctionnalités peuvent être limitées ou non prises en charge. Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.

Dans cet article, vous allez apprendre à entraîner des modèles de vision par ordinateur sur des données d’image avec le ML automatisé du kit SDK Python Azure Machine Learning.

Le ML automatisé prend en charge l’entraînement de modèles pour les tâches de vision par ordinateur telles que la classification d’images, la détection d’objets et la segmentation d’instances. La création de modèles AutoML pour les tâches de vision par ordinateur est actuellement prise en charge via le kit SDK Python Azure Machine Learning. Les exécutions, modèles et sorties des expérimentations sont accessibles dans l’interface utilisateur du studio Azure Machine Learning. En savoir plus sur le ML automatisé pour les tâches de vision par ordinateur sur les données d’image.

Notes

Le ML automatisé pour les tâches de vision par ordinateur est disponible uniquement via le kit SDK Python Azure Machine Learning.

Prérequis

Un espace de travail Azure Machine Learning. Pour créer l’espace de travail, consultez Créer des ressources d’espace de travail.
Le kit SDK Python d’Azure Machine Learning installé. Pour installer le kit de développement logiciel (SDK), vous pouvez :
- Créer une instance de calcul, qui installe automatiquement le kit SDK et est préconfigurée pour les workflows ML. Pour plus d’informations, consultez Créer et gérer une instance de calcul Azure Machine Learning.
- Installez vous-même le package automl, qui comprend l’installation par défaut du Kit de développement logiciel (SDK).
Notes

Seuls Python 3.7 et 3.8 sont compatibles avec le support du ML automatisé pour les tâches de vision par ordinateur.

Sélectionner votre type de tâche

Le ML automatisé pour les images prend en charge les types de tâches suivants :

Type de tâche	Syntaxe de la configuration d’AutoMLImage
classification d’image	`ImageTask.IMAGE_CLASSIFICATION`
classification d’images multi-étiquette	`ImageTask.IMAGE_CLASSIFICATION_MULTILABEL`
détection d’objets image	`ImageTask.IMAGE_OBJECT_DETECTION`
segmentation d’instances d’image	`ImageTask.IMAGE_INSTANCE_SEGMENTATION`

Ce type de tâche est un paramètre obligatoire et est transmis à l’aide du paramètre task d’AutoMLImageConfig.

Par exemple :

from azureml.train.automl import AutoMLImageConfig
from azureml.automl.core.shared.constants import ImageTask
automl_image_config = AutoMLImageConfig(task=ImageTask.IMAGE_OBJECT_DETECTION)

Données de formation et de validation

Pour générer des modèles de vision par ordinateur, vous devez apporter les données d’image étiquetées comme entrées pour l’entraînement de modèles sous la forme d’un TabularDataset Azure Machine Learning. Vous pouvez utiliser soit un TabularDataset que vous avez exporté à partir d’un projet d’étiquetage de données, soit créer un nouveau TabularDataset avec vos données d’entraînement étiquetées.

Si vos données d’entraînement sont dans un autre format (par exemple, pascal VOC ou COCO), vous pouvez appliquer les scripts d’assistance inclus avec les exemples de notebook pour convertir les données en JSONL. En savoir plus sur la préparation des données pour les tâches de vision par ordinateur avec le ML automatisé.

Avertissement

La création de TabularDatasets à partir de données au format JSONL n’est prise en charge qu’avec le kit SDK pour cette fonctionnalité. La création du jeu de données via l’interface utilisateur n’est pas prise en charge pour l’instant. Pour l’instant, l’interface utilisateur ne reconnaît pas le type de données StreamInfo (utilisé pour les URL d’images au format JSONL).

Notes

Le jeu de données d’entraînement doit comporter au moins 10 images afin de pouvoir envoyer une exécution AutoML.

Exemples de schémas JSONL

La structure du TabularDataset dépend de la tâche en cours. Pour les types de tâche de vision par ordinateur, elle comprend les champs suivants :

Champ	Description
`image_url`	Contient le chemin du fichier comme objet StreamInfo
`image_details`	Les informations de métadonnées d’image se composent de la hauteur, de la largeur et du format. Ce champ est facultatif et peut donc exister ou pas.
`label`	Représentation JSON de l’étiquette de l’image, en fonction du type de tâche.

Voici un exemple de fichier JSONL pour la classification d’images :

{
      "image_url": "AmlDatastore://image_data/Image_01.png",
      "image_details":
      {
          "format": "png",
          "width": "2230px",
          "height": "4356px"
      },
      "label": "cat"
  }
  {
      "image_url": "AmlDatastore://image_data/Image_02.jpeg",
      "image_details":
      {
          "format": "jpeg",
          "width": "3456px",
          "height": "3467px"
      },
      "label": "dog"
  }

Le code suivant est un exemple de fichier JSONL pour la détection d’objets :

{
    "image_url": "AmlDatastore://image_data/Image_01.png",
    "image_details":
    {
        "format": "png",
        "width": "2230px",
        "height": "4356px"
    },
    "label":
    {
        "label": "cat",
        "topX": "1",
        "topY": "0",
        "bottomX": "0",
        "bottomY": "1",
        "isCrowd": "true",
    }
}
{
    "image_url": "AmlDatastore://image_data/Image_02.png",
    "image_details":
    {
        "format": "jpeg",
        "width": "1230px",
        "height": "2356px"
    },
    "label":
    {
        "label": "dog",
        "topX": "0",
        "topY": "1",
        "bottomX": "0",
        "bottomY": "1",
        "isCrowd": "false",
    }
}

Consommer les données

Une fois que vos données sont au format JSONL, vous pouvez créer un TabularDataset avec le code suivant :

ws = Workspace.from_config()
ds = ws.get_default_datastore()
from azureml.core import Dataset

training_dataset = Dataset.Tabular.from_json_lines_files(
        path=ds.path('odFridgeObjects/odFridgeObjects.jsonl'),
        set_column_types={'image_url': DataType.to_stream(ds.workspace)})
training_dataset = training_dataset.register(workspace=ws, name=training_dataset_name)

Le ML automatisé n’impose aucune contrainte sur la taille des données d’entraînement ou de validation pour les tâches de vision par ordinateur. La taille maximale d’un jeu de données est seulement limitée par la couche de stockage derrière le jeu de données (par exemple, le magasin d’objets blob). Il n’y a aucun nombre minimal d’images ou d’étiquettes. Toutefois, nous vous recommandons de commencer avec un minimum de 10-15 échantillons par étiquette pour vous assurer que le modèle de sortie est suffisamment entraîné. Plus le nombre total d’étiquettes/classes est élevé, plus vous avez besoin d’échantillons par étiquette.

Les données d’entraînement sont obligatoires et passées à l’aide du paramètre training_data. Vous pouvez éventuellement spécifier un autre TabularDataset comme jeu de données de validation à utiliser pour votre modèle avec le paramètre validation_data d’AutoMLImageConfig. Si aucun jeu de données de validation n’est spécifié, 20 % de vos données d’entraînement sont utilisées pour la validation par défaut, sauf si vous passez l’argument validation_size avec une valeur différente.

Par exemple :

from azureml.train.automl import AutoMLImageConfig
automl_image_config = AutoMLImageConfig(training_data=training_dataset)

Capacité de calcul pour exécuter l’expérience

Fournissez une cible de calcul pour le ML automatisé afin de procéder à l’entraînement des modèles. Les modèles du ML automatisé pour les tâches de vision par ordinateur requièrent des références SKU GPU et prennent en charge les familles NC et ND. Nous recommandons d’utiliser la série NCsv3 (avec v100 GPU) pour accélérer l’entraînement. Une cible de calcul avec une référence SKU de machine virtuelle multi-GPU utilise plusieurs GPU pour également accélérer l’entraînement. De plus, lorsque vous configurez une cible de calcul avec plusieurs nœuds, vous pouvez procéder à un entraînement plus rapide des modèles via le parallélisme lors du réglage des hyperparamètres de votre modèle.

Notes

Si vous utilisez une instance de calcul comme cible de calcul, vérifiez que plusieurs travaux AutoML ne sont pas exécutés en même temps. Vérifiez également que la valeur max_concurrent_iterations est définie sur 1 dans vos ressources d’expérience.

La cible de calcul est un paramètre obligatoire et est passée à l’aide du paramètre compute_target d’AutoMLImageConfig. Par exemple :

from azureml.train.automl import AutoMLImageConfig
automl_image_config = AutoMLImageConfig(compute_target=compute_target)

Configurer les algorithmes et les hyperparamètres du modèle

Avec la prise en charge des tâches de vision par ordinateur, vous pouvez contrôler l’algorithme du modèle et balayer les hyperparamètres. Ces algorithmes et hyperparamètres du modèle sont passés comme espace de paramètres pour le balayage.

L’algorithme du modèle est obligatoire et est passé via le paramètre model_name. Vous pouvez spécifier un seul model_name ou choisir entre plusieurs.

Algorithmes de modèle pris en charge

Le tableau suivant récapitule les modèles pris en charge pour chaque tâche de vision par ordinateur.

Tâche	Algorithmes de modèle	Syntaxe des littéraux de chaîne `default_model`* indiqué par *
Classification d’images (multi-classe et multi-étiquette)	MobileNet : modèles légers pour applications mobiles ResNet : réseaux résiduels ResNeSt : réseaux d’attention partagée SE-ResNeXt50 : réseaux de compression et excitation (Squeeze-and-Excitation) ViT : réseaux de transformateurs de vision	`mobilenetv2` `resnet18` `resnet34` `resnet50` `resnet101` `resnet152` `resnest50` `resnest101` `seresnext` `vits16r224` (petit) `vitb16r224`* (base) `vitl16r224` (grand)
Détection d’objets	YOLOv5 : modèle de détection d’objets monophase Faster RCNN ResNet FPN : modèles de détection d’objets double-phase RetinaNet ResNet FPN : résolution du déséquilibre de classes avec la perte focale Remarque : Reportez-vous à l’hyperparamètre `model_size` pour les tailles de modèle YOLOv5.	`yolov5`* `fasterrcnn_resnet18_fpn` `fasterrcnn_resnet34_fpn` `fasterrcnn_resnet50_fpn` `fasterrcnn_resnet101_fpn` `fasterrcnn_resnet152_fpn` `retinanet_resnet50_fpn`
Segmentation d’instances	MaskRCNN ResNet FPN	`maskrcnn_resnet18_fpn` `maskrcnn_resnet34_fpn` `maskrcnn_resnet50_fpn`* `maskrcnn_resnet101_fpn` `maskrcnn_resnet152_fpn` `maskrcnn_resnet50_fpn`

En plus du contrôle de l’algorithme du modèle, vous pouvez également régler les hyperparamètres utilisés pour l’entraînement du modèle. Même si un grand nombre des hyperparamètres exposés sont indépendants du modèle, il existe des cas où les hyperparamètres sont spécifiques à une tâche ou à un modèle. En savoir plus sur les hyperparamètres disponibles pour ces instances.

Augmentation des données

En général, les performances des modèles Deep Learning peuvent souvent s’améliorer avec davantage de données. L’augmentation des données est une technique pratique pour amplifier la taille des données et la variabilité d’un jeu de données, ce qui permet d’empêcher le surajustement et d’améliorer la capacité de généralisation du modèle sur les données non vues. Le ML automatisé applique différentes techniques d’augmentation des données en fonction de la tâche de vision par ordinateur, avant d’alimenter les images d’entrée dans le modèle. Actuellement, il n’y a pas d’hyperparamètre exposé pour contrôler les augmentations de données.

Tâche	Jeu de données impacté	Technique(s) d’augmentation des données appliquée(s)
Classification d’images (multi-classe et multi-étiquette)	Formation Validation et test	Redimensionnement et rognage aléatoires, retournement horizontal, variation des couleurs (luminosité, contraste, saturation et teinte), normalisation avec la moyenne et l’écart type d’ImageNet au niveau canal Redimensionnement, rognage central, normalisation
Détection d’objets, segmentation d’instances	Formation Validation et test	Rognage aléatoire autour des cadres englobants, développement, retournement horizontal, normalisation, redimensionnement Normalisation, redimensionnement
Détection d’objets avec yolov5	Formation Validation et test	Mise en mosaïque, affinité aléatoire (rotation, translation, mise à l’échelle, inclinaison), retournement horizontal Redimensionnement des cadres

Configurer les paramètres de votre expérience

Avant de faire un grand balayage pour rechercher les modèles et hyperparamètres optimaux, nous vous recommandons de tester les valeurs par défaut pour obtenir une première base de référence. Ensuite, vous pouvez explorer plusieurs hyperparamètres pour le même modèle avant de faire un balayage sur plusieurs modèles et leurs paramètres. De cette façon, vous pouvez utiliser une approche plus itérative parce qu’avec plusieurs modèles et plusieurs hyperparamètres pour chacun, l’espace de recherche augmente de manière exponentielle et vous avez besoin de plus d’itérations pour trouver des configurations optimales.

Si vous souhaitez utiliser les valeurs par défaut des hyperparamètres pour un algorithme donné (par exemple, yolov5), vous pouvez spécifier que la configuration de votre image AutoML s’exécute comme suit :

from azureml.train.automl import AutoMLImageConfig
from azureml.train.hyperdrive import GridParameterSampling, choice
from azureml.automl.core.shared.constants import ImageTask

automl_image_config_yolov5 = AutoMLImageConfig(task=ImageTask.IMAGE_OBJECT_DETECTION,
                                               compute_target=compute_target,
                                               training_data=training_dataset,
                                               validation_data=validation_dataset,
                                               hyperparameter_sampling=GridParameterSampling({'model_name': choice('yolov5')}),
                                               iterations=1)

Une fois que vous avez créé un modèle de référence, vous voudrez peut-être optimiser les performances du modèle dans le but de faire un balayage sur l’espace de l’algorithme et des hyperparamètres du modèle. Vous pouvez utiliser l’exemple de configuration suivant pour balayer les hyperparamètres de chaque algorithme, en choisissant à partir d’une plage de valeurs pour learning_rate, optimizer, lr_scheduler, etc., afin de générer un modèle avec la métrique principale optimale. Si les valeurs d’hyperparamètres ne sont pas spécifiées, les valeurs par défaut sont utilisées pour l’algorithme spécifié.

Métrique principale

La métrique principale utilisée pour l’optimisation du modèle et le réglage des hyperparamètres dépend du type de tâche. L’utilisation d’autres valeurs de métriques principales n’est pas prise en charge actuellement.

accuracy pour IMAGE_CLASSIFICATION
iou pour IMAGE_CLASSIFICATION_MULTILABEL
mean_average_precision pour IMAGE_OBJECT_DETECTION
mean_average_precision pour IMAGE_INSTANCE_SEGMENTATION

Budget pour les expériences

Vous pouvez éventuellement spécifier le budget temps maximal pour votre expérience de vision AutoML avec experiment_timeout_hours, durée en heures avant l’arrêt de l’expérience. Si aucune durée n’est spécifiée, le délai d’expiration par défaut de l’expérience est de sept jours (maximum 60 jours).

Balayage des hyperparamètres pour votre modèle

Lors de l’entraînement des modèles de vision par ordinateur, les performances des modèles dépendent beaucoup des valeurs d’hyperparamètre sélectionnées. Souvent, vous voudrez probablement régler les hyperparamètres pour obtenir des performances optimales. Avec la prise en charge des tâches de vision par ordinateur dans le ML automatisé, vous pouvez balayer les hyperparamètres pour trouver les paramètres optimaux pour votre modèle. Cette fonctionnalité applique les fonctions de réglage des hyperparamètres dans Azure Machine Learning. Apprenez à régler les hyperparamètres.

Définir l’espace de recherche de paramètres

Vous pouvez définir les algorithmes et les hyperparamètres des modèles pour balayer l’espace de paramètres.

Consultez Configurer les algorithmes et les hyperparamètres des modèles pour obtenir la liste des algorithmes de modèle pris en charge pour chaque type de tâche.
Consultez Hyperparamètres pour les tâches de vision par ordinateur hyperparamètres pour chaque type de tâche de vision par ordinateur.
Consultez les Détails sur les distributions prises en charge pour les hyperparamètres discrets et continus.

Méthodes d’échantillonnage pour le balayage

Lors du balayage des hyperparamètres, vous devez spécifier la méthode d’échantillonnage à utiliser pour balayer l’espace de paramètres défini. Actuellement, les méthodes d’échantillonnage suivantes sont prises en charge avec le paramètre hyperparameter_sampling :

Notes

Seul les échantillonnages aléatoire et par grille prennent actuellement en charge les espaces conditionnels d’hyperparamètres.

Stratégies d’arrêt anticipé

Vous pouvez arrêter automatiquement les exécutions peu performantes avec une stratégie d’arrêt anticipé. Un arrêt anticipé améliore l’efficacité du calcul, en sauvant des ressources de calcul qui auraient autrement été consacrées à des configurations moins prometteuses. Le ML automatisé pour les images prend en charge les stratégies d’arrêt anticipé suivantes avec le paramètre early_termination_policy. Si aucune stratégie d’arrêt n’est spécifiée, toutes les configurations sont exécutées jusqu’à la fin.

Découvrez plus en détail comment configurer la stratégie d’arrêt anticipé pour votre balayage d’hyperparamètres.

Ressources pour le balayage

Vous pouvez contrôler les ressources consacrées à votre balayage d’hyperparamètres en spécifiant iterations et max_concurrent_iterations pour le balayage.

Paramètre Détail

iterations Paramètre obligatoire pour le nombre maximal de configurations à balayer. Doit être un entier compris entre 1 et 1000. Lorsque vous explorez juste les hyperparamètres par défaut d’un algorithme de modèle donné, affectez la valeur 1 à ce paramètre.

max_concurrent_iterations Nombre maximal d’exécutions pouvant se dérouler simultanément. En l’absence de spécification, toutes les exécutions s’exécutent en parallèle. En cas de spécification, doit être un entier compris entre 1 et 100.

REMARQUE : Le nombre d’exécutions simultanées est limité par les ressources disponibles dans la cible de calcul spécifiée. Vérifiez que la cible de calcul dispose des ressources nécessaires à l’accès concurrentiel souhaité.

Paramètre	Détail
`iterations`	Paramètre obligatoire pour le nombre maximal de configurations à balayer. Doit être un entier compris entre 1 et 1000. Lorsque vous explorez juste les hyperparamètres par défaut d’un algorithme de modèle donné, affectez la valeur 1 à ce paramètre.
`max_concurrent_iterations`	Nombre maximal d’exécutions pouvant se dérouler simultanément. En l’absence de spécification, toutes les exécutions s’exécutent en parallèle. En cas de spécification, doit être un entier compris entre 1 et 100. REMARQUE : Le nombre d’exécutions simultanées est limité par les ressources disponibles dans la cible de calcul spécifiée. Vérifiez que la cible de calcul dispose des ressources nécessaires à l’accès concurrentiel souhaité.

Notes

Pour obtenir un exemple complet de configuration de balayage, reportez-vous à ce tutoriel.

Arguments

Vous pouvez passer en tant qu’arguments des paramètres fixes qui ne changent pas pendant le balayage de l’espace de paramètres. Les arguments sont passés dans les paires nom-valeur et le nom doit être préfixé avec un double tiret.

from azureml.train.automl import AutoMLImageConfig
arguments = ["--early_stopping", 1, "--evaluation_frequency", 2]
automl_image_config = AutoMLImageConfig(arguments=arguments)

Entraînement incrémentiel (facultatif)

Une fois l’exécution d’entraînement terminée, vous avez la possibilité d’effectuer un apprentissage supplémentaire du modèle en chargeant le point de contrôle du modèle formé. Vous pouvez utiliser le même jeu de données ou un jeu différent pour un entraînement incrémentiel.

Deux options sont disponibles pour l’entraînement incrémentiel. Vous pouvez :

Transmettre l’ID d’exécution à partir duquel vous voulez charger le point de contrôle.
Transmettre les points de contrôle via un FileDataset.

Passer le point de contrôle via l’ID d’exécution

Pour trouver l’ID d’exécution à partir du modèle souhaité, vous pouvez utiliser le code suivant.

# find a run id to get a model checkpoint from
target_checkpoint_run = automl_image_run.get_best_child()

Pour passer un point de contrôle via l’ID d’exécution, vous devez utiliser le paramètre checkpoint_run_id.

automl_image_config = AutoMLImageConfig(task='image-object-detection',
                                        compute_target=compute_target,
                                        training_data=training_dataset,
                                        validation_data=validation_dataset,
                                        checkpoint_run_id= target_checkpoint_run.id,
                                        primary_metric='mean_average_precision',
                                        **tuning_settings)

automl_image_run = experiment.submit(automl_image_config)
automl_image_run.wait_for_completion(wait_post_processing=True)

Passer le point de contrôle via FileDataset

Pour passer un point de contrôle via un FileDataset, vous devez utiliser les paramètrescheckpoint_dataset_id et checkpoint_filename.

# download the checkpoint from the previous run
model_name = "outputs/model.pt"
model_local = "checkpoints/model_yolo.pt"
target_checkpoint_run.download_file(name=model_name, output_file_path=model_local)

# upload the checkpoint to the blob store
ds.upload(src_dir="checkpoints", target_path='checkpoints')

# create a FileDatset for the checkpoint and register it with your workspace
ds_path = ds.path('checkpoints/model_yolo.pt')
checkpoint_yolo = Dataset.File.from_files(path=ds_path)
checkpoint_yolo = checkpoint_yolo.register(workspace=ws, name='yolo_checkpoint')

automl_image_config = AutoMLImageConfig(task='image-object-detection',
                                        compute_target=compute_target,
                                        training_data=training_dataset,
                                        validation_data=validation_dataset,
                                        checkpoint_dataset_id= checkpoint_yolo.id,
                                        checkpoint_filename='model_yolo.pt',
                                        primary_metric='mean_average_precision',
                                        **tuning_settings)

automl_image_run = experiment.submit(automl_image_config)
automl_image_run.wait_for_completion(wait_post_processing=True)

Soumettre l’exécution

Une fois votre objet AutoMLImageConfig prêt, vous pouvez soumettre l’expérience.

ws = Workspace.from_config()
experiment = Experiment(ws, "Tutorial-automl-image-object-detection")
automl_image_run = experiment.submit(automl_image_config)

Sorties et métriques d’évaluation

Les exécutions d’entraînement ML automatisées génèrent des fichiers de modèle de sortie, des mesures d’évaluation, des journaux et des artefacts de déploiement, comme le fichier de scoring et le fichier d’environnement, que vous pouvez consulter sous l’onglet des sorties, journaux et métriques des exécutions enfants.

Conseil

Regardez comment accéder aux résultats des tâches à partir de la section Consulter les résultats des exécutions.

Pour obtenir des définitions et des exemples des graphiques et métriques de performances fournis pour chaque exécution, consultez Évaluer les résultats de l’expérience de Machine Learning automatisé.

Inscrire et déployer un modèle

Une fois l’exécution terminée, vous pouvez enregistrer le modèle qui a été créé à partir de la meilleure exécution (configuration qui a généré la meilleure métrique principale).

best_child_run = automl_image_run.get_best_child()
model_name = best_child_run.properties['model_name']
model = best_child_run.register_model(model_name = model_name, model_path='outputs/model.pt')

Après avoir enregistré le modèle que vous voulez utiliser, vous pouvez le déployer en tant que service web sur ACI (Azure Container Instances) ou AKS (Azure Kubernetes Service). ACI est l’option idéale pour tester les déploiements, tandis qu’AKS est mieux adapté à une utilisation en production à grande échelle.

Cet exemple déploie le modèle en tant que service web dans AKS. Pour déployer dans AKS, commencez par créer un cluster de calcul AKS ou utilisez un cluster AKS existant. Vous pouvez utiliser l’une des références SKU de machine virtuelle GPU ou CPU pour votre cluster de déploiement.


from azureml.core.compute import ComputeTarget, AksCompute
from azureml.exceptions import ComputeTargetException

# Choose a name for your cluster
aks_name = "cluster-aks-gpu"

# Check to see if the cluster already exists
try:
    aks_target = ComputeTarget(workspace=ws, name=aks_name)
    print('Found existing compute target')
except ComputeTargetException:
    print('Creating a new compute target...')
    # Provision AKS cluster with GPU machine
    prov_config = AksCompute.provisioning_configuration(vm_size="STANDARD_NC6", 
                                                        location="eastus2")
    # Create the cluster
    aks_target = ComputeTarget.create(workspace=ws, 
                                      name=aks_name, 
                                      provisioning_configuration=prov_config)
    aks_target.wait_for_completion(show_output=True)

Ensuite, vous pouvez définir la configuration d’inférence qui décrit comment configurer le service web contenant votre modèle. Vous pouvez utiliser le script de scoring et l’environnement de l’exécution d’entraînement dans votre configuration d’inférence.

from azureml.core.model import InferenceConfig

best_child_run.download_file('outputs/scoring_file_v_1_0_0.py', output_file_path='score.py')
environment = best_child_run.get_environment()
inference_config = InferenceConfig(entry_script='score.py', environment=environment)

Vous pouvez ensuite déployer le modèle en tant que service web AKS.

# Deploy the model from the best run as an AKS web service
from azureml.core.webservice import AksWebservice
from azureml.core.webservice import Webservice
from azureml.core.model import Model
from azureml.core.environment import Environment

aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True,                                                    
                                                cpu_cores=1,
                                                memory_gb=50,
                                                enable_app_insights=True)

aks_service = Model.deploy(ws,
                           models=[model],
                           inference_config=inference_config,
                           deployment_config=aks_config,
                           deployment_target=aks_target,
                           name='automl-image-test',
                           overwrite=True)
aks_service.wait_for_deployment(show_output=True)
print(aks_service.state)

Vous pouvez aussi déployer le modèle à partir de l’interface utilisateur du studio Azure Machine Learning. Accédez au modèle que vous souhaitez déployer sous l’onglet Modèles de l’exécution du ML automatisé et sélectionnez Déployer.

Sélectionner un modèle parmi les exécutions automl dans l’interface utilisateur du studio

Vous pouvez configurer le nom du point de terminaison du déploiement du modèle et le cluster d’inférence à utiliser pour le déploiement de votre modèle dans le volet Déployer un modèle.

Déployer la configuration

Mettre à jour la configuration de l’inférence

À l’étape précédente, nous avons téléchargé le fichier de scoring outputs/scoring_file_v_1_0_0.py du meilleur modèle dans un fichier score.py local et nous l’avons utilisé pour créer un objet InferenceConfig. Ce script peut être modifié pour changer les paramètres d’inférence spécifiques au modèle si nécessaire, une fois qu’il a été téléchargé et avant de créer InferenceConfig. Par exemple, c’est la section de code qui initialise le modèle dans le fichier de scoring :

...
def init():
    ...
    try:
        logger.info("Loading model from path: {}.".format(model_path))
        model_settings = {...}
        model = load_model(TASK_TYPE, model_path, **model_settings)
        logger.info("Loading successful.")
    except Exception as e:
        logging_utilities.log_traceback(e, logger)
        raise
...

Chacune des tâches (et certains modèles) a un ensemble de paramètres dans le dictionnaire model_settings. Par défaut, nous utilisons les mêmes valeurs pour les paramètres qui ont été utilisés pendant l’entraînement et la validation. En fonction du comportement dont nous avons besoin lors de l’utilisation du modèle pour l’inférence, nous pouvons changer ces paramètres. Vous trouverez ci-dessous une liste de paramètres pour chaque type de tâche et modèle.

Tâche	Nom du paramètre	Default
Classification d’images (multi-classe et multi-étiquette)	`valid_resize_size` `valid_crop_size`	256 224
Détection d’objets	`min_size` `max_size` `box_score_thresh` `nms_iou_thresh` `box_detections_per_img`	600 1333 0.3 0.5 100
Détection d’objets avec `yolov5`	`img_size` `model_size` `box_score_thresh` `nms_iou_thresh`	640 moyenne 0.1 0.5
Segmentation d’instances	`min_size` `max_size` `box_score_thresh` `nms_iou_thresh` `box_detections_per_img` `mask_pixel_score_threshold` `max_number_of_polygon_points` `export_as_image` `image_type`	600 1333 0.3 0.5 100 0.5 100 False JPG

Pour obtenir une description détaillée des hyperparamètres spécifiques aux tâches, consultez Hyperparamètres pour les tâches de vision par ordinateur dans AutoML.

Si vous souhaitez utiliser la mise en mosaïque et contrôler son comportement, les paramètres suivants sont disponibles : tile_grid_size, tile_overlap_ratio et tile_predictions_nms_thresh. Pour plus d’informations sur ces paramètres, consultez Entraîner un modèle de détection de petits objets avec AutoML.

Exemples de notebooks

Passez en revue les exemples de code détaillé et les cas d’usage disponibles dans le dépôt GitHub d’exemples de blocs-notes pour le Machine Learning automatisé. Vérifiez les dossiers avec le préfixe « image- » pour obtenir des exemples propres à la création de modèles de vision par ordinateur.

Partager via

Configurer AutoML pour entraîner des modèles de vision par ordinateur avec Python (v1)

Prérequis

Sélectionner votre type de tâche

Données de formation et de validation

Exemples de schémas JSONL

Consommer les données

Capacité de calcul pour exécuter l’expérience

Configurer les algorithmes et les hyperparamètres du modèle

Algorithmes de modèle pris en charge

Augmentation des données

Configurer les paramètres de votre expérience

Métrique principale

Budget pour les expériences

Balayage des hyperparamètres pour votre modèle

Définir l’espace de recherche de paramètres

Méthodes d’échantillonnage pour le balayage

Stratégies d’arrêt anticipé

Ressources pour le balayage

Arguments

Entraînement incrémentiel (facultatif)

Passer le point de contrôle via l’ID d’exécution

Passer le point de contrôle via FileDataset

Soumettre l’exécution

Sorties et métriques d’évaluation

Inscrire et déployer un modèle

Mettre à jour la configuration de l’inférence

Exemples de notebooks

Étapes suivantes

Commentaires

Ressources supplémentaires