🤛🏿 🤭 💃🏻 इसे डिक्रिप्ट किए बिना मशीन लर्निंग के लिए एन्क्रिप्टेड डेटा का उपयोग करना 🗳️ 🔖 💆🏻

इसे डिक्रिप्ट किए बिना मशीन लर्निंग के लिए एन्क्रिप्टेड डेटा का उपयोग करना
यह आलेख उन्नत क्रिप्टोग्राफ़िक तकनीकों पर चर्चा करता है। यह जूलिया कम्प्यूटिंग द्वारा किए गए शोध का सिर्फ एक अवलोकन है। वाणिज्यिक अनुप्रयोगों में यहां दिए गए उदाहरणों का उपयोग न करें। क्रिप्टोग्राफी लागू करने से पहले हमेशा क्रिप्टोग्राफर्स के साथ परामर्श करें।

यहां आप उस पैकेज को डाउनलोड कर सकते हैं जो सभी जादू को लागू करता है, और यहां लेख में चर्चा की गई कोड है।

परिचय

मान लें कि आपने अभी-अभी एक कूल नई मशीन लर्निंग मॉडल (निश्चित रूप से, फ्लक्स.जेल का उपयोग करके ) विकसित की है । और अब आप इसे अपने उपयोगकर्ताओं के लिए तैनात करना शुरू करना चाहते हैं। आप यह कैसे करेंगे? संभवत: सबसे आसान तरीका उपयोगकर्ताओं को मॉडल देना है और इसे अपने डेटा पर स्थानीय रूप से चलाने देना है। लेकिन इस दृष्टिकोण के नुकसान हैं:

मशीन लर्निंग मॉडल बड़े हैं, और उपयोगकर्ता कंप्यूटर में पर्याप्त कंप्यूटिंग या डिस्क संसाधन नहीं हो सकते हैं।
मशीन लर्निंग मॉडल अक्सर अपडेट किए जाते हैं, और यह आपके लिए नेटवर्क पर नियमित रूप से बड़ी मात्रा में डेटा भेजने के लिए सुविधाजनक नहीं हो सकता है।
मॉडल के विकास में समय लगता है और इसके लिए बड़ी मात्रा में कंप्यूटिंग संसाधनों की आवश्यकता होती है। और आप अपने मॉडल का उपयोग करने के लिए शुल्क के रूप में इसके लिए मुआवजा चाहते हैं।

तब वे आमतौर पर याद करते हैं कि मॉडल को एपीआई के माध्यम से क्लाउड में प्रदान किया जा सकता है। पिछले कुछ वर्षों में, ऐसी कई सेवाएँ सामने आई हैं, प्रत्येक बड़ा क्लाउड प्लेटफ़ॉर्म कॉर्पोरेट डेवलपर्स को समान सेवाएँ प्रदान करता है। लेकिन संभावित उपयोगकर्ताओं को एक स्पष्ट दुविधा का सामना करना पड़ता है: अब उनका डेटा एक दूरस्थ सर्वर पर संसाधित होता है, जो भरोसेमंद नहीं हो सकता है। इसके स्पष्ट नैतिक और कानूनी निहितार्थ हैं जो ऐसी सेवाओं के उपयोग को सीमित करते हैं। विनियमित उद्योगों, विशेष रूप से स्वास्थ्य देखभाल और वित्तीय सेवाओं में, प्रसंस्करण के लिए तीसरे पक्ष को रोगी और ग्राहक डेटा भेजना अक्सर संभव नहीं होता है।

कोई अन्य विकल्प?

यह पता चला है कि वहाँ है! क्रिप्टोग्राफी में हाल की खोजों ने इसे डिकोड किए बिना डेटा के साथ कंप्यूटिंग की अनुमति दी है । उदाहरण के लिए, एक उपयोगकर्ता एक क्लाउड एपीआई के लिए एन्क्रिप्टेड डेटा (कहते हैं, छवियां) भेजता है जो एक मशीन लर्निंग मॉडल लॉन्च करता है, और फिर एक एन्क्रिप्टेड प्रतिक्रिया भेजता है। किसी भी स्तर पर डेटा डिक्रिप्ट नहीं होता है, क्लाउड प्रदाता स्रोत छवियों तक पहुंच प्राप्त नहीं करता है और गणना किए गए पूर्वानुमान को डिक्रिप्ट नहीं कर सकता है। यह कैसे संभव है? आइए MNIST डाटासेट से एन्क्रिप्टेड छवियों पर लिखावट मान्यता के लिए एक सेवा बनाने के उदाहरण पर पता लगाते हैं।

Homomorphic एन्क्रिप्शन के बारे में

एन्क्रिप्टेड डेटा के साथ गणना करने की क्षमता को आमतौर पर "सुरक्षित कंप्यूटिंग" के रूप में जाना जाता है। यह अनुसंधान के लिए एक बड़ा क्षेत्र है, जिसमें सभी प्रकार के एप्लिकेशन परिदृश्यों के आधार पर क्रिप्टोग्राफी के कई दृष्टिकोण हैं। हम "होमोमोर्फिक एन्क्रिप्शन" नामक तकनीक पर ध्यान केंद्रित करेंगे। इस तरह की प्रणाली में, निम्नलिखित ऑपरेशन आमतौर पर हमारे लिए उपलब्ध हैं:

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

पहले तीन ऑपरेशन सरल और सभी के लिए परिचित हैं जिन्होंने पहले से ही किसी भी असममित एन्क्रिप्शन एल्गोरिदम का उपयोग किया है (उदाहरण के लिए, यदि आप टीएलएस के माध्यम से जुड़ा हुआ है)। सारा जादू आखिरी ऑपरेशन में होता है। एन्क्रिप्शन के दौरान, यह फ़ंक्शन f मूल्यांकन करता है और एन्क्रिप्टेड मूल्य पर f के मूल्यांकन के परिणाम के अनुसार गणना की गई एक और एन्क्रिप्टेड मान लौटाता है। इस सुविधा ने अपने दृष्टिकोण को अपना नाम दिया। मूल्यांकन एन्क्रिप्शन ऑपरेशन से संबंधित है:

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

इसी तरह, एक एन्क्रिप्टेड मूल्य का उपयोग करके, हम मनमाने ढंग से होमोमोर्फिज्म का मूल्यांकन कर सकते हैं।

कौन से कार्य f समर्थित है क्रिप्टोग्राफिक योजनाओं और समर्थित कार्यों पर निर्भर करता है। यदि केवल एक f समर्थन किया जाता है (उदाहरण के लिए, f = + ), तो सर्किट को "आंशिक रूप से होमोमोर्फिक" कहा जाता है। यदि f गेटवे का कोई भी पूरा सेट हो सकता है, जिसके आधार पर मनमानी योजनाएं बनाई जा सकती हैं, तो एक योजना के सीमित आकार के लिए इसे आंशिक रूप से होमोमोर्फिक गणना का एक और प्रकार कहा जाता है - "कुछ हद तक होमोमोर्फिक", और असीमित आकार के लिए - "पूरी तरह से होमोमोर्फिक" गणना। आप बूटस्ट्रैपिंग तकनीक का उपयोग करके "किसी तरह" को पूरी तरह से होमोमोर्फिक एन्क्रिप्शन में बदल सकते हैं, लेकिन यह हमारे लेख के दायरे से परे है। पूरी तरह से होमोमोर्फिक एन्क्रिप्शन एक अपेक्षाकृत हाल ही की खोज है, पहली कार्य योजना (यद्यपि अव्यावहारिक) 2009 में क्रेग जेंट्री द्वारा प्रकाशित की गई थी। पूरी तरह से होमोमोर्फिक योजनाएं बाद में (और व्यावहारिक) कई हैं। सॉफ्टवेयर पैकेज भी हैं जो इन योजनाओं को गुणात्मक रूप से लागू करते हैं। अक्सर वे Microsoft SEAL और PALISADE का उपयोग करते हैं। इसके अलावा, मैंने हाल ही में इन शुद्ध जूलिया एल्गोरिदम के लिए कार्यान्वयन कोड खोला है। इस लेख के लिए, हम इसमें लागू CKKS एन्क्रिप्शन का उपयोग करेंगे।

CKS अवलोकन

CKKS ( वैज्ञानिक कार्य चेओन-किम-किम-सोंग के लेखकों के नाम से, जिन्होंने 2016 में एल्गोरिथ्म का प्रस्ताव रखा था) एक होमोमोर्फिक एन्क्रिप्शन योजना है जो निम्नलिखित आदिम संचालन के होमोमोर्फिक मूल्यांकन की अनुमति देती है:

जटिल संख्याओं के n वैक्टर की लंबाई के तत्वपूर्ण जोड़।
n कॉम्प्लेक्स वैक्टर की लंबाई का तत्ववार गुणा।
एक सदिश में तत्वों ( circshift के संदर्भ में) को circshift ।
वेक्टर तत्वों की एकीकृत जोड़ी।

पैरामीटर n सुरक्षा और सटीकता के वांछित स्तर पर निर्भर करता है, और आमतौर पर काफी अधिक होता है। हमारे उदाहरण में, यह 4096 के बराबर होगा (एक उच्च मूल्य सुरक्षा बढ़ाता है, लेकिन गणना में भी कठिन है, यह लगभग n log n तरह है)।

इसके अलावा, सीकेकेएस का उपयोग करके गणना शोर है । इसलिए, परिणाम अनुमानित हैं, और ध्यान रखा जाना चाहिए कि परिणामों का मूल्यांकन पर्याप्त सटीकता के साथ किया जाए ताकि परिणाम की शुद्धता को प्रभावित न किया जा सके।

दूसरी ओर, मशीन लर्निंग पैकेज के डेवलपर्स के लिए ऐसे प्रतिबंध असामान्य नहीं हैं। GPU की तरह विशेष त्वरक भी आमतौर पर नंबर वैक्टर के साथ काम करते हैं। इसके अलावा, कई डेवलपर्स के लिए, फ़्लोटिंग पॉइंट नंबर कभी-कभी चयन एल्गोरिदम, मल्टीथ्रेडिंग, और इसी तरह के प्रभाव के कारण शोर करते हैं। मैं इस बात पर जोर देना चाहता हूं कि फ्लोटिंग पॉइंट नंबरों के साथ अंकगणितीय गणना प्रारंभिक रूप से नियतात्मक है, भले ही यह कार्यान्वयन की जटिलता के कारण स्पष्ट नहीं है, हालांकि सीकेकेएस आदिम वास्तव में शोर हैं। लेकिन शायद यह उपयोगकर्ताओं को यह समझने की अनुमति देता है कि शोर उतना डरावना नहीं है जितना यह लग सकता है।

अब देखते हैं कि आप जूलिया में इन ऑपरेशनों को कैसे कर सकते हैं (ध्यान दें: बहुत असुरक्षित मापदंडों का चयन किया जाता है, इन परिचालनों के साथ हम केवल 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

इतना सरल! एक चौकस पाठक देख सकता है कि CSQ पिछले सिफर से थोड़ा अलग है। विशेष रूप से, सिफरटेक्स्ट की "लंबाई 3" है और स्केल बहुत बड़ा है। यह क्या है और इसकी क्या आवश्यकता है, इसका स्पष्टीकरण इस लेख के दायरे से बाहर है। यह कहने के लिए पर्याप्त है कि हमें गणनाओं को जारी रखने से पहले मूल्यों को कम करने की आवश्यकता है, अन्यथा "जगह" सिफरएक्स में समाप्त हो जाएगी। सौभाग्य से, हम दो बढ़े हुए मूल्यों में से प्रत्येक को कम कर सकते हैं:

 # 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

इसके अलावा, modswitching (मापांक स्विचिंग के लिए कम, मॉड्यूल स्विचिंग) साइफरटेक्स्ट मॉड्यूल के आकार को कम करता है, ताकि हम इसे अनिश्चित काल तक जारी नहीं रख सकें (हम कुछ हद तक होम्योमोर्फिक एन्क्रिप्शन योजना का उपयोग करते हैं):

 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

हमने HE लाइब्रेरी के उपयोग की मूल बातें कवर कीं। लेकिन तंत्रिका नेटवर्क पूर्वानुमानों की गणना करने के लिए इन आदिमताओं का उपयोग करने से पहले, आइए इसे सीखने की प्रक्रिया को देखें।

मशीन सीखने का मॉडल

यदि आप मशीन लर्निंग या फ़्लक्स.ज्ल लाइब्रेरी से परिचित नहीं हैं, तो मैं फ़्लक्स.ज्ल डॉक्यूमेंटेशन के माध्यम से एक त्वरित रन की सलाह देता हूं या मशीन लर्निंग के लिए एक मुफ्त परिचय देखता हूं, क्योंकि हम केवल एन्क्रिप्टेड डेटा के लिए मॉडल को लागू करने में बदलाव पर चर्चा करेंगे।

चलो फ्लक्स चिड़ियाघर से दृढ़ तंत्रिका नेटवर्क का उपयोग करके शुरू करते हैं। हम डेटा तैयार करने के साथ एक ही प्रशिक्षण चक्र को आगे बढ़ाएंगे, बस मॉडल को थोड़ा सेट करें। यहाँ यह है:

 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), )

यह एक ही मॉडल है जैसे कि "सिक्योर आउटसोर्स्ड मैट्रिक्स कंप्युटेशन एंड एप्लीकेशन टू न्यूरल नेटवर्क्स" , जो दो अंतरों के साथ एक ही क्रिप्टोग्राफिक स्कीम का उपयोग करता है: 1) सरलता के लिए, हमने स्वयं मॉडल को एन्क्रिप्ट नहीं किया, और 2) प्रत्येक लेयर के बाद बायेसियन वैक्टर का उपयोग किया जाता है (यह फ्लक्स में डिफ़ॉल्ट रूप से किया जाता है), सुनिश्चित नहीं है कि यह उल्लेखित कार्य में था। शायद, दूसरे बिंदु के कारण, हमारे मॉडल के परीक्षण सेट पर सटीकता थोड़ी अधिक हो गई (98.6% बनाम 98.1%), लेकिन हाइपरपरमेट्रिक अंतर भी इसका कारण हो सकता है।

असामान्य (जिनके पास मशीन सीखने का अनुभव है) x.^2 फ़ंक्शन का कार्य। ज्यादातर ऐसे मामलों में वे tanh , relu या कुछ अधिक काल्पनिक का उपयोग करते हैं। लेकिन यद्यपि इन कार्यों (विशेष रूप से relu ) की गणना साधारण पाठ मूल्यों के लिए आसानी से की जाती है, हालांकि, उन्हें एन्क्रिप्टेड रूप में मूल्यांकन करने के लिए बहुत अधिक कम्प्यूटेशनल संसाधनों की आवश्यकता हो सकती है (हम आमतौर पर बहुपद सन्निकटन का अनुमान लगाते हैं)। सौभाग्य से, इस मामले में x.^2 महान काम करता है।

शेष शिक्षण चक्र समान रहा। हमने हानि-फ़ंक्शन logitcrossentropy लिए मॉडल से softmax को हटा दिया (आप इसे छोड़ सकते हैं और क्लाइंट पर डिक्रिप्शन के बाद सॉफ्टमैक्स का मूल्यांकन कर सकते हैं)। मॉडल के प्रशिक्षण के लिए पूरा कोड GitHub पर है , यह किसी भी नए वीडियो कार्ड पर कुछ ही मिनटों में चलता है।

प्रभावी संचालन

अब हमें पता है कि हमें कौन से संचालन करने की आवश्यकता है:

थक्के।
तत्व वर्ग।
मैट्रिक्स गुणन।

स्क्वेरिंग के साथ सब कुछ सरल है, हमने पहले ही ऊपर जांच की है, इसलिए हम दो अन्य ऑपरेशनों पर विचार करेंगे। हम मानते हैं कि डेटा पैकेट की लंबाई 64 है (आप नोटिस कर सकते हैं कि मॉडल पैरामीटर और पैकेट का आकार इसलिए चुना जाता है ताकि 4096-तत्व वेक्टर का लाभ उठाया जा सके जो हमने मापदंडों के यथार्थवादी विकल्प के परिणामस्वरूप प्राप्त किया था)।

जमावट

याद रखें कि जमावट कैसे काम करता है। मूल इनपुट ऐरे की एक विंडो (हमारे मामले में 7x7) लें, और प्रत्येक विंडो एलिमेंट को एक कनवल्शन मास्क तत्व से गुणा किया जाता है। फिर हम विंडो को कुछ चरण में स्थानांतरित करते हैं (हमारे मामले में, चरण 3 है, अर्थात हम 3 तत्वों को स्थानांतरित करते हैं) और प्रक्रिया को दोहराते हैं (एक ही दृढ़ संकल्प मुखौटा के साथ)। चरण (2, 2) साथ 3x3 दृढ़ संकल्प के लिए प्रक्रिया ( स्रोत ) का एनीमेशन नीचे दिखाया गया है (नीला सरणी - इनपुट, हरा - आउटपुट):

इसके अलावा, हम चार अलग-अलग "चैनलों" में कन्वेंशन करते हैं (यानी, हम 3 बार अलग-अलग मास्क के साथ कन्वर्सेशन दोहराते हैं)।

अब हम जानते हैं कि क्या करना है, यह कैसे समझ में आता है। हम भाग्यशाली हैं कि दृढ़ संकल्प हमारे मॉडल में पहला ऑपरेशन है। नतीजतन, संसाधनों को बचाने के लिए, हम ग्राहक पर डेटा को पूर्व-संसाधित कर सकते हैं, और फिर उन्हें एन्क्रिप्ट कर सकते हैं (वजन का उपयोग किए बिना)। ऐसा करते हैं:

सबसे पहले, हम प्रत्येक कनवेंशन विंडो (जो स्रोत छवियों से एक 7x7 नमूना है) की गणना करते हैं, जो हमें प्रत्येक इनपुट छवि के लिए 64 7x7 मैट्रिसेस देता है। ध्यान दें कि 2 के वेतन वृद्धि में 7x7 विंडो के लिए, 28x289 छवि का मूल्यांकन करने के लिए 8x8 कनवल्शन विंडो होगी।
आइए एक वेक्टर में प्रत्येक विंडो में समान पदों को इकट्ठा करें। यही है, प्रत्येक छवि के लिए हमारे पास 64-तत्व वेक्टर, या 64x64 तत्वों के एक वेक्टर का आकार 64 के पैकेट के लिए होगा (कुल 49 मैट्रिक्स 64x64)।
हम एन्क्रिप्ट करेंगे।

तब जमावट बस इसी मैट्रिक्स तत्व के साथ पूरे मैट्रिक्स के स्केलर गुणन में बदल जाता है। और बाद में सभी 49 तत्वों को जोड़ दें, हम तह का परिणाम प्राप्त करते हैं। यहाँ इस रणनीति के कार्यान्वयन की तरह लग सकता है (सादे पाठ में):

 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))

यह (आयाम बदलने के लिए मॉड्यूल) (modulo - आकारों के क्रम को बदलना) ऑपरेशन model.layers[1](batch) के समान उत्तर देता है। model.layers[1](batch) ।

एन्क्रिप्शन ऑपरेशन जोड़ें:

 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)

कृपया ध्यान दें कि यहां कीस्विक की आवश्यकता नहीं है क्योंकि भार सार्वजनिक हैं। इसलिए हम सिफरटेक्स्ट की लंबाई नहीं बढ़ाते हैं।

मैट्रिक्स गुणन

मैट्रिक्स गुणा करने के लिए आगे बढ़ते हुए, हम गुणन सूचकांकों के क्रम को बदलने के लिए वेक्टर में तत्वों के रोटेशन का उपयोग कर सकते हैं। वेक्टर में मैट्रिक्स तत्वों के पंक्ति-वार प्लेसमेंट पर विचार करें। यदि हम वेक्टर को पंक्ति आकार के कई भाग से स्थानांतरित करते हैं, तो हमें कॉलम घुमाव का प्रभाव मिलता है, जो मैट्रिक्स गुणन (कम से कम वर्ग मैट्रिसेस) को लागू करने के लिए एक पर्याप्त आदिम है। आइए कोशिश करते हैं:

 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)

बेशक, सामान्य मैट्रिक्स गुणन के लिए, कुछ अधिक जटिल की आवश्यकता होती है, लेकिन अभी के लिए यह पर्याप्त है।

तकनीक में सुधार

अब हमारी तकनीक के सभी घटक काम करते हैं। यहाँ पूरा कोड है (चयन विकल्प और इसी तरह की चीजों को सेट करने के अलावा):

 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)

यह बहुत साफ नहीं दिखता है, लेकिन अगर आपने यह सब किया है, तो आपको हर कदम को समझना चाहिए।
अब विचार करें कि क्या सार हमारे जीवन को सरल बना सकता है। हम कार्टोग्राफी और मशीन सीखने के क्षेत्र को छोड़ रहे हैं और प्रोग्रामिंग भाषा की वास्तुकला की ओर बढ़ रहे हैं, तो चलिए इस तथ्य का लाभ उठाते हैं कि जूलिया आपको शक्तिशाली सार का उपयोग करने और बनाने की अनुमति देता है। उदाहरण के लिए, आप अपने सरणी प्रकार में कनवल्शन निकालने की पूरी प्रक्रिया को अलग कर सकते हैं:

 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

यहाँ हमने फिर से BlockArrays का उपयोग BlockArrays सरणी को चार कोड 8x8x1x64 सरणियों के रूप में 8x8x1x64 के लिए किया है। अब पहले चरण की प्रस्तुति बहुत अधिक सुंदर हो गई है, कम से कम अनएन्क्रिप्टेड सरणियों के साथ:

 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]

अब हम इसे एन्क्रिप्शन से कैसे जोड़ते हैं? ऐसा करने के लिए, आपको चाहिए:

संरचना ( ExplodedConvArray ) को एन्क्रिप्ट करें ताकि हम प्रत्येक क्षेत्र के लिए सिफरटेक्स्ट प्राप्त करें। इस तरह के एक एन्क्रिप्टेड संरचना के साथ संचालन यह सत्यापित करेगा कि मूल संरचना के साथ फ़ंक्शन क्या करेगा, और होमोमोर्फिक रूप से एक ही कार्य करें।
एक एन्क्रिप्टेड संदर्भ में उन्हें अलग-अलग प्रदर्शन करने के लिए कुछ संचालन को बाधित करें।

सौभाग्य से, जूलिया हमें इसके लिए एक अमूर्त प्रदान करता है: एक संकलक प्लगइन जो कैसेट.जेल तंत्र का उपयोग करता है। मैंने आपको यह नहीं बताया कि यह क्या है और यह कैसे काम करता है, मैं संक्षेप में कहता हूं कि यह संदर्भ निर्धारित कर सकता है, उदाहरण के लिए, Encrypted , और फिर यह नियमों को परिभाषित करता है कि इस संदर्भ में संचालन कैसे काम करना चाहिए। उदाहरण के लिए, आप इसे दूसरी आवश्यकता के लिए लिख सकते हैं:

 # 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

परिणामस्वरूप, उपयोगकर्ता उपर्युक्त सभी को मैनुअल काम की न्यूनतम राशि के साथ लिख सकेगा:

 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 ..) , . , , , , .

निष्कर्ष

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

, ToyFHE . , , , .

इसे डिक्रिप्ट किए बिना मशीन लर्निंग के लिए एन्क्रिप्टेड डेटा का उपयोग करना