IA embarquée

Benchmark TinyML : float vs int8

Un banc reproductible qui compare float32, int8 PTQ et int8 QAT sur la taille, la latence, la RAM et la précision.

TinyMLTensorFlow LiteESP32QuantificationPython
View on GitHub
Problème

La plupart des portfolios d'IA embarquée annoncent une précision sans taille de modèle, sans latence, sans RAM et sans méthode. Le compromis est donc invérifiable et impossible à reproduire.

Approche

Entraîner un autoencodeur sur des caractéristiques de vibration, l'exporter de trois façons (float32, quantification int8 post-entraînement et quantification int8 consciente), puis mesurer chaque modèle sur l'hôte et sur un harnais ESP32. Un fichier de résultats JSON alimente un tableau README généré : chaque chiffre vient d'une commande ré-exécutable.

Architecture
Vibration synthétique→
FFT -> 64 caractéristiques→
Autoencodeur 64-32-16-8-16-32-64→
float32 / int8 PTQ / int8 QAT→
Banc hôte + ESP32→
results.json→
Rapport généré

Tech Stack

EntraînementPython + TensorFlow + tfmotAutoencodeur et quantification consciente
ConversionTFLiteConverterModèles float32, int8 PTQ et int8 QAT
Banc hôteInterpréteur TF LiteLatence p50 / p95 et erreur de reconstruction
Banc carteESP32 + TFLite MicroLatence esp_timer et RAM de l'arène
RapportPython stdlibresults.json -> tableau README

Décisions clés

  • →Le jeu de données est synthétique et annoncé comme tel : le banc démontre la méthode, pas un détecteur de défaut validé sur le terrain.
  • →Les résultats vivent en JSON et le tableau est généré : aucun chiffre n'est saisi à la main.
  • →Les tests hôte n'utilisent que la stdlib, ce qui permet à la CI de tourner sans TensorFlow.
  • →La QAT utilise tfmot avec l'API Keras historique, isolée derrière les dépendances d'entraînement optionnelles.
Deep Dive

PTQ vs QAT

La quantification post-entraînement calibre un modèle float déjà entraîné avec un jeu représentatif ; la quantification consciente simule le quantifieur pendant l'entraînement pour que les poids apprennent à le tolérer. Ici la QAT donne le plus petit modèle (10,3 Ko contre 13,5 Ko en PTQ et 24,8 Ko en float32) en gardant une précision comparable sur les données synthétiques.

text
float32  24,8 Ko  97,1%
int8 PTQ 13,5 Ko  97,4%
int8 QAT 10,3 Ko  97,0%

Lire les chiffres

Les tailles viennent des fichiers .tflite. La précision est la précision de détection d'anomalies sur un split tenu à l'écart du jeu synthétique. La latence hôte est mesurée sur x86 et n'est pas comparable à l'ESP32 ; la latence et la RAM de l'arène sur carte viennent du harnais ESP32, qui les rapporte avec esp_timer et TFLite Micro.

text
results/results.json -> tools/gen_report.py -> tableau README

Reproduire une exécution

La commande d'entraînement enregistre sa configuration dans results/run-config.json à côté de results.json. Relancer la même commande régénère les modèles, les métriques et le tableau README.

bash
python -m tinyml_bench train --windows 4000 --epochs 30
python tools/gen_report.py
Résultats
24,8 Ko / 97,1%
Float32
13,5 Ko / 97,4%
int8 PTQ
10,3 Ko / 97,0%
int8 QAT
14 / 14
Tests hôte
en attente du matériel
Métriques ESP32

Fonctionnalités démo

  • →Une commande entraîne, convertit et mesure les trois précisions
  • →Le tableau de comparaison README est généré depuis results.json
  • →Le harnais ESP32 rapporte la latence et la RAM de l'arène par modèle
  • →results/run-config.json enregistre la configuration exacte de l'exécution
Leçons apprises
  • →Un benchmark n'est utile que si le compromis est mesuré sur chaque axe, pas seulement sur la précision.
  • →Annoncer honnêtement la nature des données : une chaîne synthétique démontre la méthode, pas un modèle validé sur le terrain.
  • →Générer le rapport depuis le fichier de résultats empêche le tableau publié de diverger des mesures.