TensorFlow 14 मई को Google I/O पर वापस आ गया है! अभी पंजीकरण करें

इस पेज का अनुवाद Cloud Translation API से किया गया है.

कस्टम फ़ेडरेटेड एल्गोरिदम, भाग 1: फ़ेडरेटेड कोर का परिचय

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

इस ट्यूटोरियल दर्शाता है कि कैसे TensorFlow संघीय में फ़ेडरेटेड एल्गोरिदम (TFF) का उपयोग कर के कस्टम प्रकार लागू करने के लिए एक दो भाग श्रृंखला का पहला हिस्सा है संघीय कोर (एफसी) - निचले स्तर इंटरफेस का एक सेट है कि एक आधार के रूप में सेवा करते हैं जिस पर हम लागू कर दिया है संघीय लर्निंग (FL) परत।

यह पहला भाग अधिक वैचारिक है; हम TFF में उपयोग की जाने वाली कुछ प्रमुख अवधारणाओं और प्रोग्रामिंग एब्स्ट्रैक्शन का परिचय देते हैं, और हम तापमान सेंसर के एक वितरित सरणी के साथ एक बहुत ही सरल उदाहरण पर उनके उपयोग को प्रदर्शित करते हैं। में इस श्रृंखला का दूसरा हिस्सा है, हम तंत्र हम परिचय यहाँ का उपयोग फ़ेडरेटेड प्रशिक्षण और मूल्यांकन एल्गोरिदम का एक सरल संस्करण को लागू करने के लिए। एक अनुवर्ती के रूप में, हम अध्ययन करने के लिए प्रोत्साहित करते हैं कार्यान्वयन में फ़ेडरेटेड औसत के tff.learning ।

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

हालांकि इस ट्यूटोरियल संयमी डिज़ाइन किया गया है, तो हम आपको पर पहले पढ़ने ट्यूटोरियल करने के लिए प्रोत्साहित छवि वर्गीकरण और पाठ पीढ़ी TensorFlow संघीय ढांचे और करने के लिए एक उच्च स्तरीय और अधिक सौम्य परिचय के लिए संघीय लर्निंग API ( tff.learning ), के रूप में यह आपके द्वारा यहां वर्णित अवधारणाओं को संदर्भ में रखने में आपकी सहायता करेगा।

इच्छित उपयोग

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

आप के बारे में पता हो सकता है tf.contrib.distribute , और एक प्राकृतिक सवाल इस बिंदु पर पूछने के लिए हो सकता है: किस तरह से इस ढांचे भिन्न होता है? दोनों फ्रेमवर्क TensorFlow कंप्यूटेशंस को वितरित करने का प्रयास करते हैं, आखिरकार।

एक तरह से इसके बारे में लगता है कि है, जबकि के घोषित लक्ष्य tf.contrib.distribute उपयोगकर्ताओं वितरित प्रशिक्षण सक्षम करने के लिए कम से कम परिवर्तन के साथ मौजूदा मॉडलों और प्रशिक्षण कोड का उपयोग करने की अनुमति के लिए है, और भी बहुत ध्यान केंद्रित कैसे वितरित बुनियादी सुविधाओं का लाभ लेने के पर है मौजूदा प्रशिक्षण कोड को और अधिक कुशल बनाने के लिए, TFF के फ़ेडरेटेड कोर का लक्ष्य शोधकर्ताओं और चिकित्सकों को उनके सिस्टम में उपयोग किए जाने वाले वितरित संचार के विशिष्ट पैटर्न पर स्पष्ट नियंत्रण देना है। एफसी में लागू वितरित प्रशिक्षण क्षमताओं के एक ठोस सेट के बजाय, वितरित डेटा प्रवाह एल्गोरिदम को व्यक्त करने के लिए एक लचीली और एक्स्टेंसिबल भाषा प्रदान करने पर ध्यान केंद्रित किया गया है।

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

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

हमारे शुरू करने से पहले

इससे पहले कि हम कोड में गोता लगाएँ, कृपया यह सुनिश्चित करने के लिए निम्नलिखित "हैलो वर्ल्ड" उदाहरण चलाने का प्रयास करें कि आपका वातावरण सही तरीके से सेटअप है। यह काम नहीं करता है, तो कृपया स्थापना निर्देश के लिए गाइड।

!pip install --quiet --upgrade tensorflow-federated-nightly
!pip install --quiet --upgrade nest-asyncio

import nest_asyncio
nest_asyncio.apply()

import collections

import numpy as np
import tensorflow as tf
import tensorflow_federated as tff

@tff.federated_computation
def hello_world():
  return 'Hello, World!'

hello_world()

b'Hello, World!'

फ़ेडरेटेड डेटा

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

उपरोक्त उदाहरण में उन लोगों के रूप TFF में इलाज कर रहे हैं की तरह संघीय डेटा प्रथम श्रेणी के नागरिकों , यानी, वे मानकों और कार्यों के परिणाम के रूप में प्रकट हो सकता है, और वे प्रकार है। इस धारणा को सुदृढ़ करने के लिए, हम फ़ेडरेटेड मान, जो कि फ़ेडरेटेड डेटा सेट करने के लिए या फ़ेडरेटेड प्रकार के मूल्यों के रूप में संदर्भित करेंगे।

समझने की महत्वपूर्ण बात यह है कि हम सभी उपकरणों में डेटा आइटम के पूरे संग्रह को मॉडलिंग कर रहे हैं (उदाहरण के लिए, एक वितरित सरणी में सभी सेंसर से संपूर्ण संग्रह तापमान रीडिंग) एकल फ़ेडरेटेड मान के रूप में।

उदाहरण के लिए, यहाँ कैसे एक TFF में ग्राहक उपकरणों के एक समूह द्वारा आयोजित एक फ़ेडरेटेड नाव के प्रकार को परिभाषित करेगा। तापमान रीडिंग का एक संग्रह जो वितरित सेंसर की एक सरणी में अमल में आता है, उसे इस फ़ेडरेटेड प्रकार के मान के रूप में तैयार किया जा सकता है।

federated_float_on_clients = tff.type_at_clients(tf.float32)

आम तौर पर, TFF में एक फ़ेडरेटेड प्रकार प्रकार निर्दिष्ट द्वारा परिभाषित किया गया है T अपने सदस्य घटकों में से - डेटा के आइटम है कि अलग-अलग डिवाइस पर रहते हैं, और समूह G उपकरणों की है जिस पर इस प्रकार के फ़ेडरेटेड मूल्यों की मेजबानी कर रहे हैं (प्लस एक तिहाई, वैकल्पिक जानकारी का हम जल्द ही उल्लेख करेंगे)। हम समूह का उल्लेख G मूल्य के स्थान के रूप में एक फ़ेडरेटेड मूल्य होस्टिंग उपकरणों की। इस प्रकार, tff.CLIENTS एक प्लेसमेंट का एक उदाहरण है।

str(federated_float_on_clients.member)

'float32'

str(federated_float_on_clients.placement)

'CLIENTS'

साथ सदस्य घटक एक फ़ेडरेटेड प्रकार T और प्लेसमेंट G दृढ़तापूर्वक के रूप में प्रतिनिधित्व किया जा सकता है {T}@G नीचे दिखाए गए।

str(federated_float_on_clients)

'{float32}@CLIENTS'

घुंघराले ब्रेसिज़ {} इस संक्षिप्त में अंकन एक चेतावनी के रूप में सेवा करते हैं कि सदस्य घटक (विभिन्न उपकरणों पर डेटा के आइटम), भिन्न हो सकती है के रूप में आप जैसे उम्मीद करेंगे तापमान सेंसर रीडिंग की, है, तो एक समूह के रूप में ग्राहकों को संयुक्त रूप से एक की मेजबानी कर रहे हैं बहु सेट की T आइटम है कि एक साथ फ़ेडरेटेड मूल्य का गठन -typed।

यह नोट करना महत्वपूर्ण है कि एक फ़ेडरेटेड मूल्य के सदस्य घटक आम तौर पर प्रोग्रामर के लिए अपारदर्शी हैं, यानी, एक फ़ेडरेटेड मूल्य एक सरल रूप में की नहीं सोचा जाना चाहिए dict प्रणाली में एक डिवाइस का एक पहचानकर्ता द्वारा keyed - इन मूल्यों को करना है सामूहिक रूप से केवल फ़ेडरेटेड ऑपरेटरों कि संक्षेप में (जैसे एकत्रीकरण के रूप में) वितरित संचार प्रोटोकॉल के विभिन्न प्रकार का प्रतिनिधित्व द्वारा तब्दील किया जा। यदि यह बहुत सारगर्भित लगता है, तो चिंता न करें - हम शीघ्र ही इस पर लौटेंगे, और हम इसे ठोस उदाहरणों के साथ स्पष्ट करेंगे।

TFF में फ़ेडरेटेड प्रकार दो फ्लेवर में आते हैं: वे जहाँ फ़ेडरेटेड वैल्यू के सदस्य घटक भिन्न हो सकते हैं (जैसा कि ऊपर देखा गया है), और जहाँ वे सभी समान होने के लिए जाने जाते हैं। यह तीसरा, वैकल्पिक द्वारा नियंत्रित किया जाता all_equal में पैरामीटर tff.FederatedType निर्माता (करने के लिए दोषी False )।

federated_float_on_clients.all_equal

False

एक प्लेसमेंट के साथ एक फ़ेडरेटेड प्रकार G , जिसमें से सभी T -typed सदस्य घटक बराबर दृढ़तापूर्वक के रूप में प्रतिनिधित्व किया जा सकता है माना जाता है T@G (के रूप में करने का विरोध किया {T}@G , घुंघराले ब्रेसिज़ के साथ यह है कि, प्रतिबिंबित करने के लिए गिरा दिया तथ्य यह है कि सदस्य घटकों के बहु-सेट में एक ही आइटम होता है)।

str(tff.type_at_clients(tf.float32, all_equal=True))

'float32@CLIENTS'

इस तरह के फ़ेडरेटेड वैल्यू का एक उदाहरण जो व्यावहारिक परिदृश्यों में उत्पन्न हो सकता है, एक हाइपरपैरामीटर (जैसे सीखने की दर, एक क्लिपिंग मानदंड, आदि) है जो एक सर्वर द्वारा उन उपकरणों के समूह को प्रसारित किया गया है जो फ़ेडरेटेड प्रशिक्षण में भाग लेते हैं।

एक अन्य उदाहरण सर्वर पर पूर्व-प्रशिक्षित मशीन लर्निंग मॉडल के लिए मापदंडों का एक सेट है, जिसे तब क्लाइंट उपकरणों के एक समूह में प्रसारित किया जाता है, जहां उन्हें प्रत्येक उपयोगकर्ता के लिए वैयक्तिकृत किया जा सकता है।

उदाहरण के लिए, मान लीजिए हम की एक जोड़ी है float32 मापदंडों a और b एक सरल एक आयामी रेखीय प्रतीपगमन मॉडल के लिए। हम टीएफएफ में उपयोग के लिए ऐसे मॉडल के (गैर-संघीय) प्रकार का निर्माण कर सकते हैं। कोण ब्रेसिज़ <> मुद्रित प्रकार स्ट्रिंग में नाम या अनाम tuples के लिए एक कॉम्पैक्ट TFF अंकन कर रहे हैं।

simple_regression_model_type = (
    tff.StructType([('a', tf.float32), ('b', tf.float32)]))

str(simple_regression_model_type)

'<a=float32,b=float32>'

ध्यान दें कि हम केवल निर्दिष्ट करते हैं dtype रों ऊपर। गैर-स्केलर प्रकार भी समर्थित हैं। उपरोक्त कोड में, tf.float32 अधिक सामान्य के लिए एक शॉर्टकट अंकन है tff.TensorType(dtype=tf.float32, shape=[]) ।

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

str(tff.type_at_clients(
    simple_regression_model_type, all_equal=True))

'<a=float32,b=float32>@CLIENTS'

प्रति ऊपर फ़ेडरेटेड नाव के साथ समरूपता, हम एक फ़ेडरेटेड टपल के रूप में इस तरह के एक प्रकार के पास भेजेगा। आम तौर पर, हम अक्सर एक फ़ेडरेटेड मूल्य जिसमें सदस्य घटक XYZ की तरह कर रहे हैं उल्लेख करने के लिए अवधि फ़ेडरेटेड XYZ का उपयोग करेंगे। इस प्रकार, हम फ़ेडरेटेड tuples, फ़ेडरेटेड दृश्यों, फ़ेडरेटेड मॉडल, और इतने पर की तरह चीजों के बारे में बात करेंगे।

अब, आ रही करने के लिए वापस float32@CLIENTS - जबकि यह अधिक डिवाइस में दोहराया प्रकट होता है, यह वास्तव में एक भी है float32 , के बाद से सभी सदस्य एक ही हैं। सामान्य तौर पर, आप किसी भी सभी बराबर फ़ेडरेटेड प्रकार के, यानी, सोच सकते हैं रूप से एक T@G , एक गैर फ़ेडरेटेड प्रकार isomorphic को के रूप में T , दोनों ही मामलों में, वहाँ वास्तव में है के बाद से केवल एक ही (यद्यपि संभावित दोहराया) आइटम प्रकार के T ।

के बीच समाकृतिकता को देखते हुए T और T@G , आपको आश्चर्य हो सकता क्या प्रयोजन, यदि कोई हो, बाद प्रकार की सेवा कर सकते हैं। पढ़ते रहिये।

प्लेसमेंट

डिजाइन अवलोकन

पिछले अनुभाग में, हम नियुक्तियों की अवधारणा प्रस्तुत की है - प्रणाली प्रतिभागियों कि संयुक्त रूप से हो सकता है एक फ़ेडरेटेड मूल्य की मेजबानी के समूहों, और हम के उपयोग का प्रदर्शन किया है tff.CLIENTS एक प्लेसमेंट का एक उदाहरण के रूप में विनिर्देश।

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

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

यह विशेष रूप से महत्वपूर्ण है, जैसे, मोबाइल उपकरणों पर एप्लिकेशन डेटा। चूंकि डेटा निजी है और संवेदनशील हो सकता है, इसलिए हमें सांख्यिकीय रूप से सत्यापित करने की क्षमता की आवश्यकता है कि यह डेटा डिवाइस को कभी नहीं छोड़ेगा (और डेटा को कैसे संसाधित किया जा रहा है, इसके बारे में तथ्य साबित करें)। प्लेसमेंट विनिर्देश इसका समर्थन करने के लिए डिज़ाइन किए गए तंत्रों में से एक हैं।

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

के रूप में एक निश्चित मूल्य के प्रकार का प्रतिनिधित्व T@G या {T}@G (के रूप में बस के लिए विरोध T TFF में लिखा कार्यक्रमों की एक स्थिर विश्लेषण के साथ) डेटा नियुक्ति निर्णय स्पष्ट करता है, और साथ में, यह प्रदान करने के लिए एक आधार के रूप में काम कर सकते हैं संवेदनशील ऑन-डिवाइस डेटा के लिए औपचारिक गोपनीयता गारंटी।

इस बिंदु पर टिप्पणी करने के लिए एक महत्वपूर्ण बात यह है कि जब तक हम भाग लेने वाले उपकरणों के समूह के बारे में स्पष्ट होना करने के लिए TFF उपयोगकर्ताओं को प्रोत्साहित करते है कि मेजबान डेटा (प्लेसमेंट), प्रोग्रामर कच्चे डेटा या व्यक्तिगत प्रतिभागियों की पहचान के साथ सौदा कभी नहीं होगा है .

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

याद यहाँ क्या हम फ़ेडरेटेड प्रकार अजगर के विपरीत होने के मूल्यों के बारे में पहले ही उल्लेख किया dict , कि एक में सिर्फ अपने सदस्य घटकों की गणना नहीं कर सकते हैं। उन मूल्यों के बारे में सोचें जिन्हें आपका TFF प्रोग्राम लॉजिक अलग-अलग प्रतिभागियों के बजाय प्लेसमेंट (समूहों) से संबद्ध होने के रूप में हेरफेर करता है।

प्लेसमेंट के साथ-साथ TFF में एक प्रथम श्रेणी के नागरिक होने के लिए तैयार कर रहे हैं, और मापदंडों और एक के परिणाम के रूप में दिखाई दे सकता है placement प्रकार (द्वारा प्रतिनिधित्व किए जाने tff.PlacementType एपीआई में)। भविष्य में, हम प्लेसमेंट को बदलने या संयोजित करने के लिए विभिन्न प्रकार के ऑपरेटर प्रदान करने की योजना बना रहे हैं, लेकिन यह इस ट्यूटोरियल के दायरे से बाहर है। अभी के लिए, यह सोचने के लिए पर्याप्त होता placement के रूप में एक अपारदर्शी आदिम निर्मित TFF, के समान प्रकार कैसे int और bool अपारदर्शी में निर्मित कर रहे हैं अजगर में प्रकार, साथ tff.CLIENTS , इस प्रकार के एक निरंतर शाब्दिक जा रहा है के विपरीत नहीं 1 प्रकार की एक निरंतर शाब्दिक जा रहा है int ।

प्लेसमेंट निर्दिष्ट करना

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

TFF लिख नहीं पड़ता कि या तो tff.CLIENTS या tff.SERVER वास्तव में प्रतिनिधित्व करते हैं।

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

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

संघीय संगणना

फ़ेडरेटेड कंप्यूटेशंस की घोषणा

TFF को दृढ़ता से टाइप किए गए कार्यात्मक प्रोग्रामिंग वातावरण के रूप में डिज़ाइन किया गया है जो मॉड्यूलर विकास का समर्थन करता है।

तर्क का एक वर्ग है कि इनपुट के रूप में फ़ेडरेटेड मूल्यों को स्वीकार करने और आउटपुट के रूप में फ़ेडरेटेड मूल्यों वापस आ सकते हैं - TFF में रचना की बुनियादी इकाई एक फ़ेडरेटेड गणना है। यहां बताया गया है कि आप एक गणना को कैसे परिभाषित कर सकते हैं जो हमारे पिछले उदाहरण से सेंसर सरणी द्वारा रिपोर्ट किए गए तापमान के औसत की गणना करता है।

@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

, ऊपर कोड को देखते हुए इस बात के लिए कह रहा हो सकता है पर - वहाँ पहले से ही निर्माणों डेकोरेटर नहीं कर रहे हैं जैसे composable इकाइयों को परिभाषित करने के tf.function TensorFlow में है, और अगर हां, तो क्यों अभी तक एक और एक परिचय, और यह कैसे अलग है?

संक्षिप्त उत्तर है कि द्वारा बनाया गया कोड है tff.federated_computation यह एक आंतरिक मंच स्वतंत्र गोंद भाषा में एक वितरित प्रणाली के एक विनिर्देश है - आवरण न TensorFlow है, न ही यह अजगर है। इस बिंदु पर, यह निस्संदेह गूढ़ लगेगा, लेकिन कृपया एक वितरित प्रणाली के एक सार विनिर्देश के रूप में एक फ़ेडरेटेड गणना की इस सहज व्याख्या को ध्यान में रखें। हम इसे एक मिनट में समझाएंगे।

सबसे पहले, आइए परिभाषा के साथ थोड़ा खेलें। TFF संगणनाओं को आम तौर पर कार्यों के रूप में तैयार किया जाता है - मापदंडों के साथ या बिना, लेकिन अच्छी तरह से परिभाषित प्रकार के हस्ताक्षर के साथ। आप अपनी पूछताछ की एक गणना के प्रकार के हस्ताक्षर प्रिंट कर सकते हैं type_signature जिन्हें आप नीचे देख, संपत्ति।

str(get_average_temperature.type_signature)

'({float32}@CLIENTS -> float32@SERVER)'

टाइप सिग्नेचर हमें बताता है कि कंप्यूटेशन क्लाइंट डिवाइस पर विभिन्न सेंसर रीडिंग के संग्रह को स्वीकार करता है, और सर्वर पर एक औसत देता है।

इससे पहले कि हम किसी भी आगे जाना है, के एक मिनट के लिए इस पर चिंतन करते हैं - इनपुट और इस गणना के निर्गम (पर विभिन्न स्थानों में हैं CLIENTS पर बनाम SERVER )। याद है कि हम क्या कैसे TFF संचालन स्थानों पर होते हैं सकता है, और नेटवर्क में चलते हैं, और क्या हम सिर्फ वितरण प्रणाली का सार विनिर्देशों प्रतिनिधित्व के रूप में फ़ेडरेटेड संगणना के बारे में कहा संबंधित प्लेसमेंट पर पिछले अनुभाग में कहा। हमारे पास केवल एक परिभाषित ऐसी गणना है - एक साधारण वितरित प्रणाली जिसमें क्लाइंट उपकरणों पर डेटा की खपत होती है, और कुल परिणाम सर्वर पर सामने आते हैं।

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

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

सामान्य तौर पर, कार्यात्मक प्रकार हस्ताक्षर दृढ़तापूर्वक के रूप में प्रतिनिधित्व कर रहे हैं (T -> U) प्रकार के लिए T और U इनपुट और आउटपुट क्रमशः। औपचारिक पैरामीटर के प्रकार (जैसे sensor_readings इस मामले में) डेकोरेटर करने के लिए तर्क के रूप में निर्दिष्ट किया जाता है। आपको परिणाम के प्रकार को निर्दिष्ट करने की आवश्यकता नहीं है - यह स्वचालित रूप से निर्धारित होता है।

यद्यपि TFF बहुरूपता के सीमित रूपों की पेशकश करता है, प्रोग्रामर को उनके द्वारा काम किए जाने वाले डेटा के प्रकारों के बारे में स्पष्ट होने के लिए दृढ़ता से प्रोत्साहित किया जाता है, क्योंकि इससे आपके कोड के गुणों को समझना, डिबग करना और औपचारिक रूप से सत्यापित करना आसान हो जाता है। कुछ मामलों में, स्पष्ट रूप से प्रकार निर्दिष्ट करना एक आवश्यकता है (उदाहरण के लिए, बहुरूपी संगणना वर्तमान में सीधे निष्पादन योग्य नहीं हैं)।

फ़ेडरेटेड कंप्यूटेशंस निष्पादित करना

विकास और डिबगिंग का समर्थन करने के लिए, TFF आपको सीधे इस तरह से परिभाषित गणनाओं को पायथन फ़ंक्शंस के रूप में परिभाषित करने की अनुमति देता है, जैसा कि नीचे दिखाया गया है। कहाँ गणना के साथ एक फ़ेडरेटेड प्रकार के एक मूल्य की उम्मीद है all_equal को बिट सेट False , आप इसे एक सादे रूप में फ़ीड कर सकते हैं list अजगर में, और साथ फ़ेडरेटेड प्रकार के लिए all_equal को बिट सेट True , तो आप सिर्फ सीधे फ़ीड कर सकते हैं (एकल) सदस्य घटक। यह भी है कि परिणाम आपको वापस कैसे रिपोर्ट किए जाते हैं।

get_average_temperature([68.5, 70.3, 69.8])

69.53334

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

अब, एक नोट के लिए लेट की वापसी के बारे में हम पहले बनाया tff.federated_computation डेकोरेटर एक गोंद भाषा में कोड उत्सर्जन। हालांकि TFF संगणना के तर्क अजगर में साधारण कार्यों के रूप में व्यक्त किया जा सकता (आप उनके साथ बस को सजाने के लिए की जरूरत है tff.federated_computation और आप अजगर तर्क सिर्फ इस में किसी भी अन्य अजगर कार्यों की तरह के साथ उन्हें आह्वान सीधे कर सकते हैं हम ऊपर किया है), नोटबुक, पर्दे के पीछे, जैसा कि हम पहले उल्लेख किया, TFF संगणना वास्तव में नहीं अजगर कर रहे हैं।

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

आप निम्नानुसार एक प्रिंट स्टेटमेंट जोड़कर इसे सत्यापित कर सकते हैं:

@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):

  print ('Getting traced, the argument is "{}".'.format(
      type(sensor_readings).__name__))

  return tff.federated_mean(sensor_readings)

Getting traced, the argument is "ValueImpl".

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

इसी तरह, TFF संगणना अजगर में परिभाषित कर रहे हैं, लेकिन इस तरह के रूप में अपने शरीर, में अजगर बयान tff.federated_mean उदाहरण में बस से पता चला weve, हुड के नीचे एक पोर्टेबल और मंच स्वतंत्र serializable प्रतिनिधित्व में संकलित किया गया है।

एक डेवलपर के रूप में, आपको इस प्रतिनिधित्व के विवरण के साथ खुद को चिंतित करने की आवश्यकता नहीं है, क्योंकि आपको इसके साथ सीधे काम करने की आवश्यकता नहीं होगी, लेकिन आपको इसके अस्तित्व के बारे में पता होना चाहिए, तथ्य यह है कि टीएफएफ गणना मूल रूप से गैर-उत्सुक है, और मनमाने ढंग से पायथन राज्य पर कब्जा नहीं कर सकता। एक TFF गणना के शरीर में निहित पायथन कोड, परिभाषा समय में मार डाला जब अजगर समारोह के साथ सजाया के शरीर है tff.federated_computation धारावाहिक करने से पहले पता लगाया है। यह आह्वान के समय फिर से नहीं खोजा जाता है (सिवाय जब फ़ंक्शन बहुरूपी हो; कृपया विवरण के लिए दस्तावेज़ीकरण पृष्ठ देखें)।

आपको आश्चर्य हो सकता है कि हमने एक समर्पित आंतरिक गैर-पायथन प्रतिनिधित्व प्रस्तुत करना क्यों चुना है। एक कारण यह है कि अंततः, TFF संगणनाओं को वास्तविक भौतिक वातावरण में परिनियोजित करने का इरादा है, और मोबाइल या एम्बेडेड उपकरणों पर होस्ट किया जाता है, जहां पायथन उपलब्ध नहीं हो सकता है।

एक अन्य कारण यह है कि TFF संगणना वितरित प्रणालियों के वैश्विक व्यवहार को व्यक्त करती है, जो कि पायथन कार्यक्रमों के विपरीत है जो व्यक्तिगत प्रतिभागियों के स्थानीय व्यवहार को व्यक्त करते हैं। आप उपरोक्त सरल उदाहरण में देख सकते हैं कि, विशेष ऑपरेटर के साथ tff.federated_mean है कि ग्राहक उपकरणों पर डेटा है, लेकिन जमा सर्वर पर परिणाम स्वीकार करता है।

ऑपरेटर tff.federated_mean आसानी से, पायथन में एक साधारण ऑपरेटर के रूप में मॉडलिंग की नहीं किया जा सकता, क्योंकि यह स्थानीय स्तर पर निष्पादित नहीं करता है - जैसा कि पहले बताया गया है, यह एक वितरित प्रणाली का प्रतिनिधित्व करता है कि निर्देशांक विभिन्न सिस्टम प्रतिभागियों के व्यवहार। हम फ़ेडरेटेड ऑपरेटर के रूप में इस तरह के ऑपरेटरों के लिए संदर्भित करेंगे, उन्हें अजगर में साधारण (स्थानीय) ऑपरेटरों से अलग करने के लिए।

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

फ़ेडरेटेड कंप्यूटेशंस की रचना

जैसा कि ऊपर उल्लेख किया गया है, फ़ेडरेटेड कंप्यूटेशंस और उनके घटकों को वितरित सिस्टम के मॉडल के रूप में सबसे अच्छी तरह से समझा जाता है, और आप फ़ेडरेटेड कंप्यूटेशंस को सरल लोगों से अधिक जटिल वितरित सिस्टम की रचना के रूप में बनाने के बारे में सोच सकते हैं। आप सोच सकते हैं tff.federated_mean में निर्मित टेम्पलेट फ़ेडरेटेड गणना एक प्रकार हस्ताक्षर के साथ के एक प्रकार के रूप में ऑपरेटर ({T}@CLIENTS -> T@SERVER) (वास्तव में, बस संगणना की तरह आप लिखते हैं, इस ऑपरेटर भी एक जटिल है संरचना - हुड के तहत हम इसे सरल ऑपरेटरों में तोड़ देते हैं)।

फ़ेडरेटेड कंप्यूटेशंस की रचना के बारे में भी यही सच है। गणना get_average_temperature एक और अजगर समारोह के साथ सजाया की एक संस्था में लागू किया जा सकता tff.federated_computation - ऐसा करने, का कारण होगा कि उसे अपने जनक के शरीर में एम्बेड करने के लिए ठीक उसी तरह tff.federated_mean अपने स्वयं के शरीर पहले में एम्बेडेड था।

एक महत्वपूर्ण प्रतिबंध यह है कि के साथ सजाया अजगर कार्यों के शव है के बारे में पता होना करने के लिए tff.federated_computation केवल फ़ेडरेटेड ऑपरेटरों की, यानी मिलकर बनता है, वे सीधे TensorFlow संचालन नहीं हो सकते चाहिए। उदाहरण के लिए, आप सीधे उपयोग नहीं कर सकते tf.nest फ़ेडरेटेड मूल्यों की एक जोड़ी जोड़ने के लिए इंटरफेस। TensorFlow कोड एक साथ सजाया कोड के ब्लॉक तक सीमित रखना चाहिए tff.tf_computation निम्नलिखित भाग में चर्चा की। केवल जब इस तरह से लिपटे लिपटे TensorFlow कोड एक के शरीर में लागू किया जा सकता है tff.federated_computation ।

इस अलगाव के कारणों का तकनीकी कर रहे हैं (यह इस तरह के रूप ऑपरेटरों को ठगने के लिए मुश्किल है tf.add वास्तु के साथ ही गैर tensors के साथ काम करने के लिए)। फ़ेडरेटेड संगणना की भाषा (यानी, तर्क के साथ सजाया अजगर कार्यों के धारावाहिक शरीर से निर्माण किया tff.federated_computation ) एक मंच स्वतंत्र गोंद भाषा के रूप में सेवा करने के लिए बनाया गया है। इस गोंद भाषा वर्तमान में TensorFlow कोड (तक ही सीमित की एम्बेडेड वर्गों से सिस्टम का निर्माण वितरित करने के लिए प्रयोग किया जाता है tff.tf_computation ब्लॉक)। समय की परिपूर्णता में, हम इस तरह के रिलेशनल डेटाबेस प्रश्नों कि इनपुट पाइपलाइनों का प्रतिनिधित्व कर सकते के रूप में अन्य, गैर TensorFlow तर्क का एम्बेड वर्गों, की जरूरत है, सभी एक साथ जुड़े एक ही गोंद भाषा (का उपयोग करते हुए आशा tff.federated_computation ब्लॉक)।

टेंसरफ्लो लॉजिक

TensorFlow संगणना घोषित करना

TFF को TensorFlow के साथ उपयोग के लिए डिज़ाइन किया गया है। इसलिए, TFF में आपके द्वारा लिखे जाने वाले अधिकांश कोड सामान्य (यानी, स्थानीय रूप से निष्पादित) TensorFlow कोड होने की संभावना है। आदेश TFF के साथ इस तरह कोड का उपयोग करने के लिए, जैसा कि ऊपर उल्लेख है, यह सिर्फ के साथ सजाया जा करने की जरूरत है tff.tf_computation ।

उदाहरण के लिए, यहाँ है कि हम कैसे एक समारोह है कि एक नंबर लेता है और कहते हैं लागू सकता है 0.5 यह करने के लिए।

@tff.tf_computation(tf.float32)
def add_half(x):
  return tf.add(x, 0.5)

एक बार फिर, इस पर देख रहे हैं, तो आप सोच हो सकता है कारण है कि हम एक और डेकोरेटर परिभाषित करना चाहिए tff.tf_computation बस जैसे एक मौजूदा प्रणाली का उपयोग कर के बजाय tf.function । पिछले खंड के विपरीत, यहां हम TensorFlow कोड के एक साधारण ब्लॉक के साथ काम कर रहे हैं।

इसके कुछ कारण हैं, जिनका पूरा उपचार इस ट्यूटोरियल के दायरे से बाहर है, लेकिन यह मुख्य नाम देने लायक है:

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

सामान्य तौर पर, हम इस तरह के रूप में, रचना के लिए TensorFlow की मूल तंत्र उपयोग करने की अनुशंसा tf.function , जहां भी संभव हो, के रूप में सटीक तरीके से उत्सुक कार्यों के साथ TFF के डेकोरेटर सूचना का आदान प्रदान उम्मीद की जा सकती विकसित करने के लिए।

अब, उदाहरण के कोड के लिए आ रहा वापस ऊपर स्निपेट गणना add_half हम सिर्फ परिभाषित किसी भी अन्य TFF गणना की तरह TFF द्वारा इलाज किया जा सकता है। विशेष रूप से, इसमें एक TFF प्रकार का हस्ताक्षर है।

str(add_half.type_signature)

'(float32 -> float32)'

ध्यान दें कि इस प्रकार के हस्ताक्षर में नियुक्तियाँ नहीं होती हैं। TensorFlow गणना फ़ेडरेटेड प्रकारों का उपभोग या वापसी नहीं कर सकती है।

अब आप भी उपयोग कर सकते हैं add_half अन्य संगणना में एक इमारत ब्लॉक के रूप में। उदाहरण के लिए, आप निम्न तरीके से उपयोग कर सकते हैं tff.federated_map लागू करने के लिए ऑपरेटर add_half ग्राहक उपकरणों पर एक फ़ेडरेटेड नाव के सभी सदस्य घटकों को pointwise।

@tff.federated_computation(tff.type_at_clients(tf.float32))
def add_half_on_clients(x):
  return tff.federated_map(add_half, x)

str(add_half_on_clients.type_signature)

'({float32}@CLIENTS -> {float32}@CLIENTS)'

TensorFlow संगणना निष्पादित करना

साथ परिभाषित संगणना के निष्पादन tff.tf_computation उन हम के लिए वर्णित के रूप में एक ही नियमों का पालन करती tff.federated_computation । उन्हें निम्नानुसार पायथन में सामान्य कॉलबेल के रूप में लागू किया जा सकता है।

add_half_on_clients([1.0, 3.0, 2.0])

[<tf.Tensor: shape=(), dtype=float32, numpy=1.5>,
 <tf.Tensor: shape=(), dtype=float32, numpy=3.5>,
 <tf.Tensor: shape=(), dtype=float32, numpy=2.5>]

एक बार फिर, यह ध्यान देने योग्य है कि गणना लागू लायक है add_half_on_clients इस तरह से एक वितरित प्रक्रिया simulates। ग्राहकों पर डेटा का उपभोग किया जाता है, और ग्राहकों पर वापस किया जाता है। दरअसल, इस गणना में प्रत्येक ग्राहक स्थानीय कार्रवाई करता है। कोई है tff.SERVER स्पष्ट रूप से इस प्रणाली में उल्लेख किया है (यहां तक कि व्यवहार में अगर, इस तरह के प्रसंस्करण orchestrating एक शामिल हो सकता है)। एक गणना से धारणात्मक अनुरूप के रूप में इस तरह से परिभाषित के बारे में सोचो Map में मंच MapReduce ।

इसके अलावा, कि क्या हम के बारे में TFF संगणना परिभाषा समय में धारावाहिक रूप हो रही है पिछले अनुभाग में कहा के लिए सच बनी हुई है को ध्यान में रखना tff.tf_computation का अजगर शरीर - और साथ कोड add_half_on_clients परिभाषा समय में एक बार पता लगाया जाता है। बाद के आह्वान पर, TFF अपने क्रमबद्ध प्रतिनिधित्व का उपयोग करता है।

अजगर के तरीकों के साथ सजाया के बीच फर्क सिर्फ इतना है tff.federated_computation और के साथ सजाया उन tff.tf_computation कि बाद TensorFlow रेखांकन के रूप में क्रमानुसार लगे हुए हैं (जबकि पूर्व उन्हें सीधे में एम्बेडेड TensorFlow कोड को रोकने के लिए अनुमति नहीं है) है।

हुड के अंतर्गत, प्रत्येक विधि के साथ सजाया tff.tf_computation अस्थायी रूप से आदेश गणना की संरचना पर कब्जा कर लिया जा करने के लिए अनुमति देने के लिए उत्सुक निष्पादन अक्षम करता है। जबकि उत्सुक निष्पादन स्थानीय रूप से अक्षम है, आप उत्सुक TensorFlow, AutoGraph, TensorFlow 2.0 निर्माण, आदि का उपयोग करने के लिए स्वागत करते हैं, जब तक कि आप अपनी गणना के तर्क को इस तरह से लिखते हैं कि यह सही ढंग से क्रमबद्ध हो सके।

उदाहरण के लिए, निम्न कोड विफल हो जाएगा:

try:

  # Eager mode
  constant_10 = tf.constant(10.)

  @tff.tf_computation(tf.float32)
  def add_ten(x):
    return x + constant_10

except Exception as err:
  print (err)

Attempting to capture an EagerTensor without building a function.

इसके बाद के संस्करण में विफल रहता है क्योंकि constant_10 पहले से ही ग्राफ के बाहर है कि निर्माण किया गया है tff.tf_computation के शरीर में आंतरिक रूप से निर्माण करती add_ten क्रमबद्धता की प्रक्रिया के दौरान।

दूसरी ओर, अजगर कार्यों वर्तमान ग्राफ जब एक के अंदर बुलाया संशोधित कि लागू tff.tf_computation ठीक है:

def get_constant_10():
  return tf.constant(10.)

@tff.tf_computation(tf.float32)
def add_ten(x):
  return x + get_constant_10()

add_ten(5.0)

15.0

ध्यान दें कि TensorFlow में क्रमांकन तंत्र विकसित हो रहा है, और हम इस विवरण की अपेक्षा करते हैं कि TFF कैसे गणनाओं को क्रमबद्ध करता है और साथ ही विकसित होता है।

के साथ कार्य करना `tf.data.Dataset` रों

पहले बताया गया है, की एक अनूठी विशेषता tff.tf_computation रों है कि वे साथ काम करने की अनुमति देता है tf.data.Dataset अपने कोड द्वारा औपचारिक पैरामीटर के रूप में संक्षेप में परिभाषित किया। पैरामीटर TensorFlow में प्रतिनिधित्व करने के रूप में डेटा सेट का उपयोग कर की घोषणा की ज़रूरत tff.SequenceType निर्माता।

उदाहरण के लिए, विनिर्देश tff.SequenceType(tf.float32) TFF में नाव तत्वों का एक सार अनुक्रम को परिभाषित करता है। अनुक्रमों में या तो टेंसर या जटिल नेस्टेड संरचनाएं हो सकती हैं (हम बाद में उनके उदाहरण देखेंगे)। के अनुक्रम का संक्षिप्त प्रतिनिधित्व T आइटम -typed है T* ।

float32_sequence = tff.SequenceType(tf.float32)

str(float32_sequence)

'float32*'

Suppose that in our temperature sensor example, each sensor holds not just one temperature reading, but multiple. Here's how you can define a TFF computation in TensorFlow that calculates the average of temperatures in a single local data set using the tf.data.Dataset.reduce operator.

@tff.tf_computation(tff.SequenceType(tf.float32))
def get_local_temperature_average(local_temperatures):
  sum_and_count = (
      local_temperatures.reduce((0.0, 0), lambda x, y: (x[0] + y, x[1] + 1)))
  return sum_and_count[0] / tf.cast(sum_and_count[1], tf.float32)

str(get_local_temperature_average.type_signature)

'(float32* -> float32)'

In the body of a method decorated with tff.tf_computation , formal parameters of a TFF sequence type are represented simply as objects that behave like tf.data.Dataset , ie, support the same properties and methods (they are currently not implemented as subclasses of that type - this may change as the support for data sets in TensorFlow evolves).

You can easily verify this as follows.

@tff.tf_computation(tff.SequenceType(tf.int32))
def foo(x):
  return x.reduce(np.int32(0), lambda x, y: x + y)

foo([1, 2, 3])

Keep in mind that unlike ordinary tf.data.Dataset s, these dataset-like objects are placeholders. They don't contain any elements, since they represent abstract sequence-typed parameters, to be bound to concrete data when used in a concrete context. Support for abstractly-defined placeholder data sets is still somewhat limited at this point, and in the early days of TFF, you may encounter certain restrictions, but we won't need to worry about them in this tutorial (please refer to the documentation pages for details).

When locally executing a computation that accepts a sequence in a simulation mode, such as in this tutorial, you can feed the sequence as Python list, as below (as well as in other ways, eg, as a tf.data.Dataset in eager mode, but for now, we'll keep it simple).

get_local_temperature_average([68.5, 70.3, 69.8])

69.53333

Like all other TFF types, sequences like those defined above can use the tff.StructType constructor to define nested structures. For example, here's how one could declare a computation that accepts a sequence of pairs A , B , and returns the sum of their products. We include the tracing statements in the body of the computation so that you can see how the TFF type signature translates into the dataset's output_types and output_shapes .

@tff.tf_computation(tff.SequenceType(collections.OrderedDict([('A', tf.int32), ('B', tf.int32)])))
def foo(ds):
  print('element_structure = {}'.format(ds.element_spec))
  return ds.reduce(np.int32(0), lambda total, x: total + x['A'] * x['B'])

element_structure = OrderedDict([('A', TensorSpec(shape=(), dtype=tf.int32, name=None)), ('B', TensorSpec(shape=(), dtype=tf.int32, name=None))])

str(foo.type_signature)

'(<A=int32,B=int32>* -> int32)'

foo([{'A': 2, 'B': 3}, {'A': 4, 'B': 5}])

The support for using tf.data.Datasets as formal parameters is still somewhat limited and evolving, although functional in simple scenarios such as those used in this tutorial.

Putting it all together

Now, let's try again to use our TensorFlow computation in a federated setting. Suppose we have a group of sensors that each have a local sequence of temperature readings. We can compute the global temperature average by averaging the sensors' local averages as follows.

@tff.federated_computation(
    tff.type_at_clients(tff.SequenceType(tf.float32)))
def get_global_temperature_average(sensor_readings):
  return tff.federated_mean(
      tff.federated_map(get_local_temperature_average, sensor_readings))

Note that this isn't a simple average across all local temperature readings from all clients, as that would require weighing contributions from different clients by the number of readings they locally maintain. We leave it as an exercise for the reader to update the above code; the tff.federated_mean operator accepts the weight as an optional second argument (expected to be a federated float).

Also note that the input to get_global_temperature_average now becomes a federated float sequence . Federated sequences is how we will typically represent on-device data in federated learning, with sequence elements typically representing data batches (you will see examples of this shortly).

str(get_global_temperature_average.type_signature)

'({float32*}@CLIENTS -> float32@SERVER)'

Here's how we can locally execute the computation on a sample of data in Python. Notice that the way we supply the input is now as a list of list s. The outer list iterates over the devices in the group represented by tff.CLIENTS , and the inner ones iterate over elements in each device's local sequence.

get_global_temperature_average([[68.0, 70.0], [71.0], [68.0, 72.0, 70.0]])

70.0

This concludes the first part of the tutorial... we encourage you to continue on to the second part .