Exécutez la segmentation d'image avec Amazon SageMaker JumpStart

En décembre 2020, AWS a annoncé la disponibilité générale de Amazon SageMaker JumpStart, une capacité de Amazon Sage Maker qui vous aide à démarrer rapidement et facilement avec l'apprentissage automatique (ML). JumpStart permet d'ajuster et de déployer en un clic une grande variété de modèles pré-formés pour les tâches ML courantes, ainsi qu'une sélection de solutions de bout en bout qui résolvent les problèmes commerciaux courants. Ces fonctionnalités simplifient chaque étape du processus de ML, ce qui facilite le développement de modèles de haute qualité et réduit le temps de déploiement.

Cet article est le troisième d'une série sur l'utilisation de JumpStart pour des tâches ML spécifiques. Dans le premier message, nous avons montré comment exécuter des cas d'utilisation de classification d'images sur JumpStart. Dans le deuxième message, nous avons montré comment exécuter des cas d'utilisation de classification de texte sur JumpStart. Dans cet article, nous fournissons une procédure pas à pas sur la façon d'affiner et de déployer un modèle de segmentation d'image, en utilisant des modèles entraînés de MXNet. Nous explorons deux manières d'obtenir le même résultat : via l'interface graphique de JumpStart sur Amazon SageMakerStudio, et par programmation via API JumpStart.

Si vous souhaitez accéder directement au code de l'API JumpStart que nous expliquons dans cet article, vous pouvez vous référer aux exemples de notebooks Jupyter suivants :

Présentation de JumpStart

JumpStart vous aide à démarrer avec des modèles ML pour une variété de tâches sans écrire une seule ligne de code. Au moment de la rédaction, JumpStart vous permet d'effectuer les opérations suivantes :

• Déployer des modèles pré-formés pour les tâches ML courantes – JumpStart vous permet de traiter des tâches ML courantes sans effort de développement en fournissant un déploiement facile de modèles pré-formés sur de grands ensembles de données accessibles au public. La communauté des chercheurs en ML a déployé des efforts considérables pour rendre la majorité des modèles récemment développés accessibles au public. JumpStart héberge une collection de plus de 300 modèles, couvrant les 15 tâches ML les plus populaires telles que la détection d'objets, la classification de texte et la génération de texte, ce qui facilite leur utilisation par les débutants. Ces modèles sont tirés de hubs de modèles populaires tels que TensorFlow, PyTorch, Hugging Face et MXNet.
• Affiner les modèles pré-formés – JumpStart vous permet d'affiner les modèles pré-formés sans avoir besoin d'écrire votre propre algorithme de formation. En ML, la capacité de transférer les connaissances acquises dans un domaine vers un autre domaine est appelée transférer l'apprentissage. Vous pouvez utiliser l'apprentissage par transfert pour produire des modèles précis sur vos ensembles de données plus petits, avec des coûts de formation bien inférieurs à ceux impliqués dans la formation du modèle d'origine. JumpStart comprend également des algorithmes de formation populaires basés sur LightGBM, CatBoost, XGBoost et Scikit-learn, que vous pouvez former à partir de zéro pour la régression tabulaire et la classification.
• Utiliser des solutions prédéfinies – JumpStart fournit un ensemble de 17 solutions pour les cas d'utilisation courants du ML, tels que la prévision de la demande et les applications industrielles et financières, que vous pouvez déployer en quelques clics. Les solutions sont des applications ML de bout en bout qui regroupent divers services AWS pour résoudre un cas d'utilisation métier particulier. Ils utilisent AWS CloudFormation modèles et architectures de référence pour un déploiement rapide, ce qui signifie qu'ils sont entièrement personnalisables.
• Reportez-vous aux exemples de bloc-notes pour les algorithmes SageMaker – SageMaker fournit une suite d'algorithmes intégrés pour aider les scientifiques des données et les praticiens du ML à se lancer rapidement dans la formation et le déploiement de modèles de ML. JumpStart fournit des exemples de blocs-notes que vous pouvez utiliser pour utiliser rapidement ces algorithmes.
• Consultez les vidéos de formation et les blogs – JumpStart propose également de nombreux articles de blog et vidéos qui vous apprennent à utiliser différentes fonctionnalités dans SageMaker.

JumpStart accepte les paramètres VPC personnalisés et Service de gestion des clés AWS (AWS KMS), afin que vous puissiez utiliser les modèles et solutions disponibles en toute sécurité dans votre environnement d'entreprise. Vous pouvez transmettre vos paramètres de sécurité à JumpStart dans Studio ou via le SDK Python SageMaker.

Segmentation sémantique

La segmentation sémantique délimite chaque classe d'objets apparaissant dans une image d'entrée. Il balise (classifie) chaque pixel de l'image d'entrée avec une étiquette de classe à partir d'un ensemble prédéfini de classes. Plusieurs objets de la même classe sont mappés sur le même masque.

Le modèle disponible pour le réglage fin construit une "tête" de réseau entièrement convolutif (FCN) au-dessus du réseau de base. L'étape de réglage fin affine le FCNHead tout en gardant les paramètres du reste du modèle figés, et renvoie le modèle affiné. L'objectif est de minimiser la perte d'entropie croisée softmax par pixel pour entraîner le FCN. Le modèle renvoyé par le réglage fin peut être déployé davantage pour l'inférence.

Le répertoire d'entrée doit ressembler au code suivant si les données d'entraînement contiennent deux images. Les noms des fichiers .png peuvent être n'importe quoi.

input_directory
    |--images
        |--abc.png
        |--def.png
    |--masks
        |--abc.png
        |--def.png
    class_label_to_prediction_index.json

Les fichiers de masque doivent contenir des informations d'étiquette de classe pour chaque pixel.

Segmentation d'instance

La segmentation d'instance détecte et délimite chaque objet d'intérêt distinct apparaissant dans une image. Il marque chaque pixel avec une étiquette d'instance. Alors que la segmentation sémantique attribue la même étiquette aux pixels de plusieurs objets de la même classe, la segmentation d'instance étiquette en outre les pixels correspondant à chaque occurrence d'un objet sur l'image avec une étiquette distincte.

Actuellement, JumpStart propose des modèles d'inférence uniquement pour la segmentation d'instance et ne prend pas en charge le réglage fin.

Les images suivantes illustrent la différence entre l'inférence dans la segmentation sémantique et la segmentation d'instance. L'image originale a deux personnes dans l'image. La segmentation sémantique traite plusieurs personnes dans l'image comme une seule entité : Person. Cependant, la segmentation des instances identifie les personnes individuelles au sein du Person catégorie.

Vue d'ensemble de la solution

Les sections suivantes fournissent une démonstration étape par étape pour effectuer une segmentation sémantique avec JumpStart, à la fois via l'interface utilisateur de Studio et via les API JumpStart.

Nous suivons les étapes suivantes :

1. Accédez à JumpStart via l'interface utilisateur de Studio :
   1. Exécutez l'inférence sur le modèle pré-entraîné.
   2. Affiner le modèle pré-formé.
2. Utilisez JumpStart par programmation avec le SDK SageMaker Python :
   1. Exécutez l'inférence sur le modèle pré-entraîné.
   2. Affiner le modèle pré-formé.

Nous discutons également des fonctionnalités avancées supplémentaires de JumpStart.

Accéder à JumpStart via l'interface utilisateur de Studio

Dans cette section, nous montrons comment entraîner et déployer des modèles JumpStart via l'interface utilisateur de Studio.

Exécuter l'inférence sur le modèle pré-entraîné

La vidéo suivante vous montre comment trouver un modèle de segmentation sémantique pré-entraîné sur JumpStart et le déployer. La page du modèle contient des informations précieuses sur le modèle, comment l'utiliser, le format de données attendu et quelques détails de réglage fin. Vous pouvez déployer n'importe lequel des modèles préformés disponibles dans JumpStart. Pour l'inférence, nous choisissons le type d'instance ml.g4dn.xlarge. Il fournit l'accélération GPU nécessaire pour une faible latence d'inférence, mais à un prix inférieur. Après avoir configuré l'instance d'hébergement SageMaker, choisissez Déployer. Cela peut prendre 5 à 10 minutes pour que votre point de terminaison persistant soit opérationnel.

Après quelques minutes, votre point de terminaison est opérationnel et prêt à répondre aux demandes d'inférence.

De même, vous pouvez déployer un modèle de segmentation d'instance pré-formé en suivant les mêmes étapes dans la vidéo précédente tout en recherchant la segmentation d'instance au lieu de la segmentation sémantique dans la barre de recherche JumpStart.

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

La vidéo suivante montre comment trouver et affiner un modèle de segmentation sémantique dans JumpStart. Dans la vidéo, nous affinons le modèle en utilisant le Ensemble de données PennFudanPed, fourni par défaut dans JumpStart, que vous pouvez télécharger sous le Licence Apache 2.0.

Le réglage fin de votre propre ensemble de données implique de prendre le formatage correct des données (comme expliqué sur la page du modèle), de le télécharger sur Service de stockage simple Amazon (Amazon S3) et en spécifiant son emplacement dans la configuration de la source de données. Nous utilisons les mêmes valeurs d'hyperparamètres définies par défaut (nombre d'époques, taux d'apprentissage et taille de lot). Nous utilisons également un ml.p3.2xlarge soutenu par GPU comme instance de formation SageMaker.

Vous pouvez surveiller l'exécution de votre tâche d'entraînement directement sur la console Studio et être averti lorsqu'elle est terminée. Une fois la formation terminée, vous pouvez déployer le modèle affiné à partir de la même page qui contient les détails de la tâche de formation. Le workflow de déploiement est identique au déploiement d'un modèle pré-entraîné.

Utiliser JumpStart par programmation avec le SDK SageMaker

Dans les sections précédentes, nous avons montré comment vous pouvez utiliser l'interface utilisateur JumpStart pour déployer un modèle pré-formé et l'affiner de manière interactive, en quelques clics. Cependant, vous pouvez également utiliser les modèles de JumpStart et les ajuster facilement par programmation à l'aide d'API intégrées au SDK SageMaker. Nous passons maintenant en revue un exemple rapide de la façon dont vous pouvez reproduire le processus précédent. Toutes les étapes de cette démo sont disponibles dans les cahiers d'accompagnement Introduction à JumpStart - Segmentation d'instance ainsi que Introduction à JumpStart – Segmentation sémantique.

Exécuter l'inférence sur le modèle pré-entraîné

Dans cette section, nous choisissons un modèle pré-formé approprié dans JumpStart, déployons ce modèle sur un point de terminaison SageMaker et exécutons l'inférence sur le point de terminaison déployé.

SageMaker est une plateforme basée sur des conteneurs Docker. JumpStart utilise le framework spécifique disponible Conteneurs d'apprentissage en profondeur SageMaker (DLC). Nous récupérons tous les packages supplémentaires, ainsi que les scripts pour gérer la formation et l'inférence pour la tâche sélectionnée. Enfin, les artefacts de modèle pré-formés sont récupérés séparément avec model_uris, qui offre de la flexibilité à la plate-forme. Vous pouvez utiliser n'importe quel nombre de modèles pré-formés pour la même tâche avec un seul script de formation ou d'inférence. Voir le code suivant :

model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve(
    region=None,
    framework=None,  # automatically inferred from model_id
    image_scope="inference",
    model_id=model_id,
    model_version=model_version,
    instance_type=inference_instance_type,
)

# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="inference")

base_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference")

Par exemple la segmentation, nous pouvons définir model_id à mxnet-semseg-fcn-resnet50-ade. Le est dans l'identifiant correspond à la segmentation d'instance.

Ensuite, nous introduisons les ressources dans un Modèle SageMaker instance et déployer un point de terminaison :

# Create the SageMaker model instance
model = Model(
    image_uri=deploy_image_uri,
    source_dir=deploy_source_uri,
    model_data=base_model_uri,
    entry_point="inference.py",  # entry point file in source_dir and present in deploy_source_uri
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name,
)

# deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class,
# for being able to run inference through the sagemaker API.
base_model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=inference_instance_type,
    predictor_cls=Predictor,
    endpoint_name=endpoint_name,
)

Après quelques minutes, notre modèle est déployé et nous pouvons en tirer des prédictions en temps réel !

L'extrait de code suivant vous donne un aperçu de ce à quoi ressemble la segmentation sémantique. Le masque prédit pour chaque pixel est visualisé. Pour obtenir des inférences à partir d'un modèle déployé, une image d'entrée doit être fournie au format binaire. La réponse du point final est une étiquette prédite pour chaque pixel de l'image. Nous utilisons le query_endpoint ainsi que parse_response les fonctions d'assistance, qui sont définies dans le carnet d'accompagnement:

query_response = query(base_model_predictor, pedestrian_img)
predictions, labels, image_labels = parse_response(query_response)
print("Objects present in the picture:", image_labels)

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

Pour affiner un modèle sélectionné, nous devons obtenir l'URI de ce modèle, ainsi que celui du script de formation et de l'image de conteneur utilisée pour la formation. Heureusement, ces trois entrées dépendent uniquement du nom du modèle, de la version (pour une liste des modèles disponibles, voir Tableau des modèles disponibles JumpStart), et le type d'instance sur lequel vous souhaitez vous entraîner. Ceci est démontré dans l'extrait de code suivant :

from sagemaker import image_uris, model_uris, script_uris

model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"
training_instance_type = "ml.p3.2xlarge"
train_image_uri = image_uris.retrieve(
    region=None,
    framework=None,
    model_id=model_id,
    model_version=model_version,
    image_scope="training",
    instance_type=training_instance_type,)# 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 to further fine-tune

train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

Nous récupérons le model_id correspondant au même modèle que nous avons utilisé précédemment. Vous pouvez maintenant affiner ce modèle JumpStart sur votre propre jeu de données personnalisé à l'aide du SDK SageMaker. Nous utilisons un ensemble de données hébergé publiquement sur Amazon S3, axé sur la segmentation sémantique. L'ensemble de données doit être structuré pour un réglage fin, comme expliqué dans la section précédente. Voir l'exemple de code suivant :

# URI of your training dataset
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_SemSeg/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning")# Create SageMaker Estimator instance
semseg_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,)# Launch a SageMaker Training job by passing s3 path of the training data
semseg_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Nous obtenons les mêmes hyperparamètres par défaut pour notre modèle sélectionné que ceux que nous avons vus dans la section précédente, en utilisant sagemaker.hyperparameters.retrieve_default(). Nous instancions ensuite un estimateur SageMaker et appelons le .fit méthode pour commencer à affiner notre modèle, en lui transmettant l'URI Amazon S3 pour nos données de formation. La entry_point le script fourni est nommé transfer_learning.py (le même pour les autres tâches et modèles), et le canal de données d'entrée est passé à .fit doit être nommé training.

Pendant que l'algorithme s'entraîne, vous pouvez surveiller sa progression soit dans le bloc-notes SageMaker où vous exécutez le code lui-même, soit sur Amazon Cloud Watch. Une fois la formation terminée, les artefacts de modèle affinés sont téléchargés vers l'emplacement de sortie Amazon S3 spécifié dans la configuration de la formation. Vous pouvez maintenant déployer le modèle de la même manière que le modèle pré-entraîné.

Les fonctionnalités avancées

En plus d'affiner et de déployer des modèles pré-formés, JumpStart offre de nombreuses fonctionnalités avancées.

La première est réglage automatique du modèle. Cela vous permet d'ajuster automatiquement vos modèles ML pour trouver les valeurs d'hyperparamètres avec la plus grande précision dans la plage fournie par l'API SageMaker.

La seconde est formation incrémentale. Cela vous permet d'entraîner un modèle que vous avez déjà affiné à l'aide d'un jeu de données étendu qui contient un modèle sous-jacent non pris en compte lors des exécutions d'ajustement précis précédentes, ce qui a entraîné de mauvaises performances du modèle. La formation incrémentielle permet d'économiser du temps et des ressources car vous n'avez pas besoin de recycler le modèle à partir de zéro.

Conclusion

Dans cet article, nous avons montré comment affiner et déployer un modèle de segmentation sémantique pré-formé, et comment l'adapter pour la segmentation d'instance à l'aide de JumpStart. Vous pouvez accomplir cela sans avoir à écrire de code. Essayez la solution par vous-même et envoyez-nous vos commentaires.

Pour en savoir plus sur JumpStart et sur la façon dont vous pouvez utiliser des modèles pré-formés open source pour une variété d'autres tâches de ML, consultez ce qui suit Vidéo AWS re:Invent 2020.

À propos des auteurs

Dr Vivek Madan est un scientifique appliqué au sein de l'é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.

Santosh Kulkarni est un architecte de solutions d'entreprise chez Amazon Web Services qui travaille avec des clients sportifs en Australie. Il est passionné par la création d'applications distribuées à grande échelle pour résoudre des problèmes commerciaux en utilisant ses connaissances en IA/ML, en mégadonnées et en développement de logiciels.

Léonardo Bachega est scientifique senior et responsable de l'équipe Amazon SageMaker JumpStart. Il est passionné par la création de services d'IA pour la vision par ordinateur.