Les microcontrôleurs disposent d'une RAM et d'un espace de stockage limités, ce qui impose des contraintes sur la taille des modèles de machine learning. De plus, LiteRT pour microcontrôleurs n'est actuellement compatible qu'avec un sous-ensemble limité d'opérations. Par conséquent, toutes les architectures de modèles ne sont pas possibles.
Ce document explique comment convertir un modèle TensorFlow pour l'exécuter sur des microcontrôleurs. Il décrit également les opérations compatibles et fournit des conseils sur la conception et l'entraînement d'un modèle pour qu'il tienne dans une mémoire limitée.
Pour obtenir un exemple exécutable de bout en bout de création et de conversion d'un modèle, consultez l'exemple Hello World.
Conversion de modèles
Pour convertir un modèle TensorFlow entraîné afin qu'il s'exécute sur des microcontrôleurs, vous devez utiliser l'API Python du convertisseur LiteRT. Cela convertira le modèle en FlatBuffer, réduisant ainsi sa taille, et le modifiera pour qu'il utilise les opérations LiteRT.
Pour obtenir la taille de modèle la plus petite possible, vous devez envisager d'utiliser la quantification post-entraînement.
Convertir en tableau C
De nombreuses plates-formes de microcontrôleurs ne sont pas compatibles avec les systèmes de fichiers natifs. Le moyen le plus simple d'utiliser un modèle à partir de votre programme consiste à l'inclure en tant que tableau C et à le compiler dans votre programme.
La commande Unix suivante génère un fichier source C contenant le modèle LiteRT sous forme de tableau char :
xxd -i converted_model.tflite > model_data.cc
Le résultat ressemblera à ce qui suit :
unsigned char converted_model_tflite[] = {
0x18, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c, 0x33, 0x00, 0x00, 0x0e, 0x00,
// <Lines omitted>
};
unsigned int converted_model_tflite_len = 18200;
Une fois le fichier généré, vous pouvez l'inclure dans votre programme. Il est important de remplacer la déclaration de tableau par const pour une meilleure efficacité de la mémoire sur les plates-formes intégrées.
Pour obtenir un exemple d'inclusion et d'utilisation d'un modèle dans votre programme, consultez hello_world_test.cc dans l'exemple Hello World.
Architecture et entraînement du modèle
Lorsque vous concevez un modèle à utiliser sur des microcontrôleurs, il est important de tenir compte de la taille du modèle, de la charge de travail et des opérations utilisées.
Taille du modèle
Un modèle doit être suffisamment petit pour tenir dans la mémoire de votre appareil cible, en plus du reste de votre programme, à la fois en tant que binaire et au moment de l'exécution.
Pour créer un modèle plus petit, vous pouvez utiliser des couches moins nombreuses et plus petites dans votre architecture. Toutefois, les petits modèles sont plus susceptibles de souffrir de sous-apprentissage. Cela signifie que, pour de nombreux problèmes, il est judicieux d'essayer d'utiliser le plus grand modèle qui tiendra en mémoire. Toutefois, l'utilisation de modèles plus volumineux entraînera également une charge de travail accrue du processeur.
Charge de travail
La taille et la complexité du modèle ont un impact sur la charge de travail. Les modèles volumineux et complexes peuvent entraîner un cycle d'utilisation plus élevé, ce qui signifie que le processeur de votre appareil passe plus de temps à travailler et moins de temps au repos. Cela augmentera la consommation d'énergie et la production de chaleur, ce qui peut poser problème selon votre application.
Assistance opérationnelle
LiteRT pour microcontrôleurs est actuellement compatible avec un sous-ensemble limité d'opérations TensorFlow, ce qui a un impact sur les architectures de modèles qu'il est possible d'exécuter. Nous nous efforçons d'étendre la compatibilité des opérations, à la fois en termes d'implémentations de référence et d'optimisations pour des architectures spécifiques.
Les opérations compatibles sont disponibles dans le fichier micro_mutable_ops_resolver.h.