Transférer l'apprentissage pour les modèles de détection d'objets TensorFlow dans Amazon SageMaker

Amazon Sage Maker offre une suite de algorithmes intégrés, modèles pré-entraînéset modèles de solutions prédéfinis pour aider les scientifiques des données et les praticiens de l'apprentissage automatique (ML) à démarrer rapidement la formation et le déploiement de modèles ML. Vous pouvez utiliser ces algorithmes et modèles pour l'apprentissage supervisé et non supervisé. Ils peuvent traiter différents types de données d'entrée, notamment des tableaux, des images et du texte.

Cet article est le deuxième d'une série sur les nouveaux algorithmes intégrés à SageMaker. Dans le premier message, nous avons montré comment SageMaker fournit un algorithme intégré pour la classification des images. Aujourd'hui, nous annonçons que SageMaker fournit un nouvel algorithme intégré pour la détection d'objets à l'aide de TensorFlow. Cet algorithme d'apprentissage supervisé prend en charge l'apprentissage par transfert pour de nombreux modèles pré-entraînés disponibles dans TensorFlow. Il prend une image en entrée et affiche les objets présents dans l'image ainsi que les cadres de délimitation. Vous pouvez affiner ces modèles pré-entraînés à l’aide de l’apprentissage par transfert, même lorsqu’un grand nombre d’images d’entraînement ne sont pas disponibles. Il est disponible via SageMaker algorithmes intégrés ainsi que par le Interface utilisateur JumpStart de SageMaker in Amazon SageMakerStudio. Pour plus d'informations, reportez-vous à Tensorflow de détection d'objets et l'exemple de cahier Introduction à SageMaker Tensorflow – Détection d'objets.

La détection d'objets avec TensorFlow dans SageMaker permet un apprentissage par transfert sur de nombreux modèles pré-entraînés disponibles dans TensorFlow Hub. Selon le nombre d'étiquettes de classe dans les données d'entraînement, une nouvelle tête de détection d'objets initialisée de manière aléatoire remplace la tête existante du modèle TensorFlow. Soit l'ensemble du réseau, y compris le modèle pré-entraîné, soit seule la couche supérieure (tête de détection d'objets) peut être affinée sur les nouvelles données d'entraînement. Dans ce mode d'apprentissage par transfert, vous pouvez réaliser une formation même avec un ensemble de données plus petit.

Comment utiliser le nouvel algorithme de détection d'objets TensorFlow

Cette section décrit comment utiliser l'algorithme de détection d'objets TensorFlow avec le Kit de développement logiciel (SDK) SageMaker Python. Pour plus d'informations sur son utilisation à partir de l'interface utilisateur de Studio, consultez SageMaker JumpStart.

L'algorithme prend en charge l'apprentissage par transfert pour les modèles pré-formés répertoriés dans Modèles TensorFlow. Chaque modèle est identifié par un identifiant unique model_id. Le code suivant montre comment affiner un modèle FPN ResNet50 V1 identifié par model_id tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8 sur un jeu de données d'entraînement personnalisé. Pour chaque model_id, afin de lancer une tâche de formation SageMaker via le Estimateur classe du SDK Python SageMaker, vous devez récupérer l'URI de l'image Docker, l'URI du script de formation et l'URI du modèle pré-entraîné via les fonctions utilitaires fournies dans SageMaker. L'URI du script de formation contient tout le code nécessaire au traitement des données, au chargement du modèle pré-entraîné, à la formation du modèle et à l'enregistrement du modèle entraîné pour l'inférence. L'URI du modèle pré-entraîné contient la définition de l'architecture du modèle pré-entraîné et les paramètres du modèle. Notez que l'URI de l'image Docker et l'URI du script de formation sont les mêmes pour tous les modèles de détection d'objets TensorFlow. L'URI du modèle pré-entraîné est spécifique au modèle particulier. Les archives tar du modèle pré-entraîné ont été pré-téléchargées à partir de TensorFlow et enregistrées avec la signature de modèle appropriée dans Service de stockage simple Amazon (Amazon S3), de sorte que la tâche de formation s'exécute en isolation réseau. Voir le code suivant :

from sagemaker import image_uris, model_uris, script_urisfrom sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-od1-ssd-resnet50-v1-fpn-640x640-coco17-tpu-8", "*"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")# Retrieve the pre-trained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tensorflow-od-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

Avec ces artefacts de formation spécifiques au modèle, vous pouvez construire un objet du Estimateur classe:

# Create SageMaker Estimator instance
tf_od_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,)

Ensuite, pour l'apprentissage par transfert sur votre jeu de données personnalisé, vous devrez peut-être modifier les valeurs par défaut des hyperparamètres de formation, qui sont répertoriés dans Hyperparamètres. Vous pouvez récupérer un dictionnaire Python de ces hyperparamètres avec leurs valeurs par défaut en appelant hyperparameters.retrieve_default, mettez-les à jour si nécessaire, puis transmettez-les à la classe Estimator. Notez que les valeurs par défaut de certains des hyperparamètres sont différentes pour différents modèles. Pour les grands modèles, la taille de lot par défaut est plus petite et le train_only_top_layer l'hyperparamètre est défini sur True. L'hyperparamètre train_only_top_layer définit les paramètres du modèle qui changent pendant le processus de réglage fin. Si train_only_top_layer is True, les paramètres des couches de classification changent et les autres paramètres restent constants pendant le processus de réglage fin. D'autre part, si train_only_top_layer is False, tous les paramètres du modèle sont ajustés. Voir le code suivant :

from sagemaker import hyperparameters# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

Nous offrons le temps de réponse Ensemble de données PennFudanPed comme ensemble de données par défaut pour affiner les modèles. L'ensemble de données comprend des images de piétons. Le code suivant fournit l'ensemble de données de formation par défaut hébergé dans les compartiments S3 :

# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_COCO_format/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

Enfin, pour lancer la tâche d'entraînement SageMaker pour affiner le modèle, appelez .fit sur l'objet de la classe Estimator, en passant l'emplacement S3 du jeu de données d'apprentissage :

# Launch a SageMaker Training job by passing s3 path of the training data
tf_od_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Pour plus d'informations sur l'utilisation du nouvel algorithme de détection d'objets SageMaker TensorFlow pour l'apprentissage par transfert sur un ensemble de données personnalisé, le déploiement du modèle affiné, l'exécution de l'inférence sur le modèle déployé et le déploiement du modèle pré-entraîné tel quel sans réglage préalable. sur un ensemble de données personnalisé, consultez l'exemple de bloc-notes suivant : Introduction à SageMaker TensorFlow – Détection d'objets.

Interface d'entrée/sortie pour l'algorithme de détection d'objets TensorFlow

Vous pouvez affiner chacun des modèles pré-formés répertoriés dans Modèles TensorFlow à n'importe quel ensemble de données comprenant des images appartenant à n'importe quel nombre de classes. L'objectif est de minimiser l'erreur de prédiction sur les données d'entrée. Le modèle renvoyé par le réglage fin peut être déployé davantage pour l'inférence. Voici les instructions sur la façon dont les données d'apprentissage doivent être formatées pour être entrées dans le modèle :

• Entrée – Un répertoire avec sous-répertoire images et un fichier annotations.json.
• Sortie – Il y a deux sorties. Le premier est un modèle affiné, qui peut être déployé à des fins d’inférence ou entraîné davantage à l’aide d’un entraînement incrémentiel. Le deuxième est un fichier qui mappe les index de classe aux étiquettes de classe ; ceci est enregistré avec le modèle.

Le répertoire d'entrée devrait ressembler à l'exemple suivant :

input_directory
      | -- images
            |--abc.png
            |--def.png
      |--annotations.json

La annotations.json le fichier doit contenir des informations pour bounding_boxes et leurs étiquettes de classe. Il devrait avoir un dictionnaire avec les clés "images" ainsi que "annotations". La valeur pour le "images" la clé doit être une liste d'entrées, une pour chaque image du formulaire {"file_name": image_name, "height": height, "width": width, "id": image_id}. La valeur de la "annotations" la clé doit être une liste d'entrées, une pour chaque cadre de délimitation du formulaire {"image_id": image_id, "bbox": [xmin, ymin, xmax, ymax], "category_id": bbox_label}.

Inférence avec l'algorithme de détection d'objets TensorFlow

Les modèles générés peuvent être hébergés pour l'inférence et prendre en charge les formats d'image codés .jpg, .jpeg et .png comme application/x-image type de contenu. L'image d'entrée est redimensionnée automatiquement. La sortie contient les cases, les classes prédites et les scores pour chaque prédiction. Le modèle de détection d'objets TensorFlow traite une seule image par requête et ne génère qu'une seule ligne dans le JSON. Voici un exemple de réponse en JSON :

accept: application/json;verbose

{"normalized_boxes":[[xmin1, xmax1, ymin1, ymax1],....], "classes":[classidx1, class_idx2,...], "scores":[score_1, score_2,...], "labels": [label1, label2, ...], "tensorflow_model_output":}

If accept est fixé à application/json, le modèle génère uniquement les boîtes, classes et scores prédits. Pour plus de détails sur la formation et l'inférence, consultez l'exemple de bloc-notes Introduction à SageMaker TensorFlow – Détection d'objets.

Utiliser les algorithmes intégrés de SageMaker via l'interface utilisateur JumpStart

Vous pouvez également utiliser la détection d'objets SageMaker TensorFlow et n'importe lequel des autres algorithmes intégrés en quelques clics via l'interface utilisateur JumpStart. JumpStart est une fonctionnalité SageMaker qui vous permet de former et de déployer des algorithmes intégrés et des modèles pré-entraînés à partir de divers frameworks ML et hubs de modèles via une interface graphique. Il vous permet également de déployer des solutions ML à part entière qui regroupent des modèles ML et divers autres services AWS pour résoudre un cas d'utilisation ciblé.

Voici deux vidéos qui montrent comment vous pouvez reproduire le même processus de réglage fin et de déploiement que nous venons de suivre en quelques clics via l'interface utilisateur JumpStart.

Affiner le modèle pré-entraîné

Voici le processus pour affiner le même modèle de détection d'objets pré-entraîné.

Déployer le modèle affiné

Une fois la formation du modèle terminée, vous pouvez déployer directement le modèle sur un point de terminaison persistant en temps réel en un seul clic.

Conclusion

Dans cet article, nous avons annoncé le lancement de l'algorithme intégré de détection d'objets SageMaker TensorFlow. Nous avons fourni un exemple de code sur la façon d'effectuer un apprentissage par transfert sur un ensemble de données personnalisé à l'aide d'un modèle pré-entraîné de TensorFlow à l'aide de cet algorithme.

Pour plus d'informations, consultez Documentation et par exemple de cahier.

À propos des auteurs

Dr Vivek Madan est un scientifique appliqué avec le Équipe Amazon SageMaker JumpStart. Il a obtenu son doctorat à l'Université de l'Illinois à Urbana-Champaign et a été chercheur postdoctoral à Georgia Tech. Il est un chercheur actif en apprentissage automatique et en conception d'algorithmes et a publié des articles dans les conférences EMNLP, ICLR, COLT, FOCS et SODA.

Joao Moura est architecte de solutions spécialisées en IA/ML chez Amazon Web Services. Il se concentre principalement sur les cas d'utilisation du NLP et aide les clients à optimiser la formation et le déploiement de modèles d'apprentissage en profondeur. Il est également un partisan actif des solutions ML low-code et du matériel spécialisé ML.

Dr Ashish Khetan est un scientifique appliqué senior avec Algorithmes intégrés d'Amazon SageMaker et aide à développer des algorithmes d'apprentissage automatique. Il a obtenu son doctorat à l'Université de l'Illinois Urbana Champaign. Il est un chercheur actif en apprentissage automatique et en inférence statistique et a publié de nombreux articles dans les conférences NeurIPS, ICML, ICLR, JMLR, ACL et EMNLP.