Hugging Face lance 207 noyaux WebGPU pour faire tourner l'IA 2,5 fois plus vite dans ton navigateur

UNE LIBRAIRIE MINIMALISTE POUR FAIRE VOLER LES PERFORMANCES

L'équipe WebAI de Hugging Face a un objectif clair : rendre l'inférence dans le navigateur aussi rapide et simple que possible. Pour y parvenir, trois couches de travail sont nécessaires. D'abord, les modèles doivent être représentés de manière compatible avec les navigateurs. Ensuite, les environnements d'exécution doivent créer des plans d'exécution efficaces. Enfin, au bas de la pile, les opérations GPU individuelles doivent exploiter au maximum les différents appareils et implémentations des navigateurs.

La première couche de cet effort est désormais disponible : @huggingface/kernels, une librairie minimaliste pour charger et exécuter des noyaux WebGPU optimisés depuis le Hub Hugging Face. Elle s'accompagne d'une première collection de 207 noyaux hébergés sur huggingface.co/webgpu-kernels.

207 NOYAUX POUR TOUTES LES OPÉRATIONS D'IA

Cette collection couvre les opérations utilisées dans une grande variété d'architectures et de charges de travail en apprentissage automatique. Chaque noyau est publié sous forme de paquet complet et versionné : son interface, ses modèles de shaders, ses cas de correction, ses cas de benchmark et ses instructions d'utilisation sont tous regroupés sur le Hub.

Ces noyaux ne sont pas de simples shaders. Chaque noyau possède sa propre carte de documentation qui détaille la sémantique de l'opération, ses entrées, ses sorties, ses attributs, les types de données supportés, les fichiers sources et un exemple prêt à l'emploi pour @huggingface/kernels.

Par exemple, le noyau ai.onnx.Add implémente l'addition élément par élément avec diffusion multidirectionnelle. C'est l'une des opérations les plus simples dans un réseau de neurones, utilisée partout, des connexions résiduelles à l'ajout d'un biais. Sa carte documente les deux entrées, la forme de sortie diffusée, les types de données supportés et les variantes disponibles pour différentes formes et appareils.

FLEET : LE BENCHMARK QUI FAIT PARLER TOUS LES ORDINATEURS

Hugging Face lance également Fleet, une suite de test et de benchmarking GPU directement dans le navigateur. Fleet exécute et note les noyaux sur ton Matériel. Au-delà des résultats pour ta propre machine, Fleet offre à la communauté un moyen de contribuer des preuves de performance et de correction issues d'appareils qu'un laboratoire de test classique ne pourrait jamais couvrir.

Avec ton consentement, chaque exécution ajoute des preuves privées qui aident à détecter les échecs (résultats incorrects, cas pathologiquement lents, etc.), à améliorer les variantes de noyaux et à prendre de meilleures décisions d'optimisation sur du matériel réel. Fleet devient ainsi un outil collaboratif pour rendre les noyaux plus rapides et plus fiables pour tout le monde.

POURQUOI COMMENCER PAR LES NOYAUX ?

Un modèle exécuté dans le navigateur finit par se transformer en une séquence d'opérations GPU : multiplications de matrices, normalisations, convolutions, primitives d'attention, opérations de quantification, transformations de mise en page des données, et bien plus encore. WebGPU rend ces opérations disponibles dans les navigateurs modernes grâce à une API portable, tandis que le WGSL fournit un langage commun pour les shaders qui les exécutent.

La portabilité ne garantit pas automatiquement la performance. Deux shaders peuvent implémenter la même opération et produire la même sortie tout en se comportant différemment selon l'accélérateur. Les tailles de workgroup, les motifs d'accès mémoire, la vectorisation, les types de données et les stratégies de fusion peuvent tous influencer la performance. Le meilleur choix peut également changer en fonction de la forme des entrées, de l'appareil, du navigateur et des fonctionnalités WebGPU disponibles.

C'est pourquoi les noyaux forment une couche fondamentale pour une inférence rapide dans le navigateur. Les environnements d'exécution de haut niveau ne peuvent être aussi efficaces que les opérations qu'ils dispatchent. En rendant ces opérations individuellement découvrables, testables, benchmarkables et versionnées, il devient possible d'améliorer la base indépendamment tout en conservant un contrat stable pour les couches supérieures.

UNE STRUCTURE QUI TRANSFORME UN SHADER EN LOGICIEL RÉUTILISABLE

Chaque noyau de la collection possède son propre dépôt et sa carte de noyau. Cette carte documente la sémantique de l'opération, ses entrées, ses sorties, ses attributs, les types de données supportés, les fichiers sources et un exemple prêt à l'emploi pour @huggingface/kernels.

Derrière la carte, le dépôt contient les artefacts nécessaires pour comprendre et évaluer l'implémentation. Cette structure transforme un shader en un artefact logiciel réutilisable. L'interface est inspectable sans lire le WGSL, les cas de correction et de performance accompagnent l'implémentation, et les versions publiées peuvent être chargées explicitement plutôt que de dépendre d'une URL de fichier non versionnée. Les noyaux peuvent également servir de références pour les développeurs qui construisent des noyaux WebGPU personnalisés ou intègrent ces opérations dans leurs propres environnements d'exécution.

INSTALLER ET UTILISER @HUGGINGFACE/KERNELS

Pour installer le paquet depuis npm, utilise la commande suivante :

npm install @huggingface/kernels@preview

L'exécution de ces noyaux nécessite un navigateur avec support WebGPU. La disponibilité de WebGPU dépend du navigateur, du système d'exploitation, du GPU et du pilote. Tu peux vérifier sa présence en JavaScript avec "gpu" in navigator.

@huggingface/kernels fait le lien entre un dépôt de noyaux et ton application. Appelle getKernel avec un identifiant de dépôt Hub et une version de contrat, puis invoque la fonction retournée avec des données d'entrée typées et des formes de tenseurs. Voici un petit exemple d'ajout de biais :

import { getKernel } from "@huggingface/kernels";

const add = await getKernel("webgpu-kernels/ai.onnx.Add", { version: 1 });

const { c } = await add({
  a: {
    data: new Float32Array([1, 2, 3, 4, 5, 6]),
    shape: [2, 3],
  },
  b: {
    data: new Float32Array([10, 20, 30]),
    shape: [3],
  },
});

Le deuxième entrée est diffusée sur la première dimension, produisant une sortie de forme [2, 3]. Le chargeur déduit cette forme de sortie et le type de données logique à partir du contrat de manifeste et des entrées, puis alloue c automatiquement.

POURQUOI LES NOYAUX ONT BESOIN DE VARIANTES

Même cette opération élémentaire illustre pourquoi les noyaux ont besoin de variantes. L'addition de formes égales peut utiliser un chemin vectorisé direct, tandis que les entrées diffusées nécessitent une logique d'indexation différente. Le noyau Add publié inclut des variantes pour les formes égales, la diffusion vectorisée, le traitement scalaire et la diffusion générale. L'environnement d'exécution peut sélectionner une implémentation qui correspond à l'appel et à l'appareil actuels sans changer l'API exposée à l'application.

L'option version: 1 sélectionne la version 1 du contrat de noyau publié. Elle est distincte d'un opset ONNX, de la since_version d'un opérateur ou d'une révision de modèle. Garder ces concepts séparés permet aux applications de dépendre d'un contrat stable face à l'API JavaScript, tandis que les implémentations des noyaux évoluent derrière.

À QUEL POINT LES NOYAUX SONT-ILS RAPIDES ?

Alors, à quel point les noyaux optimisés font-ils la différence ? L'équipe a comparé sa collection de noyaux à ORT WebGPU sur un GPU Apple M4, en utilisant ONNX Runtime Web 1.30.0-dev.20260826-b1f76d586a. Ils ont commencé avec 1 756 cas de test couvrant les 207 opérations et ont conservé les 809 cas où les deux côtés produisaient des sorties correspondantes et des chronométrages fiables.

Sur ces comparaisons, les noyaux de Hugging Face étaient 2,57 fois plus rapides en moyenne géométrique et 1,90 fois plus rapides à la médiane, avec 629 victoires, 176 défaites et 4 matchs nuls. Voici un aperçu plus détaillé de quatre opérations familières :

DES CAS EXTRÊMES QUI MONTRRENT LA PUISSANCE DES NOYAUX SPÉCIALISÉS

Certaines victoires individuelles étaient bien plus importantes. Un cas difficile d'Einsum bilinéaire (i,ij,j avec taille 4096) s'est exécuté en 0,136 ms avec le noyau de Hugging Face contre 1 396 ms avec ORT WebGPU : plus de 10 000 fois plus rapide. Une somme cumulative par ligne sur [256, 4096] était 301 fois plus rapide, à 0,016 ms contre 4,784 ms. Ces cas sont inhabituels plutôt que les accélérations que tu peux attendre partout, mais ils montrent à quel point un noyau spécialisé peut aider quand une implémentation générale atteint un chemin lent.

L'équipe a chronométré le travail effectué sur le GPU lui-même, en excluant la configuration comme le chargement des noyaux, la création de sessions, le téléchargement des entrées, la compilation des shaders et la lecture des sorties. Les charges de travail très courtes sont naturellement plus difficiles à mesurer, et les petits cas peuvent bénéficier du cache GPU, donc ces chiffres sont à lire comme une comparaison utile plutôt qu'une promesse pour chaque application.

Il s'agit également de résultats pour des opérations individuelles, et non pour des modèles complets. La performance exacte variera selon les GPU et les navigateurs, c'est pourquoi Fleet est si important pour construire une image plus large.

L'équipe travaille également avec l'équipe ONNX Runtime pour intégrer ces améliorations en amont afin qu'elles puissent bénéficier à l'écosystème plus large de ONNX Runtime Web.

D'UN APPAREIL À UNE FLOTTE : LA PERFORMANCE VARIE SELON LES CONFIGURATIONS

La performance WebGPU varie selon les GPU, les navigateurs et les pilotes, donc les résultats d'une seule machine ne racontent qu'une partie de l'histoire. Fleet permet à chacun d'exécuter des vérifications de correction et de performance dans le navigateur et de voir comment les noyaux se comportent sur son matériel.

Avec ton consentement, chaque exécution contribue privément des preuves qui aident à repérer les échecs spécifiques à un appareil, à comparer les variantes et à améliorer les règles de sélection. L'objectif est simple : utiliser une couverture large et réelle pour rendre les noyaux plus rapides et plus fiables pour tout le monde.

CONSTRUIRE UNE BASE PARTAGÉE POUR WEBAI

Les 207 noyaux initiaux ne sont qu'un point de départ, pas un état final. Publier des noyaux indépendamment sur le Hub donne un endroit commun pour inspecter les contrats, comparer les implémentations, reproduire les vérifications de correction et améliorer les performances sans intégrer chaque shader directement dans chaque environnement d'exécution.

La collection fait également partie de l'écosystème plus large de noyaux du Hub : sur la page Noyaux, les noyaux WebGPU côtoient les noyaux pour CUDA, ROCm, Metal et d'autres plateformes. Ils peuvent être filtrés, triés et explorés comme n'importe quel autre artefact sur le Hub.

Cela constitue la base de bas niveau pour les prochaines étapes de la pile d'inférence dans le navigateur. L'équipe est enthousiaste à l'idée de connecter ces noyaux à des outils de modélisation de haut niveau, de continuer à élargir la couverture des opérations et de rendre l'inférence locale rapide plus facile à utiliser dans tout l'écosystème WebAI.

EXPLORER, TESTER ET CONTRIBUER

Explore la collection de noyaux WebGPU, essaie @huggingface/kernels et rejoins Fleet pour contribuer des preuves issues de ton appareil et aider à rendre les noyaux meilleurs pour tout le monde.

UNE BASE DE CODE EXEMPLAIRE POUR DÉBUTER

Pour commencer à utiliser @huggingface/kernels, voici un exemple minimaliste qui montre comment charger et exécuter un noyau d'addition :

import { getKernel } from "@huggingface/kernels";

// Charger le noyau d'addition depuis le Hub
const add = await getKernel("webgpu-kernels/ai.onnx.Add", { version: 1 });

// Exécuter l'addition avec des tenseurs d'entrée
const { c } = await add({
  a: {
    data: new Float32Array([1, 2, 3, 4, 5, 6]),
    shape: [2, 3],
  },
  b: {
    data: new Float32Array([10, 20, 30]),
    shape: [3],
  },
});

console.log(c.data); // [11, 22, 33, 14, 25, 36]

L'ARCHITECTURE D'UN NOYAU WEBGPU

Chaque noyau WebGPU dans la collection est structuré comme un dépôt GitHub indépendant. Voici ce que contient chaque dépôt :

• Une carte de noyau documentant l'opération, ses entrées/sorties, ses attributs et ses variantes.
• Un contrat de manifeste définissant l'interface stable du noyau.
• Des cas de correction pour valider que le noyau produit les bons résultats.
• Des cas de benchmark pour mesurer les performances sur différents matériels.
• Un template de shader WGSL définissant le code exécuté sur le GPU.
• Des variantes de noyau pour différentes tailles d'entrée et types de données.

LES BÉNÉFICES POUR LES DÉVELOPPEURS

Pour les développeurs qui veulent intégrer des noyaux WebGPU dans leurs propres projets, la collection offre plusieurs avantages :

• Une API stable qui ne change pas même si les implémentations internes évoluent.
• Des preuves de correction et de performance pour chaque noyau et variante.
• Un écosystème ouvert où tout le monde peut contribuer des améliorations ou des variantes.
• Une intégration facile grâce à la librairie @huggingface/kernels.

LES LIMITES À CONNAÎTRE

Malgré les performances impressionnantes, il y a quelques limites à garder à l'esprit :

• La performance varie selon le matériel : un noyau optimisé sur un GPU Apple M4 ne donnera pas les mêmes résultats sur un GPU NVIDIA ou AMD.
• Les petites opérations peuvent ne pas bénéficier des gains de performance, car le coût de la communication avec le GPU dépasse le temps de calcul.
• Le support WebGPU dépend du navigateur et du système d'exploitation. Certains navigateurs ou versions peuvent ne pas supporter toutes les fonctionnalités.

COMMENT FONCTIONNE FLEET EN PRATIQUE

Fleet est un outil de benchmarking qui s'exécute directement dans ton navigateur. Voici comment il fonctionne :

1. Tu sélectionnes un noyau et une variante à tester.
2. Fleet exécute le noyau sur ton matériel avec différents cas de test.
3. Les résultats de performance et de correction sont enregistrés localement.
4. Avec ton consentement, ces résultats sont envoyés anonymement pour contribuer à la base de données globale.
5. Tu peux voir comment ton matériel se compare aux autres appareils testés.

LES PROCHAINES ÉTAPES POUR HUGGING FACE

Hugging Face a plusieurs objectifs pour les mois à venir :

• Étendre la couverture des opérations supportées par les noyaux WebGPU.
• Améliorer l'intégration avec les outils de modélisation de haut niveau.
• Optimiser davantage les variantes de noyaux pour des cas d'usage spécifiques.
• Développer des outils pour aider les développeurs à créer leurs propres noyaux.

UN PAS DE GÉANT POUR L'IA DANS LE NAVIGATEUR

Avec la publication de ces 207 noyaux WebGPU optimisés et de la librairie @huggingface/kernels, Hugging Face franchit une étape majeure pour rendre l'IA locale dans le navigateur aussi puissante que sur un PC dédié. Cette avancée ouvre la voie à des applications d'IA plus rapides, plus accessibles et plus respectueuses de la vie privée, sans avoir besoin de serveurs distants.

Pour les développeurs, c'est une opportunité de créer des applications d'IA plus performantes et plus fluides. Pour les utilisateurs, c'est la promesse d'une expérience sans latence et sans dépendance à des infrastructures coûteuses. Et pour la communauté open source, c'est une nouvelle preuve que l'innovation collective peut accélérer l'adoption de l'IA locale.

CONCLUSION : UNE RÉVOLUTION EN MARCHE

Les 207 noyaux WebGPU de Hugging Face et la librairie @huggingface/kernels marquent un tournant pour l'exécution de l'IA dans le navigateur. En combinant des noyaux optimisés, une API simple et un outil de benchmarking collaboratif comme Fleet, Hugging Face rend l'IA locale accessible à tous, sur tous les appareils.

Que tu sois un développeur cherchant à intégrer des modèles d'IA dans ton application web, ou un utilisateur souhaitant exécuter des modèles localement sans latence, cette initiative ouvre des possibilités inédites. Et avec la communauté qui contribue via Fleet, les noyaux ne cesseront de s'améliorer, devenant encore plus rapides et plus fiables avec le temps.

L'avenir de l'IA locale dans le navigateur est là. À toi de jouer.