En vision par ordinateur, la segmentation sémantique est la tâche de classer chaque pixel d'une image avec une classe à partir d'un ensemble connu d'étiquettes de sorte que les pixels avec la même étiquette partagent certaines caractéristiques. Il génère un masque de segmentation des images d'entrée. Par exemple, les images suivantes montrent un masque de segmentation du cat étiquette.

En Novembre 2018, Amazon Sage Maker a annoncé le lancement de l'algorithme de segmentation sémantique SageMaker. Avec cet algorithme, vous pouvez former vos modèles avec un jeu de données public ou votre propre jeu de données. Les ensembles de données de segmentation d'image populaires incluent l'ensemble de données Common Objects in Context (COCO) et PASCAL Visual Object Classes (PASCAL VOC), mais les classes de leurs étiquettes sont limitées et vous pouvez former un modèle sur des objets cibles qui ne sont pas inclus dans le ensembles de données publics. Dans ce cas, vous pouvez utiliser Vérité au sol Amazon SageMaker pour étiqueter votre propre jeu de données.

Dans cet article, je démontre les solutions suivantes :

• Utilisation de Ground Truth pour étiqueter un ensemble de données de segmentation sémantique
• Transformer les résultats de Ground Truth au format d'entrée requis pour l'algorithme de segmentation sémantique intégré de SageMaker
• Utilisation de l'algorithme de segmentation sémantique pour entraîner un modèle et effectuer des inférences

Étiquetage des données de segmentation sémantique

Pour créer un modèle d'apprentissage automatique pour la segmentation sémantique, nous devons étiqueter un ensemble de données au niveau du pixel. Ground Truth vous donne la possibilité d'utiliser des annotateurs humains via Turc mécanique d'Amazon, des fournisseurs tiers ou votre propre main-d'œuvre privée. Pour en savoir plus sur les effectifs, consultez Créer et gérer des effectifs. Si vous ne souhaitez pas gérer vous-même le personnel d'étiquetage, Amazon SageMaker Vérité au sol Plus est une autre excellente option en tant que nouveau service d'étiquetage de données clé en main qui vous permet de créer rapidement des ensembles de données de formation de haute qualité et de réduire les coûts jusqu'à 40 %. Pour cet article, je vous montre comment étiqueter manuellement l'ensemble de données avec la fonction de segmentation automatique Ground Truth et l'étiquetage participatif avec une main-d'œuvre Mechanical Turk.

Étiquetage manuel avec Ground Truth

En décembre 2019, Ground Truth a ajouté une fonctionnalité de segmentation automatique à l'interface utilisateur d'étiquetage de segmentation sémantique pour augmenter le débit d'étiquetage et améliorer la précision. Pour plus d'informations, reportez-vous à Segmentation automatique des objets lors de l'étiquetage de segmentation sémantique avec Amazon SageMaker Ground Truth. Avec cette nouvelle fonctionnalité, vous pouvez accélérer votre processus d'étiquetage sur les tâches de segmentation. Au lieu de dessiner un polygone étroitement ajusté ou d'utiliser l'outil Pinceau pour capturer un objet dans une image, vous ne dessinez que quatre points : les points les plus en haut, les plus en bas, les plus à gauche et les plus à droite de l'objet. Ground Truth prend ces quatre points en entrée et utilise l'algorithme Deep Extreme Cut (DEXTR) pour produire un masque bien ajusté autour de l'objet. Pour un didacticiel utilisant Ground Truth pour l'étiquetage de segmentation sémantique d'image, reportez-vous à Segmentation sémantique des images. Voici un exemple de la manière dont l'outil de segmentation automatique génère automatiquement un masque de segmentation une fois que vous avez choisi les quatre points extrêmes d'un objet.

Étiquetage participatif avec une main-d'œuvre Mechanical Turk

Si vous disposez d'un grand ensemble de données et que vous ne souhaitez pas étiqueter vous-même manuellement des centaines ou des milliers d'images, vous pouvez utiliser Mechanical Turk, qui fournit une main-d'œuvre humaine évolutive et à la demande pour effectuer des tâches que les humains peuvent faire mieux que les ordinateurs. Le logiciel Mechanical Turk formalise les offres d'emploi aux milliers de travailleurs prêts à effectuer un travail au coup par coup à leur convenance. Le logiciel récupère également le travail effectué et le compile pour vous, le demandeur, qui paie les travailleurs pour un travail satisfaisant (uniquement). Pour démarrer avec Mechanical Turk, reportez-vous à Présentation d'Amazon Mechanical Turk.

Créer une tâche d'étiquetage

Voici un exemple de tâche d'étiquetage Mechanical Turk pour un jeu de données de tortues marines. Le jeu de données sur les tortues marines provient du concours Kaggle Détection de visage de tortue de mer, et j'ai sélectionné 300 images de l'ensemble de données à des fins de démonstration. La tortue de mer n'est pas une classe courante dans les ensembles de données publics, elle peut donc représenter une situation qui nécessite l'étiquetage d'un ensemble de données massif.

1. Sur la console SageMaker, choisissez Étiquetage des travaux dans le volet de navigation.
2. Selectionnez Créer un travail d'étiquetage.
3. Entrez un nom pour votre tâche.
4. Pour Configuration des données d'entrée, sélectionnez Configuration automatisée des données.
   Cela génère un manifeste des données d'entrée.
5. Pour Emplacement S3 pour les ensembles de données d'entrée, entrez le chemin du jeu de données.
   
6. Pour Catégorie de tâche, choisissez Image(s).
7. Pour Sélection de tâche, sélectionnez Segmentation sémantique.
   
8. Pour Types de travailleurs, sélectionnez Turc mécanique d'Amazon.
9. Configurez vos paramètres pour le délai d'expiration de la tâche, l'heure d'expiration de la tâche et le prix par tâche.
   
10. Ajouter un libellé (pour ce post, sea turtle), et fournir des instructions d'étiquetage.
11. Selectionnez Création.
    

Après avoir configuré la tâche d'étiquetage, vous pouvez vérifier la progression de l'étiquetage sur la console SageMaker. Lorsqu'il est marqué comme terminé, vous pouvez choisir le travail pour vérifier les résultats et les utiliser pour les étapes suivantes.

Transformation de jeu de données

Après avoir obtenu la sortie de Ground Truth, vous pouvez utiliser les algorithmes intégrés de SageMaker pour former un modèle sur cet ensemble de données. Tout d'abord, vous devez préparer le jeu de données étiqueté comme interface d'entrée demandée pour l'algorithme de segmentation sémantique SageMaker.

Canaux de données d'entrée demandés

La segmentation sémantique SageMaker s'attend à ce que votre ensemble de données d'entraînement soit stocké sur Service de stockage simple Amazon (Amazon S3). L'ensemble de données dans Amazon S3 devrait être présenté sur deux canaux, un pour train et une pour validation, en utilisant quatre répertoires, deux pour les images et deux pour les annotations. Les annotations doivent être des images PNG non compressées. Le jeu de données peut également avoir une carte d'étiquettes qui décrit comment les mappages d'annotations sont établis. Sinon, l'algorithme utilise une valeur par défaut. Pour l'inférence, un point de terminaison accepte des images avec un image/jpeg type de contenu. Voici la structure requise des canaux de données :

s3://bucket_name
    |- train
                 | - image1.jpg
                 | - image2.jpg
    |- validation
                 | - image3.jpg
                 | - image4.jpg
    |- train_annotation
                 | - image1.png
                 | - image2.png
    |- validation_annotation
                 | - image3.png
                 | - image4.png
    |- label_map
                 | - train_label_map.json
                 | - validation_label_map.json

Chaque image JPG dans les répertoires de train et de validation a une image d'étiquette PNG correspondante avec le même nom dans le train_annotation et validation_annotation répertoires. Cette convention de nommage aide l'algorithme à associer une étiquette à son image correspondante lors de la formation. Le train, train_annotation, validation et validation_annotation les chaînes sont obligatoires. Les annotations sont des images PNG monocanal. Le format fonctionne tant que les métadonnées (modes) de l'image aident l'algorithme à lire les images d'annotation dans un entier non signé 8 bits à canal unique.

Résultat de la tâche d'étiquetage Ground Truth

Les sorties générées à partir de la tâche d'étiquetage Ground Truth ont la structure de dossiers suivante :

s3://turtle2022/labelturtles/
    |- activelearning
    |- annotation-tool
    |- annotations
                 | - consolidated-annotation
                                   | - consolidation-request                               
                                   | - consolidation-response
                                   | - output
			                                  | -0_2022-02-10T17:40:03.294994.png
                                              | -0_2022-02-10T17:41:04.530266.png
                 | - intermediate
                 | - worker-response
    |- intermediate
    |- manifests
                 | - output
                                | - output.manifest

Les masques de segmentation sont enregistrés dans s3://turtle2022/labelturtles/annotations/consolidated-annotation/output. Chaque image d'annotation est un fichier .png nommé d'après l'index de l'image source et l'heure à laquelle cet étiquetage d'image a été effectué. Par exemple, voici l'image source (Image_1.jpg) et son masque de segmentation générés par la main-d'œuvre Mechanical Turk (0_2022-02-10T17:41:04.724225.png). Notez que l'index du masque est différent du numéro dans le nom de l'image source.

Le manifeste de sortie de la tâche d'étiquetage se trouve dans le /manifests/output/output.manifest dossier. C'est un fichier JSON, et chaque ligne enregistre un mappage entre l'image source et son étiquette et d'autres métadonnées. La ligne JSON suivante enregistre un mappage entre l'image source affichée et son annotation :

{"source-ref":"s3://turtle2022/Image_1.jpg","labelturtles-ref":"s3://turtle2022/labelturtles/annotations/consolidated-annotation/output/0_2022-02-10T17:41:04.724225.png","labelturtles-ref-metadata":{"internal-color-map":{"0":{"class-name":"BACKGROUND","hex-color":"#ffffff","confidence":0.25988},"1":{"class-name":"Turtle","hex-color":"#2ca02c","confidence":0.25988}},"type":"groundtruth/semantic-segmentation","human-annotated":"yes","creation-date":"2022-02-10T17:41:04.801793","job-name":"labeling-job/labelturtles"}}

L'image source s'appelle Image_1.jpg et le nom de l'annotation est 0_2022-02-10T17:41: 04.724225.png. Pour préparer les données en tant que formats de canal de données requis de l'algorithme de segmentation sémantique SageMaker, nous devons modifier le nom de l'annotation afin qu'il ait le même nom que les images JPG source. Et nous devons également diviser l'ensemble de données en train et validation répertoires pour les images source et les annotations.

Transformez la sortie d'un travail d'étiquetage Ground Truth au format d'entrée demandé

Pour transformer la sortie, procédez comme suit :

1. Téléchargez tous les fichiers de la tâche d'étiquetage depuis Amazon S3 vers un répertoire local :

   !aws s3 cp s3://turtle2022/ Seaturtles --recursive

2. Lisez le fichier manifeste et remplacez les noms de l'annotation par les mêmes noms que les images source :

   import os
   import re
   
   label_job='labelturtles'
   manifest_path=dir_name+'/'+label_job+'/'+'manifests/output/output.manifest'
   
   file = open(manifest_path, "r") 
   txt=file.readlines()
   output_path=dir_name+'/'+label_job+'/'+'annotations/consolidated-annotation/output'
   S3_name='turtle2022/'
   im_list=[]
   for i in range(len(txt)):
       string = txt[i]
       try:
           im_name = re.search(S3_name+'(.+)'+'.jpg', string).group(1)
           print(im_name)
           im_png=im_name+'.png'
           im_list.append(im_name)
           annotation_name = re.search('output/(.+?)"', string).group(1)
           os.rename(annotation_name, im_png)
       except AttributeError:
           pass

3. Divisez les ensembles de données d'apprentissage et de validation :

   import numpy as np
   from random import sample
     
   # Prints list of random items of given length
   train_num=len(im_list)*0.8
   test_num=len(im_list)*0.2
   train_name=sample(im_list,int(train_num))
   test_name = list(set(im_list) - set(train_name))

4. Créez un répertoire au format requis pour les canaux de données de l'algorithme de segmentation sémantique :

   os.chdir('./semantic_segmentation_pascalvoc_2022-01-11')
   os.mkdir('train')
   os.mkdir('validation')
   os.mkdir('train_annotation')
   os.mkdir('validation_annotation')

5. Déplacez les images de train et de validation et leurs annotations dans les répertoires créés.
   1. Pour les images, utilisez le code suivant :

      for i in range(len(train_name)):
          train_im=train_name[i]+'.jpg'
          train_im_path=dir_name+'/'+train_im
          train_new_path='train/'+train_im
          shutil.move(train_im_path,train_new_path) 
          
          train_annotation=train_name[i]+'.png'
          train_annotation_path=dir_name+'/labelturtles/annotations/consolidated-annotation/output/'+train_annotation
          train_annotation_new_path='train_annotation/'+train_annotation
          shutil.move(train_annotation_path,train_annotation_new_path)

   2. Pour les annotations, utilisez le code suivant :

      for i in range(len(test_name)):
          val_im=test_name[i]+'.jpg'
          val_im_path=dir_name+'/'+val_im
          val_new_path='validation/'+val_im
          shutil.move(val_im_path,val_new_path) 
          
          val_annotation=test_name[i]+'.png'
          val_annotation_path=dir_name+'/labelturtles/annotations/consolidated-annotation/output/'+val_annotation
          val_annotation_new_path='validation_annotationT/'+val_annotation
          shutil.move(val_annotation_path,val_annotation_new_path)

6. Chargez les ensembles de données d'entraînement et de validation et leurs ensembles de données d'annotation sur Amazon S3 :

   !aws s3 cp train s3://turtle2022/train/ --recursive
   !aws s3 cp train_annotation s3://turtle2022/train_annotation/ --recursive
   !aws s3 cp validation s3://turtle2022/validation/ --recursive
   !aws s3 cp validation_annotation s3://turtle2022/validation_annotation/ --recursive

Formation au modèle de segmentation sémantique SageMaker

Dans cette section, nous passons en revue les étapes pour former votre modèle de segmentation sémantique.

Suivez l'exemple de bloc-notes et configurez les canaux de données

Vous pouvez suivre les instructions de L'algorithme de segmentation sémantique est désormais disponible dans Amazon SageMaker pour implémenter l'algorithme de segmentation sémantique dans votre jeu de données étiqueté. Cet échantillon cahier montre un exemple de bout en bout introduisant l'algorithme. Dans le bloc-notes, vous apprendrez à entraîner et à héberger un modèle de segmentation sémantique à l'aide du réseau entièrement convolutif (FCN) algorithme utilisant la Jeu de données Pascal VOC pour s'entraîner. Parce que je ne prévois pas de former un modèle à partir de l'ensemble de données Pascal VOC, j'ai sauté l'étape 3 (préparation des données) dans ce bloc-notes. Au lieu de cela, j'ai créé directement train_channel, train_annotation_channe, validation_channelet validation_annotation_channel en utilisant les emplacements S3 où j'ai stocké mes images et mes annotations :

Train_channel=’s3://turtle2022/train’
train_annotation_channel=’s3://turtle2022/train_annotation’
validation_channel=’s3://turtle2022/validation’
validation_annotation_channel=’s3://turtle2022/validation_annotation’

Ajustez les hyperparamètres pour votre propre ensemble de données dans l'estimateur SageMaker

J'ai suivi le bloc-notes et créé un objet estimateur SageMaker (ss_estimator) pour entraîner mon algorithme de segmentation. Une chose que nous devons personnaliser pour le nouvel ensemble de données est dans ss_estimator.set_hyperparameters: nous devons changer num_classes=21 à num_classes=2 (turtle et background), et j'ai aussi changé epochs=10 à epochs=30 car 10 est uniquement à des fins de démonstration. Ensuite, j'ai utilisé l'instance p3.2xlarge pour la formation de modèles en définissant instance_type="ml.p3.2xlarge". La formation terminée en 8 minutes. Le meilleur MIOU (Intersection moyenne sur Union) de 0.846 est atteint à l'époque 11 avec un pix_acc (le pourcentage de pixels de votre image qui sont classés correctement) de 0.925, ce qui est un assez bon résultat pour ce petit ensemble de données.

Résultats de l'inférence du modèle

J'ai hébergé le modèle sur une instance ml.c5.xlarge à faible coût :

training_job_name = 'ss-notebook-demo-2022-02-12-03-37-27-151'
ss_estimator = sagemaker.estimator.Estimator.attach(training_job_name)
ss_predictor = ss_estimator.deploy(initial_instance_count=1, instance_type="ml.c5.xlarge")

Enfin, j'ai préparé un ensemble de test de 10 images de tortues pour voir le résultat d'inférence du modèle de segmentation formé :

import os

path = "testturtle/"
img_path_list=[]
files = os.listdir(path)

for file in files:
 
    if file.endswith(('.jpg', '.png', 'jpeg')):
        img_path = path + file
        img_path_list.append(img_path)

colnum=5
fig, axs = plt.subplots(2, colnum, figsize=(20, 10))

for i in range(len(img_path_list)):
    print(img_path_list[i])
    img = mpimg.imread(img_path_list[i])
    with open(img_path_list[i], "rb") as imfile:
        imbytes = imfile.read()
    cls_mask = ss_predictor.predict(imbytes)
    axs[int(i/colnum),i%colnum].imshow(img, cmap='gray') 
    axs[int(i/colnum),i%colnum].imshow(np.ma.masked_equal(cls_mask,0), cmap='jet', alpha=0.8)
    
plt.show()

Les images suivantes montrent les résultats.

Les masques de segmentation des tortues marines semblent précis et je suis satisfait de ce résultat formé sur un ensemble de données de 300 images étiquetées par les travailleurs de Mechanical Turk. Vous pouvez également explorer d'autres réseaux disponibles tels que réseau d'analyse de scènes pyramidales (PSP) or DeepLab-V3 dans l'exemple de bloc-notes avec votre ensemble de données.

Nettoyer

Supprimez le point de terminaison lorsque vous en avez terminé pour éviter d'encourir des coûts continus :

ss_predictor.delete_endpoint()

Conclusion

Dans cet article, j'ai montré comment personnaliser l'étiquetage des données de segmentation sémantique et la formation de modèles à l'aide de SageMaker. Tout d'abord, vous pouvez configurer une tâche d'étiquetage avec l'outil de segmentation automatique ou utiliser une main-d'œuvre Mechanical Turk (ainsi que d'autres options). Si vous avez plus de 5,000 2 objets, vous pouvez également utiliser l'étiquetage automatisé des données. Ensuite, vous transformez les sorties de votre tâche d'étiquetage Ground Truth dans les formats d'entrée requis pour la formation à la segmentation sémantique intégrée de SageMaker. Après cela, vous pouvez utiliser une instance de calcul accéléré (telle que p3 ou pXNUMX) pour former un modèle de segmentation sémantique avec les éléments suivants cahier et déployer le modèle sur une instance plus rentable (telle que ml.c5.xlarge). Enfin, vous pouvez consulter les résultats d'inférence sur votre jeu de données de test avec quelques lignes de code.

Démarrer avec la segmentation sémantique SageMaker étiquetage des données et formation modèle avec votre jeu de données préféré !

À propos de l’auteur

Kara Yang est Data Scientist dans AWS Professional Services. Elle se passionne pour aider les clients à atteindre leurs objectifs commerciaux avec les services cloud AWS. Elle a aidé des organisations à créer des solutions de ML dans plusieurs secteurs tels que la fabrication, l'automobile, la durabilité environnementale et l'aérospatiale.