Résumé Technique : SparsePixels : Convolution efficace pour données éparses sur FPGA

1. Énoncé du problème

Les réseaux de neurones convolutifs (CNN) standards déployés sur des circuits intégrés programmables (FPGA) pour les expériences de physique des particules souffrent souvent d'une latence d'inférence élevée et d'intervalles d'initiation longs. Cette inefficacité provient du fait que la convolution standard nécessite le traitement dense de chaque pixel d'entrée, qu'il contienne ou non une information sémantique. Dans de nombreuses applications modernes de détecteurs, telles que le traçage de muons dans les chambres à gaz ou l'identification de neutrinos dans les chambres à projection temporelle d'argon liquide (LArTPC), les données d'entrée sont spatialement éparses. Par exemple, une trace de muon peut occuper moins de 0,3 % d'une image 2D, et les traces de neutrinos dans les LArTPC peuvent présenter aussi peu que 0,01 % de pixels non nuls.

Les implémentations actuelles sur FPGA, comme celles utilisant la bibliothèque hls4ml, reposent généralement sur un flux d'entrée/sortie (I/O) en streaming pour gérer les contraintes de ressources. Bien que le streaming réduise l'utilisation des ressources, il traite les pixels séquentiellement, ce qui entraîne des latences qui augmentent linéairement avec la taille de l'image (par exemple, en parcourant des milliers de pixels vides). Cela rend les CNN standards incompatibles avec les systèmes de déclenchement (trigger) en temps réel dans les expériences de physique des hautes énergies, qui nécessitent des latences de décision de l'ordre de la microseconde ou de la sous-microseconde pour gérer des taux de collision de 40 MHz.

Les méthodes de convolution éparse existantes pour les GPU (par exemple, MinkowskiEngine, SpConv) permettent souvent aux pixels actifs de se « dilater » à travers les couches, augmentant ainsi le coût computationnel, ou reposent sur des flux de données irréguliers qui entraînent des temps d'exécution dépendants de l'entrée. Dans les systèmes avec des limites de latence strictes, un temps d'exécution variable est inacceptable.

2. Méthodologie : Le cadre SparsePixels

Les auteurs introduisent SparsePixels, un cadre conçu pour implémenter la convolution éparse sur FPGA tout en maintenant un temps d'exécution constant et indépendant de l'entrée. La philosophie centrale est de conserver et de calculer sélectivement un petit sous-ensemble prédéfini de pixels actifs tout en ignorant le reste, garantissant que le nombre total d'opérations reste fixe pour chaque entrée.

2.1 Architecture centrale

Le cadre se compose de cinq couches éparses spécialisées conçues pour la synthèse de haut niveau (HLS) :

1. Réduction d'entrée éparse : La première couche identifie les pixels actifs (ceux dépassant un seuil) et les extrait dans des tableaux compacts. Pour éviter les adresses d'écriture dépendantes des données (qui causent des problèmes de planification en HLS), les auteurs utilisent un arbre de réduction binaire récursif. Ce schéma efficace pour le matériel balaie l'entrée selon un motif fixe pour peupler deux tableaux : un tableau de caractéristiques (afeat) et un tableau de hachage de coordonnées (ahash). Le nombre de pixels conservés est limité par un hyperparamètre, $N_{max}^{active}$.
2. Convolution éparse : Cette couche effectue une convolution préservant la parcimonie. Crucialement, un pixel de sortie est calculé uniquement si le pixel d'entrée correspondant au même emplacement est actif. Cela empêche la « dilatation » de l'ensemble actif observée dans d'autres méthodes éparses. L'algorithme itère sur les tableaux éparses de taille fixe plutôt que sur la grille d'image complète. Le nombre d'itérations dépend de $N_{max}^{active}$, et non de la taille du noyau $K$, car les positions du noyau sont déterminées via des vérifications de décalage (offset) plutôt que par des boucles explicites sur toutes les $K^2$ positions.
3. Activation éparse : Applique une non-linéarité élément par élément sur le tableau de caractéristiques éparses.
4. Pooling éparse : Sous-échantillonne la représentation éparse en cartographiant les coordonnées et en accumulant les caractéristiques pour les pixels tombant dans le même pool.
5. Aplatissement éparse : Convertit la représentation éparse finale en un tableau dense pour la connexion à des couches denses standards (MLP).

2.2 Détails d'implémentation

• Temps d'exécution constant : Comme le système opère sur des tableaux de taille fixe ($N_{max}^{active}$), complétés par des drapeaux d'invalidité si l'entrée possède moins de pixels actifs, la latence d'inférence est indépendante de la parcimonie réelle de l'entrée.
• Entraînement : Une bibliothèque Python a été développée pour entraîner ces CNN épars en utilisant l'entraînement conscient de la quantification (QAT) avec QKeras comme backend. L'entraînement imite le comportement HLS, incluant la contrainte de taille fixe $N_{max}^{active}$.
• Cible matérielle : La conception cible les FPGA AMD/Xilinx Alveo (xcu250) utilisant Vitis HLS, fonctionnant à 200 MHz.

3. Principales contributions

1. Méthode de convolution éparse : Une nouvelle approche pour les FPGA qui sélectionne de manière adaptative les pixels actifs mais impose un budget de calcul fixe ($N_{max}^{active}$), garantissant une latence constante quelle que soit la parcimonie de l'entrée.
2. Implémentation de preuve de concept : Une démonstration d'accélérations significatives de l'inférence sur FPGA pour des données d'images spatialement éparses avec des performances de modèle comparables aux CNN standards.
3. Outils open-source : Une bibliothèque Python publiée pour l'entraînement de CNN épars et des modules C++ HLS pour le déploiement, facilitant l'adoption par la communauté de la physique des particules.

4. Résultats expérimentaux

Les auteurs ont évalué SparsePixels sur trois jeux de données : une variante éparsie de MNIST, la détection de neutrinos MicroBooNE, et le marquage de saveur de jets LHC. Les modèles étaient compacts (~4k paramètres) et comparés à des bases de référence CNN standards implémentées avec un I/O en streaming.

• Performance vs Latence : Sur le jeu de données MicroBooone (images de 63×63, ~4k pixels), un CNN standard de 8 bits nécessitait 48,665 µs (9 733 cycles d'horloge) pour l'inférence. La variante « sparse-large » de SparsePixels (calculant sur seulement 20 pixels actifs, <1 % de l'entrée) a atteint un temps d'inférence de 0,665 µs (133 cycles d'horloge). Cela représente une accélération de 73× avec une perte de performance négligeable (<2 % de baisse de l'AUC ROC).
• Scalabilité : Des accélérations similaires ont été observées pour MNIST (jusqu'à 41×) et le marquage de jets LHC (jusqu'à 112×).
• Utilisation des ressources : Bien que les CNN épars utilisent plus de ressources (en raison du déroulement des boucles pour le parallélisme) que les CNN standards en streaming, l'utilisation des ressources reste largement dans les budgets sur puce (par exemple, ~20 % des LUTs pour les modèles les plus grands).
• Intervalle d'initiation (II) : L'II pour les CNN épars est déterminé uniquement par la couche de réduction d'entrée éparse (la première couche), car les couches suivantes opèrent en parallèle sur les tableaux éparses de taille fixe.

5. Signification et limites

Signification :
L'article affirme que SparsePixels permet le déploiement de CNN dans des régimes de latence ultra-faible (sous la microseconde) requis par les déclencheurs modernes de physique des particules, où les CNN standards sont actuellement impossibles en raison de la latence. En échangeant une petite quantité contrôlable de précision contre des accélérations massives, le cadre permet des algorithmes en ligne plus sophistiqués dans des expériences comme le High-Luminosity LHC.

Limites et travaux futurs :

• Contraintes de parallélisation : L'implémentation actuelle déroule complètement les boucles pour minimiser la latence, ce qui limite la taille maximale des entrées et la complexité des modèles en raison de l'épuisement des ressources FPGA. Les travaux futurs visent à introduire un contrôle flexible sur la parallélisation pour échanger la latence contre l'efficacité des ressources.
• Réglage des hyperparamètres : Le choix de $N_{max}^{active}$ est actuellement empirique. Les auteurs proposent de rendre ce paramètre (et potentiellement le seuil) entraînables dans les versions futures.
• Quantification : Le backend actuel utilise une quantification uniforme par couche. Les futures mises à jour prévoient d'adopter la quantification à haute granularité (HGQ) pour un contrôle plus fin.

Les auteurs concluent que SparsePixels offre une voie viable pour une lecture de données efficace dans les expériences ayant des exigences de latence de l'ordre de la microseconde, comblant le fossé entre le besoin de modèles ML complexes et les contraintes de temps strictes des déclencheurs matériels en temps réel.