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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

अवलोकन

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

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

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

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

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

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

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

मॉडल

वास्तु अनुमान

क्रमबद्धता

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

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

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

एकत्रीकरण

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

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

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

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

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

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

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

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

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

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

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

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

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

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

सार इंटरफेस

यह मूल कंस्ट्रक्टर + मेटाडेटा इंटरफ़ेस tff.learning.models.VariableModel इंटरफ़ेस द्वारा निम्नानुसार दर्शाया गया है:

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

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

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

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

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

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

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

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 क्रमांकन होता है, लेकिन अधिक कुशल निष्पादन का समर्थन करने के लिए अन्य परिवर्तन हो सकते हैं। हम संकलक द्वारा उत्सर्जित क्रमबद्ध प्रतिनिधित्व को संघबद्ध संगणना के रूप में संदर्भित करते हैं।

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

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

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

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

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

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

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

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

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

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

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

  • tff.learning.algorithms.build_weighted_fed_avg , जो इनपुट के रूप में एक मॉडल फ़ंक्शन और क्लाइंट ऑप्टिमाइज़र लेता है, और एक स्टेटफुल tff.learning.templates.LearningProcess LearningProcess देता है (जो 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 का उपयोग करते समय, फ़ेडरेटेड डेटा को उस डिवाइस के स्थानीय tf.data.Dataset का प्रतिनिधित्व करने के लिए प्रति भाग लेने वाले क्लाइंट डिवाइस के एक तत्व के साथ Python list s के रूप में स्वीकार किया जाता है।

सार इंटरफेस

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

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

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

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