Utilisation de données chiffrées pour l'apprentissage automatique sans les déchiffrer

Utilisation de données chiffrées pour l'apprentissage automatique sans les déchiffrer
Cet article décrit les techniques cryptographiques avancées. Ceci est juste un aperçu des recherches menées par Julia Computing. N'utilisez pas les exemples donnés ici dans les applications commerciales. Consultez toujours les cryptographes avant d'appliquer la cryptographie.

Ici, vous pouvez télécharger le package qui implémente toute la magie, et voici le code qui est discuté dans l'article.

Présentation

Supposons que vous venez de développer un nouveau modèle d'apprentissage automatique sympa (bien sûr, en utilisant Flux.jl ). Et maintenant, vous voulez commencer à le déployer pour vos utilisateurs. Comment allez-vous faire cela? Le moyen le plus simple est probablement de donner le modèle aux utilisateurs et de le laisser s'exécuter localement sur leurs données. Mais cette approche présente des inconvénients:

1. Les modèles d'apprentissage automatique sont volumineux et les ordinateurs des utilisateurs peuvent ne pas disposer de suffisamment de ressources informatiques ou disque.
2. Les modèles d'apprentissage automatique sont souvent mis à jour et il peut ne pas être pratique pour vous d'envoyer régulièrement de grandes quantités de données sur le réseau.
   
3. Le développement de modèles prend du temps et nécessite une grande quantité de ressources informatiques. Et vous voudrez peut-être une compensation sous forme de frais pour l'utilisation de votre modèle.

Ensuite, ils se souviennent généralement que le modèle peut être fourni dans le cloud via l'API. Au cours des dernières années, de nombreux services de ce type sont apparus; chaque grande plateforme cloud offre des services similaires aux développeurs d'entreprise. Mais les utilisateurs potentiels sont confrontés à un dilemme évident: désormais, leurs données sont traitées sur un serveur distant, qui peut ne pas être fiable. Cela a des implications éthiques et juridiques claires qui limitent l'utilisation de ces services. Dans les secteurs réglementés, notamment les soins de santé et les services financiers, il est souvent impossible d'envoyer des données sur les patients et les clients à des tiers pour traitement.

D'autres options?

Il s'avère que c'est le cas! Les découvertes récentes en cryptographie permettent de calculer avec des données sans les décoder . Par exemple, un utilisateur envoie des données chiffrées (par exemple, des images) à l'API cloud, qui lance un modèle d'apprentissage automatique, puis envoie une réponse chiffrée. À aucun moment, les données ne sont déchiffrées, le fournisseur de cloud n'a pas accès aux images sources et ne peut pas déchiffrer les prévisions calculées. Comment est-ce possible? Voyons l'exemple de la création d'un service de reconnaissance de l'écriture manuscrite sur des images chiffrées à partir de l'ensemble de données MNIST.

À propos du chiffrement homomorphe

La capacité d'effectuer des calculs avec des données chiffrées est communément appelée «informatique sécurisée». Il s'agit d'un vaste domaine de recherche, avec de nombreuses approches de la cryptographie en fonction de toutes sortes de scénarios d'application. Nous nous concentrerons sur une technique appelée «cryptage homomorphique». Dans un tel système, les opérations suivantes sont généralement disponibles pour nous:

• pub_key, eval_key, priv_key = keygen()
  
• encrypted = encrypt(pub_key, plaintext)
  
• decrypted = decrypt(priv_key, encrypted)
  
• encrypted′ = eval(eval_key, f, encrypted)
  

Les trois premières opérations sont simples et familières à tous ceux qui ont déjà utilisé des algorithmes de chiffrement asymétriques (par exemple, si vous vous êtes connecté via TLS). Toute magie opère lors de la dernière opération. Lors du chiffrement, il évalue la fonction f et renvoie une autre valeur chiffrée calculée en fonction du résultat de l'évaluation f sur la valeur chiffrée. Cette caractéristique a donné son nom à son approche. L'évaluation est liée à l'opération de chiffrement:

 f(decrypt(priv_key, encrypted)) == decrypt(priv_key, eval(eval_key, f, encrypted)) 

De même, en utilisant une valeur chiffrée, nous pouvons évaluer des homomorphismes arbitraires f .

Les fonctions f prises en charge dépendent des schémas cryptographiques et des opérations prises en charge. Si un seul f pris en charge (par exemple, f = + ), alors le circuit est appelé «partiellement homomorphe». Si f peut être un ensemble complet de passerelles, sur la base desquelles des schémas arbitraires peuvent être créés, alors pour une taille limitée du schéma, cela s'appelle un autre type de calcul partiellement homomorphe - "quelque peu homomorphique", et pour une taille illimitée - calcul "complètement homomorphique". Vous pouvez transformer "en quelque sorte" un cryptage complètement homomorphe en utilisant la technique d'amorçage, mais cela dépasse le cadre de notre article. Le cryptage entièrement homomorphe est une découverte relativement récente, le premier schéma de travail (bien que peu pratique) a été publié par Craig Gentry en 2009 . Il existe un certain nombre de schémas ultérieurs (et pratiques) complètement homomorphes. Il existe également des progiciels qui mettent en œuvre qualitativement ces schémas. Le plus souvent, ils utilisent Microsoft SEAL et PALISADE . De plus, j'ai récemment ouvert le code d'implémentation de ces algorithmes Pure Julia . Pour cet article, nous utiliserons le cryptage CKKS implémenté.

Présentation de CKS

CKKS (par les noms des auteurs de l' ouvrage scientifique Cheon-Kim-Kim-Song, qui a proposé l'algorithme en 2016) est un schéma de cryptage homomorphique qui permet une évaluation homomorphique des opérations primitives suivantes:

• L'addition élément par élément des longueurs de n vecteurs de nombres complexes.
  
• Multiplication par élément des longueurs de n vecteurs complexes.
  
• Faire pivoter (dans le contexte du circshift ) les éléments d'un vecteur.
  
• Appariement intégré des éléments vectoriels.
  

Le paramètre n dépend du niveau de sécurité et de précision souhaité et est généralement assez élevé. Dans notre exemple, il sera égal à 4096 (une valeur plus élevée augmente la sécurité, mais est également plus difficile dans les calculs, elle évolue approximativement comme n log n ).

De plus, les calculs utilisant CKKS sont bruyants . Par conséquent, les résultats sont approximatifs et il faut veiller à ce que les résultats soient évalués avec une précision suffisante pour ne pas affecter l'exactitude du résultat.

D'un autre côté, de telles restrictions ne sont pas inhabituelles pour les développeurs de packages d'apprentissage automatique. Des accélérateurs spéciaux comme le GPU fonctionnent également généralement avec des vecteurs numériques. De plus, pour de nombreux développeurs, les nombres à virgule flottante semblent parfois bruyants en raison de l'influence des algorithmes de sélection, du multithreading, etc. Je tiens à souligner que la principale différence ici est que les calculs arithmétiques avec des nombres à virgule flottante sont initialement déterministes, même si cela n'est pas évident en raison de la complexité de la mise en œuvre, bien que les primitives CKKS soient vraiment bruyantes. Mais cela permet peut-être aux utilisateurs de comprendre que le bruit n'est pas aussi effrayant qu'il n'y paraît.

Voyons maintenant comment vous pouvez effectuer ces opérations dans Julia (remarque: des paramètres très dangereux sont sélectionnés, avec ces opérations, nous n'illustrons que l'utilisation de la bibliothèque dans REPL).

 julia> using ToyFHE # Let's play with 8 element vectors julia> N = 8; # Choose some parameters - we'll talk about it later julia> ℛ = NegacyclicRing(2N, (40, 40, 40)) ℤ₁₃₂₉₂₂₇₉₉₇₅₆₈₀₈₁₄₅₇₄₀₂₇₀₁₂₀₇₁₀₄₂₄₈₂₅₇/(x¹⁶ + 1) # We'll use CKKS julia> params = CKKSParams(ℛ) CKKS parameters # We need to pick a scaling factor for a numbers - again we'll talk about that later julia> Tscale = FixedRational{2^40} FixedRational{1099511627776,T} where T # Let's start with a plain Vector of zeros julia> plain = CKKSEncoding{Tscale}(zero(ℛ)) 8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7: 0.0 + 0.0im 0.0 + 0.0im 0.0 + 0.0im 0.0 + 0.0im 0.0 + 0.0im 0.0 + 0.0im 0.0 + 0.0im 0.0 + 0.0im # Ok, we're ready to get started, but first we'll need some keys julia> kp = keygen(params) CKKS key pair julia> kp.priv CKKS private key julia> kp.pub CKKS public key # Alright, let's encrypt some things: julia> foreach(i->plain[i] = i+1, 0:7); plain 8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7: 1.0 + 0.0im 2.0 + 0.0im 3.0 + 0.0im 4.0 + 0.0im 5.0 + 0.0im 6.0 + 0.0im 7.0 + 0.0im 8.0 + 0.0im julia> c = encrypt(kp.pub, plain) CKKS ciphertext (length 2, encoding CKKSEncoding{FixedRational{1099511627776,T} where T}) # And decrypt it again julia> decrypt(kp.priv, c) 8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7: 0.9999999999995506 - 2.7335193113350057e-16im 1.9999999999989408 - 3.885780586188048e-16im 3.000000000000205 + 1.6772825551165524e-16im 4.000000000000538 - 3.885780586188048e-16im 4.999999999998865 + 8.382500573679615e-17im 6.000000000000185 + 4.996003610813204e-16im 7.000000000001043 - 2.0024593503998215e-16im 8.000000000000673 + 4.996003610813204e-16im # Note that we had some noise. Let's go through all the primitive operations we'll need: julia> decrypt(kp.priv, c+c) 8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7: 1.9999999999991012 - 5.467038622670011e-16im 3.9999999999978817 - 7.771561172376096e-16im 6.00000000000041 + 3.354565110233105e-16im 8.000000000001076 - 7.771561172376096e-16im 9.99999999999773 + 1.676500114735923e-16im 12.00000000000037 + 9.992007221626409e-16im 14.000000000002085 - 4.004918700799643e-16im 16.000000000001346 + 9.992007221626409e-16im julia> csq = c*c CKKS ciphertext (length 3, encoding CKKSEncoding{FixedRational{1208925819614629174706176,T} where T}) julia> decrypt(kp.priv, csq) 8-element CKKSEncoding{FixedRational{1208925819614629174706176,T} where T} with indices 0:7: 0.9999999999991012 - 2.350516767363621e-15im 3.9999999999957616 - 5.773159728050814e-15im 9.000000000001226 - 2.534464540987068e-15im 16.000000000004306 - 2.220446049250313e-15im 24.99999999998865 + 2.0903753311370056e-15im 36.00000000000222 + 4.884981308350689e-15im 49.000000000014595 + 1.0182491378134327e-15im 64.00000000001077 + 4.884981308350689e-15im 

Si simple! Un lecteur attentif peut remarquer que CSQ est légèrement différent du texte chiffré précédent. En particulier, le texte chiffré a une «longueur 3» et l'échelle est beaucoup plus grande. Une explication de ce que c'est et de ce qui est nécessaire dépasse le cadre de cet article. Il suffit de dire que nous devons baisser les valeurs avant de poursuivre les calculs, sinon le "lieu" se terminera dans le texte chiffré. Heureusement, nous pouvons réduire chacune des deux valeurs augmentées:

 # To get back down to length 2, we need to `keyswitch` (aka # relinerarize), which requires an evaluation key. Generating # this requires the private key. In a real application we would # have generated this up front and sent it along with the encrypted # data, but since we have the private key, we can just do it now. julia> ek = keygen(EvalMultKey, kp.priv) CKKS multiplication key julia> csq_length2 = keyswitch(ek, csq) CKKS ciphertext (length 2, encoding CKKSEncoding{FixedRational{1208925819614629174706176,T} where T}) # Getting the scale back down is done using modswitching. julia> csq_smaller = modswitch(csq_length2) CKKS ciphertext (length 2, encoding CKKSEncoding{FixedRational{1.099511626783e12,T} where T}) # And it still decrypts correctly (though note we've lost some precision) julia> decrypt(kp.priv, csq_smaller) 8-element CKKSEncoding{FixedRational{1.099511626783e12,T} where T} with indices 0:7: 0.9999999999802469 - 5.005163520332181e-11im 3.9999999999957723 - 1.0468514951188039e-11im 8.999999999998249 - 4.7588542623100616e-12im 16.000000000023014 - 1.0413447889166631e-11im 24.999999999955193 - 6.187833723406491e-12im 36.000000000002345 + 1.860733715346631e-13im 49.00000000001647 - 1.442396043149794e-12im 63.999999999988695 - 1.0722489563648028e-10im 

De plus, la commutation de modules (abréviation de commutation de module, commutation de module) réduit la taille du module de texte chiffré, nous ne pouvons donc pas continuer à le faire indéfiniment (nous utilisons un schéma de cryptage quelque peu homomorphique):

 julia> ℛ # Remember the ring we initially created ℤ₁₃₂₉₂₂₇₉₉₇₅₆₈₀₈₁₄₅₇₄₀₂₇₀₁₂₀₇₁₀₄₂₄₈₂₅₇/(x¹⁶ + 1) julia> ToyFHE.ring(csq_smaller) # It shrunk! ℤ₁₂₀₈₉₂₅₈₂₀₁₄₄₅₉₃₇₇₉₃₃₁₅₅₃/(x¹⁶ + 1)</code>     —  (rotations).      keyswitch,       (evaluation key,     ): <source lang="julia">julia> gk = keygen(GaloisKey, kp.priv; steps=2) CKKS galois key (element 25) julia> decrypt(circshift(c, gk)) decrypt(kp, circshift(c, gk)) 8-element CKKSEncoding{FixedRational{1099511627776,T} where T} with indices 0:7: 7.000000000001042 + 5.68459112632516e-16im 8.000000000000673 + 5.551115123125783e-17im 0.999999999999551 - 2.308655353580721e-16im 1.9999999999989408 + 2.7755575615628914e-16im 3.000000000000205 - 6.009767921608429e-16im 4.000000000000538 + 5.551115123125783e-17im 4.999999999998865 + 4.133860996136768e-17im 6.000000000000185 - 1.6653345369377348e-16im # And let's compare to doing the same on the plaintext julia> circshift(plain, 2) 8-element OffsetArray(::Array{Complex{Float64},1}, 0:7) with eltype Complex{Float64} with indices 0:7: 7.0 + 0.0im 8.0 + 0.0im 1.0 + 0.0im 2.0 + 0.0im 3.0 + 0.0im 4.0 + 0.0im 5.0 + 0.0im 6.0 + 0.0im 

Nous avons couvert les bases de l'utilisation de la bibliothèque HE. Mais avant de passer à l'utilisation de ces primitives pour calculer les prévisions du réseau de neurones, regardons le processus d'apprentissage.

Modèle d'apprentissage automatique

Si vous n'êtes pas familier avec l'apprentissage automatique ou la bibliothèque Flux.jl, je vous recommande de parcourir rapidement la documentation de Flux.jl ou de voir une introduction gratuite à l'apprentissage automatique , car nous ne discuterons que des modifications apportées à l'application du modèle aux données chiffrées.

Commençons par utiliser le réseau de neurones convolutifs du zoo Flux . Nous allons effectuer le même cycle de formation, avec la préparation des données et ainsi de suite, il suffit de configurer un peu le modèle. Le voici:

 function reshape_and_vcat(x) let y=reshape(x, 64, 4, size(x, 4)) vcat((y[:,i,:] for i=axes(y,2))...) end end model = Chain( # First convolution, operating upon a 28x28 image Conv((7, 7), 1=>4, stride=(3,3), x->x.^2), reshape_and_vcat, Dense(256, 64, x->x.^2), Dense(64, 10), ) 

Il s'agit du même modèle que dans le travail «Secure Outsourced Matrix Computation and Application to Neural Networks» , qui utilise le même schéma cryptographique avec deux différences: 1) pour des raisons de simplicité, nous n'avons pas chiffré le modèle lui-même, et 2) après chaque couche que nous avons Des vecteurs bayésiens sont utilisés (dans Flux, cela se fait par défaut), je ne sais pas ce que c'était dans le travail mentionné. Peut-être, en raison du deuxième point, la précision sur l'ensemble de test de notre modèle s'est avérée être légèrement plus élevée (98,6% contre 98,1%), mais des différences hyperparamétriques pourraient également être la raison.

L'activation des fonctions x.^2 est inhabituelle (pour ceux qui ont de l'expérience en apprentissage automatique). Le plus souvent, dans de tels cas, ils utilisent le tanh , le relu ou quelque chose de plus fantaisiste. Mais bien que ces fonctions (en particulier relu ) soient facilement calculées pour les valeurs de texte ordinaires, cependant, elles peuvent nécessiter beaucoup de ressources informatiques pour les évaluer sous forme cryptée (nous estimons généralement l'approximation polynomiale). Heureusement, dans ce cas, x.^2 fonctionne très bien.

Le reste du cycle d'apprentissage est resté le même. Nous avons supprimé softmax du modèle pour la fonction de perte de logitcrossentropy (vous pouvez le laisser et évaluer softmax après décryptage sur le client). Le code complet pour la formation du modèle se trouve sur GitHub , il s'exécute en quelques minutes sur n'importe quelle nouvelle carte vidéo.

Opérations efficaces

Nous savons maintenant quelles opérations nous devons effectuer:

• Coagulation.
  
• Élément au carré.
  
• Multiplication matricielle.
  

Avec la quadrature, tout est simple, nous l'avons déjà examiné ci-dessus, nous allons donc considérer deux autres opérations. Nous supposons que la longueur du paquet de données est de 64 (vous remarquerez peut-être que les paramètres du modèle et la taille du paquet sont choisis de manière à tirer parti du vecteur à 4096 éléments que nous avons obtenu à la suite d'un choix réaliste de paramètres).

La coagulation

Rappelez-vous comment fonctionne la coagulation. Prenez une fenêtre (dans notre cas 7x7) du tableau d'entrée d'origine, et chaque élément de fenêtre est multiplié par un élément de masque de convolution. Ensuite, nous déplaçons la fenêtre à une étape (dans notre cas, l'étape est 3, c'est-à-dire que nous déplaçons 3 éléments) et répétons le processus (avec le même masque de convolution). L'animation du processus ( source ) pour la convolution 3x3 avec l'étape (2, 2) montrée ci-dessous (tableau bleu - entrée, vert - sortie):


De plus, nous effectuons la convolution dans quatre «canaux» différents (c'est-à-dire que nous répétons la convolution 3 fois de plus avec des masques différents).

Maintenant que nous savons quoi faire, il reste à comprendre comment. Nous avons la chance que la convolution soit la première opération de notre modèle. Par conséquent, afin d'économiser des ressources, nous pouvons prétraiter les données sur le client, puis les chiffrer (sans utiliser de poids). Faisons ça:

• Tout d'abord, nous calculons chaque fenêtre de convolution (c'est-à-dire un échantillon 7x7 à partir des images source), ce qui nous donne 64 matrices 7x7 pour chaque image d'entrée. Notez que pour une fenêtre 7x7 par incréments de 2, il y aura des fenêtres de convolution 8x8 pour évaluer l'image d'entrée 28x28.
  
• Collectons dans un vecteur les mêmes positions dans chaque fenêtre. Autrement dit, pour chaque image, nous aurons un vecteur à 64 éléments, ou un vecteur d'éléments 64x64 pour un paquet de taille 64 (un total de 49 matrices 64x64).
  
• Nous crypterons.
  

La coagulation se transforme alors simplement en une multiplication scalaire de la matrice entière avec l'élément de masque correspondant. Et en résumant plus tard les 49 éléments, nous obtenons le résultat du pliage. Voici à quoi pourrait ressembler la mise en œuvre de cette stratégie (en texte brut):

 function public_preprocess(batch) ka = OffsetArray(0:7, 0:7) # Create feature extracted matrix I = [[batch[i′*3 .+ (1:7), j′*3 .+ (1:7), 1, k] for i′=ka, j′=ka] for k = 1:64] # Reshape into the ciphertext Iᵢⱼ = [[I[k][l...][i,j] for k=1:64, l=product(ka, ka)] for i=1:7, j=1:7] end Iᵢⱼ = public_preprocess(batch) # Evaluate the convolution weights = model.layers[1].weight conv_weights = reverse(reverse(weights, dims=1), dims=2) conved = [sum(Iᵢⱼ[i,j]*conv_weights[i,j,1,channel] for i=1:7, j=1:7) for channel = 1:4] conved = map(((x,b),)->x .+ b, zip(conved, model.layers[1].bias)) 

Ce (module pour changer la dimension) (modulo - changer l'ordre des tailles) donne la même réponse que l'opération model.layers[1](batch) .

Ajoutez des opérations de chiffrement:

 Iᵢⱼ = public_preprocess(batch) C_Iᵢⱼ = map(Iᵢⱼ) do Iij plain = CKKSEncoding{Tscale}(zero(plaintext_space(ckks_params))) plain .= OffsetArray(vec(Iij), 0:(N÷2-1)) encrypt(kp, plain) end weights = model.layers[1].weight conv_weights = reverse(reverse(weights, dims=1), dims=2) conved3 = [sum(C_Iᵢⱼ[i,j]*conv_weights[i,j,1,channel] for i=1:7, j=1:7) for channel = 1:4] conved2 = map(((x,b),)->x .+ b, zip(conved3, model.layers[1].bias)) conved1 = map(ToyFHE.modswitch, conved2) 

Veuillez noter que l'interrupteur à clé n'est pas requis ici car les poids sont publics. Nous n'augmentons donc pas la longueur du texte chiffré.

Multiplication matricielle

Passant à la multiplication matricielle, nous pouvons utiliser la rotation des éléments dans le vecteur pour changer l'ordre des indices de multiplication. Envisagez le placement en ligne des éléments de matrice dans un vecteur. Si nous décalons le vecteur d'un multiple de la taille de la ligne, nous obtenons l'effet de la rotation des colonnes, qui est une primitive suffisante pour implémenter la multiplication matricielle (au moins les matrices carrées). Essayons:

 function matmul_square_reordered(weights, x) sum(1:size(weights, 1)) do k # We rotate the columns of the LHS and take the diagonal weight_diag = diag(circshift(weights, (0,(k-1)))) # We rotate the rows of the RHS x_rotated = circshift(x, (k-1,0)) # We do an elementwise, broadcast multiply weight_diag .* x_rotated end end function matmul_reorderd(weights, x) sum(partition(1:256, 64)) do range matmul_square_reordered(weights[:, range], x[range, :]) end end fc1_weights = model.layers[3].W x = rand(Float64, 256, 64) @assert (fc1_weights*x) ≈ matmul_reorderd(fc1_weights, x) 

Bien sûr, pour la multiplication matricielle générale, quelque chose de plus compliqué est nécessaire, mais pour l'instant cela suffit.

Améliorer la technique

Maintenant, tous les composants de notre technique fonctionnent. Voici le code entier (sauf pour définir les options de sélection et des choses similaires):

 ek = keygen(EvalMultKey, kp.priv) gk = keygen(GaloisKey, kp.priv; steps=64) Iᵢⱼ = public_preprocess(batch) C_Iᵢⱼ = map(Iᵢⱼ) do Iij plain = CKKSEncoding{Tscale}(zero(plaintext_space(ckks_params))) plain .= OffsetArray(vec(Iij), 0:(N÷2-1)) encrypt(kp, plain) end weights = model.layers[1].weight conv_weights = reverse(reverse(weights, dims=1), dims=2) conved3 = [sum(C_Iᵢⱼ[i,j]*conv_weights[i,j,1,channel] for i=1:7, j=1:7) for channel = 1:4] conved2 = map(((x,b),)->x .+ b, zip(conved3, model.layers[1].bias)) conved1 = map(ToyFHE.modswitch, conved2) Csqed1 = map(x->x*x, conved1) Csqed1 = map(x->keyswitch(ek, x), Csqed1) Csqed1 = map(ToyFHE.modswitch, Csqed1) function encrypted_matmul(gk, weights, x::ToyFHE.CipherText) result = repeat(diag(weights), inner=64).*x rotated = x for k = 2:64 rotated = ToyFHE.rotate(gk, rotated) result += repeat(diag(circshift(weights, (0,(k-1)))), inner=64) .* rotated end result end fq1_weights = model.layers[3].W Cfq1 = sum(enumerate(partition(1:256, 64))) do (i,range) encrypted_matmul(gk, fq1_weights[:, range], Csqed1[i]) end Cfq1 = Cfq1 .+ OffsetArray(repeat(model.layers[3].b, inner=64), 0:4095) Cfq1 = modswitch(Cfq1) Csqed2 = Cfq1*Cfq1 Csqed2 = keyswitch(ek, Csqed2) Csqed2 = modswitch(Csqed2) function naive_rectangular_matmul(gk, weights, x) @assert size(weights, 1) < size(weights, 2) weights = vcat(weights, zeros(eltype(weights), size(weights, 2)-size(weights, 1), size(weights, 2))) encrypted_matmul(gk, weights, x) end fq2_weights = model.layers[4].W Cresult = naive_rectangular_matmul(gk, fq2_weights, Csqed2) Cresult = Cresult .+ OffsetArray(repeat(vcat(model.layers[4].b, zeros(54)), inner=64), 0:4095) 

Cela n'a pas l'air trop soigné, mais si vous avez fait tout cela, vous devez comprendre chaque étape.
Réfléchissons maintenant aux abstractions qui pourraient simplifier nos vies. Nous quittons le domaine de la cartographie et du machine learning et passons à l'architecture du langage de programmation, profitons donc du fait que Julia vous permet d'utiliser et de créer des abstractions puissantes. Par exemple, vous pouvez encapsuler l'ensemble du processus d'extraction des convolutions dans votre type de tableau:

 using BlockArrays """ ExplodedConvArray{T, Dims, Storage} <: AbstractArray{T, 4} Represents a an `nxmx1xb` array of images, but rearranged into a series of convolution windows. Evaluating a convolution compatible with `Dims` on this array is achievable through a sequence of scalar multiplications and sums on the underling storage. """ struct ExplodedConvArray{T, Dims, Storage} <: AbstractArray{T, 4} # sx*sy matrix of b*(dx*dy) matrices of extracted elements # where (sx, sy) = kernel_size(Dims) # (dx, dy) = output_size(DenseConvDims(...)) cdims::Dims x::Matrix{Storage} function ExplodedConvArray{T, Dims, Storage}(cdims::Dims, storage::Matrix{Storage}) where {T, Dims, Storage} @assert all(==(size(storage[1])), size.(storage)) new{T, Dims, Storage}(cdims, storage) end end Base.size(ex::ExplodedConvArray) = (NNlib.input_size(ex.cdims)..., 1, size(ex.x[1], 1)) function ExplodedConvArray{T}(cdims, batch::AbstractArray{T, 4}) where {T} x, y = NNlib.output_size(cdims) kx, ky = NNlib.kernel_size(cdims) stridex, stridey = NNlib.stride(cdims) kax = OffsetArray(0:x-1, 0:x-1) kay = OffsetArray(0:x-1, 0:x-1) I = [[batch[i′*stridex .+ (1:kx), j′*stridey .+ (1:ky), 1, k] for i′=kax, j′=kay] for k = 1:size(batch, 4)] Iᵢⱼ = [[I[k][l...][i,j] for k=1:size(batch, 4), l=product(kax, kay)] for (i,j) in product(1:kx, 1:ky)] ExplodedConvArray{T, typeof(cdims), eltype(Iᵢⱼ)}(cdims, Iᵢⱼ) end function NNlib.conv(x::ExplodedConvArray{<:Any, Dims}, weights::AbstractArray{<:Any, 4}, cdims::Dims) where {Dims<:ConvDims} blocks = reshape([ Base.ReshapedArray(sum(xx[i,j]*weights[i,j,1,channel] for i=1:7, j=1:7), (NNlib.output_size(cdims)...,1,size(x, 4)), ()) for channel = 1:4 ],(1,1,4,1)) BlockArrays._BlockArray(blocks, BlockArrays.BlockSizes([8], [8], [1,1,1,1], [64])) end 

Ici, nous avons de nouveau utilisé BlockArrays pour représenter un tableau 8x8x4x64 comme quatre tableaux 8x8x1x64 comme dans le code source. Maintenant, la présentation de la première étape est devenue beaucoup plus belle, au moins avec des tableaux non chiffrés:

 julia> cdims = DenseConvDims(batch, model.layers[1].weight; stride=(3,3), padding=(0,0,0,0), dilation=(1,1)) DenseConvDims: (28, 28, 1) * (7, 7) -> (8, 8, 4), stride: (3, 3) pad: (0, 0, 0, 0), dil: (1, 1), flip: false julia> a = ExplodedConvArray{eltype(batch)}(cdims, batch); julia> model(a) 10×64 Array{Float32,2}: [snip] 

Maintenant, comment pouvons-nous connecter cela avec le cryptage? Pour ce faire, vous avez besoin de:

1. Chiffrez la structure ( ExplodedConvArray ) afin que nous obtenions le texte chiffré pour chaque champ. Les opérations avec une telle structure cryptée vérifieront ce que la fonction ferait avec la structure d'origine et feront la même chose de manière homomorphe.
   
2. Intercepter certaines opérations afin de les effectuer différemment dans un contexte chiffré.

Heureusement, Julia nous fournit une abstraction pour cela: un plugin de compilation qui utilise le mécanisme Cassette.jl . Je ne vous dirai pas ce que c'est et comment cela fonctionne, je dirai brièvement qu'il peut déterminer le contexte, par exemple, Encrypted , puis il définit les règles de fonctionnement des opérations dans ce contexte. Par exemple, vous pouvez écrire ceci pour la deuxième exigence:

 # Define Matrix multiplication between an array and an encrypted block array function (*::Encrypted{typeof(*)})(a::Array{T, 2}, b::Encrypted{<:BlockArray{T, 2}}) where {T} sum(a*b for (i,range) in enumerate(partition(1:size(a, 2), size(b.blocks[1], 1)))) end # Define Matrix multiplication between an array and an encrypted array function (*::Encrypted{typeof(*)})(a::Array{T, 2}, b::Encrypted{Array{T, 2}}) where {T} result = repeat(diag(a), inner=size(a, 1)).*x rotated = b for k = 2:size(a, 2) rotated = ToyFHE.rotate(GaloisKey(*), rotated) result += repeat(diag(circshift(a, (0,(k-1)))), inner=size(a, 1)) .* rotated end result end 

En conséquence, l'utilisateur pourra écrire tout ce qui précède avec un minimum de travail manuel:

 kp = keygen(ckks_params) ek = keygen(EvalMultKey, kp.priv) gk = keygen(GaloisKey, kp.priv; steps=64) # Create evaluation context ctx = Encrypted(ek, gk) # Do public preprocessing batch = ExplodedConvArray{eltype(batch)}(cdims, batch); # Run on encrypted data under the encryption context Cresult = ctx(model)(encrypt(kp.pub, batch)) # Decrypt the answer decrypt(kp, Cresult) 

, . ( ℛ, modswitch, keyswitch ..) , . , , , , .

Conclusion

— . Julia . RAMPARTS ( paper , JuliaCon talk ) : Julia- - PALISADE. Julia Computing RAMPARTS Verona, . , . . , , .

, ToyFHE . , , , .