Sutra: Tensor-Op RNNs as a Compilation Target for Vector Symbolic Architectures

L'article présente Sutra, un langage de programmation purement fonctionnel qui compile les opérations d'architecture symbolique vectorielle en graphes de tenseurs PyTorch fusionnés, permettant aux programmes d'atteindre une précision de décodage parfaite sur divers substrats d'incrustation figés et d'être entraînés par rétropropagation tout en restant entièrement lisibles et recompilables sous forme de code source.

L'essentiel

Imaginez que vous possédiez une immense bibliothèque de connaissances gelée. Dans cette bibliothèque, chaque concept (comme « pomme », « justice » ou « protéine ») n'est pas un mot sur une page, mais une couleur ou une forme unique et multidimensionnelle. Cette bibliothèque est construite par une intelligence artificielle géante qui a lu l'internet entier, et elle est « gelée », ce qui signifie que les couleurs et les formes ne changent jamais une fois la bibliothèque construite.

Le problème est le suivant : comment faire des mathématiques ou de la logique avec ces couleurs ? Si vous essayez de les mélanger en utilisant des règles standard (comme le « produit de Hadamard » mentionné dans l'article), les couleurs deviennent troubles et vous ne pouvez plus les distinguer. C'est comme essayer de mélanger du rouge et du bleu pour obtenir du violet, mais au lieu de cela, vous obtenez simplement un marron boueux qui ressemble à toutes les autres couleurs de la pièce.

Sutra est un nouvel outil qui résout ce problème. C'est un langage de programmation qui vous permet d'écrire des règles logiques, mais au lieu de s'exécuter sur un processeur d'ordinateur normal, il compile ces règles en une seule machine ultra-efficace qui opère directement sur ces « couleurs » (vecteurs) à l'intérieur de la bibliothèque gelée.

Voici comment Sutra fonctionne, décomposé en concepts simples :

1. La « Rotation Magique » (Liaison)

Dans l'ancienne façon de faire cela, mélanger deux concepts revenait à les écraser ensemble, ce qui créait un désordre. Sutra utilise une astuce appelée Liaison par Rotation.

• L'analogie : Imaginez que chaque concept possède une « clé » unique (un rôle). Pour attacher un détail spécifique (un « remplisseur ») à cette clé, Sutra ne les écrase pas ; il fait tourner le détail comme une clé dans une serrure.
• Pourquoi cela fonctionne : Parce que la bibliothèque est gelée et que la rotation est mathématiquement parfaite, vous pouvez toujours tourner la clé en sens inverse pour récupérer le détail original, même si vous l'avez mélangé avec d'autres détails. L'article prouve que cela fonctionne parfaitement sur du texte et même sur des séquences de protéines (biologie), alors que l'ancienne méthode d'« écrasement » échouait complètement.

2. La « Logique Fluide » (Mathématiques Floues)

Habituellement, les ordinateurs pensent en interrupteurs stricts « Oui/Non » ou « Marche/Arrêt ». Mais les « couleurs » de la bibliothèque ne sont pas parfaites ; elles sont un peu floues.

• L'analogie : Imaginez un gradateur au lieu d'un interrupteur lumineux. Sutra utilise un type spécial de mathématiques (des polynômes) qui traite la logique comme un curseur fluide. Il peut gérer « Peut-être » (0), « Vrai » (+1) et « Faux » (-1) sans se briser.
• La magie : L'article montre que Sutra transforme ces règles de logique floue en une seule formule mathématique fluide. Cela signifie qu'un ordinateur peut non seulement exécuter la logique, mais aussi apprendre d'elle.

3. La « Machine en Une Étape » (Compilation)

Normalement, si vous écrivez un programme avec des boucles (étapes répétées) ou des décisions « si-alors », l'ordinateur doit vérifier ces règles une par une, ce qui est lent.

• L'analogie : Sutra est comme un chef étoilé qui prend votre recette (le programme) et pré-cuit tout le repas en un seul bloc prêt à être mangé avant même que vous ne vous asseyiez.
• Le résultat : Lorsque vous exécutez le programme, il n'y a pas de vérifications « si » ou de boucles « tant que » en temps réel. L'ordinateur effectue simplement un flux mathématique géant et continu. C'est comme un train qui ne s'arrête jamais aux gares ; il glisse simplement du début à la fin.

4. Apprentissage et Code « Lisible »

L'une des choses les plus surprenantes que fait Sutra est d'apprendre.

• L'analogie : Habituellement, lorsqu'un réseau de neurones apprend, il devient une « boîte noire » — un amas de nombres qu'aucun humain ne peut lire. Sutra est différent. Il peut ajuster un seul nombre (un « gain » ou un bouton de volume) pour améliorer le fonctionnement de la logique.
• La surprise : Après que l'ordinateur a trouvé le réglage parfait pour ce bouton, Sutra prend ce nombre et l'écrit de nouveau dans le code original sous forme d'un nombre simple.
• Pourquoi cela compte : Vous n'obtenez pas une boîte noire mystérieuse ; vous obtenez un programme propre et lisible qui dit : « Faites cette logique, mais multipliez le résultat par 1,43 ». Le modèle entraîné reste un texte lisible par l'humain.

5. Le « Dictionnaire » (Codebook)

Puisque l'ordinateur ne comprend que les « couleurs » (vecteurs), comment parle-t-il aux humains ?

• L'analogie : Sutra transporte un dictionnaire intégré (un codebook). Lorsque vous tapez un mot comme « pomme », le compilateur le traduit instantanément en sa « couleur » avant que le programme ne commence. Lorsque le programme se termine, il examine la « couleur » résultante et trouve le mot le plus proche dans le dictionnaire pour vous renvoyer une réponse lisible par l'humain.

Ce que l'article a réellement prouvé

L'article ne prétend pas que Sutra peut guérir des maladies ou prédire le marché boursier pour l'instant. Il prouve trois choses spécifiques :

1. Il fonctionne sur différentes bibliothèques : Il a exécuté avec succès le même programme logique sur du texte (comme des livres) et sur de la biologie (comme des protéines) sans modifier le code.
2. Il bat les anciennes méthodes : Sur ces bibliothèques gelées, la méthode de « rotation » de Sutra pouvait récupérer des informations avec une précision de 100 %, tandis que l'ancienne méthode d'« écrasement » échouait lamentablement (tombant à un niveau proche du hasard).
3. Il peut apprendre et rester lisible : Ils ont entraîné un classifieur simple (un programme qui trie les mots en catégories) à partir de zéro. Il a commencé par des suppositions aléatoires, a appris à atteindre 100 % de précision, et le résultat final était un morceau de code propre et lisible avec un nombre spécifique intégré.

En bref, Sutra est un pont qui nous permet d'écrire des règles logiques qui s'exécutent directement à l'intérieur des « cerveaux gelés » de l'IA moderne, les transformant en machines rapides, apprenantes et lisibles par l'humain.

Résumé technique

Résumé technique : Sutra : Les RNN à opérations tensorielles comme cible de compilation pour les architectures symboliques vectorielles

Énoncé du problème

Les architectures symboliques vectorielles (VSA) reposent traditionnellement sur des vecteurs de haute dimension issus de distributions aléatoires contrôlées, utilisant des opérations telles que le produit de Hadamard (multiplication élément par élément) ou la convolution circulaire pour la liaison. Cependant, les embeddings modernes de modèles de langage (LLM) « figés » ne respectent pas ces hypothèses. Ils sont anisotropes, se concentrant dans des cônes étroits au sein de l'espace vectoriel, ce qui comprime la similarité cosinus et entraîne l'échec des opérations de liaison standard (comme Hadamard) en raison d'un diaphonie destructrice lors du regroupement de plusieurs éléments.

De plus, les systèmes neuro-symboliques existants suivent souvent une architecture en deux étapes : un modèle neuronal extrait des symboles discrets, qui sont ensuite traités par un raisonneur symbolique séparé. Cela crée une rupture entre l'espace d'embedding continu et la couche de logique discrète. Il manque un système qui traite l'espace d'embedding continu comme le substrat principal d'un langage de programmation complet, où le flux de contrôle, la logique et les E/S sont tous compilés dans un seul graphe d'opérations tensorielles différentiable.

Méthodologie

L'article présente Sutra, un langage de programmation typé et purement fonctionnel conçu spécifiquement pour compiler vers un réseau neuronal PyTorch opérant sur un substrat d'embedding figé. La méthodologie centrale repose sur quatre primitives consolidées qui remplacent les opérations VSA standard et les mécanismes de flux de contrôle :

1. Logique floue polynomiale : Au lieu des opérateurs min/max non différentiables (t-normes de Gödel) utilisés dans la logique floue standard, Sutra emploie des polynômes interpolés de Lagrange pour la logique trivalente de Kleene (valeurs de vérité : $+1, 0, -1$). Ces polynômes sont exacts sur la grille discrète $\{-1, 0, +1\}$ mais sont $C^\infty$ (lisses) ailleurs, permettant le flux de gradient à travers les connecteurs logiques (ET, OU, NON) au sein d'un graphe tensoriel.
2. Réduction bêta vers des graphes tensoriels : Le compilateur Sutra effectue une réduction bêta agressive, intégrant les définitions de la bibliothèque standard et simplifiant les expressions algébriques. Le résultat est un graphe d'opérations tensorielles pur au substrat ne contenant aucune liaison nommée, aucun appel de fonction ni aucun flux de contrôle Python. Les conditionnels sont abaissés vers des polynômes de soft-mux, et les boucles sont compilées en cellules RNN à arrêt doux.
3. Liaison par rotation : Pour répondre à l'anisotropie des embeddings de LLM figés, Sutra remplace le produit de Hadamard par une liaison par rotation orthogonale de Haar. Une matrice orthogonale spécifique au rôle $R_{role}$ est générée via un hachage de contenu et appliquée au vecteur remplisseur ($bind(role, filler) = R_{role} \times filler$). Cette opération est inversible et bien conditionnée même sur des substrats anisotropes.
4. Boucles récursives terminales comme RNN : Les boucles sont exprimées sous forme de déclarations de fonctions récursives terminales. Le compilateur les abaisse en cellules RNN à arrêt doux où le vecteur d'état est de largeur fixe. Un signal d'« arrêt » est calculé via une somme monotone cumulative d'une condition de Heaviside, permettant à la boucle de figer l'état sans branchement au niveau Python.

Le système utilise un livre de codes au moment de la compilation (stocké dans un fichier .sdb) pour mapper les littéraux de chaînes vers des embeddings et décoder les chaînes du plus proche voisin à la sortie, bouclant ainsi les E/S de chaînes sans nécessiter de recherches dans un dictionnaire côté hôte pendant le passage avant.

Contributions clés

L'article présente quatre contributions techniques spécifiques :

1. Logique différentiable par interpolation de Lagrange : La dérivation de connecteurs polynomiaux exacts sur la grille de Kleene mais différentiables partout ailleurs, résolvant les problèmes de flux de gradient associés aux opérateurs de logique floue standard dans les contextes neuro-symboliques.
2. Compilation pure au substrat : Un pipeline de compilateur qui réduit un langage fonctionnel de haut niveau en un seul graphe tensoriel fusionné (multiplication matricielle, élément par élément, non linéaire) sans flux de contrôle côté hôte, garantissant que l'ensemble du programme est une fonction différentiable de ses entrées et de ses paramètres apprenables.
3. Liaison par rotation pour les substrats anisotropes : Validation empirique montrant que la liaison par rotation surpasse la liaison de Hadamard sur les embeddings de LLM figés (modèles de texte et de protéines), maintenant une précision de décodage de 100 % pour des largeurs de regroupement où la liaison de Hadamard s'effondre vers des niveaux de hasard.
4. Modèles entraînés lisibles et recompileables : Une démonstration montrant que les paramètres entraînés (spécifiquement des gains scalaires) peuvent être intégrés dans le code source sous forme de littéraux numériques. Cela permet de représenter un modèle entraîné non pas comme un point de contrôle opaque, mais comme un programme Sutra lisibles par l'homme et recompileable qui reproduit le comportement entraîné avec une grande précision.

Résultats

L'article valide l'approche à travers deux axes expérimentaux principaux :

• Capacité inter-substrat : Des expériences ont été menées sur quatre substrats figés : trois encodeurs de texte (nomic-embed-text, all-minilm, mxbai-embed-large) et un modèle de langage de protéines (ESM-2).

  • Liaison par rotation : A atteint une précision de 100 % dans le décodage d'enregistrements regroupés à une largeur $k=8$ sur tous les substrats.
  • Liaison de Hadamard : S'est effondrée de manière significative, la précision chutant à 2,5 % sur mxbai-embed-large et 7,5 % sur all-minilm à la même largeur.
  • Accumulation de bruit : La précision est restée à 100 % pour les enregistrements à cycle unique mais s'est dégradée vers des niveaux de hasard à une longueur de chaîne $L=8$, définissant le régime validé pour l'implémentation actuelle.

• Entraînement différentiable de bout en bout :

  • Un classificateur à règles floues écrit en Sutra a été entraîné à partir d'une initialisation aléatoire (précision $\approx 18,7\%$, hasard $= 20\%$) jusqu'à 100,0 % de précision sur 30 époques en utilisant la rétropropagation standard de PyTorch.
  • Il a été vérifié que les gradients circulaient à travers le graphe tensoriel compilé (similarité $\to$ polynômes Lagrange-Kleene $\to$ entropie croisée) sans réimplémentation.
  • Une variante pondérée a entraîné un gain scalaire $w$ pour contrer l'anisotropie des embeddings. Le modèle entraîné a été « cuit » avec succès dans le code source (par exemple 1.431431 * similarity(...)), et la recompilation de ce code source a reproduit les logits entraînés avec une différence maximale d'environ $2 \times 10^{-7}$.

Signification et revendications

L'article revendique que Sutra représente une position novatrice dans le paysage du calcul neuro-symbolique et de la programmation différentiable. Sa signification réside dans l'unification de la logique et de l'apprentissage au sein d'un seul artefact :

• Forme de l'artefact : Contrairement aux bibliothèques (par exemple TorchHD) qui exposent des primitives aux scripts Python, ou aux langages neuro-symboliques (par exemple Scallop, DeepProbLog) qui séparent la perception du raisonnement, Sutra compile l'ensemble du programme, y compris le flux de contrôle et les E/S de chaînes, en un seul graphe d'opérations tensorielles fusionné.
• Agnosticisme du substrat : L'architecture n'est pas liée à un modèle d'embedding spécifique ; elle peut cibler n'importe quel réseau produisant des représentations vectorielles denses, comme le démontre le portage réussi du même code source vers des embeddings de texte et de protéines.
• Lisibilité : En entraînant des paramètres qui peuvent être réécrits sous forme de littéraux source, le système comble le fossé entre les poids neuronaux boîte noire et les programmes logiques interprétables. Le modèle entraîné n'est pas un « blob » mais un programme recompileable.

Les auteurs déclarent explicitement que ce travail est une vérification de l'« aller-retour d'entraînement à partir du source » et du flux de gradient à travers le graphe compilé, plutôt qu'un benchmark de généralisation par rapport à d'autres systèmes. Le système est actuellement limité aux enregistrements à cycle unique et à des substrats figés spécifiques, les enregistrements imbriqués profonds et les modèles d'embedding arbitraires étant identifiés comme des travaux futurs.