संघीय कार्यक्रम

यह दस्तावेज़ीकरण ऐसे किसी भी व्यक्ति के लिए है जो फ़ेडरेटेड प्रोग्राम अवधारणाओं के उच्च-स्तरीय अवलोकन में रुचि रखता है। यह TensorFlow Federated, विशेष रूप से इसके प्रकार प्रणाली का ज्ञान मानता है।

फ़ेडरेटेड प्रोग्राम के बारे में अधिक जानकारी के लिए देखें:

फ़ेडरेटेड प्रोग्राम क्या है?

फ़ेडरेटेड प्रोग्राम एक प्रोग्राम है जो फ़ेडरेटेड वातावरण में गणना और अन्य प्रसंस्करण तर्क निष्पादित करता है।

अधिक, विशेष रूप से एक फ़ेडरेटेड प्रोग्राम :

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

टीएफएफ की फ़ेडरेटेड प्रोग्राम लाइब्रेरी ( tff.program ) फ़ेडरेटेड प्रोग्राम बनाने के लिए आवश्यक अमूर्तताओं को परिभाषित करती है और प्लेटफ़ॉर्म-अज्ञेयवादी घटक प्रदान करती है।

अवयव 

<!--#include file="components.dot"-->

टीएफएफ के फ़ेडरेटेड प्रोग्राम लाइब्रेरी के घटकों को डिज़ाइन किया गया है ताकि उनका स्वामित्व और लेखन विभिन्न भूमिकाओं द्वारा किया जा सके।

कार्यक्रम

प्रोग्राम एक पायथन बाइनरी है जो:

  1. पैरामीटर परिभाषित करता है (जैसे झंडे)
  2. प्लेटफ़ॉर्म-विशिष्ट घटकों और प्लेटफ़ॉर्म-अज्ञेयवादी घटकों का निर्माण करता है
  3. फ़ेडरेटेड संदर्भ में प्रोग्राम तर्क का उपयोग करके गणना निष्पादित करता है

उदाहरण के लिए:

# Parameters set by the customer.
flags.DEFINE_string('output_dir', None, 'The output path.')

def main() -> None:

  # Parameters set by the program.
  total_rounds = 10
  num_clients = 3

  # Construct the platform-specific components.
  context = tff.program.NativeFederatedContext(...)
  data_source = tff.program.DatasetDataSource(...)

  # Construct the platform-agnostic components.
  summary_dir = os.path.join(FLAGS.output_dir, 'summary')
  metrics_manager = tff.program.GroupingReleaseManager([
      tff.program.LoggingReleaseManager(),
      tff.program.TensorBoardReleaseManager(summary_dir),
  ])
  program_state_dir = os.path.join(..., 'program_state')
  program_state_manager = tff.program.FileProgramStateManager(program_state_dir)

  # Define the computations.
  initialize = ...
  train = ...

  # Execute the computations using program logic.
  tff.framework.set_default_context(context)
  asyncio.run(
      train_federated_model(
          initialize=initialize,
          train=train,
          data_source=data_source,
          total_rounds=total_rounds,
          num_clients=num_clients,
          metrics_manager=metrics_manager,
          program_state_manager=program_state_manager,
      )
  )

पैरामीटर

पैरामीटर प्रोग्राम के इनपुट हैं, ये इनपुट ग्राहक द्वारा सेट किए जा सकते हैं, यदि वे झंडे के रूप में प्रदर्शित होते हैं, या वे प्रोग्राम द्वारा सेट किए जा सकते हैं। उपरोक्त उदाहरण में, output_dir एक पैरामीटर है जो ग्राहक द्वारा निर्धारित किया गया है, और total_rounds और num_clients प्रोग्राम द्वारा निर्धारित पैरामीटर हैं।

प्लेटफ़ॉर्म-विशिष्ट घटक

प्लेटफ़ॉर्म-विशिष्ट घटक टीएफएफ के फ़ेडरेटेड प्रोग्राम लाइब्रेरी द्वारा परिभाषित अमूर्त इंटरफेस को लागू करने वाले प्लेटफ़ॉर्म द्वारा प्रदान किए गए घटक हैं।

प्लेटफ़ॉर्म-अज्ञेयवादी घटक

प्लेटफ़ॉर्म-अज्ञेयवादी घटक एक लाइब्रेरी (जैसे टीएफएफ) द्वारा प्रदान किए गए घटक हैं जो टीएफएफ के फ़ेडरेटेड प्रोग्राम लाइब्रेरी द्वारा परिभाषित अमूर्त इंटरफेस को लागू करते हैं।

संगणना

संगणनाएँ अमूर्त इंटरफ़ेस tff.Computation का कार्यान्वयन हैं।

उदाहरण के लिए, TFF प्लेटफ़ॉर्म में आप tff.framework.ConcreteComputation बनाने के लिए tff.tensorflow.computation या tff.federated_computation डेकोरेटर का उपयोग कर सकते हैं:

अधिक जानकारी के लिए गणना का जीवन देखें।

प्रोग्राम तर्क

प्रोग्राम लॉजिक एक पायथन फ़ंक्शन है जो इनपुट के रूप में लेता है:

और कुछ ऑपरेशन करता है, जिसमें आम तौर पर शामिल हैं:

और कुछ आउटपुट प्राप्त कर सकता है, जिसमें आम तौर पर शामिल हैं:

उदाहरण के लिए:

async def program_logic(
    initialize: tff.Computation,
    train: tff.Computation,
    data_source: tff.program.FederatedDataSource,
    total_rounds: int,
    num_clients: int,
    metrics_manager: tff.program.ReleaseManager[
        tff.program.ReleasableStructure, int
    ],
) -> None:
  state = initialize()
  start_round = 1

  data_iterator = data_source.iterator()
  for round_number in range(1, total_rounds + 1):
    train_data = data_iterator.select(num_clients)
    state, metrics = train(state, train_data)

    _, metrics_type = train.type_signature.result
    metrics_manager.release(metrics, metrics_type, round_number)

भूमिकाएँ

फ़ेडरेटेड प्रोग्रामों पर चर्चा करते समय तीन भूमिकाएँ परिभाषित करना उपयोगी होता है: ग्राहक , प्लेटफ़ॉर्म और लाइब्रेरी । इनमें से प्रत्येक भूमिका फ़ेडरेटेड प्रोग्राम बनाने के लिए उपयोग किए जाने वाले कुछ घटकों का स्वामी और लेखक है। हालाँकि, एक इकाई या समूह के लिए कई भूमिकाएँ निभाना संभव है।

ग्राहक

ग्राहक आमतौर पर:

लेकिन हो सकता है:

प्लैटफ़ॉर्म

मंच आम तौर पर:

लेकिन हो सकता है:

पुस्तकालय

एक पुस्तकालय आम तौर पर:

अवधारणाओं 

<!--#include file="concepts.dot"-->

ऐसी कुछ अवधारणाएँ हैं जिन्हें फ़ेडरेटेड कार्यक्रमों पर चर्चा करते समय परिभाषित करना उपयोगी होता है।

ग्राहक भंडारण

ग्राहक संग्रहण वह संग्रहण है जिसे ग्राहक के पास पढ़ने और लिखने की पहुंच है और प्लेटफ़ॉर्म के पास लिखने की पहुंच है।

प्लेटफार्म भंडारण

प्लेटफ़ॉर्म स्टोरेज वह स्टोरेज है जिसे केवल प्लेटफ़ॉर्म ही पढ़ और लिख सकता है।

मुक्त करना

मूल्य जारी करने से मूल्य ग्राहक भंडारण के लिए उपलब्ध हो जाता है (उदाहरण के लिए डैशबोर्ड पर मूल्य प्रकाशित करना, मूल्य लॉग करना, या डिस्क पर मूल्य लिखना)।

अमल में लाना

किसी मान संदर्भ को मूर्त रूप देने से संदर्भित मान प्रोग्राम के लिए उपलब्ध हो जाता है। अक्सर मूल्य जारी करने या प्रोग्राम तर्क को दोष सहिष्णु बनाने के लिए मूल्य संदर्भ को मूर्त रूप देना आवश्यक होता है।

दोष सहिष्णुता

दोष सहनशीलता किसी गणना को निष्पादित करते समय विफलता से उबरने के लिए प्रोग्राम लॉजिक की क्षमता है। उदाहरण के लिए, यदि आप 100 में से पहले 90 राउंड को सफलतापूर्वक प्रशिक्षित करते हैं और फिर विफलता का अनुभव करते हैं, तो क्या प्रोग्राम लॉजिक राउंड 91 से प्रशिक्षण फिर से शुरू करने में सक्षम है या क्या प्रशिक्षण को राउंड 1 में फिर से शुरू करने की आवश्यकता है?