Tutoriel : Entraîner un modèle de détection d’objet (préversion) avec AutoML et Python

S’APPLIQUE À :Extension Azure ML CLI v2 (actuel)

Important

Les fonctionnalités présentées dans cet article sont en préversion. Elles doivent être considérées comme des fonctionnalités en préversion expérimentales qui peuvent changer à tout moment.

Dans ce tutoriel, vous allez découvrir comment entraîner un modèle de détection d’objet à l’aide du ML automatisé d’Azure Machine Learning avec l’extension Azure Machine Learning CLI v2 ou le Kit de développement logiciel (SDK) Python Azure Machine Learning v2 (préversion). Ce modèle de détection d’objet détermine si l’image contient des objets, tels qu’une canette, un carton, une bouteille de lait ou une bouteille d’eau.

Le ML automatisé accepte des données d’entraînement et des paramètres de configuration, et itère automatiquement des combinaisons de différentes méthodes de normalisation/standardisation des fonctionnalités, de modèles et de paramètres hyperparamètres afin d’obtenir le meilleur modèle.

Dans ce tutoriel, vous allez écrire du code à l’aide du kit SDK Python et découvrir comment effectuer les tâches suivantes :

  • Télécharger et transformer des données
  • Entraîner un modèle de détection d’objet Machine Learning automatisé
  • Spécifier des valeurs d’hyperparamètres pour votre modèle
  • Effectuer un balayage hyperparamétrique
  • Déployer votre modèle
  • Visualiser les détections

Prérequis

  • Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante d’Azure Machine Learning dès aujourd’hui.

  • Python 3.6 ou 3.7 sont pris en charge pour cette fonctionnalité

  • Suivez le guide Démarrage rapide : Bien démarrer avec Azure Machine Learning si vous ne disposez pas encore d’un espace de travail Azure Machine Learning.

  • Téléchargez et décompressez le fichier de données *odFridgeObjects.zip. Le jeu de données est annoté au format Pascal VOC, dans lequel chaque image correspond à un fichier XML. Chaque fichier XML contient des informations sur l’emplacement de son fichier image correspondant. Il contient également des informations sur les cadres englobants et les étiquettes d’objet. Pour pouvoir utiliser ces données, vous devez d’abord les convertir au format JSON, comme indiqué dans la section Convert the downloaded data to JSONL de ce notebook.

Ce didacticiel est également disponible dans le référentiel azureml-examples sur GitHub. Si vous souhaitez l’exécuter dans votre propre environnement local, configurez-le à l’aide des instructions suivantes

Configuration de la cible de calcul

Vous devez d’abord configurer une cible de calcul à utiliser pour l’entraînement de votre modèle ML automatisé. Les modèles ML automatisé pour les tâches d’image requièrent des références (SKU) GPU.

Ce tutoriel utilise la série NCsv3 (avec des GPU V100), car ce type de cible de calcul s’appuie sur plusieurs GPU pour accélérer l’entraînement. En outre, vous pouvez configurer plusieurs nœuds afin de tirer parti du parallélisme lors du réglage des hyperparamètres pour votre modèle.

Le code suivant crée un calcul GPU d’une taille de Standard_NC24s_v3 avec 4 nœuds.

S’APPLIQUE À :Extension ml Azure CLI v2 (actuelle)

Créez un fichier yml avec la configuration suivante.

$schema: https://azuremlschemas.azureedge.net/latest/amlCompute.schema.json 
name: gpu-cluster
type: amlcompute
size: Standard_NC24s_v3
min_instances: 0
max_instances: 4
idle_time_before_scale_down: 120

Pour créer le calcul, vous exécutez la commande CLI v2 suivante avec le chemin d’accès à votre fichier .yml, le nom de l’espace de travail, le groupe de ressources et l’ID d’abonnement.

az ml compute create -f [PATH_TO_YML_FILE] --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Le calcul créé peut être fourni à l’aide de la clé compute dans le fichier .yaml de configuration de tâche automl :

compute: azureml:gpu-cluster

Configuration de l’expérience

Vous pouvez utiliser un Essai pour suivre les exécutions de formation de votre modèle.

S’APPLIQUE À :Extension Azure ML CLI v2 (actuel)

Le nom de l’essai peut être fourni à l’aide de la clé experiment_name comme suit :

experiment_name: dpv2-cli-automl-image-object-detection-experiment

Visualiser les données d’entrée

Une fois les données d’image d’entrée préparées au format JSONL (JSON Lines), vous pouvez visualiser les cadres englobants de vérité fondamentale pour une image. Pour cela, vérifiez que matplotlib est installé.

%pip install --upgrade matplotlib

%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib.patches as patches
from PIL import Image as pil_image
import numpy as np
import json
import os

def plot_ground_truth_boxes(image_file, ground_truth_boxes):
    # Display the image
    plt.figure()
    img_np = mpimg.imread(image_file)
    img = pil_image.fromarray(img_np.astype("uint8"), "RGB")
    img_w, img_h = img.size

    fig,ax = plt.subplots(figsize=(12, 16))
    ax.imshow(img_np)
    ax.axis("off")

    label_to_color_mapping = {}

    for gt in ground_truth_boxes:
        label = gt["label"]

        xmin, ymin, xmax, ymax =  gt["topX"], gt["topY"], gt["bottomX"], gt["bottomY"]
        topleft_x, topleft_y = img_w * xmin, img_h * ymin
        width, height = img_w * (xmax - xmin), img_h * (ymax - ymin)

        if label in label_to_color_mapping:
            color = label_to_color_mapping[label]
        else:
            # Generate a random color. If you want to use a specific color, you can use something like "red".
            color = np.random.rand(3)
            label_to_color_mapping[label] = color

        # Display bounding box
        rect = patches.Rectangle((topleft_x, topleft_y), width, height,
                                 linewidth=2, edgecolor=color, facecolor="none")
        ax.add_patch(rect)

        # Display label
        ax.text(topleft_x, topleft_y - 10, label, color=color, fontsize=20)

    plt.show()

def plot_ground_truth_boxes_jsonl(image_file, jsonl_file):
    image_base_name = os.path.basename(image_file)
    ground_truth_data_found = False
    with open(jsonl_file) as fp:
        for line in fp.readlines():
            line_json = json.loads(line)
            filename = line_json["image_url"]
            if image_base_name in filename:
                ground_truth_data_found = True
                plot_ground_truth_boxes(image_file, line_json["label"])
                break
    if not ground_truth_data_found:
        print("Unable to find ground truth information for image: {}".format(image_file))

À l’aide des fonctions d’assistance ci-dessus, pour une image donnée, vous pouvez exécuter le code suivant pour afficher les cadres englobants.

image_file = "./odFridgeObjects/images/31.jpg"
jsonl_file = "./odFridgeObjects/train_annotations.jsonl"

plot_ground_truth_boxes_jsonl(image_file, jsonl_file)

Charger des données et créer MLTable

Pour utiliser les données pour la formation, chargez les données dans le Stockage Blob par défaut de votre espace de travail Azure ML et inscrivez-les en tant que ressources. Les avantages de l’inscription des données sont les suivants :

  • Partager facilement avec d’autres membres de l’équipe
  • Contrôle de version des métadonnées (emplacement, description, etc.)
  • Suivi de la traçabilité

S’APPLIQUE À :Extension ml Azure CLI v2 (actuelle)

Créez un fichier .yml avec la configuration suivante.

$schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
name: fridge-items-images-object-detection
description: Fridge-items images Object detection
path: ./data/odFridgeObjects
type: uri_folder

Pour charger des images en tant que ressources de données, vous exécutez la commande CLI v2 suivante avec le chemin d’accès à votre fichier .yml, le nom de l’espace de travail, le groupe de ressources et l’ID d’abonnement.

az ml data create -f [PATH_TO_YML_FILE] --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

L’étape suivante consiste à créer MLTable à partir de vos données au format jsonl, comme indiqué ci-dessous. MLtable intègre vos données dans un objet consommable à des fins de formation.

paths:
  - file: ./train_annotations.jsonl
transformations:
  - read_json_lines:
        encoding: utf8
        invalid_lines: error
        include_path_column: false
  - convert_column_types:
      - columns: image_url
        column_type: stream_info

S’APPLIQUE À :Extension Azure ML CLI v2 (actuel)

La configuration suivante crée des données de formation et de validation à partir de MLTable.

target_column_name: label
training_data:
  path: data/training-mltable-folder
  type: mltable
validation_data:
  path: data/validation-mltable-folder
  type: mltable

Configurer votre expérience de détection d’objet

Pour configurer des exécutions de ML automatisées pour les tâches liées à l’image, créez un travail AutoML spécifique à une tâche.

S’APPLIQUE À :Extension Azure ML CLI v2 (actuel)

task: image_object_detection
primary_metric: mean_average_precision

Dans votre travail AutoML, vous pouvez spécifier les algorithmes de modèle en utilisant le paramètre model_name et configurer les paramètres de façon à effectuer un balayage hyperparamétrique sur un espace de recherche défini afin de trouver le modèle optimal.

Dans cet exemple, nous allons effectuer l'apprentissage d’un modèle de détection d’objet avec yolov5 et fasterrcnn_resnet50_fpn, tous deux étant préformés sur COCO, un jeu de données de détection d’objet, de segmentation et d’étiquetage à grande échelle qui contient des milliers d’images étiquetées avec plus de 80 catégories d’étiquettes.

Balayage hyperparamétrique pour les tâches d’image

Vous pouvez effectuer un balayage hyperparamétrique sur un espace de recherche défini pour trouver le modèle optimal.

Le code suivant définit l’espace de recherche en vue du balayage hyperparamétrique pour chaque algorithme défini, yolov5 et fasterrcnn_resnet50_fpn. Dans l’espace de recherche, spécifiez la plage de valeurs pour learning_rate, optimizer, lr_scheduler, etc., parmi laquelle AutoML devra choisir lorsqu’il tentera 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 chaque algorithme.

Pour les paramètres de réglage, utilisez l’échantillonnage aléatoire afin de choisir des échantillons à partir de cet espace de paramètres en utilisant le sampling_algorithm random. Cela indique au ML automatisé qu’il doit d’essayer en tout 10 essais avec ces différents échantillons, en exécutant 2 essais à la fois sur notre cible de calcul, qui a été configurée à l’aide de 4 nœuds. Plus l’espace de recherche contient de paramètres, plus il faut d’essais pour trouver des modèles optimaux.

La stratégie d’arrêt anticipé Bandit est également utilisée. Cette stratégie met fin aux configurations dont les performances sont médiocres, autrement dit celles qui ne sont pas dans une fourchette de 20 % par rapport à la configuration la plus performante, ce qui permet d’économiser de manière significative les ressources de calcul.

S’APPLIQUE À :Extension Azure ML CLI v2 (actuel)

sweep:
  limits:
    max_trials: 10
    max_concurrent_trials: 2
  sampling_algorithm: random
  early_termination:
    type: bandit
    evaluation_interval: 2
    slack_factor: 0.2
    delay_evaluation: 6
search_space:
  - model_name: "yolov5"
    learning_rate: "uniform(0.0001, 0.01)"
    model_size: "choice('small', 'medium')"
  - model_name: "fasterrcnn_resnet50_fpn"
    learning_rate: "uniform(0.0001, 0.001)"
    optimizer: "choice('sgd', 'adam', 'adamw')"
    min_size: "choice(600, 800)"

Une fois les paramètres de l’espace de recherche et de balayage définis, vous pouvez soumettre le travail pour effectuer l'apprentissage d’un modèle d’image à l’aide de votre jeu de données de formation.

S’APPLIQUE À :Extension Azure ML CLI v2 (actuelle)

Pour soumettre votre travail AutoML, vous exécutez la commande CLI v2 suivante avec le chemin d’accès à votre fichier .yml, le nom de l’espace de travail, le groupe de ressources et l’ID d’abonnement.

az ml job create --file ./hello-automl-job-basic.yml --workspace-name [YOUR_AZURE_WORKSPACE] --resource-group [YOUR_AZURE_RESOURCE_GROUP] --subscription [YOUR_AZURE_SUBSCRIPTION]

Lorsque vous procédez à un balayage hyperparamétrique, il peut être utile de visualiser les différentes configurations qui ont été tentées à l’aide de l’interface utilisateur HyperDrive. Vous pouvez accéder à cette interface utilisateur en accédant à l’onglet « Exécutions enfants » dans l’interface utilisateur de l’automl_image_rune principale ci-dessus, qui est l’exécution parente HyperDrive. Vous pouvez ensuite accéder à son onglet « Exécutions enfants ».

En guise d’alternative, vous pouvez voir ci-dessous l’exécution parente HyperDrive et accéder à son onglet « Exécutions enfants » :

hd_job = ml_client.jobs.get(returned_job.name + '_HD')
hd_job

Inscrire et déployer un modèle en tant que service web

Une fois que vous avez votre modèle entraîné, vous pouvez le déployer sur Azure. Vous pouvez déployer votre modèle entraîné 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.

Vous pouvez déployer le modèle à partir de l’interface utilisateur d’Azure Machine Learning studio. 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.

Select model from the automl runs in studio UI

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.

Deploy configuration

Test du service web

Vous pouvez tester le service web déployé pour prédire de nouvelles images. Pour ce tutoriel, transmettez une image aléatoire du jeu de données et transmettez-la à l’URI de scoring.

import requests

# URL for the web service
scoring_uri = <scoring_uri from web service>

# If the service is authenticated, set the key or token
key, _ = <keys from the web service>

sample_image = './test_image.jpg'

# Load image data
data = open(sample_image, 'rb').read()

# Set the content type
headers = {'Content-Type': 'application/octet-stream'}

# If authentication is enabled, set the authorization header
headers['Authorization'] = f'Bearer {key}'

# Make the request and display the response
resp = requests.post(scoring_uri, data, headers=headers)
print(resp.text)

Visualiser les détections

Maintenant que vous avez attribué un score à une image de test, vous pouvez visualiser les cadres englobants pour cette image. Pour ce faire, vérifiez que matplotlib est installé.

%pip install --upgrade matplotlib
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib.patches as patches
from PIL import Image
import numpy as np
import json

IMAGE_SIZE = (18,12)
plt.figure(figsize=IMAGE_SIZE)
img_np=mpimg.imread(sample_image)
img = Image.fromarray(img_np.astype('uint8'),'RGB')
x, y = img.size

fig,ax = plt.subplots(1, figsize=(15,15))
# Display the image
ax.imshow(img_np)

# draw box and label for each detection
detections = json.loads(resp.text)
for detect in detections['boxes']:
    label = detect['label']
    box = detect['box']
    conf_score = detect['score']
    if conf_score > 0.6:
        ymin, xmin, ymax, xmax =  box['topY'],box['topX'], box['bottomY'],box['bottomX']
        topleft_x, topleft_y = x * xmin, y * ymin
        width, height = x * (xmax - xmin), y * (ymax - ymin)
        print('{}: [{}, {}, {}, {}], {}'.format(detect['label'], round(topleft_x, 3),
                                                round(topleft_y, 3), round(width, 3),
                                                round(height, 3), round(conf_score, 3)))

        color = np.random.rand(3) #'red'
        rect = patches.Rectangle((topleft_x, topleft_y), width, height,
                                 linewidth=3, edgecolor=color,facecolor='none')

        ax.add_patch(rect)
        plt.text(topleft_x, topleft_y - 10, label, color=color, fontsize=20)

plt.show()

Nettoyer les ressources

Sautez cette section si vous prévoyez d’exécuter d’autres tutoriels Azure Machine Learning.

Si vous n’avez pas l’intention d’utiliser les ressources que vous avez créées, supprimez-les pour éviter des frais.

  1. Dans le portail Azure, sélectionnez Groupes de ressources tout à gauche.
  2. À partir de la liste, sélectionnez le groupe de ressources créé.
  3. Sélectionnez Supprimer le groupe de ressources.
  4. Entrez le nom du groupe de ressources. Puis sélectionnez Supprimer.

Vous pouvez également conserver le groupe de ressources mais supprimer un espace de travail unique. Affichez les propriétés de l’espace de travail, puis sélectionnez Supprimer.

Étapes suivantes

Dans ce tutoriel sur le machine learning automatisé, vous avez effectué les tâches suivantes :

  • Configuration d’un espace de travail et préparation des données pour une expérience
  • Entraînement d’un modèle de détection d’objet automatisé
  • Spécification des valeurs d’hyperparamètres pour votre modèle
  • Balayage hyperparamétrique
  • Déploiement de votre modèle
  • Visualisation des détections

Notes

L’utilisation du jeu de données des objets réfrigérants est disponible sous la licence MIT.