फ़ेडरेटेड लर्निंग

अवलोकन

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

इस परत द्वारा पेश किए गए इंटरफेस में निम्नलिखित तीन प्रमुख भाग होते हैं:

  • मॉडल । कक्षाएं और सहायक कार्य जो आपको TFF के साथ उपयोग के लिए अपने मौजूदा मॉडल को लपेटने की अनुमति देते हैं। किसी मॉडल को लपेटना उतना ही सरल हो सकता है जितना कि एक रैपिंग फ़ंक्शन को कॉल करना (उदाहरण के लिए, tff.learning.from_keras_model ), या पूर्ण अनुकूलन के लिए tff.learning.Model इंटरफ़ेस के उपवर्ग को परिभाषित करना।

  • संघीय संगणना बिल्डर्स । हेल्पर फ़ंक्शंस जो आपके मौजूदा मॉडल का उपयोग करके प्रशिक्षण या मूल्यांकन के लिए फ़ेडरेटेड कंप्यूटेशंस का निर्माण करते हैं।

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

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

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

मॉडल

वास्तु धारणा

क्रमबद्धता

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

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

वर्तमान में, TensorFlow उत्सुक-मोड TensorFlow को क्रमबद्ध और अक्रमांकन करने का पूरी तरह से समर्थन नहीं करता है। इस प्रकार, TFF में क्रमांकन वर्तमान में TF 1.0 पैटर्न का अनुसरण करता है, जहां सभी कोड एक tf.Graph के अंदर बनाए जाने चाहिए जो TFF नियंत्रित करता है। इसका मतलब है कि वर्तमान में TFF पहले से निर्मित मॉडल का उपभोग नहीं कर सकता है; इसके बजाय, मॉडल परिभाषा तर्क को नो-आर्ग फ़ंक्शन में पैक किया जाता है जो tff.learning.Model देता है। इस फ़ंक्शन को तब TFF द्वारा यह सुनिश्चित करने के लिए कहा जाता है कि मॉडल के सभी घटकों को क्रमबद्ध किया गया है। इसके अलावा, दृढ़ता से टाइप किया गया वातावरण होने के कारण, TFF को कुछ अतिरिक्त मेटाडेटा की आवश्यकता होगी, जैसे कि आपके मॉडल के इनपुट प्रकार का विवरण।

एकत्रीकरण

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

फ़ेडरेटेड लर्निंग में एग्रीगेशन की हमेशा कम से कम दो परतें होती हैं: स्थानीय ऑन-डिवाइस एग्रीगेशन, और क्रॉस-डिवाइस (या फ़ेडरेटेड) एग्रीगेशन:

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

    इस स्तर पर एकत्रीकरण करना आपके मॉडल कोड की जिम्मेदारी है, और मानक TensorFlow निर्माणों का उपयोग करके पूरा किया जाता है।

    प्रसंस्करण की सामान्य संरचना इस प्रकार है:

    • मॉडल पहले tf.Variable s को समुच्चय धारण करने के लिए बनाता है, जैसे बैचों की संख्या या संसाधित किए गए उदाहरणों की संख्या, प्रति-बैच या प्रति-उदाहरण हानियों का योग, आदि।

    • TFF क्लाइंट डेटा के बाद के बैचों पर क्रमिक रूप से आपके Model पर कई बार forward_pass विधि का आह्वान करता है, जो आपको साइड इफेक्ट के रूप में विभिन्न समुच्चय रखने वाले चर को अपडेट करने की अनुमति देता है।

    • अंत में, TFF आपके मॉडल पर report_local_unfinalized_metrics विधि को आमंत्रित करता है ताकि आपका मॉडल क्लाइंट द्वारा निर्यात किए जाने वाले मीट्रिक के एक कॉम्पैक्ट सेट में एकत्र किए गए सभी सारांश आँकड़ों को संकलित कर सके। यह वह जगह है जहां आपका मॉडल कोड, उदाहरण के लिए, औसत नुकसान को निर्यात करने के लिए संसाधित उदाहरणों की संख्या से नुकसान के योग को विभाजित कर सकता है, आदि।

  • संघीय एकत्रीकरण । एकत्रीकरण का यह स्तर सिस्टम में कई ग्राहकों (उपकरणों) में एकत्रीकरण को संदर्भित करता है। फिर से, यह मॉडल पैरामीटर (चर) दोनों पर लागू होता है, जो ग्राहकों के बीच औसत किए जा रहे हैं, साथ ही स्थानीय एकत्रीकरण के परिणामस्वरूप आपके मॉडल द्वारा निर्यात किए गए मीट्रिक पर भी लागू होता है।

    इस स्तर पर एकत्रीकरण करना TFF की जिम्मेदारी है। हालांकि, एक मॉडल निर्माता के रूप में, आप इस प्रक्रिया को नियंत्रित कर सकते हैं (इस पर और अधिक)।

    प्रसंस्करण की सामान्य संरचना इस प्रकार है:

    • प्रारंभिक मॉडल, और प्रशिक्षण के लिए आवश्यक कोई भी पैरामीटर, सर्वर द्वारा ग्राहकों के सबसेट को वितरित किया जाता है जो प्रशिक्षण या मूल्यांकन के दौर में भाग लेंगे।

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

    • TFF पूरे सिस्टम में मॉडल मापदंडों और स्थानीय रूप से निर्यात किए गए मेट्रिक्स को संचित और एकत्र करने के लिए एक वितरित एकत्रीकरण प्रोटोकॉल चलाता है। यह तर्क TFF की अपनी फ़ेडरेटेड गणना भाषा (TensorFlow में नहीं) का उपयोग करके एक घोषणात्मक तरीके से व्यक्त किया गया है। एकत्रीकरण API पर अधिक के लिए कस्टम एल्गोरिदम ट्यूटोरियल देखें।

सार इंटरफेस

यह मूल कंस्ट्रक्टर + मेटाडेटा इंटरफ़ेस इंटरफ़ेस tff.learning.Model द्वारा दर्शाया गया है, जो इस प्रकार है:

  • कंस्ट्रक्टर, फ़ॉरवर्ड_पास और forward_pass विधियों को मॉडल वैरिएबल, फ़ॉरवर्ड पास और उन आंकड़ों का निर्माण करना चाहिए report_local_unfinalized_metrics आप रिपोर्ट करना चाहते हैं। जैसा कि ऊपर चर्चा की गई है, इन विधियों द्वारा निर्मित TensorFlow क्रमबद्ध होना चाहिए।

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

इसके अलावा, अमूर्त इंटरफ़ेस tff.learning.Model एक ऐसी संपत्ति metric_finalizers को उजागर करता है जो एक मीट्रिक के अंतिम मानों को लेता है ( report_local_unfinalized_metrics() द्वारा लौटाया जाता है) और अंतिम मीट्रिक मान लौटाता है। फ़ेडरेटेड प्रशिक्षण प्रक्रियाओं या मूल्यांकन गणनाओं को परिभाषित करते समय क्रॉस-क्लाइंट मेट्रिक्स एग्रीगेटर बनाने के लिए metric_finalizers और रिपोर्ट_लोकल_अनफ़ाइनलाइज़्ड_मेट्रिक्स report_local_unfinalized_metrics() पद्धति का एक साथ उपयोग किया जाएगा। उदाहरण के लिए, एक साधारण tff.learning.metrics.sum_then_finalize एग्रीगेटर पहले क्लाइंट से अनिर्धारित मीट्रिक मानों को जोड़ देगा, और फिर सर्वर पर फ़ाइनलाइज़र फ़ंक्शन को कॉल करेगा।

आप हमारे छवि वर्गीकरण ट्यूटोरियल के दूसरे भाग में अपने स्वयं के कस्टम tff.learning.Model को परिभाषित करने के उदाहरण पा सकते हैं, साथ ही उदाहरण मॉडल में हम model_examples.py में परीक्षण के लिए उपयोग करते हैं।

केरासो के लिए कन्वर्टर्स

टीएफएफ द्वारा आवश्यक लगभग सभी जानकारी tf.keras इंटरफेस को कॉल करके प्राप्त की जा सकती है, इसलिए यदि आपके पास केरस मॉडल है, तो आप tff.learning.Model पर tff.learning.from_keras_model के लिए भरोसा कर सकते हैं।

ध्यान दें कि TFF अभी भी चाहता है कि आप एक कंस्ट्रक्टर प्रदान करें - एक बिना तर्क वाला मॉडल फ़ंक्शन जैसे कि निम्नलिखित:

def model_fn():
  keras_model = ...
  return tff.learning.from_keras_model(keras_model, sample_batch, loss=...)

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

केरस रैपर का उपयोग हमारे छवि वर्गीकरण और टेक्स्ट जनरेशन ट्यूटोरियल में दिखाया गया है।

संघीय संगणना बिल्डर्स

tff.learning पैकेज tff.Computation के लिए कई निर्माता प्रदान करता है जो सीखने से संबंधित कार्य करता है; हम उम्मीद करते हैं कि भविष्य में ऐसी गणनाओं के सेट का विस्तार होगा।

वास्तु धारणा

कार्यान्वयन

फ़ेडरेटेड गणना चलाने में दो अलग-अलग चरण होते हैं।

  • संकलित करें : TFF पहले फ़ेडरेटेड लर्निंग एल्गोरिदम को संपूर्ण वितरित गणना के एक सार क्रमबद्ध प्रतिनिधित्व में संकलित करता है। यह तब होता है जब TensorFlow क्रमांकन होता है, लेकिन अधिक कुशल निष्पादन का समर्थन करने के लिए अन्य परिवर्तन हो सकते हैं। हम कंपाइलर द्वारा उत्सर्जित क्रमबद्ध प्रतिनिधित्व को एक फ़ेडरेटेड कंप्यूटेशन के रूप में संदर्भित करते हैं।

  • Execute TFF इन गणनाओं को निष्पादित करने के तरीके प्रदान करता है। अभी के लिए, निष्पादन केवल स्थानीय सिमुलेशन के माध्यम से समर्थित है (उदाहरण के लिए, नकली विकेन्द्रीकृत डेटा का उपयोग कर नोटबुक में)।

TFF के फेडरेटेड लर्निंग एपीआई द्वारा उत्पन्न एक फ़ेडरेटेड गणना, जैसे एक प्रशिक्षण एल्गोरिथ्म जो फ़ेडरेटेड मॉडल औसत का उपयोग करता है, या फ़ेडरेटेड मूल्यांकन में कई तत्व शामिल हैं, विशेष रूप से:

  • आपके मॉडल कोड का क्रमबद्ध रूप और साथ ही आपके मॉडल के प्रशिक्षण/मूल्यांकन लूप को चलाने के लिए फ़ेडरेटेड लर्निंग फ्रेमवर्क द्वारा निर्मित अतिरिक्त TensorFlow कोड (जैसे ऑप्टिमाइज़र का निर्माण, मॉडल अपडेट लागू करना, tf.data.Dataset s पर पुनरावृति, और कंप्यूटिंग मेट्रिक्स, और सर्वर पर समेकित अद्यतन लागू करना, कुछ नाम रखने के लिए)।

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

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

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

मॉडलिंग राज्य

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

चूंकि TFF कार्यात्मक है, इसलिए स्टेटफुल प्रक्रियाओं को TFF में गणना के रूप में तैयार किया जाता है जो वर्तमान स्थिति को एक इनपुट के रूप में स्वीकार करते हैं और फिर एक आउटपुट के रूप में अद्यतन स्थिति प्रदान करते हैं। एक स्टेटफुल प्रोसेस को पूरी तरह से परिभाषित करने के लिए, किसी को यह भी निर्दिष्ट करने की आवश्यकता होती है कि प्रारंभिक अवस्था कहाँ से आती है (अन्यथा हम प्रक्रिया को बूटस्ट्रैप नहीं कर सकते हैं)। यह सहायक वर्ग tff.templates.IterativeProcess की परिभाषा में कैप्चर किया गया है, जिसमें 2 गुण क्रमशः initialize और पुनरावृत्ति के अनुरूप next

उपलब्ध बिल्डर्स

फिलहाल, TFF विभिन्न बिल्डर फ़ंक्शंस प्रदान करता है जो फ़ेडरेटेड प्रशिक्षण और मूल्यांकन के लिए फ़ेडरेटेड कंप्यूटेशंस उत्पन्न करते हैं। दो उल्लेखनीय उदाहरणों में शामिल हैं:

  • tff.learning.algorithms.build_weighted_fed_avg , जो इनपुट के रूप में एक मॉडल फ़ंक्शन और एक क्लाइंट ऑप्टिमाइज़र लेता है, और एक स्टेटफुल tff.learning.templates.LearningProcess देता है (जो tff.templates.IterativeProcess को tff.templates.IterativeProcess )।

  • tff.learning.build_federated_evaluation एक मॉडल फ़ंक्शन लेता है और मॉडल के फ़ेडरेटेड मूल्यांकन के लिए एकल फ़ेडरेटेड गणना देता है, क्योंकि मूल्यांकन स्टेटफुल नहीं है।

डेटासेट

वास्तु धारणा

ग्राहक चयन

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

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

अपने फ़ेडरेटेड लर्निंग कोड की वास्तविक तैनाती का अनुकरण करने के लिए, आप आमतौर पर एक प्रशिक्षण लूप लिखेंगे जो इस तरह दिखता है:

trainer = tff.learning.algorithms.build_weighted_fed_avg(...)
state = trainer.initialize()
federated_training_data = ...

def sample(federate_data):
  return ...

while True:
  data_for_this_round = sample(federated_training_data)
  result = trainer.next(state, data_for_this_round)
  state = result.state

इसे सुविधाजनक बनाने के लिए, सिमुलेशन में TFF का उपयोग करते समय, फ़ेडरेटेड डेटा को Python list s के रूप में स्वीकार किया जाता है, जिसमें प्रति प्रतिभागी क्लाइंट डिवाइस में एक तत्व उस डिवाइस के स्थानीय tf.data.Dataset का प्रतिनिधित्व करने के लिए होता है।

सार इंटरफेस

सिम्युलेटेड फ़ेडरेटेड डेटा सेट के साथ व्यवहार को मानकीकृत करने के लिए, TFF एक अमूर्त इंटरफ़ेस tff.simulation.datasets.ClientData प्रदान करता है, जो किसी को क्लाइंट के सेट की गणना करने और एक tf.data.Dataset बनाने की अनुमति देता है जिसमें किसी विशेष डेटा का डेटा होता है। ग्राहक। उन tf.data.Dataset s को उत्सुक मोड में जेनरेट किए गए फ़ेडरेटेड कंप्यूटेशंस के इनपुट के रूप में सीधे फीड किया जा सकता है।

यह ध्यान दिया जाना चाहिए कि क्लाइंट पहचान तक पहुंचने की क्षमता एक ऐसी सुविधा है जो केवल सिमुलेशन में उपयोग के लिए डेटासेट द्वारा प्रदान की जाती है, जहां ग्राहकों के विशिष्ट सबसेट से डेटा पर प्रशिक्षित करने की क्षमता की आवश्यकता हो सकती है (उदाहरण के लिए, विभिन्न की दैनिक उपलब्धता को अनुकरण करने के लिए) ग्राहकों के प्रकार)। संकलित गणना और अंतर्निहित रनटाइम में क्लाइंट पहचान की कोई धारणा शामिल नहीं है। एक बार क्लाइंट के विशिष्ट सबसेट के डेटा को इनपुट के रूप में चुना गया है, उदाहरण के लिए, tff.templates.IterativeProcess.next पर कॉल में, क्लाइंट पहचान अब इसमें दिखाई नहीं देती है।

उपलब्ध डेटा सेट

हमने डेटासेट के लिए नेमस्पेस tff.simulation.datasets को समर्पित किया है जो सिमुलेशन में उपयोग के लिए tff.simulation.datasets.ClientData इंटरफ़ेस को लागू करता है, और छवि वर्गीकरण और टेक्स्ट जनरेशन ट्यूटोरियल का समर्थन करने के लिए इसे डेटासेट के साथ सीड किया है। हम आपको प्लेटफ़ॉर्म पर अपने स्वयं के डेटासेट योगदान करने के लिए प्रोत्साहित करना चाहते हैं।