<jupyter_start><jupyter_text>भाग 8 - योजनांचा परिचय संदर्भआम्ही येथे एक वस्तू सादर करीत आहोत जी औद्योगिक फेडरेटेड लर्निंग: द प्लॅनच्या (plan) प्रमाणात महत्त्वाची आहे. हे नाटकीयरित्या बँडविड्थ वापर कमी करते, एसिन्क्रॉनस योजनांना परवानगी देते आणि दूरस्थ उपकरणांना अधिक स्वायत्तता देते. योजनेची मूलभूत संकल्पना पेपर [Towards Federated Learning at Scale: System Design](https://arxiv.org/pdf/1902.01046.pdf) मध्ये आढळू शकते परंतु PySyft लायब्ररीत आपल्या गरजा भागवल्या आहेत.योजनेचा उद्देश एखाद्या फंक्शनप्रमाणेच torch ऑपरेशन्सचा क्रम संग्रहित करण्याचा होता, परंतु तो ऑपरेशनचा हा क्रम दुर्गम कामगारांना पाठविण्यास आणि त्यास संदर्भ ठेवण्यास अनुमती देतो. अशाप्रकारे दूरस्थपणे या क्रमाची गणना करणे $n$ काही रिमोट इनपुटवरील ऑपरेशन्स पाठविण्याऐवजी पॉईंटर्सद्वारे संदर्भित $n$ आपल्याला आता आवश्यक असलेले संदेश आणि योजनेच्या संदर्भात एक संदेश पाठविण्यासाठी आवश्यक आहे. आपण आपल्या फंक्शनसह टेन्सर देखील प्रदान करू शकता (ज्यास आम्ही विस्तारित कार्यक्षमतेसाठी _state tensors_ म्हणतो). एकतर आपण पाठवू शकता असे फंक्शन किंवा दूरस्थपणे पाठविल्या जाणार्‍या आणि अंमलात आणल्या जाणार्‍या वर्गाप्रमाणे ही योजना पाहिली जाऊ शकते. म्हणूनच, उच्च स्तरावरील वापरकर्त्यांसाठी, नियोजन करण्याची कल्पना अदृश्य होते आणि त्या जागी जादूची वैशिष्ट्ये घेतली जातात ज्यामुळे अनियंत्रित कार्य अनुक्रमित torch कार्यांसह दूरस्थ कामगारांना पाठविण्याची परवानगी मिळते.एक गोष्ट लक्षात घेण्यासारखी आहे की आपण ज्या योजनांचे रुपांतर करू शकता अशा फंक्शन्सचा वर्ग सध्या केवळ hooked torch च्या अनुक्रमांपुरता मर्यादित आहे. आपण लवकरच वर्कआउंड करण्याचे कार्य करत असलो तरीही `if`, `for` आणि `while` स्टेटमेन्ट यासारख्या विशिष्ट लॉजिकल स्ट्रक्चर्समध्ये हे समाविष्ट नाही. _तंतोतंत, आपण ते वापरू शकता परंतु आपण घेतलेला लॉजिकल मार्ग (उदाहरणार्थ पहिले `if` ला चुकीच आणि 5 loops ला  `for` मध्ये) आपल्या योजनेच्या पहिल्या गणनामध्ये सर्वांसाठी ठेवलेला मार्ग असेल. पुढील मोजणी, जी आपल्याला बर्‍याच प्रकरणांमध्ये टाळायची आहे_.लेखक:- Thé<NAME> - Twitter [@theoryffel](https://twitter.com/theoryffel) - Github: [@LaRiffle](https://github.com/LaRiffle)- <NAME> - Twitter [@bobbyawagner](https://twitter.com/bobbyawagner) - GitHub: [@robert-wagner](https://github.com/robert-wagner)- <NAME> - Twitter [@hereismari](https://twitter.com/hereismari) - GitHub: [@mari-linhares](https://github.com/mari-linhares)अनुवादक/संपादक:- <NAME> - Twitter: [@krunal_wrote](https://twitter.com/krunal_wrote) - Github: [@Noob-can-Compile](https://github.com/Noob-can-Compile)  आयात आणि मॉडेल वैशिष्ट्यप्रथम अधिकृत आयात.<jupyter_code>import torch
import torch.nn as nn
import torch.nn.functional as F<jupyter_output><empty_output><jupyter_text>आणि PySyft ला विशिष्ट, एका महत्त्वपूर्ण नोटसहः **स्थानिक कामगार ग्राहक नसावेत.** * ग्राहक नसलेले कामगार आयटम साठवू शकतात आणि योजना चालविण्यासाठी आम्हाला या क्षमतेची आवश्यकता आहे.*<jupyter_code>import syft as sy  # import the Pysyft library
hook = sy.TorchHook(torch)  # hook PyTorch ie add extra functionalities 

# IMPORTANT: Local worker should not be a client worker
hook.local_worker.is_client_worker = False


server = hook.local_worker<jupyter_output><empty_output><jupyter_text>आपण संदर्भ लेखात प्रदान केलेल्या गृहितकांशी सुसंगत राहण्यासाठी दूरस्थ कामगार किंवा _उपकरणे(devices)_, परिभाषित करतो. आपण त्यांना काही डेटा प्रदान करतो.<jupyter_code>x11 = torch.tensor([-1, 2.]).tag('input_data')
x12 = torch.tensor([1, -2.]).tag('input_data2')
x21 = torch.tensor([-1, 2.]).tag('input_data')
x22 = torch.tensor([1, -2.]).tag('input_data2')

device_1 = sy.VirtualWorker(hook, id="device_1", data=(x11, x12)) 
device_2 = sy.VirtualWorker(hook, id="device_2", data=(x21, x22))
devices = device_1, device_2<jupyter_output><empty_output><jupyter_text>मूळ उदाहरणचला आपण एखाद्या योजनेत रूपांतरित करायचे फंक्शन परिभाषित करू. असे करण्यासाठी हे फंक्शन डेफिनेशनच्या वर डेकोरेटर घालण्याइतके सोपे आहे!<jupyter_code>@sy.func2plan()
def plan_double_abs(x):
    x = x + x
    x = torch.abs(x)
    return x<jupyter_output><empty_output><jupyter_text>चला आता तपासूया, आपली आता एक योजना आहे!<jupyter_code>plan_double_abs<jupyter_output><empty_output><jupyter_text>योजना वापरण्यासाठी आपल्याला दोन गोष्टी आवश्यक आहेतः एक योजना तयार करणे (_फंक्शनमध्ये उपस्थित असलेल्या क्रियांच्या क्रमाची नोंदणी करा_ ) आणि त्यास कामगार / साधनाकडे पाठवणे. सुदैवाने आपण हे अगदी सहजपणे करू शकता! योजना तयार करुयातयोजना तयार करण्यासाठी आपल्याला त्यास फक्त काही डेटावर कॉल करण्याची आवश्यकता आहे.चला प्रथम काही दूरस्थ डेटाचा संदर्भ घेऊ: एक विनंती नेटवर्कवर पाठविली जाते आणि संदर्भ पॉईंटर परत केला जातो.<jupyter_code>pointer_to_data = device_1.search('input_data')[0]
pointer_to_data<jupyter_output><empty_output><jupyter_text>आपण योजना सांगल्यास ते डिव्हाइस स्थानावर दूरस्थपणे अंमलात आणले जावे `location: device_1` ... आपल्याला एक त्रुटी मिळेल कारण योजना अद्याप तयार केलेली नव्हती.<jupyter_code>plan_double_abs.is_built
# Sending non-built Plan will fail
try:
    plan_double_abs.send(device_1)
except RuntimeError as error:
    print(error)<jupyter_output><empty_output><jupyter_text>एक योजना तयार करण्यासाठी आपल्याला योजनेवर `build` कॉल करण्याची आवश्यकता आहे आणि योजनेची अंमलबजावणी करण्यासाठी आवश्यक तर्कशास्त्र पास करणे आवश्यक आहे (काही डेटा a.k.a). जेव्हा एखादी योजना तयार केली जाते तेव्हा सर्व कमांड स्थानिक कामगार क्रमाने अंमलात आणतात आणि योजनेद्वारे ते कॅप्चर करतात आणि त्या `actions` विशेषतामध्ये संग्रहित करतात!<jupyter_code>plan_double_abs.build(torch.tensor([1., -2.]))
plan_double_abs.is_built<jupyter_output><empty_output><jupyter_text>आपण आता योजना पाठविण्याचा प्रयत्न केल्यास ते कार्य करते!<jupyter_code># This cell is executed successfully
pointer_plan = plan_double_abs.send(device_1)
pointer_plan<jupyter_output><empty_output><jupyter_text>तोपर्यंत टेन्सरसह, आम्हाला पाठविलेल्या ऑब्जेक्टसाठी एक पॉईंटर मिळेल. येथे त्याला फक्त `PointerPlan` म्हणतात. लक्षात ठेवण्याची एक महत्त्वाची गोष्ट म्हणजे जेव्हा एखादी योजना तयार केली जाते, तेव्हा आम्ही पुढे आयडी (एस) प्री-सेट करतो, जिथे निकाल संग्रहित केला जावा. आभासी निकालाच्या संदर्भात आणि दूरस्थ निकालाची गणना न करता स्थानिक मोजणी चालू ठेवण्यासाठी हे आदेशांना एसिंक्रोनोली पाठविण्यास अनुमती देईल. जेव्हा आपल्याला device_1 वरील बॅचची गणना करण्याची आवश्यकता असते आणि device_2 वरील दुसर्‍या बॅचची गणना करणे प्रारंभ करण्यासाठी या गणनेची प्रतीक्षा करण्याची आवश्यकता नसते तेव्हा एक मोठा अनुप्रयोग असतो.  दूरस्थपणे योजना चालवाआता आम्ही योजनेतील काही डेटा पॉईंटरवर कॉल करून रिमोट चालवू शकतो. ही योजना दूरस्थपणे चालविण्यासाठी कमांड जारी करते, जेणेकरून योजनेच्या आऊटपुटच्या पूर्वनिर्धारित ठिकाणी आता निकालाचा समावेश असेल (लक्षात ठेवा आम्ही गणना करण्यापूर्वी निकालाचे पूर्व-निर्धारित स्थान गमावतो). यासाठी एका संप्रेषणाची फेरी देखील आवश्यक आहे.परिणाम फक्त एक पॉईंटर असतो, जेव्हा आपण सामान्य हुक torch फंक्शनला कॉल करता तेव्हा!<jupyter_code>pointer_to_result = pointer_plan(pointer_to_data)
print(pointer_to_result)<jupyter_output><empty_output><jupyter_text>आणि आपण फक्त मूल्य परत विचारू शकता.<jupyter_code>pointer_to_result.get()<jupyter_output><empty_output><jupyter_text>एका ठोस उदाहरणाच्या दिशेनेपण आपल्याला डीप अँड फेडरेटेड लर्निंगवर प्लॅन लागू करणे म्हणजे काय? तर आपण जरासे जटिल उदाहरण पाहू या, neural नेटवर्क वापरुन आपण कदाचित त्यांचा वापर करण्यास इच्छुक असाल तर. लक्षात घ्या की आपण आता क्लासचे योजनेमध्ये रूपांतर करीत आहोत. असे करण्यासाठी, आपण sy.Plan वरून आपल्या वर्गाचे वारस आहोत (nn.Module वरुन वारसाऐवजी).<jupyter_code>class Net(sy.Plan):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(2, 3)
        self.fc2 = nn.Linear(3, 2)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=0)

net = Net()
net<jupyter_output><empty_output><jupyter_text>चला काही मॉक डेटा वापरुन प्लॅन बनवूया.<jupyter_code>net.build(torch.tensor([1., 2.]))<jupyter_output><empty_output><jupyter_text>आपण आता ही योजना दुर्गम कामगाराला पाठवित आहोत<jupyter_code>pointer_to_net = net.send(device_1)
pointer_to_net<jupyter_output><empty_output><jupyter_text>चला काही दूरस्थ डेटा पुनर्प्राप्त करू<jupyter_code>pointer_to_data = device_1.search('input_data')[0]<jupyter_output><empty_output><jupyter_text>तर सिंटॅक्स सामान्य रिमोट अनुक्रमिक एक्झिक्युशन प्रमाणेच असते, म्हणजेच स्थानिक एक्झिक्युशन. परंतु क्लासिक रिमोट एक्जीक्यूशनच्या तुलनेत, प्रत्येक एक्झिक्युशनसाठी एकच संप्रेषण फेरी असते.<jupyter_code>pointer_to_result = pointer_to_net(pointer_to_data)
pointer_to_result<jupyter_output><empty_output><jupyter_text>आणि आपल्याला नेहमीप्रमाणेच निकाल मिळतो!<jupyter_code>pointer_to_result.get()<jupyter_output><empty_output><jupyter_text>Et voilà! स्थानिक कामगार (किंवा सर्व्हर) आणि दूरस्थ उपकरणांमधील संवाद नाटकीयरित्या कसे कमी करावे हे आम्ही पाहिले आहे!  कामगारांन दरम्यान स्विच कराआपल्याला पाहिजे असलेले एक प्रमुख वैशिष्ट्य म्हणजे अनेक कामगारांसाठी समान योजना वापरणे, आपण ज्या डेटाचा विचार करीत आहोत त्या दूरस्थ बॅचवर अवलंबून बदलू. विशेषतः, प्रत्येक वेळी कामगार बदलल्यास आपल्याला ही योजना पुन्हा तयार करायची नाही. आपल्या छोट्या नेटवर्कसह मागील उदाहरण वापरुन आपण हे कसे करतो ते पाहूया.<jupyter_code>class Net(sy.Plan):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(2, 3)
        self.fc2 = nn.Linear(3, 2)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=0)
net = Net()

# Build plan
net.build(torch.tensor([1., 2.]))<jupyter_output><empty_output><jupyter_text>आपण नुकत्याच अंमलात आणलेल्या मुख्य चरणे येथे आहेत<jupyter_code>pointer_to_net_1 = net.send(device_1)
pointer_to_data = device_1.search('input_data')[0]
pointer_to_result = pointer_to_net_1(pointer_to_data)
pointer_to_result.get()<jupyter_output><empty_output><jupyter_text>आणि प्रत्यक्षात आपण त्याच योजनेतून इतर पॉइंटरप्लान्स(PointerPlans) तयार करू शकता, जेणेकरून सिंटॅक्स दुसर्‍या डिव्हाइसवर दूरस्थपणे योजना चालविण्यासाठी समान असेल<jupyter_code>pointer_to_net_2 = net.send(device_2)
pointer_to_data = device_2.search('input_data')[0]
pointer_to_result = pointer_to_net_2(pointer_to_data)
pointer_to_result.get()<jupyter_output><empty_output><jupyter_text>> टीपः सध्या, योजना वर्गांसह आपण फक्त एक पद्धत वापरू शकता आणि आपल्याला त्यास "forward" असे नाव द्यावे लागेल.   कार्ये असलेल्या स्वयंचलितपणे योजना तयार करणेफंक्शन्ससाठी (`@` `sy.func2plan`) आपण स्वयंचलितपणे `build` कॉल करण्याची आवश्यकता नसलेली योजना स्वयंचलितपणे तयार करू शकतो, प्रत्यक्षात निर्मितीच्या क्षणी योजना आधीच तयार केली गेली आहे.ही कार्यक्षमता साध्य करण्यासाठी जेव्हा एखादी योजना तयार करता तेव्हा आपल्याला एक गोष्ट बदलण्याची आवश्यकता असते ती म्हणजे `args_shape` नावाच्या decorator साठी एक argument सेट करणे, ज्यामध्ये प्रत्येक argument च्या आकारासह एक यादी असावी.<jupyter_code>@sy.func2plan(args_shape=[(-1, 1)])
def plan_double_abs(x):
    x = x + x
    x = torch.abs(x)
    return x

plan_double_abs.is_built<jupyter_output><empty_output><jupyter_text>`args_shape` पॅरामीटर अंतर्गत आकारात मॉक टेन्सर तयार करण्यासाठी वापरला जातो जो प्लॅन तयार करण्यासाठी वापरला जातो.<jupyter_code>@sy.func2plan(args_shape=[(1, 2), (-1, 2)])
def plan_sum_abs(x, y):
    s = x + y
    return torch.abs(s)

plan_sum_abs.is_built<jupyter_output><empty_output><jupyter_text>आपण कार्य करण्यासाठी state elements देखील प्रदान करू शकता!<jupyter_code>@sy.func2plan(args_shape=[(1,)], state=(torch.tensor([1]), ))
def plan_abs(x, state):
    bias, = state.read()
    x = x.abs()
    return x + bias
pointer_plan = plan_abs.send(device_1)
x_ptr = torch.tensor([-1, 0]).send(device_1)
p = pointer_plan(x_ptr)
p.get()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.24431466241925492, 'fraction_numerical': 0.009202725422528979, 'mean_word_length': 6.1216131064902335, 'pattern_counts': {'":': 0, '<': 97, '<?xml version=': 0, '>': 98, 'https://': 9, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '23', 'dir': 'jupyter-structured-clean-dedup', 'id': '91647', 'license': 'Apache-2.0', 'n_tokens_mistral': 8394, 'n_tokens_neox': 8537, 'n_words': 1127, 'path': 'examples/tutorials/translations/marathi/Part 08 - Introduction to Plans.ipynb', 'repo_name': 'NicoSerranoP/PySyft', 'size': '11331'}