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

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

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें

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

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

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

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

इरादा उपयोग

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

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

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

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

एक पूरे के रूप में 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 ग्राहक के एक समूह द्वारा होस्ट किए गए फ़ेडरेटेड फ्लोट के प्रकार को 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 में फेडरेटेड प्रकार दो फ्लेवर में आते हैं: वे जहाँ संघटित मूल्य के सदस्य घटक अलग-अलग हो सकते हैं (जैसा कि अभी ऊपर देखा गया है), और वे जहाँ वे सभी समान हैं। यह tff.FederatedType कंस्ट्रक्टर ( False लिए डिफ़ॉल्ट) में तीसरे, वैकल्पिक all_equal पैरामीटर द्वारा नियंत्रित किया जाता है।

federated_float_on_clients.all_equal
False

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

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

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

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

उदाहरण के लिए, मान लें कि हमारे पास एक सरल एक-आयामी रैखिक प्रतिगमन मॉडल के लिए float32 मापदंडों की एक जोड़ी a और b । हम टीएफएफ में उपयोग के लिए इस तरह के मॉडल (गैर-फ़ेडरेटेड) प्रकार का निर्माण कर सकते हैं। मुद्रित प्रकार स्ट्रिंग में कोण ब्रेसिज़ <> नामांकित या अनाम ट्यूपल्स के लिए एक कॉम्पैक्ट 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'

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

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

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

प्लेसमेंट

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

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

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

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

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

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

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

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

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

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

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

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

स्थान निर्दिष्ट करना

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

TFF यह नहीं tff.CLIENTS कि tff.CLIENTS या tff.SERVER वास्तव में क्या 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)

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

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

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

इससे हमारा तात्पर्य यह है कि जब पायथन दुभाषिया का सामना tff.federated_computation सजाए गए फ़ंक्शन से होता है, तो यह इस फ़ंक्शन के निकाय में दिए गए कथनों को एक बार (परिभाषा के समय पर) 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.federated_mean , हुड के तहत एक पोर्टेबल और प्लेटफ़ॉर्म-स्वतंत्र पहचान योग्य प्रतिनिधित्व में संकलित हैं।

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

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

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

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

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

संघटित संगणनाओं की रचना

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

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

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

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

TensorFlow तर्क

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

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

उदाहरण के लिए, यहां बताया गया है कि हम एक फ़ंक्शन को कैसे लागू कर सकते हैं जो एक संख्या लेता है और इसमें 0.5 जोड़ता है।

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

एक बार फिर, यह देखकर, आप सोच रहे होंगे कि हमें एक मौजूदा तंत्र जैसे tf.function का उपयोग करने के बजाय एक अन्य डेकोरेटर tff.tf_computation को क्यों परिभाषित करना चाहिए। पूर्ववर्ती अनुभाग के विपरीत, यहां हम 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 लागू करने के लिए।

@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.tf_computation का निष्पादन उन्हीं नियमों का पालन करता है, जिन्हें हमने tff.federated_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 को इस तरीके से लागू करना एक वितरित प्रक्रिया का अनुकरण करता है। डेटा का उपभोग ग्राहकों पर किया जाता है, और ग्राहकों पर लौटाया जाता है। वास्तव में, इस गणना में प्रत्येक ग्राहक एक स्थानीय कार्रवाई करता है। इस प्रणाली में स्पष्ट रूप से उल्लेखित कोई tff.SERVER नहीं है (भले ही अभ्यास में, इस तरह के प्रसंस्करण को ऑर्केस्ट्रेट करना एक शामिल हो सकता है)। एक गणना से धारणात्मक अनुरूप के रूप में इस तरह से परिभाषित के बारे में सोचो Map में मंच MapReduce

यह भी ध्यान रखें कि परिभाषा समय पर क्रमबद्ध होने वाली TFF tff.tf_computation के बारे में पूर्ववर्ती खंड में हमने जो कहा है, वह tff.tf_computation कोड के लिए भी सही है - add_half_on_clients Python body की परिभाषा के समय में एक बार पता लगाया जाता है। बाद के आक्रमणों पर, 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 s के साथ काम करना

जैसा कि पहले उल्लेख किया गया है, tff.tf_computation s की एक अनूठी विशेषता यह है कि वे आपको अपने कोड द्वारा औपचारिक मापदंडों के रूप में परिभाषितtf.data.Dataset साथ काम करने की अनुमति देते हैं। Parameters to be represented in TensorFlow as data sets need to be declared using the tff.SequenceType constructor.

For example, the type specification tff.SequenceType(tf.float32) defines an abstract sequence of float elements in TFF. Sequences can contain either tensors, or complex nested structures (we'll see examples of those later). The concise representation of a sequence of T -typed items is 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 liketf.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])
6

Keep in mind that unlike ordinarytf.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 atf.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}])
26

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 .