Détection d'objets avec les cartes Sipeed MaiX (Kendryte K210): 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Dans la continuité de mon précédent article sur la reconnaissance d'images avec les cartes Sipeed MaiX, j'ai décidé d'écrire un autre tutoriel, axé sur la détection d'objets. Du matériel intéressant est apparu récemment avec la puce Kendryte K210, notamment Seeed AI Hat pour Edge Computing, le M5StickV de la pile M5 et le HuskyLens de DFRobot (bien que celui-ci ait un micrologiciel propriétaire et plus destiné aux débutants complets). En raison de son prix bon marché, Kendryte K210 a séduit les personnes souhaitant ajouter la vision par ordinateur à leurs projets. Mais comme d'habitude avec les produits matériels chinois, le support technique fait défaut et c'est quelque chose que j'essaie d'améliorer avec mes articles et vidéos. Mais gardez à l'esprit que je ne fais pas partie de l'équipe de développeurs Kendryte ou Sipeed et que je ne peux pas répondre à toutes les questions liées à leur produit.

Dans cet esprit, commençons ! Nous commencerons par un bref (et simplifié) aperçu du fonctionnement des modèles CNN de reconnaissance d'objets.

MISE À JOUR MAI 2020: Voyant comment mon article et ma vidéo sur la détection d'objets avec les cartes K210 sont toujours très populaires et parmi les meilleurs résultats sur YouTube et Google, j'ai décidé de mettre à jour l'article pour inclure les informations sur aXeleRate, framework basé sur Keras pour l'IA sur le Bord je développe. aXeleRate, essentiellement, est basé sur la collection de scripts que j'ai utilisés pour former des modèles de reconnaissance d'images/détection d'objets - combinés dans un cadre unique et optimisés pour le flux de travail sur Google Colab. Il est plus pratique à utiliser et plus à jour.

Pour l'ancienne version de l'article, vous pouvez toujours la voir sur steemit.com.

Étape 1: Explication de l'architecture du modèle de détection d'objets

Les modèles de reconnaissance d'images (ou de classification d'images) prennent l'image entière en entrée et produisent une liste de probabilités pour chaque classe que nous essayons de reconnaître. C'est très utile si l'objet qui nous intéresse occupe une grande partie de l'image et que nous ne nous soucions pas beaucoup de son emplacement. Mais que se passe-t-il si notre projet (par exemple, une caméra de suivi du visage) nous oblige non seulement à avoir une connaissance du type d'objet dans l'image, mais aussi de ses coordonnées. Et qu'en est-il des projets nécessitant la détection de plusieurs objets (par exemple pour le comptage) ?

C'est ici que les modèles de détection d'objets sont utiles. Dans cet article, nous utiliserons l'architecture YOLO (vous ne regardez qu'une seule fois) et concentrerons l'explication sur les mécanismes internes de cette architecture particulière.

Nous essayons de déterminer quels objets sont présents dans l'image et quelles sont leurs coordonnées. Puisque l'apprentissage automatique n'est pas de la magie et n'est pas "une machine à penser", mais juste un algorithme qui utilise des statistiques pour optimiser la fonction (réseau de neurones) afin de mieux résoudre un problème particulier. Nous devons paraphraser ce problème pour le rendre plus "optimisable". Une approche naïve ici serait d'avoir l'algorithme minimisant la perte (différence) entre sa prédiction et les coordonnées correctes de l'objet. Cela fonctionnerait plutôt bien, tant que nous n'avons qu'un seul objet dans l'image. Pour plusieurs objets, nous adoptons une approche différente: nous ajoutons la grille et faisons prédire à notre réseau la présence (ou l'absence) du ou des objets dans chaque grille. Cela semble bien, mais laisse encore trop d'incertitude pour le réseau - comment générer la prédiction et que faire lorsqu'il y a plusieurs objets avec un centre à l'intérieur d'une cellule de grille ? Nous devons ajouter une contrainte supplémentaire - ce qu'on appelle des ancres. Les ancres sont des tailles initiales (largeur, hauteur) dont certaines (les plus proches de la taille de l'objet) seront redimensionnées à la taille de l'objet - en utilisant certaines sorties du réseau de neurones (carte de caractéristiques finale).

Voici donc une vue de haut niveau de ce qui se passe lorsque le réseau de neurones de l'architecture YOLO effectue une détection d'objet sur l'image. Selon les caractéristiques détectées par le réseau d'extraction de caractéristiques, pour chaque cellule de la grille, un ensemble de prédictions est effectué, qui comprend le décalage des ancres, la probabilité d'ancre et la classe d'ancre. Ensuite, nous écartons les prédictions avec une faible probabilité et le tour est joué !

Étape 2: préparer l'environnement

aXeleRate est basé sur le merveilleux projet de penny4860, le détecteur de chiffres SVHN yolo-v2. aXeleRate fait passer cette implémentation du détecteur YOLO à Keras à un niveau supérieur et utilise son système de configuration pratique pour effectuer la formation et la conversion des réseaux de reconnaissance d'images/détection d'objets et de segmentation d'images avec divers backends.

Il existe deux manières d'utiliser aXeleRate: en s'exécutant localement sur une machine Ubuntu ou dans Google Colab. Pour exécuter dans Google Colab, jetez un œil à cet exemple:

Bloc-notes Colab de détection d'objets PASCAL-VOC

Former votre modèle localement et l'exporter pour qu'il soit utilisé avec l'accélération matérielle est également beaucoup plus facile maintenant. Je vous recommande fortement d'installer toutes les dépendances nécessaires dans l'environnement Anaconda pour garder votre projet séparé des autres et éviter les conflits.

Téléchargez le programme d'installation ici.

Une fois l'installation terminée, créez un nouvel environnement:

conda créer -n yolo python=3.7

Activons le nouvel environnement

conda activer yolo

Un préfixe avant votre shell bash apparaîtra avec le nom de l'environnement, indiquant que vous travaillez maintenant dans cet environnement.

Installez aXeleRate sur votre machine locale avec

pip installer git+https://github.com/AIWintermuteAI/aXeleRate

Et puis exécutez ceci pour télécharger les scripts dont vous aurez besoin pour la formation et l'inférence:

git clone

Vous pouvez exécuter des tests rapides avec tests_training.py dans le dossier aXeleRate. Il exécutera la formation et l'inférence pour chaque type de modèle, enregistrera et convertira les modèles formés. Comme il ne s'agit que d'un entraînement pour 5 époques et que l'ensemble de données est très petit, vous ne pourrez pas obtenir de modèles utiles, mais ce script est uniquement destiné à vérifier l'absence d'erreurs.

Étape 3: Former un modèle de détection d'objets avec Keras

Nous pouvons maintenant exécuter un script d'entraînement avec le fichier de configuration. Étant donné que l'implémentation Keras du détecteur d'objets YOLO est assez compliquée, au lieu d'expliquer chaque morceau de code pertinent, j'expliquerai comment configurer la formation et décrirai également les modules pertinents, au cas où vous souhaiteriez y apporter vous-même des modifications.

Commençons par un exemple de jouet et formons un détecteur de raton laveur. Il existe un fichier de configuration dans le dossier /config, raccoon_detector.json. Nous choisissons MobileNet7_5 comme architecture (où 7_5 est le paramètre alpha de l'implémentation originale de Mobilenet, contrôle la largeur du réseau) et 224x224 comme taille d'entrée. Jetons un coup d'œil aux paramètres les plus importants de la configuration:

Le type est le frontend du modèle - Classifier, Detector ou SegnetArchitecture est le backend du modèle (extracteur de caractéristiques)

- Yolo complet - Yolo minuscule - MobileNet1_0 - MobileNet7_5 - MobileNet5_0 - MobileNet2_5 - SqueezeNet - VGG16 - ResNet50

Pour plus d'informations sur les ancres, veuillez lire ici

Les étiquettes sont des étiquettes présentes dans votre ensemble de données. IMPORTANT: Veuillez énumérer toutes les étiquettes présentes dans l'ensemble de données.

object_scale détermine de combien pénaliser une mauvaise prédiction de confiance des prédicteurs d'objet

no_object_scale détermine de combien pénaliser une mauvaise prédiction de confiance des prédicteurs non-objet

coord_scale détermine de combien pénaliser les mauvaises prédictions de position et de taille (x, y, w, h)

class_scale détermine de combien pénaliser une mauvaise prédiction de classe

augmentation - augmentation de l'image, redimensionnement, décalage et flou de l'image afin d'éviter le surajustement et d'avoir une plus grande variété dans l'ensemble de données.

train_times, validation_times - combien de fois répéter l'ensemble de données. Utile si vous avez une augmentation

activée

first_trainable_layer - vous permet de geler certaines couches si vous utilisez un réseau d'entités pré-entraîné

Nous devons maintenant télécharger l'ensemble de données, que j'ai partagé sur mon Google Drive (ensemble de données d'origine), qui est un ensemble de données de détection de raton laveur, contenant 150 images annotées.

Assurez-vous de modifier les lignes du fichier de configuration (train_image_folder, train_annot_folder) en conséquence, puis démarrez la formation avec la commande suivante:

python axelerate/train.py -c configs/raccoon_detector.json

train.py lit la configuration à partir du fichier.json et entraîne le modèle avec le script axelerate/networks/yolo/yolo_frontend.py. yolo/backend/loss.py est l'endroit où la fonction de perte personnalisée est implémentée et yolo/backend/network.py est l'endroit où le modèle est créé (entrée, extracteur de caractéristiques et couches de détection réunies). axelerate/networks/common_utils/fit.py est un script qui implémente le processus de formation et axelerate/networks/common_utils/feature.py contient des extracteurs de caractéristiques. Si vous avez l'intention d'utiliser un modèle entraîné avec la puce K210 et le micrologiciel Micropython, en raison des limitations de mémoire, vous pouvez choisir entre MobileNet (2_5, 5_0 et 7_5) et TinyYolo, mais j'ai trouvé que MobileNet donne une meilleure précision de détection.

Puisqu'il s'agit d'un exemple de jouet et qu'il ne contient que 150 images de ratons laveurs, le processus d'entraînement devrait être assez rapide, même sans GPU, bien que la précision soit loin d'être stellaire. Pour un projet lié au travail, j'ai formé un détecteur de panneaux de signalisation et un détecteur de numéros, les deux ensembles de données comprenaient plus de quelques milliers d'exemples de formation.

Étape 4: Convertissez-le au format.kmodel

Avec aXeleRate, la conversion du modèle est effectuée automatiquement - c'est probablement la plus grande différence par rapport à l'ancienne version des scripts d'entraînement ! De plus, vous obtenez les fichiers de modèle et le graphique d'entraînement enregistrés soigneusement dans le dossier du projet. J'ai également constaté que la précision de la validation ne permet parfois pas d'estimer les performances réelles du modèle pour la détection d'objets et c'est pourquoi j'ai ajouté mAP comme métrique de validation pour les modèles de détection d'objets. Vous pouvez en savoir plus sur mAP ici.

Si le mAP, la précision moyenne moyenne (notre métrique de validation) ne s'améliore pas pendant 20 époques, l'entraînement s'arrêtera prématurément. Chaque fois que mAP s'améliore, le modèle est enregistré dans le dossier du projet. Une fois la formation terminée, aXeleRate convertit automatiquement le meilleur modèle dans les formats spécifiés - vous pouvez désormais choisir "tflite", "k210" ou "edgepu".

Passons maintenant à la dernière étape, l'exécution de notre modèle sur du matériel Sipeed !

Étape 5: Exécuter sur le micrologiciel Micropython

Il est possible d'exécuter l'inférence avec notre modèle de détection d'objets avec du code C, mais pour des raisons de commodité, nous utiliserons plutôt le micrologiciel Micropython et l'IDE MaixPy.

Téléchargez MaixPy IDE à partir d'ici et le firmware micropython à partir d'ici. Vous pouvez utiliser le script python kflash.py pour graver le firmware ou télécharger un outil flash GUI séparé ici.

Copiez model.kmodel à la racine d'une carte SD et insérez la carte SD dans Sipeed Maix Bit (ou autre appareil K210). Alternativement, vous pouvez graver.kmodel dans la mémoire flash de l'appareil. Mon exemple de script lit.kmodel à partir de la mémoire flash. Si vous utilisez une carte SD, veuillez modifier cette ligne

tâche = kpu.load (0x20000)

à

tâche = kpu.load("/sd/model.kmodel")

Ouvrez MaixPy IDE et appuyez sur le bouton de connexion. Ouvrez le script raccoon_detector.py à partir du dossier example_scripts/k210/detector et appuyez sur le bouton Démarrer. Vous devriez voir un flux en direct de la caméra avec des cadres de délimitation autour… eh bien, des ratons laveurs. Vous pouvez augmenter la précision du modèle en fournissant plus d'exemples de formation, mais gardez à l'esprit qu'il s'agit d'un petit modèle féerique (1,9 M) et qu'il aura du mal à détecter les petits objets (en raison de la faible résolution).

L'une des questions que j'ai reçues dans les commentaires de mon article précédent sur la reconnaissance d'images est de savoir comment envoyer les résultats de la détection via UART/I2C à d'autres appareils connectés aux cartes de développement Sipeed. Dans mon référentiel github, vous pourrez trouver un autre exemple de script, raccoon_detector_uart.py, qui (vous l'aurez deviné) détecte les ratons laveurs et envoie les coordonnées des cadres de délimitation sur UART. Gardez à l'esprit que les broches utilisées pour la communication UART sont différentes des différentes cartes, c'est quelque chose que vous devez vérifier vous-même dans la documentation.

Étape 6: Résumé

Kendryte K210 est une puce solide pour la vision par ordinateur, flexible, mais avec une mémoire disponible limitée. Jusqu'à présent, dans mes didacticiels, nous l'avons utilisé pour reconnaître des objets personnalisés, détecter des objets personnalisés et exécuter certaines tâches de vision par ordinateur basées sur OpenMV. Je sais pertinemment qu'il convient également à la reconnaissance faciale et avec un peu de bricolage, il devrait être possible de faire la détection de pose et la segmentation d'image (vous pouvez utiliser aXeleRate pour former le modèle de segmentation sémantique, mais je n'ai pas encore implémenté l'inférence avec K210). N'hésitez pas à jeter un œil aux problèmes du référentiel aXeleRate et à faire un PR si vous pensez qu'il y a des améliorations que vous pouvez apporter !

Voici quelques articles que j'ai utilisés pour écrire ce tutoriel, jetez un œil si vous voulez en savoir plus sur la détection d'objets avec les réseaux de neurones:

Détecteurs d'objets en forme de boîte englobante: comprendre YOLO, vous ne regardez qu'une seule fois

Comprendre YOLO (plus de maths)

Guide en douceur sur le fonctionnement de la localisation d'objets YOLO avec Keras (partie 2)

Détection d'objets en temps réel avec YOLO, YOLOv2 et maintenant YOLOv3

J'espère que vous pourrez utiliser les connaissances que vous avez maintenant pour créer des projets impressionnants avec la vision industrielle ! Vous pouvez acheter des cartes Sipeed ici, elles font partie des options les moins chères disponibles pour le ML sur les systèmes embarqués.

Ajoutez-moi sur LinkedIn si vous avez des questions et abonnez-vous à ma chaîne YouTube pour être informé des projets les plus intéressants impliquant l'apprentissage automatique et la robotique.