Dans ce troisième et dernier volet, nous vous partageons les résultats et enseignements tirés, suite à la création du « Calendrier de l’I.A.vent » évoqué dans le volet 2 et « Happy Face » dans le volet 1.

L’intelligence artificielle déployée à la périphérie du cloud permet de répondre aux nouveaux défis technologiques que doivent aujourd’hui relever la plupart des entreprises. Il est cependant crucial que les algorithmes de Machine Learning soient optimisés pour répondre aux contraintes de temps réel de la majorité des cas d’usages. Nous avons développé une méthodologie pour déterminer quelles sont les configurations logicielles et matérielles capables de reproduire de telles performances sur des objets connectés. En décembre 2020 , nous avons publié les résultats de nos premières expérimentations sur quelques configurations de notre banc d’essai. Nous présentons dans cette série d’articles les enseignements de ce benchmark qui confirment l'importance et la technicité de la miniaturisation des algorithmes d'IA pour le Edge Computing (dont l'IoT). Nous proposons à ce titre un ensemble de méthodes et de techniques permettant d’adapter l’IA pour le Edge Computing.

Le Calendrier de l’I.A.vent en chiffres

Notre objectif est d’évaluer les performances de notre modèle « Masky » sur plusieurs configurations différentes. Nous avons choisi de tester :
- 9 devices :
o Raspberry Pi 4B,
o Qualcomm Vision AI DevKit,
o Macbook Pro 13 2019,
o Surface Pro 7 Core i7,
o Jetson Nano 2Gb,
o Coral USB Accelerator,
o VM Azure Nvidia Tesla P100,
o PC Dell Inspiron 15 7000 GPU Nvidia Geforce GTX 1050,
o PC Asus Vivobook Core i7 GPU Nvidia Geforce GTX 1050

- 5 frameworks :
o Keras,
o ONNX,
o TensorRT,
o Tensorflow Lite (Edge TPU),
o Darknet

- 1 modèle (« Masky ») : il s’agit d’un modèle custom YOLOv3 dans sa version allégée dite « Tiny », entraîné avec Keras. Lors du training, nous avons effectué un transfert d’apprentissage à partir des poids synaptiques de YOLOv3, pré-entraînés sur le dataset de référence Microsoft COCO [1]. Nous avons converti ces poids à partir de leur format initial Darknet [2] vers un format compatible avec notre processus d’entraînement sur Keras.

Figure 6 : Processus de conversion des poids de YOLO et d’entraînement du modèle Masky

Les résultats en chiffres

- Les métriques qui sont analysées par le benchmark sont :
- # de tests
- Min / max
- Inférence médiane et moyenne
- IPS / Cost

Le choix du framework

Pour élaborer notre banc d’essai, nous avons choisi les frameworks les plus couramment utilisés par la communauté. Tout d’abord Keras, avec lequel nous avons effectué notre entraînement. Ensuite ONNX, dont nous utilisons le runtime pour exécuter le modèle Masky « on-device ».
ONNX Runtime est un optimiseur, il permet d’accélérer les inférences de machine learning sur toutes les cibles de déploiement à l’aide d’un seul ensemble d’API. Son principe de fonctionnement est d’analyser automatiquement le modèle pour en identifier les opportunités d’optimisation et donner ainsi accès à la meilleure accélération matérielle possible.
Sur notre PC, nos tests montrent une différence de performance significative entre les vitesses d’inférence constatées sur Keras (9,5 IPS) et sur ONNX (26,8 IPS), en atteignant le cap du temps réel, supérieur à 25 IPS. Nous avons souhaité connaître les performances de l’implémentation originale de l’algorithme YOLOv3 initialement conçu pour le framework Darknet : le score IPS de 17,8 IPS démontre également une performance de près du double de Keras.

💡 Enseignement : ONNX est la solution la plus performante sur un PC Windows 10.

Figure 7 : Résultats sur notre PC de test

Nous avons effectué les mêmes tests sur un Raspberry Pi 4B tournant sur Raspberry Pi OS, une version de Debian modifiée et spécifiquement adaptée pour les systèmes sur puce du type ARM. Ce mini-ordinateur peu cher (environ 50$ pour notre modèle) est l’une des références majeures en IoT.
Sur l’appareil, la différence entre ONNX et Keras est également très marquée. En revanche, le score IPS d’ONNX s’avère cette fois-ci moins élevé qu’avec Darknet, le runtime ONNX étant sur cette configuration moins performant pour exploiter le simple CPU du Raspberry Pi.

💡 Enseignement : ONNX n’optimise pas suffisamment bien sur un CPU de type ARM

Figure 8 : Résultats sur notre Raspberry Pi de test

En convertissant le modèle de son format d’entraînement Keras vers le format Darknet, on gagne en performance passant de 1,5 IPS à 4,2 IPS. Néanmoins, nous sommes encore loin de notre objectif d’inférence en temps réel sur un appareil Edge.
💡 Enseignement : Keras simplifie le travail d’entraînement mais le résultat est moins performant à l’inférence que Darknet, le framework de base de l’algorithme YOLO.

L’électronique neuromorphique

Les CPU ne sont pas des processeurs adaptés pour exécuter des réseaux de neurones. Les chercheurs en machine learning ont rapidement découvert que les GPU, initialement destinés à la manipulation d’images (comme le jeu vidéo), produisaient de bien meilleures performances. A l’instar de la base mathématique des réseaux neuronaux, les GPU sont capables de traiter des tâches parallèles complexes impliquant des matrices. Ainsi, pour de l’inférence de modèles de Deep Learning, on a tout intérêt de se rapprocher de ce qu’est un réseau de neurones en électronique pour réduire la consommation électrique de l’IA.
C’est l’objectif de l’électronique neuromorphique dont l’objet est d’assembler des composants électroniques pour imiter des neurones et des synapses. Ce qui n’est pas le cas de nos ordinateurs classiques. Les algorithmes sont actuellement écrits sous forme de programmes qui sont ensuite compilés : on obtient des séries de 0 et de 1 qui sont envoyées dans les processeurs, CPU ou GPU.

De nombreux fondeurs commencent à produire depuis quelques années de premières puces neuromorphiques, notamment destinées à réduire la consommation de l’IA sur les smartphones.

Figure 9 : un exemple de processeur neuromorphique fabriqué par Intel, sur lequel on devine aisément la forme des neurones et des synapses électroniques.

Le Edge Computing profite également de ces avancées. Plusieurs fabriquant proposent des coprocesseurs neuromorphiques destinés aux appareils IoT. Aussi, nous avons associé à notre Raspberry Pi des puces neuronales (aussi appelées « TPU », pour Tensor Processor Unit), reproduisant les neurones et les synapses.

Le Neural Compute Stick 2 d’Intel et le Coral USB Accelerator (produit par Google) se branchent directement sur l’un des ports USB du Raspberry Pi. Leur puce ne prend en charge des poids synaptiques qu’uniquement codés en nombres entiers. Il convient donc d’effectuer préalablement une quantification du modèle (« quantization » en anglais). Cette opération consiste à diminuer la taille d’un modèle d’IA en réduisant l’ensemble des valeurs possibles de ses poids synaptiques : l’objectif est ainsi de réduire autant que possible l’occupation mémoire du modèle. Chaque paramètre d’un modèle est, de base, codé en float32. La quantification signifie tout simplement que ce float32 est converti en nombre entier : en Integer 16, voire en Integer 8 (si l’on ne réduit pas sa taille au-delà du int8 le modèle préserve en principe sa précision).

Figure 10: le Neural Compute Stick 2 d’Intel (à gauche) et le Google Coral Accelerator connecté à un Pi 4B (à droite)

En l’occurrence, la puce Coral nécessite d’avoir des poids uniquement codés en int8. Il convient également de convertir le modèle au format compatible avec le moteur d’inférence de l’appareil, une version dérivée de Tensorflow : Tensorflow Lite Edge TPU. Les tests d’inférence de notre modèle Masky sur cette configuration ont montré de très bons résultats (12,1 IPS). Avec TPU, la rapidité est près de trois fois plus importante que le meilleur score obtenu avec le CPU seul.

💡 Enseignement : l’ajout d’un coprocesseur TPU sur un Raspberry Pi accélère l’inférence x 3

Figure 11 : Score IPS sur notre Raspberry Pi de test avec le coprocesseur Coral USB Accelerator

Les moteurs d’inférence

Comme nous l’avons vu précédemment, pour faire fonctionner notre modèle sur la puce Coral, nous avons dû le convertir au format compatible. Dans ce cas, le software fonctionne de pair avec le hardware pour en exploiter tout le potentiel. Pour ce faire, les fabricants de matériel fournissent généralement leur SDK « maison » dédié. Ainsi Google utilise son framework Tensorflow (Lite) pour l’utilisation de sa gamme Coral. Intel utilise de son côté OpenVINO pour exploiter son processeur Movidius Myriad X.

Figure 12 : Les principaux constructeurs, leur matériel et leur moteur d’inférence respectifs

Nous avons testé un matériel tout-en-un, le Jetson Nano d’Nvidia, un nano-ordinateur composé d’un GPU mobile « Maxwell » intégré, permettant d’exécuter des modèles de deep learning. Pour pouvoir bénéficier de la puissance du GPU, le SDK TensorRT est mis à disposition des développeurs : il s’agit d’un optimiseur d’inférence calibré pour le hardware du constructeur : TensorRT est en effet construit sur CUDA, le modèle de programmation parallélisé d’Nvidia. Le SDK fournit notamment les outils d’optimisation nécessaires pour effectuer une quantification en int16 ou int8.
Nos résultats de tests sur Jetson Nano sont supérieurs à ceux opérés sur Raspberry Pi. Les performances de Keras et Darknet sont sensiblement similaires, avec respectivement 2,7 IPS et 2,9 IPS. De son côté, ONNX près de trois fois plus rapide, affiche un score de 7,7 IPS.

Figure 13 : Résultats sur notre Jetson Nano de test

Nous avons ensuite testé notre modèle avec TensorRT, avec une quantification des poids synaptiques en int16 : le gain de performance apporté par le GPU + le moteur d’inférence TensorRT s’avère très élevé, affichant un score IPS de 29,2. Ce dernier test confirme qu’il est possible d’atteindre le cap du temps réel sur un appareil Edge.

💡 Enseignement : l’utilisation du moteur d’inférence proposé par le constructeur du hardware permet de l’exploiter pleinement.

Figure 14 : Score IPS sur notre Jetson Nano de test avec le moteur d’inférence TensorRT

Les conclusions

Nous pouvons tirer plusieurs conclusions de notre banc d’essai. Tout d’abord, il convient de bien choisir le framework d’exécution de son modèle. Nous avons entraîné Masky avec Keras. Comme nous l’avons démontré, il eût été désavantageux de s’arrêter simplement sur son utilisation pour l’inférence. Le format Darknet a présenté de bien meilleurs résultats car il s’agit de l’implémentation initiale de l’algorithme YOLO. Il s’agit là néanmoins d’une spécificité, Keras pourra probablement montrer de meilleurs résultats avec d’autres algorithmes. En revanche, nous pouvons recommander aux développeurs d’opter pour optimiseur tel qu’ONNX Runtime. Par principe compatible avec de nombreux formats, il permettra d’obtenir des gains de performance dans la majorité des cas.

Le principal enjeu de notre benchmark est de déterminer quelles sont les solutions permettant de réduire le gap de puissance entre un PC et un device Edge. Nous avons pour cela démontré qu’un simple processeur n’est pas adapté pour exécuter des modèles de deep learning. L’algorithme que nous utilisons pour notre modèle Masky, un Tiny-YOLOv3, est parmi les plus légers et rapides. Pourtant, sur l’une des plus grosses configurations de Raspberry Pi, il est difficile de dépasser les 4 IPS.

Si l’on a de véritables exigences en termes de vitesse d’inférence pour des applications critiques, par exemple sur des cas d’usage industriels, il est plus que recommandé d’associer son appareil à un TPU ou à un GPU mobile. Pour exploiter pleinement le potentiel de ces processeurs, il faut obligatoirement passer par le moteur d’inférence proposé par le constructeur et convertir son modèle au format compatible. L’acquisition d’un tel matériel ne représente pas forcément de coût très élevé si l’on opte pour une solution « all-in-one » telle que le Jetson Nano d’Nvidia (moins de 100 euros). Il s’agit de la meilleure configuration Edge que nous ayons pu tester, dépassant aisément le cap « real time » des 25 IPS.

Les coprocesseurs neuronaux sont quant à eux recommandés si l’on dispose déjà d’un Raspberry Pi ou d’un appareil équivalent (environ 60$ à l’import). A l’instar du Coral USB, ils permettent une vitesse triplée de l’inférence. Les principes de l’électronique neuromorphique dessinent les contours du futur du Edge AI. Les chercheurs tentent notamment d’optimiser la consommation d’énergie en distribuant la mémoire au niveau des synapses, comme le fait le cerveau humain. La prochaine génération de processeurs est à surveiller de près.

Références :
[1] Microsoft COCO Dataset [1405.0312] Microsoft COCO: Common Objects in Context (arxiv.org)
[2 ] YOLO Real Time Object Detection YOLO: Real-Time Object Detection (pjreddie.com)
Note : Cet article a été rédigé fin 2020 et reflète l’état de l’art des compétences Avanade à cette date. L’exploration des technologies IA et Edge Computing continue à ce jour au Technology Office, le département Innovation d’Avanade France, tenant compte des évolutions des technologies et de matériels. Nos connaissances, notre expertise, notre méthodologie et nos outils ont fortement progressé depuis la rédaction de cet article.

Résultats complets du banc d’essai

L’équipe

Chef de projet : Jean-Pierre RIEHL , Technology Innovation Lead
IA/Data Science : Jonathan PACIFICO, Alexis DUBOS, Jason ENGUEHARD
IoT/Edge Computing : Othmane ALAOUI M’DAGHRI, Paul PASCAL, Maxime EHANNO
Data Engineering : Benjamin BENITO, Thibaut MARTINOT