Une plateforme, 1 930 algorithmes, tous les backends : comment nous avons construit la pile complète pour l'IA discrète

Une plateforme, 1 930 algorithmes, tous les backends : comment nous avons construit la pile complète pour l'IA discrète

Le problème de la fragmentation

Votre environnement de développement IA est fragmenté.

Vous prototypiez avec PyTorch parce que les chercheurs le préfèrent. Vous déployez avec TensorFlow parce que les équipes de production veulent les outils de Google. Vous écrivez des kernels CUDA pour les GPU NVIDIA. Vous portez vers ROCm pour le matériel AMD. Vous réécrivez tout pour le mobile avec TensorFlow Lite ou Core ML. Vous utilisez ONNX pour convertir entre les frameworks, en espérant que rien ne casse. Vous maintenez des codebases séparés pour le cloud, la périphérie et le navigateur.

Dix outils différents. Des milliers de dépendances. Des cauchemars de compatibilité de versions. Des changements cassants à chaque cycle de publication.

Mettre à jour PyTorch ? Espérez que votre version CUDA corresponde. Déployer sur AMD ? Réécrivez vos kernels. Besoin d'inférence dans le navigateur ? Repartez de zéro avec WebAssembly. Passer de GPU NVIDIA à AMD ? Bonne chance pour porter ce codebase. Déployer sur des FPGA ? Apprenez une chaîne d'outils entièrement différente.

Cette fragmentation n'est pas un accident. C'est le résultat naturel de chaque framework qui optimise pour son cas d'utilisation spécifique tout en ignorant l'interopérabilité. PyTorch excelle pour la recherche mais traite le déploiement comme une réflexion après coup. TensorFlow cible la production mais l'expérience de recherche est pénible. CUDA vous enferme dans le matériel NVIDIA. Chaque outil résout un problème tout en en créant trois autres.

Il y a une meilleure voie.

Dweve Core : la plateforme complète pour l'IA discrète

Dweve Core est une plateforme unifiée pour construire des réseaux neuronaux discrets, de la précision binaire à 8 bits. Ce n'est pas un autre framework. C'est un remplacement complet de votre pile fragmentée.

Une seule installation. Une seule API. Un seul codebase. Déploiement automatique sur CPU, GPU, FPGA, WebAssembly, partout où vous avez besoin d'exécuter.

Voici ce que « complet » signifie :

1 930 algorithmes couvrant chaque opération dont vous avez besoin :

• 415 primitives : opérations atomiques comme XNOR, popcount, manipulation de bits, quantification, conversion entre formats
• 500 kernels : opérations composites optimisées pour les motifs courants
• 191 couches : blocs de construction complets de réseaux neuronaux (convolution, dense, normalisation, activation, attention)
• 674 algorithmes : méthodes de haut niveau incluant transformations, procédures d'entraînement, recherche évolutionnaire, distillation de connaissances
• 30 utilitaires d'interop : ponts flottants optionnels pour les approches hybrides
• 120 architectures de modèles : gabarits de réseaux pré-optimisés, des ResNets aux Transformers

Ce n'est pas un sous-ensemble. C'est une complétude mathématique. Nous avons analysé chaque grande architecture de réseau neuronal et construit chaque opération qu'elles requièrent, optimisée pour le calcul discret à partir des premiers principes.

6 backends avec compilation automatique :

• SIMD CPU : kernels optimisés à la main pour x86 et ARM avec détection automatique d'ISA (SSE2, AVX2, AVX-512, NEON, SVE/SVE2)
• CUDA : optimisation GPU NVIDIA avec primitives au niveau warp et utilisation des Tensor Cores
• Rust-HDL : synthèse directe FPGA et ASIC à partir de descriptions d'algorithmes
• WebAssembly : inférence dans le navigateur avec support SIMD128 pour un traitement sur appareil conforme au RGPD
• ROCm : optimisation GPU AMD avec opérations au niveau wavefront
• Metal : optimisation Apple Silicon utilisant l'architecture de mémoire unifiée

6 largeurs de bits avec précision adaptative :

• Binaire (1 bit) : efficacité maximale avec une compression 16× par rapport au FP16
• Ternaire : {-1, 0, +1} avec parcimonie explicite
• 2 bits : quatre niveaux pour une compression équilibrée
• 3 bits : huit niveaux pour les couches sensibles à la qualité
• 4 bits : seize niveaux proches de la qualité FP16
• 8 bits : quasi pleine précision pour les opérations critiques

La plateforme apprend la largeur de bits optimale de chaque couche pendant l'entraînement grâce à une sélection par descente de gradient. Pas d'heuristiques. Pas de conjectures. Une véritable optimisation fondée sur l'amélioration de la précision apportée par une précision accrue.

Écrivez une fois, déployez partout

La plateforme utilise une API Rust déclarative. Vous décrivez ce que vous voulez, le compilateur détermine comment l'exécuter de manière optimale sur votre matériel cible.

Exemple de définition de réseau :

let model = NetworkBuilder::new()
    .input(BinaryTensor::new([1024, 784]))
    .dense(784, 512, activation=BinaryActivation::Sign)
    .dense(512, 256, activation=BinaryActivation::Sign)
    .output(256, 10)
    .build();

Voilà. Écrivez ceci une seule fois, et le compilateur génère automatiquement des implémentations optimisées pour chaque backend.

Le pipeline de compilation fonctionne à travers quatre niveaux :

Niveau 1 : IR du réseau neuronal - Votre description de réseau de haut niveau est analysée en un graphe computationnel avec opérations, flux de données et hyperparamètres.

Niveau 2 : Optimisation du graphe - Les passes standard du compilateur éliminent le code mort, replient les constantes, dédupliquent les expressions et fusionnent les opérations séquentielles. Une couche dense suivie d'une normalisation par lot et d'une activation devient un noyau fusionné unique qui charge l'entrée une fois et produit la sortie finale.

Niveau 3 : Dialecte BitOps - Le graphe est abaissé en opérations au niveau du bit, explicitement typées avec leur précision. Cette représentation intermédiaire est indépendante du matériel mais proche des opérations machine réelles. Construit sur l'infrastructure MLIR (Multi-Level Intermediate Representation) pour une optimisation de niveau industriel.

Niveau 4 : Abaissement matériel - La génération de code finale produit des implémentations spécifiques à la plateforme. Pour AVX-512, les opérations binaires deviennent des instructions VPXORQ et VPOPCNTQ. Pour CUDA, elles deviennent des intrinsèques au niveau warp avec accès mémoire coalescé. Pour FPGA, elles deviennent des portes XNOR et des arbres d'additionneurs synthétisés en Verilog.

Le même code source s'exécute sur le processeur de votre ordinateur portable pendant le développement, se déploie sur des GPU cloud en production et se compile vers des FPGA pour une inférence en temps réel déterministe. Aucune traduction. Aucun portage. Aucun code spécifique à la plateforme.

Conçu pour que les clients puissent construire

Dweve Core alimente Dweve Loom, notre système de raisonnement par contraintes. Mais ce n'est pas seulement pour nous. C'est une plateforme complète pour toute personne construisant des réseaux neuronaux discrets.

Vous pouvez créer :

• Des architectures personnalisées à partir des 191 types de couches et 674 algorithmes
• Des modèles spécialisés par domaine optimisés pour vos exigences exactes
• Des approches hybrides combinant calcul discret et continu grâce aux 30 utilitaires d'interopérabilité
• Des méthodes d'entraînement inédites utilisant la recherche évolutionnaire, la distillation de connaissances ou des estimateurs de gradient personnalisés

La plateforme propose :

Une infrastructure d'entraînement complète : six variantes d'estimateurs à passage direct pour le flux de gradient binaire/ternaire. Des optimiseurs conscients du binaire qui maintiennent des poids en pleine précision en interne tout en les binarisant pour les passages avant. Une sélection automatique de la largeur de bits par optimisation basée sur le gradient. Une distillation progressive en plusieurs étapes, de FP32 à INT8, INT4, ternaire, puis binaire.

Une optimisation matérielle automatique : détection à l'exécution des capacités du processeur (CPUID sur x86, registres système sur ARM) et répartition automatique vers l'implémentation SIMD la plus rapide disponible. Des variantes de noyaux GPU sélectionnées selon la taille de la warp, la mémoire partagée et le nombre de registres. Une synthèse FPGA avec insertion automatique de registres de pipeline selon les contraintes de synchronisation.

Une quantification flexible : quantification symétrique et asymétrique avec échelles par tenseur, par canal ou par groupe. Quantification dynamique avec détection de plage à l'exécution, ou quantification statique avec échelles précalculées à partir de données de calibration. Calcul d'échelles optimal selon l'erreur quadratique moyenne et basé sur la divergence KL pour une perte de précision minimale.

Pourquoi le calcul discret est important

Les réseaux de neurones traditionnels calculent tout en virgule flottante 16 bits ou 32 bits, puis prennent des décisions discrètes à la fin. Nous opérons directement dans l'espace discret, du binaire au 8 bits, en éliminant le calcul continu intermédiaire.

Il ne s'agit pas d'une simple quantification de modèles existants. L'architecture du framework repose dès ses fondements sur des opérations discrètes :

La réalité matérielle : les processeurs modernes sont constitués de milliards de transistors à deux états. Une porte XNOR nécessite 6 transistors. Un multiplicateur en virgule flottante 32 bits en exige des milliers et consomme des ordres de grandeur plus d'énergie. Les opérations discrètes s'alignent sur les fondamentaux du matériel.

L'efficacité mémoire : les poids binaires regroupent 64 valeurs par mot de 64 bits. Un ResNet-50 avec 25,6 millions de paramètres occupe 3,1 Mo en binaire contre 50 Mo en FP16. Le modèle entier tient dans le cache L3 du processeur (en général : 36 à 64 Mo). Vous devenez limité par le calcul plutôt que par la mémoire.

La flexibilité de déploiement : les petits modèles permettent l'inférence sur l'appareil. Aucune dépendance au cloud. Aucune latence réseau. Aucun souci de confidentialité des données. Traitez les informations sensibles entièrement sur les appareils des utilisateurs, sans jamais les transmettre à des serveurs.

La matrice complète des algorithmes

La plateforme offre une couverture complète sur trois dimensions : les algorithmes, les backends et les largeurs de bits.

Opérations fondamentales (415 primitives) :

• 46 opérations binaires : portes logiques, manipulation, décalages, comptage, recherche
• 16 opérations de champ : extraction, dépôt, regroupement, dispersion, collecte, création de masque
• 25 réductions : ET/OU/XOR logiques, somme/produit arithmétiques, vote et consensus
• 17 métriques de distance : Hamming, Jaccard, Dice, Tanimoto, cosinus, Manhattan, Euclidienne
• 12 opérations d'entrelacement : entrelacement de 2 à 4 voies, courbes de remplissage d'espace de Morton et de Hilbert
• 44 opérations arithmétiques : addition, soustraction, multiplication, division, opérations en virgule fixe
• 39 transformations : Walsh-Hadamard, FFT, DCT, NTT, ondelettes (Haar, Daubechies, CDF97)
• 11 hachages : SHA-256, Blake3, xxHash, MinHash, SimHash, hachage sensible à la localité
• 22 générations de nombres aléatoires : LFSR, Mersenne Twister, ChaCha20, suites de Sobol
• 15 quantifications : symétrique, asymétrique, par tenseur, par canal, calcul d'échelle
• 30 calculs binaires : XNOR-popcount, encodage ternaire, mises à jour de poids, opérations de gradient
• 48 conversions de format : conversions FP32/FP16/FP8/INT8/INT4/INT2 dans toutes les directions
• 42 opérations en virgule fixe : arithmétique, transcendantes, saturation sur toutes les largeurs de bits

Opérations composites (500 noyaux) :

Noyaux optimisés combinant les primitives pour les motifs courants. Variantes de multiplication matricielle (standard, transposée, par blocs). Types de convolution (2D, 3D, depthwise, groupée, dilatée). Normalisation (par lot, par couche, par groupe, par instance). Fonctions d'activation (signe, tanh dure, linéaire par morceaux). Mécanismes d'attention (auto-attention, attention croisée, multi-têtes). Regroupement (max, moyenne, stochastique).

Couches de réseau (191 couches) :

Blocs de construction complets pour la construction de réseaux. Couches denses avec poids binaires, ternaires et multi-bits. Couches convolutionnelles avec toutes les variantes courantes. Couches récurrentes (LSTM, GRU avec portes binaires). Couches d'attention (produit scalaire mis à l'échelle, multi-têtes, position relative). Couches de normalisation avec statistiques de lot et paramètres appris. Connexions résiduelles avec correspondance de dimensions.

Algorithmes de haut niveau (674 algorithmes) :

Méthodes complètes pour l'entraînement, l'inférence et l'optimisation. Distillation de connaissances avec raffinement progressif en plusieurs étapes. Découverte de contraintes évolutives avec programmation génétique. Recherche d'architecture neuronale pour réseaux discrets. Estimateurs de gradient (direct, écrêté, adaptatif, momentum, hyperréseau). Optimiseurs (BinaryAdam, TernaryAdam, quantification adaptative). Entraînement distribué avec agrégation robuste aux défaillances byzantines.

Profondeur de l'implémentation du backend

Chaque algorithme existe en plusieurs variantes optimisées par backend. Pas d'implémentations génériques. Du code spécifique au matériel exploitant chaque caractéristique architecturale.

SIMD CPU : SSE2 offre une compatibilité x86-64 universelle (tous les processeurs depuis 2001). AVX2 offre une accélération de 4 à 8× sur Haswell et plus récents (2013+). AVX-512 atteint 10 à 16× avec des registres de masque pour la prédication et VPTERNLOG pour toute fonction booléenne à 3 entrées. NEON apporte une accélération de 3 à 4× à tous les processeurs ARMv8, y compris mobiles et Apple Silicon. SVE/SVE2 fournit un code indépendant de la longueur de vecteur qui utilise automatiquement des vecteurs plus larges sur le matériel plus récent.

CUDA : Les primitives au niveau warp organisent 32 threads qui s'exécutent en lockstep. Chaque thread traite 32 valeurs binaires regroupées dans un uint32. Un warp complet traite 1 024 valeurs binaires en parallèle. Les intrinsèques matérielles incluent __popc pour le comptage de population, __ballot_sync pour le vote au sein du warp, et __shfl_sync pour une communication rapide sans mémoire partagée. L'accès mémoire coalescé garantit une utilisation optimale de la bande passante. Les Tensor Cores sont utilisés pour les opérations matricielles, même avec des données binaires.

Rust-HDL : Synthèse matérielle directe à partir de code Rust annoté. Le framework génère automatiquement du Verilog/VHDL. Les opérations binaires XNOR-popcount correspondent à des portes XNOR (logique combinatoire, délai de propagation nul) plus des arbres d'additionneurs. Les registres de pipeline sont insérés automatiquement en fonction des contraintes de timing. La synthèse cible à la fois les FPGA (Xilinx, Intel) et les ASIC.

WebAssembly : SIMD128 fournit des opérations vectorielles 128 bits dans tous les navigateurs modernes (Chrome 91+, Firefox 89+, Safari 16.4+). Les opérations incluent v128.and/or/xor pour la logique binaire et i8x16.popcnt pour le comptage de population. Combiné avec les Web Workers pour le multithreading et SharedArrayBuffer pour la mémoire partagée, cela atteint 60 à 80 % des performances CPU natives. L'inférence dans le navigateur permet un traitement conforme au RGPD sans envoi de données vers un serveur.

ROCm : Optimisation au niveau wavefront pour les architectures AMD avec 64 threads par wavefront (le double des 32 de NVIDIA). Chaque thread traite 32 valeurs binaires, soit 2 048 valeurs par wavefront. Les intrinsèques sont similaires à celles de CUDA avec __builtin_popcount, __ballot et ds_swizzle. Le modèle de programmation est suffisamment proche pour que les développeurs CUDA puissent écrire du code ROCm immédiatement.

Metal : Optimisation pour Apple Silicon utilisant une architecture mémoire unifiée où le CPU et le GPU partagent la RAM physique avec cohérence de cache. Élimine la surcharge de copie des données. Les opérations binaires exploitent les moteurs matriciels personnalisés d'Apple. Le Neural Engine du M3 Max délivre 50 à 80 TOPS en inférence binaire grâce aux accélérateurs dédiés intégrés au SoC.

Ce que nous ne faisons pas (et pourquoi la concentration compte)

Il est important de clarifier : nous ne faisons pas tout. La concentration permet l'excellence.

Pas d'inférence en virgule flottante : Calcul discret uniquement, du binaire au 8 bits. Si vous avez besoin de FP32/FP16/BFloat16 pour le déploiement, utilisez PyTorch ou JAX à la place. Nous optimisons exclusivement pour les opérations discrètes, ce qui permet des spécialisations impossibles avec la virgule flottante en précision mixte. On ne peut pas être excellent partout. Nous avons choisi l'IA discrète et optimisé sans compromis.

Pas de graphes d'inférence dynamiques : Les modèles sont compilés en graphes statiques pour le déploiement. L'entraînement prend en charge le calcul dynamique (nécessaire pour la flexibilité de la recherche), mais l'inférence en production est statique. Cela permet une optimisation en amont : fusion de noyaux sur l'ensemble du réseau, optimisation de la disposition mémoire avec des formes de tenseurs connues, insertion d'instructions de préchargement avec des schémas d'accès prévisibles.

Prétraitement des données ciblé : Nous fournissons 8 algorithmes spécialisés pour la préparation des entrées de réseaux de neurones (normalisation, mise à l'échelle adaptative, quantification apprise, augmentation binaire), et non un ETL généraliste. Pour les pipelines de feature engineering et le chargement de données, utilisez les outils existants (Pandas, Polars, DuckDB). Nous excellons dans l'inférence de réseaux de neurones discrets, du binaire au 8 bits. Nous ne remplaçons pas toute votre pile de données.

Ce ne sont pas des limitations. C'est de la concentration. En limitant le périmètre aux réseaux de neurones discrets avec des graphes d'inférence statiques, nous atteignons une profondeur d'optimisation que les frameworks généralistes ne peuvent pas égaler.

Construire avec Dweve Core

La plateforme est prête à l'emploi. Vous pouvez commencer à construire des réseaux de neurones discrets dès aujourd'hui.

Chaîne d'outils complète :

• API déclarative : DSL Rust avec NetworkBuilder pour la définition de modèles
• Infrastructure de compilation : pipeline d'optimisation basé sur MLIR avec quatre niveaux de IR
• Cadre d'entraînement : six variantes de STE, optimiseurs tenant compte du binaire, sélection automatique de la largeur de bits
• Générateurs de code backend : C avec intrinsèques pour CPU, noyaux CUDA/HIP pour GPU, Verilog pour FPGA
• Outils de déploiement : export vers ONNX, Core ML, TensorFlow Lite ou binaires autonomes

Exemple de flux de travail :

1. Définissez votre réseau avec NetworkBuilder
2. Entraînez-le avec des optimiseurs tenant compte du binaire et une sélection adaptative de la largeur de bits
3. Compilez pour le matériel cible avec une sélection automatique du backend
4. Déployez-le comme binaire optimisé ou exportez-le dans un format standard
5. Exécutez-le partout : serveurs cloud, appareils périphériques, navigateurs, FPGA

Une plateforme. Un codebase. Chaque backend. IA discrète complète.

Arrêtez de jongler avec dix frameworks. Arrêtez de réécrire le code pour chaque cible de déploiement. Arrêtez de lutter contre les problèmes de compatibilité de versions. Construisez une fois sur Dweve Core et déployez partout.

Dweve Core alimente Dweve Loom, notre système de raisonnement par contraintes qui sera lancé en 2026. Le framework implémente la pile complète de 1 930 algorithmes sur 6 backends avec une quantification multi-bits adaptative, du binaire à 8 bits. Développé par une équipe d'ingénieurs néerlandais sur trois ans de développement.