L'agrégation sécurisée
Pourquoi c'est important Une appli de sport veut le total des pas faits dans une ville ; un fabricant de claviers veut savoir à quelle fréquence un mot est tapé sur tous les téléphones. Dans chaque cas, l'entreprise a besoin d'un seul nombre venant de beaucoup d'appareils. L'agrégation sécurisée lui permet d'apprendre ce total sans jamais voir la valeur d'une personne donnée, et c'est étonnamment simple.
De la crypto pédagogique, pas sûre : les nombres des labos de ce module sont assez petits pour être lus et l'aléatoire a une graine pour que la notation soit reproductible. Les vrais systèmes utilisent des bibliothèques éprouvées et des nombres bien plus grands. Ne copie jamais du code pédagogique dans un produit.
L'astuce des salaires
Trois amis veulent leur salaire moyen sans que personne ne révèle le sien. La première ajoute un grand nombre aléatoire à son salaire et chuchote le résultat au deuxième. Il ajoute son salaire et chuchote à la suite. La troisième ajoute le sien et le renvoie. La première soustrait son nombre aléatoire, et le total en sort. Chaque chuchotement ressemblait à un nombre aléatoire pour celui qui l'entendait.
Agrégation sécurisée : calculer un total (ou une moyenne) des valeurs de beaucoup de gens de façon qu'aucune valeur ne soit révélée à personne, y compris au serveur qui les collecte.
Partage de secret additif : couper un nombre secret en plusieurs parts qui ont l'air aléatoires seules mais dont la somme vaut le secret. N'importe quelle part seule, ou n'importe quel groupe auquel il manque au moins une part, ne révèle rien du secret.
Comment marchent les parts
Pour couper le nombre 7 350 en trois parts, choisis deux nombres aléatoires et choisis la troisième pour que les trois aient une somme de 7 350. Avec une arithmétique qui fait le tour (le modulo M, ici 2 puissance 32, un peu plus de 4 milliards), chaque part est seule un nombre aléatoire uniforme :
M = 2 ** 32
s1, s2 = 3919211450, 120775123 # random
s3 = (7350 - s1 - s2) % M # whatever makes it add up
print((s1 + s2 + s3) % M) # 7350
Pourquoi faire le tour ? Sans ça, une part serait parfois négative ou étrangement proche du secret. Avec, chaque valeur de part a autant de chances quel que soit le secret, donc une part seule ne porte aucune information.
Beaucoup d'appareils, plusieurs serveurs
Maintenant, chaque téléphone coupe son nombre de pas en une part par serveur et envoie la part 1 au serveur 1, la part 2 au serveur 2, et ainsi de suite. Chaque serveur additionne les parts qu'il a reçues. Le total de chaque serveur a encore l'air aléatoire. Ce n'est qu'en additionnant les totaux des serveurs que le vrai total de la ville apparaît. Tant que les serveurs ne mettent pas en commun leurs parts brutes pour un téléphone, la valeur d'aucun téléphone n'est jamais vue.
La version du monde réel
Les systèmes utilisés pour entraîner des modèles sur beaucoup de téléphones (ce qu'on appelle l'apprentissage fédéré) utilisent une variante plus astucieuse avec un seul serveur : des paires d'appareils s'accordent sur des masques aléatoires qui s'annulent quand tout est additionné, plus des étapes supplémentaires pour gérer les téléphones qui se déconnectent en cours de route. L'idée de base est celle que tu vas construire : des morceaux d'apparence aléatoire qui n'ont de sens qu'ensemble.
Ce que l'agrégation sécurisée ne fait pas
Le total est révélé exactement. Si seulement deux personnes ont contribué et que l'une connaît sa propre valeur, elle peut la soustraire et apprendre celle de l'autre. Si le total lui-même est sensible, ajoute-lui aussi un bruit de confidentialité différentielle. Les deux outils marchent bien ensemble : l'agrégation cache les entrées, la DP cache l'effet de chaque personne sur le résultat.
Dans d'autres langages
Le découpage en JavaScript, avec un tour sur 32 bits par >>> 0 et la source aléatoire sûre du navigateur :
function split(value, n) {
const shares = Array.from(crypto.getRandomValues(new Uint32Array(n - 1)));
const sum = shares.reduce((a, b) => (a + b) >>> 0, 0);
shares.push((value - sum) >>> 0);
return shares;
}Et en Rust, où wrapping_sub sur un u32 fait le tour pour toi :
let last = value.wrapping_sub(shares.iter().fold(0u32, |a, &b| a.wrapping_add(b)));Récap
- L'agrégation sécurisée révèle un total mais aucune contribution individuelle.
- Le partage de secret additif coupe une valeur en parts d'apparence aléatoire dont la somme la redonne, avec une arithmétique qui fait le tour.
- Chaque serveur ne voit que des parts d'apparence aléatoire ; seuls tous les totaux des serveurs ensemble donnent la réponse.
- Le total lui-même est révélé exactement, donc associe-le à un bruit de DP quand le total pourrait exposer quelqu'un.
Écris trois fonctions, avec M (2 puissance 32) du monde d'entraînement. split(value, n, rng) renvoie une liste de n parts : les n - 1 premières venant de rng.randrange(M), la dernière égale à (value - sum(shares)) % M. combine(shares) renvoie sum(shares) % M. aggregate(values, n_servers, rng) coupe chaque valeur avec split, ajoute la part j à server_totals[j] (modulo M), et renvoie un tuple (total, server_totals) où total = combine(server_totals).
Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon
Cet exercice s'ouvre bientôt
Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.
Ce navigateur bloque les cookies pour learn.floati.life, donc les leçons que tu as terminées ici ne peuvent pas s'ouvrir dans l'ordre. Autorise les cookies pour ce site et recharge la page.