Intelligence artificielle Segmentation et détection d’objets en temps réel avec Tensorflow

Pour approfondir le sujet

Sur le même thème :

Focus sur GrAI One, la puce IA de GrAI Matter Labs pour une latence ultra-faible en périphérie

GrAI Matter Labs (alias GML) a lancé, le 24 octobre 2019, GrAI One, présenté comme le tout premier processeur IA au monde optimisé pour...

Google publie en open source une nouvelle API de détection d’objets TensorFlow

Google a annoncé la publication en open source de l'API TensorFlow Object Detection. Ce framework, intégré à TensorFlow, permet de faciliter l'identification des objets...

Microsoft lance de nouveaux outils de machine learning

Microsoft a profité de la conférence Ignite pour annoncer le lancement de différents outils pour développeurs et datascientists. L'idée est de faciliter la création...

JetBrains propose DataSpell, son nouvel environnement de développement dédié à la data science

JetBrains, un éditeur de logiciels pour développeurs, présente en mode preview, son nouvel environnement de développement (IDE) intitulé DataSpell. Dédié à la data science,...

Segmentation et détection d’objets en temps réel avec Tensorflow

L’objectif de ce billet est d’expliquer la segmentation d’objets en temps réel par l’exemple. Pour cela, nous allons développer une application de segmentation en temps réel avec une webcam simple (embarquée dans le PC, USB ou autre). Nous utiliserons le framework Tensorflow, le réseau Mask RCNN ResNet101 appris avec le dataset COCO; ce qui nous permet de détecter jusqu’à 90 types d’objets différents.

Dans une première partie, je vais poser les grandes définitions et expliquer les choix de ce petit projet : pourquoi tensorflow, mask RCNN ResNet101 (what?), 90 objets mais lesquels, etc. La seconde partie est dédiée à la mise en place de l’environnement de travail, du téléchargement du modèle à l’installation des librairies utiles. Dans un troisième partie, nous créerons ensemble le code étape par étape en expliquant les points clés. Enfin pour faire plaisir à tous les profs de Français, je terminerai par une conclusion.

Le code est disponible sur ma page Github.

Définitions

La détection d’objets est un domaine très actif de la recherche qui cherche à classer et localiser des régions/zones d’une image ou d’un flux vidéo. Ce domaine est à la croisée de deux autres : la classification d’image et la localisation d’objets. En effet, le principe de la détection d’objets est le suivant : pour une image donnée, on recherche les régions de celle-ci qui pourraient contenir un objet puis pour chacune de ces régions découvertes, on l’extrait et on la classe à l’aide d’un modèle de classification d’image – par exemple – . Les régions de l’image d’origine ayant de bons résultats de classification sont conservés et les autres jetés. Ainsi, pour avoir une bonne méthode de détection d’objets, il est nécessaire d’avoir un algo solide de détection de régions et un bon algo de classification d’images.

La clef de la réussite est détenue dans l’algorithme de classification d’image. Depuis les résultats du challenge ImageNet 2012, le deep learning (et notamment les réseaux de convolution) est devenue la méthode number #1 pour résoudre ce genre de problème. Le recherches en détection d’objets ont donc tout naturellement intégré les modèles de classification d’image, ce qui a permis de créer des bijoux tels que SSD et R-CNN (le R signifiant ici Region). L’image #1 illustre le résultat d’une détection d’objets (de voitures en l’occurrence). On observe que plusieurs objets peuvent être découverts et localisés dans une même image.

voiture-defile-detect
Image 1 – Exemple de détection d’objets par un modèle de deep learning

SSD et R-CNN ne sont jamais utilisés seuls, ils sont couplés avec un réseau pré-calculé de classification d’image. Un réseau auquel on a calculé les poids est appelé un modèle. Il existe ainsi des SSD Mobilenet, des R-CNN Inception, etc.

Malgré tout, il manque quelque chose dans cette équation : avec quoi les poids des réseaux de classification d’image ont été calculé ? La réponse est : un gros dataset d’images. Généralement c’est avec le dataset MSCOCO (souvent réduit à COCO) qui est utilisé. MSCOCO est un ensemble de plus de 330k images contenant des dizaines de types d’objets différents. Je vous invite à fouiller le site officiel pour en savoir davantage.

Mais soyons plus exigeants et demandons à notre IA d’être précise au pixel près. Répondre à cette question, c’est faire de la segmentation d’objets (instance segmentation).

Pour ce genre de tâche le principe reste globalement le même, simplement, à la fin de notre réseau est ajouté une étape de création de masque capable de dire si oui ou non un pixel fait parti de notre objet détecté.

Les réseaux de segmentation d’objets commencent en général par le mot clé “Mask”. Tensorflow propose par exemple 4 modèles de segmentation. Celui que nous utiliserons dans ce tutoriel est mask_rcnn_resnet101_atrous_coco. L’image #2 illustre le résultat d’un modèle de segmentation d’objets.

voiture-segmentation
Image 2 – Exemple de segmentation d’objets

Enfin, les modèles de segmentation d’objets et de détection d’objets sont évalués non pas en fonction de leur précision/accuracy (à l’instar des modèles de classification d’image) mais à l’aide d’une mesure de calcul de recouvrement : le mAP (Mean Average Precision). L’objectif de cette mesure est de comparer la région détectée avec la vraie région de l’objet. Un article entier est consacré à cette mesure.

J’ai présenté les informations essentielles de la détection et la segmentation d’objets. Je ne suis pas entré dans les détails des réseaux mais beaucoup d’autres articles le font bien. Je vous invite à fouiller scholar.google ou tout simplement google pour en connaître davantage. Dans la partie suivante, je vais parler de la configuration nécessaire pour faire tourner notre programme de segmentation d’objets en temps réel.

Récupération des outils (+ détails des versions)

Avant toute choses, faisons la liste de nos outils et librairies à installer.

  • Linux Ubuntu 18.04. Tout ce qui suit a été testé avec Ubuntu 18.04. Que vous soyez sur Mac ou Windows, le programme fonctionnera, seuls les indications des installations ne sont pas compatibles.
  • Python. Nous utiliserons le langage de programmation python dans sa version 3, faites donc en sorte d’installer cette version de python (python3.6 pour être précis). Il est très probable que le programme tourne avec une autre version de python, mais je ne garantis rien.
  • Tensorflow. Il évidemment nécessaire d’installer tensorflow (tensorflow-gpu si votre PC est muni d’un GPU compatible). Si pip3 est installé, rien de plus simple avec la commande pip3 install tensorflow.
  • Tensorflow object detection. On aura besoin du module object detection de tensorflow. Vous trouverez toutes les informations sur l’installation de ce module ici. Note : si vous faites l’export du pythonpath dans un terminal, conservez bien ce terminal pour exécuter le programme de segmentation sinon la modification du pythonpath sera perdue. Vous pouvez aussi l’ajouter au bashrc également.
  • Open CV. La gestion du flux vidéo est géré par la célèbre libraire opencv. Pour l’installer, entrer dans votre terminal pip3 install opencv-python.

Pour tester si votre système est prêt, ouvrez une console python3 dans le terminal en tapant python3. Faites les imports suivant :

import cv2
import numpy as np
import tensorflow as tf
from object_detection.utils import label_map_util
from object_detection.utils import ops as utils_ops
from object_detection.utils import visualization_utils as vis_util

Si il y a une erreur, alors vérifiez vos installations.

Pour faire fonctionner le modèle, il faut… le réseau et ses poids. Vous trouverez la liste de tous les modèles d’object detection disponibles avec tensorflow sur ce model zoo. Pour ce tutoriel, téléchargez mask_rcnn_resnet101_atrous_coco.

Développement étape par étape

1 – Initialisation du modèle avec tensorflow

La première étape de notre programme est l’initialisation du modèle de tensorflow. Il s’agit ici d’importer le graphe du modèle associé à ses poids pré-calculés à l’aide du fichier frozen_inference_graphe.pb, de récupérer les tenseurs de sorties et celui d’entrée, d’importer les labels et d’initialiser la capture vidéo de la webcam.

On commence d’ailleurs par le dernier point : initialiser la webcam. Cela permet deux choses : (1) créer le flux vidéo et (2) obtenir la largeur et la hauteur d’une frame du flux dans le but de configurer le tenseur de sortie du masque.

# Init the video stream (with the first plugged webcam)
cap = cv2.VideoCapture(0)
if cap.isOpened():
  # get vcap property
  global_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
  global_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

Rien de compliqué ici. Si vous souhaitez gérer le flux vidéo dans un Thread à part, je vous conseille de regarder du côté de la librairie imutils.

La suite concerne l’importation du fichier label_map. Elle se réalise à l’aide des méthodes délivrées avec object_detection de tensorflow.

label_map = label_map_util.load_labelmap("PATH/TO/LABELS")
categories = label_map_util.convert_label_map_to_categories(
  label_map, 
  max_num_classes=NUM_CLASSES,
  use_display_name=True)
category_index = label_map_util.create_category_index(categories)

On poursuit ensuite avec l’importation du modèle et la récupération des tenseurs.

# Init TF Graph and get all needed tensors
detection_graph = tf.Graph()
with detection_graph.as_default():
  # Init the graph
  od_graph_def = tf.GraphDef()
  with tf.gfile.GFile("/chemin/vers/*.pbb') as fid:
    serialized_graph = fid.read()
    od_graph_def.ParseFromString(serialized_graph)
    tf.import_graph_def(od_graph_def, name='')

  # Get all tensors
  ops = tf.get_default_graph().get_operations()
  all_tensor_names = {output.name for op in ops for output in op.outputs}
  tensor_dict = {}
  for key in ['num_detections', 'detection_boxes', 'detection_scores', 'detection_classes', 'detection_masks']:
    tensor_name = key + ':0'
      if tensor_name in all_tensor_names:
        tensor_dict[key] = tf.get_default_graph().get_tensor_by_name(tensor_name)

  # detection_masks tensor need ops
  detection_boxes = tf.squeeze(tensor_dict['detection_boxes'], [0])
  detection_masks = tf.squeeze(tensor_dict['detection_masks'], [0])
  # Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
  real_num_detection = tf.cast(tensor_dict['num_detections'][0], tf.int32)
  detection_boxes = tf.slice(detection_boxes, [0, 0], [real_num_detection, -1])
  detection_masks = tf.slice(detection_masks, [0, 0, 0], [real_num_detection, -1, -1])
  detection_masks_reframed =  utils_ops.reframe_box_masks_to_image_masks(
detection_masks, detection_boxes, global_height, global_width)
  detection_masks_reframed = tf.cast(tf.greater(detection_masks_reframed, 0.5), tf.uint8)
  # Follow the convention by adding back the batch dimension
  tensor_dict['detection_masks'] = tf.expand_dims(detection_masks_reframed, 0)

  image_tensor = tf.get_default_graph().get_tensor_by_name('image_tensor:0')

L’importation est classique, il n’y a rien de spécifique à expliquer. Concernant les tenseurs de sortie, on récupère ‘num_detections‘, ‘detection_boxes‘, ‘detection_scores‘, ‘detection_classes‘, ‘detection_masks‘ et, ‘detection_masks‘. On notera qu’on se fout un peu de ‘num_detections’ mais ce tenseur est appelé dans la doc officielle, alors moi aussi je l’appelle.

Poursuivons notre programme avec la méthode main. Dans cette méthode qui est appelé après les initialisations que je viens de présenter, on capture la dernière image de la webcam, on la traite, on affiche l’image modifiée et on recommence. La méthode main ressemble donc à :

if __name__ == '__main__':
  # Do that here and save a lot of time
  with detection_graph.as_default():
    with tf.Session(graph=detection_graph) as sess:
      while True:
        # Get the last frame
        frame = cap.read()[1]
        # Process last img
        new_frame = detect_objects(image_np, sess)
        # Display the resulting frame
        cv2.imshow('new_frame', new_frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
          break

On commence notre code avec une série de deux blocs with (en réalité on peut n’en faire qu’un mais c’est plus joli et plus propre avec deux). Ces blocs permettent de définir la session tensorflow. S’en suit une boucle infinie qui nous permet de boucler sur le flux vidéo. À chaque étape de cette boucle, on récupère la dernière image du buffer du flux de la caméra avec la commande cap.read puis on fait un appelle à la méthode detect_objects() que je vais présenter juste après. On finit en affichant la frame modifiée avec cv2.imshow.

Et donc le cœur de programme se trouve dans la méthode detect_objects() qui prend en arguments l’image (au format numpy array) et la session tensorflow qui nous permettra de runner notre modèle.

Le code est le suivant :

def detect_objects(image_np, sess):
  # Run inference
  output_dict = sess.run(tensor_dict, feed_dict={image_tensor: np.expand_dims(image_np, 0)})

  # all outputs are float32 numpy arrays, so convert types as appropriate
  output_dict['num_detections'] = int(output_dict['num_detections'][0])
  output_dict['detection_classes'] = output_dict['detection_classes'][0].astype(np.uint8)
  output_dict['detection_boxes'] = output_dict['detection_boxes'][0]
  output_dict['detection_scores'] = output_dict['detection_scores'][0]
  output_dict['detection_masks'] = output_dict['detection_masks'][0]

  # Display boxes and color pixels
  vis_util.visualize_boxes_and_labels_on_image_array(
    image_np,
    output_dict['detection_boxes'],
    output_dict['detection_classes'],
    output_dict['detection_scores'],
    category_index,
    instance_masks=output_dict.get('detection_masks    use_normalized_coordinates=True)

  return image_np

Comme on le voit, tensorflow s’occupe de tout, de l’appel des bons tenseurs à la coloration des pixels de l’image en fonction des résultats de l’object detection. La première étape consiste à passer notre image dans le réseau et de récupérer les résultats. C’est exactement ce qu’il se passe avec la ligne sess.run. Ensuite, les résultats sont mis au bon formats afin d’être traiter par le script du module d’object detection permettant la visualisation des résultats. Enfin, on appelle la méthode visualize_boxes_and_labels_on_image_array qui se trouve dans le fichier object_detection/utils:visualization_utils.py. Si vous souhaitez modifier l’apparence des résultats, c’est donc ce fichier qu’il faudra modifier.

Conclusion

Nous avons développé un programme de segmentation et détection d’objets en temps réel en python. Pour cela, on s’est appuyé sur le réseau Mask RCNN ResNet101 implémenté par tensorflow et qui a été entraîné avec le dataset MSCOCO. Le code complet est disponible sur Github par ici. N’hésitez pas si vous avez la moindre question ou remarque.


1ère Marketplace de l'IA et de la transformation numérique vous recommande :
 

Contributeur expert

Jean-Charles Risch

Jean-Charles Risch est co-fondateur de la société Elter (Société de services informatiques sp

Partager l'article

Levée de fonds de 6 millions d’euros de la fintech lyonnaise Mon Petit Placement

Mon Petit Placement, start-up lancée en 2017, a bouclé en ce mois de novembre sa troisième levée de fonds pour un montant de 6...

Lutte contre la cybercriminalité : l’exemple du défi IA lancé par le gouvernement canadien aux petites entreprises

Comme les autres organismes de police canadiens, la Gendarmerie royale du Canada (GRC) peine à accéder aux données chiffrées saisies lors d'enquêtes criminelles. C'est...

Continuity annonce une levée de fonds de 5 millions d’euros auprès d’Elaia Partners, Bpifrance et Kamet Ventures

Continuity a levé 5 millions d’euros en Seed auprès d'Elaia Partners, Bpifrance et Kamet Ventures a annoncé la jeune pousse cette semaine. La start-up...

ADAM9, un gène potentiellement impliqué dans les formes graves de Covid-19 identifié par l’intelligence artificielle

Pourquoi certains patients atteints de Covid-19 sont-ils asymptomatiques alors que d'autres développent des formes graves, notamment le SDRA (syndrome de détresse respiratoire aigüe) ?...
Recevoir une notification en cas d'actualité importante    OK Non merci