गोपनीयता संरक्षण, विकेंद्रीकृत गहन शिक्षा के लिए PySyft के परिचयात्मक ट्यूटोरियल में आपका स्वागत है। नोटबुक की यह श्रृंखला आपके लिए एक कदम-दर-चरण मार्गदर्शिका है, ताकि एक प्राधिकरण के तहत उन्हें केंद्रीकृत किए बिना गुप्त / निजी डेटा / मॉडल पर गहन सीखने के लिए आवश्यक नए उपकरणों और तकनीकों को जान सकें।
क्षेत्र: ध्यान दें कि हम केवल डेटा के विकेंद्रीकृत (decentralized) / एन्क्रिप्ट (encrypt) करने के तरीके के बारे में बात नहीं कर रहे हैं, लेकिन हम यह बता रहे हैं कि कैसे डेटा के आसपास पूरे पारिस्थितिकी तंत्र को विकेंद्रीकृत करने में मदद करने के लिए PySyft का उपयोग किया जा सकता है, यहां तक कि डेटाबेस भी शामिल है जहां डेटा संग्रहीत और संगीन है, और तंत्रिका मॉडल (Neural Network) जिनका उपयोग डेटा से जानकारी निकालने के लिए किया जाता है। जैसा कि PySyft के लिए नए एक्सटेंशन बनाए गए हैं, नई कार्यक्षमता को समझाने के लिए इन नोटबुक को नए ट्यूटोरियल के साथ बढ़ाया जाएगा।
लेखक:
अनुवादक:
1) प्रतियोगी कैरियर लाभ - पिछले 20 वर्षों से, डिजिटल क्रांति ने बड़ी मात्रा में डेटा को अधिक से अधिक सुलभ बना दिया है क्योंकि एनालॉग प्रक्रियाएं डिजिटल हो गई हैं। हालांकि, नए विनियमन जैसे कि GDPR के साथ, उद्यमों पर दबाव होता है कि वे किस तरह से कम स्वतंत्रता का उपयोग करें - और अधिक महत्वपूर्ण बात यह है कि वे कैसे - व्यक्तिगत जानकारी का विश्लेषण करते हैं। Bottom Line: डेटा वैज्ञानिकों के पास "पुराने स्कूल"(Old school) टूल के साथ अधिक से अधिक डेटा तक पहुंच नहीं है, लेकिन प्राइवेट डीप लर्निंग के उपकरण सीखने से, आप इस वक्र से आगे हो सकते हैं और आपके करियर में प्रतिस्पर्धात्मक लाभ हो सकता है।
2) उद्यमी अवसर - समाज में समस्याओं की एक पूरी मेजबानी है जिसे डीप लर्निंग हल कर सकता है, लेकिन कई सबसे महत्वपूर्ण का पता नहीं लगाया गया है क्योंकि इसे लोगों के बारे में अविश्वसनीय रूप से संवेदनशील जानकारी तक पहुंच की आवश्यकता होगी (मानसिक या रिश्ते के मुद्दों के साथ लोगों की मदद करने के लिए डीप लर्निंग का उपयोग करने पर विचार करें) !)। इस प्रकार, निजी डीप लर्निंग सीखना आपके लिए नए स्टार्टअप अवसरों की एक पूरी मेजबानी को अनलॉक करता है जो पहले इन टूलसेट के बिना दूसरों के लिए उपलब्ध नहीं थे।
3) सोशल गुड - डीप लर्निंग का उपयोग वास्तविक दुनिया में कई प्रकार की समस्याओं को हल करने के लिए किया जा सकता है, लेकिन डीप लर्निंग व्यक्तिगत जानकारी पर डीप लर्निंग लोगों के बारे में, लोगों के लिए है। दीप लर्निंग कैसे करना है डेटा पर सीखना आपके पास कैरियर या उद्यमशीलता के अवसर से अधिक का प्रतिनिधित्व नहीं करता है, यह लोगों के जीवन में कुछ सबसे व्यक्तिगत और महत्वपूर्ण समस्याओं को हल करने में मदद करने का अवसर है - और इसे पैमाने पर करने के लिए।
... ठीक है ... आओ इसे करें!
शुरू करने के लिए, आपको यह सुनिश्चित करने की आवश्यकता होगी कि आपके पास सही चीजें स्थापित हैं। ऐसा करने के लिए, PySyft की रीडमी पर जाएं और सेटअप निर्देशों का पालन करें। अधिकांश लोगों के लिए TLDR है।
यदि इसका कोई हिस्सा आपके लिए काम नहीं करता है (या कोई भी परीक्षण विफल रहता है) - पहले README की जांच करें स्थापना सहायता के लिए और फिर एक GitHub Issue जारी करें या हमारे स्लैक में #beginner चैनल को पिंग करें! slack.openmined.org
In [1]:
# चीजें देखने के लिए इस सेल को चलाएं
import sys
import torch
from torch.nn import Parameter
import torch.nn as nn
import torch.nn.functional as F
import syft as sy
hook = sy.TorchHook(torch)
torch.tensor([1,2,3,4,5])
Out[1]:
यदि इस सेल को निष्पादित किया जाता है, तो आप दौड़ से बाहर हो जाएंगे! आओ इसे करें!
तो - पहला सवाल जो आप सोच रहे होंगे वह यह है - दुनिया में कैसे हम उस डेटा पर एक मॉडल को प्रशिक्षित करते हैं जिसकी हमें एक्सेस नहीं है?
खैर, जवाब आश्चर्यजनक रूप से सरल है। यदि आप PyTorch में काम करने के आदी हैं, तो आप इन जैसे torch.Tensor वस्तुओं के साथ काम करने के आदी हैं!
In [2]:
x = torch.tensor([1,2,3,4,5])
y = x + x
print(y)
जाहिर है, इन सुपर फैंसी (और शक्तिशाली!) टेंसरों का उपयोग करना महत्वपूर्ण है, लेकिन इसके लिए आपको अपने स्थानीय मशीन पर डेटा भी रखना होगा। यहीं से हमारी यात्रा शुरू होती है।
जबकि आमतौर पर हम डेटा को रखने वाली मशीन पर डेटा साइंस / डीप लर्निंग का प्रदर्शन करते थे, अब हम किसी अन्य मशीन पर इस तरह की गणना करना चाहते हैं। विशेष रूप से, हम अब यह नहीं मान सकते हैं कि डेटा हमारे स्थानीय मशीन पर है।
इस प्रकार, Torch Tensor का उपयोग करने के बजाय, अब हम पॉइंटर्स के साथ टेंसरों पर काम करने जा रहे हैं। मे तुम्हें दिखाता हूँ की मेरा क्या मतलब हैं। पहले, चलो एक "ढोंग"(pretend) मशीन बनाते हैं जो एक "ढोंग"(pretend) व्यक्ति के स्वामित्व में है - हम उसे बॉब(Bob) कहेंगे।
In [3]:
bob = sy.VirtualWorker(hook, id="bob")
मान लीजिए कि बॉब की मशीन दूसरे ग्रह पर है - शायद मंगल पर! लेकिन, फिलहाल मशीन खाली है। आइए कुछ डेटा बनाएं ताकि हम इसे बॉब को भेज सकें और पॉइंटर्स (Pointers) के बारे में जान सकें!
In [4]:
x = torch.tensor([1,2,3,4,5])
y = torch.tensor([1,1,1,1,1])
और अब - चलो हमारे Tensor को बॉब(Bob) को भेजें !!
In [5]:
x_ptr = x.send(bob)
y_ptr = y.send(bob)
In [6]:
x_ptr
Out[6]:
BOOM! अब बॉब(Bob) के दो Tensor हैं! मुझपे विश्वास नहीं है? अपने लिए इसे देख लें!
In [7]:
bob._objects
Out[7]:
In [8]:
z = x_ptr + x_ptr
In [9]:
z
Out[9]:
In [10]:
bob._objects
Out[10]:
अब कुछ नोटिस करो। जब हमने x.send(bob) को फोन किया तो उसने एक नई वस्तु लौटा दी जिसे हमने x_ptr कहा। यह एक टेंसर के लिए हमारा पहला पॉइंटर है। दसियों को इंगित करने वाले वास्तव में स्वयं डेटा नहीं रखते हैं। इसके बजाय, वे बस एक मशीन पर संग्रहीत एक Tensor (डेटा के साथ) के बारे में मेटाडेटा होते हैं। इन टेंसरों का उद्देश्य हमें एक सहज ज्ञान युक्त एपीआई देना है जो अन्य मशीन को इस टेंसर का उपयोग करके कार्यों की गणना करने के लिए बताए। आइए मेटाडेटा पर एक नज़र डालें जिसमें Pointer होते हैं।
In [11]:
x_ptr
Out[11]:
उस मेटाडेटा (Metadata) की जाँच करें!
Pointer करने के लिए विशिष्ट दो मुख्य विशेषताएं हैं:
x_ptr.location : bob, स्थान, उस स्थान का संदर्भ जिसे सूचक (Pointer) इंगित कर रहा हैx_ptr.id_at_location : <random integer>, वह आईडी जहां स्थान पर Tensor संग्रहीत होता हैवे प्रारूप में मुद्रित होते हैं <id_at_location>@<location>
अन्य अधिक सामान्य विशेषताएँ भी हैं:
x_ptr.id : <random integer>, हमारे पॉइंटर Tensor की आईडी, इसे बेतरतीब ढंग (Randomly Allocated) से आवंटित किया गया थाx_ptr.owner : "me", वर्कर जो पॉइंटर (Pointer) टेनर का मालिक है, यहाँ उसका स्थानीय कर्मी है, जिसका नाम "me" है
In [12]:
x_ptr.location
Out[12]:
In [13]:
bob
Out[13]:
In [14]:
bob == x_ptr.location
Out[14]:
In [15]:
x_ptr.id_at_location
Out[15]:
In [16]:
x_ptr.owner
Out[16]:
आपको आश्चर्य हो सकता है कि स्थानीय कर्मचारी जो सूचक (Pointer) का मालिक है, वह भी एक VirtualWorker है, हालांकि हमने इसे नहीं बनाया है।
मजेदार तथ्य, ठीक उसी तरह जैसे बॉब (Bob) के लिए हमारे पास VirtualWorker ऑब्जेक्ट था, हमारे पास भी (डिफ़ॉल्ट रूप से) हमेशा ही वैसे ही एक होता है। जब हम hook = sy.TorchHook () कहते हैं, तो यह कार्यकर्ता स्वचालित रूप से बनाया जाता है और इसलिए आपको आमतौर पर इसे स्वयं बनाने की आवश्यकता नहीं है।
In [17]:
me = sy.local_worker
me
Out[17]:
In [18]:
me == x_ptr.owner
Out[18]:
और अंत में, जैसे हम एक Tensor पर .send () कॉल कर सकते हैं, हम इसे वापस पाने के लिए एक Tensor के लिए पॉइंटर (Pointer) पर .get () कॉल कर सकते हैं !!!
In [19]:
x_ptr
Out[19]:
In [20]:
x_ptr.get()
Out[20]:
In [21]:
y_ptr
Out[21]:
In [22]:
y_ptr.get()
Out[22]:
In [23]:
z.get()
Out[23]:
In [24]:
bob._objects
Out[24]:
और जैसा कि आप देख सकते हैं ... बॉब (Bob) में अब टेंसर्स नहीं हैं !!! वे हमारी मशीन में वापस चले गए हैं!
तो, बॉब (Bob) से Tensor भेजना और प्राप्त करना बहुत अच्छा है, लेकिन यह शायद ही डीप लर्निंग है! हम दूरस्थ Tensor पर Tensor operations का प्रदर्शन करने में सक्षम होना चाहते हैं। सौभाग्य से, Tensor पॉइंटर्स (Pointers) इसे काफी आसान बनाते हैं! आप बस Pointers का उपयोग कर सकते हैं जैसे आप सामान्य Tensors करेंगे!
In [25]:
x = torch.tensor([1,2,3,4,5]).send(bob)
y = torch.tensor([1,1,1,1,1]).send(bob)
In [26]:
z = x + y
In [27]:
z
Out[27]:
तथा देखा (And voilà!)
पर्दे के पीछे, बहुत शक्तिशाली कुछ हुआ। x और y के बजाय स्थानीय रूप से एक computing करने के बजाय, एक कमांड (Commend) को क्रमबद्ध किया गया और बॉब(Bob) को भेजा गया, जिन्होंने गणना करने के लिए, एक Tensor z बनाया, और फिर पॉइंटर(Pointer) को हमें वापस z करने के लिए वापस कर दिया!
यदि हम सूचक पर .get () कॉल करते हैं, तो हम फिर से अपनी मशीन पर परिणाम प्राप्त करेंगे!
In [28]:
z.get()
Out[28]:
In [29]:
x
Out[29]:
In [30]:
y
Out[30]:
In [31]:
z = torch.add(x,y)
z
Out[31]:
In [32]:
z.get()
Out[32]:
In [33]:
x = torch.tensor([1,2,3,4,5.], requires_grad=True).send(bob)
y = torch.tensor([1,1,1,1,1.], requires_grad=True).send(bob)
In [34]:
z = (x + y).sum()
In [35]:
z.backward()
Out[35]:
In [36]:
x = x.get()
In [37]:
x
Out[37]:
In [38]:
x.grad
Out[38]:
तो जैसा कि आप देख सकते हैं, एपीआई वास्तव में काफी लचीला है और लगभग किसी भी ऑपरेशन को करने में सक्षम है जो आप सामान्य रूप से दूरस्थ डेटा पर Torch में प्रदर्शन करेंगे। यह फेडरेटेड लर्निंग (Federated Learning), सिक्योर मल्टी-पार्टी कम्प्यूटेशन (Secure Multi-Party Computation) और डिफरेंशियल प्राइवेसी (Differential Privacy) जैसे प्रोटोकॉल को संरक्षित करने वाले हमारे अधिक उन्नत गोपनीयता के लिए आधार बनाता है!
In [ ]:
इस नोटबुक ट्यूटोरियल को पूरा करने पर बधाई! यदि आपने इसका आनंद लिया है और एआई और एआई आपूर्ति श्रृंखला (डेटा) के विकेन्द्रीकृत स्वामित्व के संरक्षण की ओर आंदोलन में शामिल होना चाहते हैं, तो आप निम्न तरीकों से ऐसा कर सकते हैं!
हमारे समुदाय की मदद करने का सबसे आसान तरीका GitHub repos अभिनीत है! यह हमारे द्वारा बनाए जा रहे कूल टूल्स के बारे में जागरूकता बढ़ाने में मदद करता है।
नवीनतम प्रगति पर अद्यतित रहने का सबसे अच्छा तरीका हमारे समुदाय में शामिल होना है! आप फॉर्म भरकर ऐसा कर सकते हैं। http://slack.openmined.org
हमारे समुदाय में योगदान करने का सबसे अच्छा तरीका एक कोड योगदानकर्ता बनना है! किसी भी समय आप PySyft GitHub Issues जारी करने वाले पृष्ठ पर जा सकते हैं और "प्रोजेक्ट्स\ के लिए फ़िल्टर कर सकते हैं। यह आपको सभी शीर्ष स्तर के टिकट दिखाएगा कि आप किन परियोजनाओं में शामिल हो सकते हैं! यदि आप किसी परियोजना में शामिल नहीं होना चाहते हैं, लेकिन आप थोड़ी सी कोडिंग करना चाहते हैं, तो आप "अच्छा पहला अंक" चिह्नित गीथहब मुद्दों की खोज करके अधिक "वन ऑफ़" मिनी-प्रोजेक्ट्स की तलाश कर सकते हैं।
यदि आपके पास हमारे कोडबेस में योगदान करने का समय नहीं है, लेकिन फिर भी समर्थन उधार देना चाहते हैं, तो आप हमारे ओपन कलेक्टिव में भी एक बैकर बन सकते हैं। सभी दान हमारी वेब होस्टिंग और अन्य सामुदायिक खर्चों जैसे कि हैकाथॉन और मीटअप की ओर जाते हैं!
In [ ]: