🤖 AI

FuseFSS: Efficient Secure LLM Inference with Function Secret Sharing

FuseFSS est un compilateur qui rationalise l'inférence sécurisée des LLM en remplaçant les protocoles sur mesure par opérateur par un pipeline unifié pour les non-linéarités en virgule fixe, réalisant ainsi des accélérations significatives et une réduction de la communication et des surcoûts de prétraitement tout en maintenant la précision.

Auteurs originaux : Yuhan Ma, Yong Li, Stefan Schmid

Publié 2026-06-09

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Yuhan Ma, Yong Li, Stefan Schmid

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous vouliez poser une question secrète à une IA super intelligente (un modèle de langage étendu), comme un diagnostic médical privé ou une stratégie commerciale confidentielle. Vous ne voulez pas que le propriétaire de l'IA voie votre question, et vous ne voulez pas que l'IA vous révèle son « cerveau » (le modèle).

Pour résoudre cela, les chercheurs utilisent une astuce à « deux serveurs ». Ils divisent le secret entre deux serveurs qui ne communiquent pas entre eux. Aucun des deux serveurs ne connaît l'image complète, mais ensemble, ils peuvent calculer la réponse. C'est comme deux chefs travaillant dans des cuisines séparées ; ils ne peuvent pas voir les ingrédients de l'autre, mais ils peuvent combiner leur travail pour cuire un gâteau sans jamais révéler la recette ni l'ingrédient secret.

Cependant, il y a un problème. Bien que les parties mathématiques « faciles » (comme l'addition de nombres) soient rapides en ce mode secret, les parties « difficiles » (comme décider si un nombre est positif ou négatif, ou arrondir des décimales) sont lentes et laborieuses. Actuellement, les ingénieurs doivent construire une machine sur mesure et unique pour chaque étape mathématique difficile. C'est comme devoir fabriquer une clé à molette personnalisée pour chaque vis d'une voiture. C'est coûteux, lent et facile à casser.

Entrez en scène, FuseFSS.

Les auteurs de cet article ont construit un compilateur (un traducteur) appelé FuseFSS. Au lieu de fabriquer une clé à molette sur mesure pour chaque vis, FuseFSS dit : « Utilisons seulement deux outils universels pour toutes les étapes mathématiques difficiles. »

Voici comment cela fonctionne, en utilisant une analogie simple :

L'analogie de l'« Enveloppe Masquée »

Imaginez que vous avez un nombre secret, mais que vous ne pouvez pas le montrer directement. Vous le placez donc dans une enveloppe avec un morceau de papier aléatoire (un « masque ») et vous la remettez aux serveurs. Les serveurs peuvent voir le poids total de l'enveloppe (la « valeur masquée »), mais ils ne connaissent ni votre nombre secret, ni le papier aléatoire à l'intérieur.

Dans l'ancienne méthode (le système « Sigma »), chaque fois que les serveurs avaient besoin d'une astuce mathématique complexe (comme « ce nombre est-il supérieur à 5 ? »), ils devaient ouvrir une boîte de protocole spécifique et construite sur mesure pour cette seule question.

FuseFSS change la donne :

Une Spécification : Les auteurs ont créé un « manuel d'instructions » standard pour toute astuce mathématique. Ils décrivent l'astuce comme un ensemble de zones (intervalles) et de formules simples.
Deux Outils Magiques : Au lieu de construire de nouvelles boîtes, FuseFSS utilise seulement deux outils standards pour chaque astuce :
- L'Outil A (Le Comparateur) : Il vérifie toutes les questions de type « Est-ce plus grand que X ? » en une seule fois et donne aux serveurs une liste de réponses « Oui/Non » (partagées secrètement).
- L'Outil B (La Recherche/Lookup) : Il agit comme un distributeur automatique. En se basant sur les réponses de l'Outil A, il transmet instantanément les nombres et les formules nécessaires pour terminer le calcul.
Le Résultat : Les serveurs font le calcul, puis soustraient le papier aléatoire (le masque) pour révéler la réponse finale.

Pourquoi est-ce important ?

L'article affirme qu'en passant des « clés à molettes personnalisées » à ces « deux outils universels », ils ont rendu le processus nettement plus rapide et plus léger.

Vitesse : Ils ont rendu l'ensemble du processus 1,24 à 1,5 fois plus rapide. Si un calcul prenait autrefois 10 secondes, il en prend désormais environ 7.
Moins de communication : Les deux serveurs doivent envoyer moins de données d'un côté à l'autre (environ 9 % à 16 % de moins).
Moins de configuration : Avant même de commencer, ils doivent générer certaines « clés » (comme installer les verrous sur les enveloppes). FuseFSS rend cette configuration 14 % à 23 % plus rapide et les clés elles-mêmes sont 20 % à 24 % plus petites.

L'essentiel

L'article ne prétend pas avoir inventé un nouveau type d'IA ou une nouvelle façon de prédire le marché boursier. Il prétend simplement avoir construit un meilleur « moteur » pour faire fonctionner les modèles d'IA existants de manière sécurisée.

Ils ont testé cela sur des modèles d'IA populaires (comme BERT et GPT) et ont constaté que cela fonctionne aussi précisément que les anciennes méthodes, mais que cela tourne beaucoup plus fluidement. C'est comme améliorer le moteur d'une voiture : la voiture va à la même vitesse et transporte les mêmes passagers, mais elle consomme moins de carburant et accélère plus vite parce que le moteur est conçu plus efficacement.

En bref : FuseFSS est un compilateur qui transforme un processus désordonné et sur mesure pour les mathématiques d'IA secrètes en une routine propre, standardisée et beaucoup plus rapide utilisant seulement deux outils puissants et réutilisables.

Résumé technique : FuseFSS

Énoncé du problème

Dans l'inférence sécurisée pour les grands modèles de langage (LLM) à deux serveurs, les clients peuvent interroger des modèles hébergés sans révéler leurs prompts ou leurs plongements (embeddings) en partageant secrètement les entrées entre des serveurs non collusoires. Bien que les systèmes récents basés sur les GPU utilisant le Partage de Fonctions Secrètes (FSS - Function Secret Sharing) aient rendu les couches linéaires efficaces, des goulots d'étranglement importants subsistent dans les non-linéarités à virgule fixe (par exemple, les activations comme GELU, les composantes de Softmax) et les opérations de mise à l'échelle (rescaling).

Les systèmes de pointe actuels (par exemple, Sigma) reposent sur des protocoles spécifiques par opérateur. Chaque opérateur nécessite une implémentation personnalisée impliquant des comparaisons spécifiques, des corrections de dépassement (wrap-around) et du matériel de pré-traitement. Cette approche est fragile : elle complique les preuves de correction, duplique la logique de génération de clés et rend l'ajout de nouveaux opérateurs difficile sans introduire des bogues subtils liés au dépassement modulo- $2^n$ ou à la signature. De plus, ces protocoles personnalisés entraînent souvent une surcharge de communication en ligne élevée et des coûts de pré-traitement lourds (temps et taille de génération de clés).

Méthodologie : FuseFSS

Les auteurs présentent FuseFSS, un compilateur qui remplace l'ingénierie de protocoles par opérateur par un pipeline de compilation uniforme et adapté aux GPU. L'idée centrale est qu'à travers les non-linéarités communes à virgule fixe, la logique dépendante des données suit un schéma similaire : la sélection d'une région à l'aide d'un petit ensemble de bits de prédicat, puis l'application d'une forme arithmétique de faible degré avec un petit nombre de constantes.

1. Spécifications d'opérateur

FuseFSS introduit une spécification d'opérateur typée qui sert de représentation intermédiaire (IR) pour les opérateurs à virgule fixe élément par élément. Une spécification définit :

Partition d'intervalle : Une partition complète des représentants canoniques de $\mathbb{Z}_{2^n}$ en intervalles $I_i = [\alpha_i, \alpha_{i+1})$ .
Pièces arithmétiques : Pour chaque intervalle, un vecteur de polynômes de faible degré $P_i(x)$ pour calculer la sortie arithmétique.
Bits de prédicat : Des formules booléennes $B_i(x)$ construites à partir de prédicats primitifs (par exemple, $x < \beta$ ) pour déterminer quel intervalle est actif.

2. Compilation sensible au masque (Mask-Aware)

Le compilateur traduit ces spécifications en un protocole uniforme qui opère sur une valeur masquée publique $\hat{x} = x + r_{in} \pmod{2^n}$ , où $r_{in}$ est un masque frais partagé secrètement, échantillonné lors du pré-traitement.

Réécriture de prédicat : Le compilateur réécrit les prédicats sur l'entrée secrète $x$ en comparaisons sur la valeur publique $\hat{x}$ , en utilisant les bits de retenue (carry bits) partagés secrètement dérivés du masque $r_{in}$ pour gérer correctement le dépassement modulo.
Structure uniforme : Quel que soit l'opérateur, le compilateur émet exactement deux évaluations FSS standard sur la valeur publique $\hat{x}$ $\overset{x}{^}$ :
1. Comparaison packée : Une évaluation unique retournant les parts XOR de tous les bits de prédicat requis (indicateurs d'intervalle).
2. Recherche d'intervalle vectorielle : Une évaluation unique retournant les parts additives des coefficients et des constantes du polynôme pour l'intervalle sélectionné.

3. Post-traitement

Le calcul restant est un circuit de post-traitement fixe basé sur les parts. Cela inclut :

Règle de Horner : L'évaluation du polynôme de faible degré sélectionné sur les parts secrètes de $x$ (dérivées localement de $\hat{x}$ et $r_{in}$ ) en utilisant des triplets de Beaver.
Opérations auxiliaires : L'application de la logique booléenne (XOR, AND) et des conversions de domaines mixtes (B2A/A2B) pour combiner les résultats arithmétiques et booléens.
Portes compatibles avec la spécification : Pour les opérations qui ne peuvent pas être purement polynomiales (par exemple, troncature, décalages arithmétiques à droite), le compilateur ajoute un circuit de post-traitement déterministe $\Phi$ qui prend la sortie polynomiale et les constantes dérivées du masque pour produire le résultat final.

4. Sécurité et fuite

FuseFSS respecte la sémantique des fils masqués (masked-wire semantics), garantissant des masques indépendants et frais par fil. Crucialement, le compilateur impose des formes publiques indépendantes du masque. Le nombre de comparaisons, la largeur des bits et les dimensions de recherche d'intervalle dépendent uniquement de la spécification de l'opérateur publique et des métadonnées de virgule fixe, et non des masques échantillonnés. Cela empêche la fuite d'informations secrètes via la taille des clés ou les formes d'instances. Le modèle de sécurité suppose un adversaire semi-honnête dans un contexte de pré-traitement à deux serveurs.

Contributions clés

Performance de pointe : FuseFSS atteint les meilleures performances rapportées pour l'inférence sécurisée basée sur FSS sur des modèles de type BERT et GPT, améliorant la latence et réduisant les coûts de pré-traitement tout en maintenant la précision du modèle.
Cible de compilateur pratique : Il démontre qu'un large éventail d'opérateurs scalaires à virgule fixe peut être unifié sous un format de spécification unique, exécuté via deux appels FSS standards plus un post-traitement uniforme, éliminant ainsi le besoin de conception de protocoles sur mesure.
Compilation sensible au masque avec sécurité : Le système dérive des évaluations de prédicat correctes à partir d'entrées publiques masquées tout en imposant l'invariance de forme, permettant une preuve de correction unifiée et de sécurité semi-honnête pour différents opérateurs.

Résultats expérimentaux

Les auteurs ont évalué FuseFSS par rapport à Sigma, la solution de référence actuelle basée sur FSS, sur des modèles de type BERT et GPT (incluant BERT-tiny/base/large, GPT-2 et GPT-Neo) avec une longueur de séquence de 128 et une taille de lot (batch size) de 1.

Accélération de bout en bout : FuseFSS atteint une accélération de la latence en ligne de 1,24×–1,50×. Par exemple, le temps d'inférence de BERT-base-128 est passé de 1613,80 ms (Sigma) à 1149,50 ms (FuseFSS), soit une réduction de 28,8 %.
Réduction de la communication : La communication en ligne est réduite de 9 %–16 %.
Efficacité du pré-traitement :
- Temps de génération de clés : Réduit de 14 %–23 %.
- Taille de clé : Réduite de 20 %–24 %.
Scalabilité : L'accélération reste constante (1,36×–1,45×) lorsque la longueur de la séquence augmente de 32 à 512.
Attribution : Les gains sont principalement portés par l'accélération des blocs scalaires non linéaires et auxiliaires (par exemple, GELU, composantes de Softmax), qui représentent la majorité de la latence dans la solution de base. Par exemple, le chemin compilé pour Softmax (nExp + réciproque) a vu une accélération de 4,5×–4,7×.

Signification et affirmations

L'article affirme que FuseFSS s'attaque au principal goulot d'étranglement de l'inférence sécurisée à deux serveurs : la complexité d'ingénierie et la surcharge de performance des non-linéarités à virgule fixe. En passant de protocoles spécifiques par opérateur à un pipeline de compilation uniforme, FuseFSS simplifie la conception du système, améliore les garanties de correction et réduit considérablement les coûts en ligne et hors ligne.

Les auteurs positionnent FuseFSS comme une solution pratique pour le déploiement de l'inférence de LLM préservant la confidentialité dans des contextes exigeant une forte confidentialité pour les prompts et les plongements (par exemple, la santé, la finance). Ils précisent explicitement que leur travail se concentre sur les non-linéarités scalaires ; les opérations au niveau des vecteurs (comme les réductions ou la sparsification de l'attention) restent en dehors de l'IR de spécification d'opérateur et sont gérées par des sous-protocoles MPC standards. L'analyse de sécurité est limitée au modèle semi-honnête avec deux serveurs non collusoires, reconnaissant que l'extension vers des modèles adverses plus forts est une direction future.