Utiliser la caméra OpenMV pour appliquer rapidement l'apprentissage automatique à la détection d'objets

L'application de l'apprentissage automatique (ML) à la détection et à la classification d'objets est devenue un impératif dans l'industrie des systèmes embarqués, notamment pour l'Internet des objets (IoT), la sécurité, les systèmes d'aide à la conduite (ADAS) et les systèmes basés sur l'automatisation industrielle. Cependant, la détection d'objets est un sujet complexe et l'apprentissage automatique est assez récent. C'est pourquoi le développement d'applications d'apprentissage automatique pour détecter des objets peut être difficile et fastidieux.

Par exemple, la détection d'objets a toujours exigé des développeurs qu'ils maîtrisent une structure comme OpenCV et qu'ils consacrent des milliers de dollars au matériel informatique pour être performants. Ainsi, les approches traditionnelles de la détection d'objets et de la vision artificielle ne sont pas seulement fastidieuses : elles sont également coûteuses.

Pour les ingénieurs qui cherchent à appliquer le ML aux applications de détection d'objets et de vision artificielle sans avoir besoin de devenir un expert en ML ou de dépenser une petite fortune en matériel, le module de caméra programmable Python OpenMV H7 de SparkFun Electronics constitue une solution innovante. Le module est conçu pour être un module économique de type « Arduino » pour la détection et le traitement d'images. Ainsi, ce module et son écosystème logiciel fournissent une solution unique et intéressante pour permettre une détection et une classification faciles des objets à l'aide du ML sous forme de module à faible coût.

Cet article présente le module de caméra OpenMV H7 et explique comment les développeurs peuvent appliquer l'apprentissage automatique à la détection d'objets grâce à des jeux de données d'images de vision par ordinateur CIFAR-10.

Le module de caméra OpenMV H7

Grâce à ses bibliothèques logicielles riches en fonctionnalités, le module de caméra OpenMV H7 offre de nombreuses options qui permettent d'aider un développeur à créer rapidement une application de ML. Par exemple, les développeurs peuvent utiliser la caméra OpenMV pour la détection du visage et des yeux, et même pour suivre avec précision les pupilles. Elle peut être utilisée pour créer des formes ou des marqueurs qui peuvent ensuite suivre une couleur. Il existe même des exemples qui illustrent la manière d'utiliser le ML pour détecter et suivre des objets personnalisés.

Le module de caméra OpenMV H7 est une carte de développement intégrée simple qui inclut tous les composants matériels nécessaires pour la détection et la classification d'objets basées sur le ML, à un coût nettement inférieur à celui des systèmes de vision artificielle traditionnels. Le module est relativement compact, mesurant seulement 35,56 mm x 44,45 mm et il inclut :

• Un microcontrôleur haut de gamme
• Un module de caméra intégré et remplaçable
• Un connecteur de batterie
• Un connecteur micro-USB
• Une LED tricolore
• Un logement microSD (prenant en charge des cartes jusqu'à 64 Go)
• Des entrées et des sorties (E/S) d'extension

Figure 1 : Le module de caméra OpenMV H7 est équipé de tous les composants nécessaires pour développer et déployer rapidement une application de vision artificielle grâce au ML. (Source de l'image : SparkFun Electronics)

Les E/S d'extension fournissent aux développeurs une gamme de fonctionnalités périphériques à partir du microcontrôleur (Figure 2). Ces fonctionnalités incluent des interfaces de communication telles que :

• UART
• SPI
• I²C
• CAN

Les E/S d'extension incluent également des canaux de contrôle et de données pour commander des servos, générer des signaux par le biais d'un convertisseur numérique-analogique (CNA) ou lire des valeurs de capteurs via un convertisseur analogique-numérique (CAN). Ces E/S d'extension rendent le module OpenMV extrêmement intéressant pour les applications de vision dans la domotique, le guidage de robots, l'automatisation industrielle, la détection d'objets et le suivi.

Figure 2 : Le module de caméra OpenMV H7 est fourni avec une multitude de broches E/S extensibles. Ces broches peuvent être utilisées pour contrôler des servomoteurs ou des capteurs, ou pour communiquer avec un module Wi-Fi afin de créer un dispositif IoT. (Source de l'image : SparkFun)

Le microcontrôleur intégré STM32F765VIT6 de STMicroelectronics inclut un processeur Arm Cortex-M7 dans un boîtier LQFP à 100 broches. Le processeur fonctionne à 216 mégahertz (MHz) et dispose de 2 méga-octets (Mo) de mémoire Flash et de 512 kilo-octets (Ko) de mémoire RAM. Le processeur est très performant et convient parfaitement aux applications de vision artificielle grâce à son unité en virgule flottante (FPU) à double précision et à ses instructions DSP complètes. Le microcontrôleur inclut également un codeur JPEG matériel qui peut accélérer les applications d'imagerie. Le schéma fonctionnel général du STM32F765VIT6 est illustré à la Figure 3.

Figure 3 : Le STM32F765VIT est une solution idéale pour les applications de vision artificielle, car il inclut 2 Mo de mémoire Flash, 512 Ko de RAM et des périphériques comme un codeur JPEG matériel et des instructions DSP. (Source de l'image : STMicroelectronics)

Le module de caméra OpenMV H7 est unique, car il prend en charge plusieurs modules de caméras différents. Par exemple, si un développeur ne souhaite pas utiliser la caméra intégrée à résolution de 640 x 480, il peut opter pour un module qui prend en charge le capteur d'images MT9V034 d'ON Semiconductor. Le MT9V034 est un capteur d'imagerie numérique à pixel actif CMOS au format VGA de 8,5 mm de large qui inclut un mode à grande gamme dynamique (HDR) et un obturateur global. Le capteur offre une résolution d'image de 752 x 480 et est conçu pour fonctionner sur une vaste plage de températures de -30°C à +70°C. ON Semiconductor propose une carte de développement pour ce capteur d'images, la carte MT9V034C12STCH-GEVB (Figure 4).

Figure 4 : La carte MT9V034C12STCH-GEVB est une carte de développement pour le capteur d'images MT9V034 qui inclut une lentille intégrée pour accélérer le développement et les tests. (Source de l'image : ON Semiconductor)

Développement d'une première application de détection d'objets

Le développement d'applications pour le module de caméra OpenMV H7 se fait entièrement grâce à l'IDE OpenMV, qui fournit une interface Python pour le développement d'applications (Figure 5). Avec Python, inutile de connaître un langage de programmation de bas niveau. En effet, non seulement le script est écrit dans le langage Python, mais le module de caméra OpenMV H7 exécute aussi MicroPython de manière native. Cela permet aux développeurs de se lancer très facilement dans l'écriture d'applications de vision artificielle et dans l'exécution d'inférences de ML en déployant très peu d'efforts.

Figure 5 : L'IDE OpenMV offre une interface basée sur Python pour développer du code d'application pour le module de caméra OpenMV H7. L'application est ensuite envoyée sous forme de script au module de caméra, qui exécute MicroPython. (Source de l'image : Beningo Embedded Group)

L'une des premières choses que fait un développeur une fois la configuration terminée consiste à exécuter le script hello_world.py de base, qui contient le code illustré dans la Liste 1. Le script Python indique au développeur comment activer la caméra OpenMV et réaliser des instantanés en continu. Cela permet au développeur d'obtenir une vidéo en direct et de mesurer la fréquence d'images. Avec une connexion à un PC, la fréquence d'images peut varier de 25 images par seconde (fps) à environ 60 fps. L'application s'exécute en connectant simplement la caméra OpenMV à l'IDE OpenMV grâce au bouton de connexion en bas à gauche de l'écran, puis en cliquant sur le bouton d'exécution vert.

Copier # Hello World Example # # Welcome to the OpenMV IDE! Click on the green run arrow button below to run the script!
import sensor, image, time   sensor.reset()                      # Reset and initialize the sensor.
sensor.set_pixformat(sensor.RGB565) # Set pixel format to RGB565 (or GRAYSCALE) sensor.set_framesize(sensor.QVGA)   # Set frame size to QVGA (320x240) sensor.skip_frames(time = 2000)     # Wait for settings take effect.
clock = time.clock()                # Create a clock object to track the FPS.
while(True):     clock.tick()                    # Update the FPS clock.
img = sensor.snapshot()         # Take a picture and return the image.
print(clock.fps())              # Note: OpenMV Cam runs about half as fast when connected                                                                         # to the IDE. The FPS should increase once disconnected. 

Liste 1 : L'application de hello_world.py dans l'IDE OpenMV permet au module de caméra OpenMV de fournir une vidéo en direct. (Source du code : OpenMV)

Afin d'effectuer un premier test de détection et de classification d'objets, il faut former un réseau ML avec les catégories de reconnaissance d'objets souhaitées. Le CIFAR-10 est un jeu de données d'image couramment utilisé pour former les modèles de détection d'objets et tester leur fonctionnement. Le jeu de données CIFAR-10 est constitué de 60 000 images, notamment des images en couleur 32 x 32 pour les 10 catégories d'images différentes suivantes :

• Avion
• Automobile
• Oiseau
• Chat
• Cerf
• Chien
• Grenouille
• Cheval
• Bateau
• Camion

La description du processus utilisé pour former le modèle et le convertir en inférence à exécuter sur la caméra OpenMV dépasse le cadre de cet article. Mais il est possible d'exécuter le réseau formé CIFAR-10 sans passer par le développement de modèle : l'IDE OpenMV inclut déjà un modèle formé pour CIFAR-10 qu'il suffit de charger sur la caméra.

Pour utiliser ce modèle, connectez la caméra OpenMV au PC et à l'IDE OpenMV. Depuis l'IDE OpenMV, cliquez sur tools (outils) -> machine learning (apprentissage automatique) -> CNN Network Library (bibliothèque de réseaux CNN). Une fenêtre apparaît avec le dossier des modèles qtcreator d'OpenMV. Il existe deux options :

• cmsisnn
• tensorflow

Sous cmsisnn, accédez au dossier cifar10, puis cliquez sur cifar10.network pour l'ouvrir. Une autre fenêtre s'ouvre. Cette fenêtre permet d'enregistrer le fichier de réseau formé sur la caméra OpenMV. Vous pouvez alors sélectionner le disque de stockage de masse qui apparaît avec la caméra pour enregistrer le réseau.

Une fois le réseau enregistré, chargez l'exemple d'apprentissage automatique CIFAR-10 en accédant à File (Fichier) -> Examples (Exemples) -> 25-Machine-Learning -> nn_cifar10_search_whole_window.py. Cela charge le script d'exemple illustré ci-dessous (Liste 2).

Copier # CIFAR-10 Search Whole Window Example # # CIFAR is a convolutional neural network designed to classify its field of view into several # different object types and works on RGB video data.
# # In this example we slide the LeNet detector window over the image and get a list of activations # where there might be an object. Note that use a CNN with a sliding window is extremely compute # expensive so for an exhaustive search do not expect the CNN to be real-time.
import sensor, image, time, os, nn   sensor.reset()                         # Reset and initialize the sensor.
sensor.set_pixformat(sensor.RGB565)    # Set pixel format to RGB565 (or GRAYSCALE) sensor.set_framesize(sensor.QVGA)      # Set frame size to QVGA (320x240) sensor.set_windowing((128, 128))       # Set 128x128 window.
sensor.skip_frames(time=750)           # Don't let autogain run very long.
sensor.set_auto_gain(False)            # Turn off autogain.
sensor.set_auto_exposure(False)        # Turn off whitebalance.
# Load cifar10 network (You can get the network from OpenMV IDE).
net = nn.load('/cifar10.network') # Faster, smaller and less accurate.
# net = nn.load('/cifar10_fast.network') labels = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']   clock = time.clock() while(True):     clock.tick()       img = sensor.snapshot()       # net.search() will search an roi in the image for the network (or the whole image if the roi is not     # specified). At each location to look in the image if one of the classifier outputs is larger than     # threshold the location and label will be stored in an object list and returned. At each scale the     # detection window is moved around in the ROI using x_overlap (0-1) and y_overlap (0-1) as a guide.
# If you set the overlap to 0.5 then each detection window will overlap the previous one by 50%. Note     # the computational work load goes WAY up the more overlap. Finally, for mult-scale matching after     # sliding the network around in the x/y dimensions the detection window will shrink by scale_mul (0-1)     # down to min_scale (0-1). For example, if scale_mul is 0.5 the detection window will shrink by 50%.
# Note that at a lower scale there's even more area to search if x_overlap and y_overlap are small...
# contrast_threshold skips running the CNN in areas that are flat.
for obj in net.search(img, threshold=0.6, min_scale=0.5, scale_mul=0.5, \             x_overlap=0.5, y_overlap=0.5, contrast_threshold=0.5):         print("Detected %s - Confidence %f%%" % (labels[obj.index()], obj.value()))         img.draw_rectangle(obj.rect(), color=(255, 0, 0))     print(clock.fps()) 

Liste 2 : L'application d'exemple nn_cifar10_search_whole_window.py de l'IDE OpenMV est utilisée pour classifier les images et mesurer le niveau de confiance de la classification. (Source du code : OpenMV)

L'application de test peut être exécutée avec le script hello_world.py : connectez l'IDE OpenMV au module en cliquant sur Connect (Connecter) en bas à gauche, puis sur Run (Exécuter). À ce stade, la caméra exécute le script et essaie de classifier les images qu'elle voit. La fenêtre du terminal indique si une image est classifiée ou non et précise le niveau de confiance.

À ce stade, un développeur doit simplement présenter différents objets qui se trouvent dans le jeu de données CIFAR-10 et laisser la caméra les classifier. Pour les besoins de cet article, nous avons présenté à la caméra une image de chat (Figure 6) et une image d'avion (Figure 7). Il est difficile de le voir sur l'image, mais le niveau de confiance était d'environ 70 %. Le niveau de confiance peut être faible en raison des différences entre les images formées et les images de test, des conditions d'éclairage et d'autres facteurs. Il est certainement possible d'atteindre des niveaux plus élevés avec une formation supplémentaire et un contrôle plus strict de l'environnement de la caméra.

Figure 6 : La caméra dans l'IDE OpenMV exécute un réseau CNN pour le jeu de données CIFAR-10 et doit reconnaître un chat. (Source de l'image : Beningo Embedded Group)

Figure 7 : La caméra dans l'IDE OpenMV exécute un réseau CNN pour le jeu de données CIFAR-10 et doit reconnaître un avion. (Source de l'image : Beningo Embedded Group)

Extension des capacités de l'OpenMV H7

Il existe de nombreuses possibilités d'étendre le module OpenMV afin de l'utiliser avec différents modules de caméra et un nombre pratiquement illimité de capteurs externes.

Même si le module OpenMV dispose d'une capacité d'extension E/S, il peut être intéressant d'utiliser une carte d'extension externe pour fournir un accès supplémentaire à l'alimentation, à la terre et aux signaux de communication. Le shield d'extension Gravity DFR0578 de DFRobot pour le module OpenMV M7 constitue une carte d'extension utile (Figure 8). Sur la Figure, on peut voir que le module Gravity donne accès à de nombreuses broches d'alimentation et de mise à la terre supplémentaires. Il offre même des lignes I²C supplémentaires et fournit des options complémentaires pour alimenter le module. Cela facilite grandement la communication avec des capteurs et des modules externes sans avoir à utiliser un montage d'essai ou à raccorder des fils.

Figure 8 : La carte d'extension Gravity de DFRobot pour la caméra OpenMV M7 offre plusieurs embases supplémentaires faciles d'accès pour simplifier le prototypage rapide. (Source de l'image : DFRobot)

En plus de la carte Gravity, le système DFR0498 FireBeetle (carte multimédia audio et caméra) de DFRobot constitue une autre carte d'extension qui peut intéresser les développeurs (Figure 9). Le module de développement FireBeetle inclut :

• Une interface pour connecter des codecs IIS
• Un module de caméra
• Des écouteurs
• Un microphone

Il existe de nombreuses autres cartes d'extension qui peuvent être connectées au module de caméra OpenMV H7 en fonction de l'application finale.

Figure 9 : Le système DFR0498 FireBeetle de DFRobot inclut une extension pour des dispositifs multimédias tels qu'un microphone. (Source de l'image : DFRobot)

Conseils et astuces pour travailler avec OpenMV

Les premiers pas avec le module de caméra OpenMV H7 sont simples, mais les développeurs qui travaillent avec ce module pour la première fois doivent être conscients des nombreuses nuances et décisions que cela implique. Voici quelques « conseils et astuces » pour commencer avec le module :

• Lors de la première utilisation du module, assurez-vous de régler la mise au point du module à l'aide de la procédure décrite dans la documentation OpenMV.
• À partir du menu Files (Fichier) -> Examples (Exemples), accédez à des dizaines d'exemples s'étendant de la détection d'une couleur à la reconnaissance faciale.
• Pour ajouter une connectivité Internet, vous pouvez utiliser un shield Wi-Fi. Un shield Wi-Fi peut être automatiquement activé lors du démarrage dans l'IDE OpenMV depuis l'option Tools (Outils) -> OpenMV Cam Settings (Paramètres de la caméra OpenMV).
• Envisagez d'utiliser TensorFlow Lite pour former un modèle ML aux objets qui vous intéressent.

Les développeurs qui suivent ces « conseils et astuces » constateront qu'ils peuvent économiser pas mal de temps et d'efforts lorsqu'ils utilisent le module de caméra OpenMV H7 pour la première fois.

Conclusion

Comme indiqué ici, le module de caméra OpenMV H7 est particulièrement approprié pour aider les développeurs à appliquer rapidement les principes de l'apprentissage automatique à la détection d'objets et aux applications associées. Non seulement il existe des applications d'exemple que les développeurs peuvent exploiter pour accélérer leur conception, mais de nombreuses options d'extension pour les caméras et les capteurs sont également disponibles. Pour pouvoir se lancer, il suffit aux développeurs de savoir rédiger quelques lignes de code Python. Ils pourront ainsi créer une application fonctionnelle en quelques heures, en fonction de la complexité.