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

इमेज क्लासिफिकेशन के लिए फेडरेटेड लर्निंग

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

इस ट्यूटोरियल में, हम TFF की फेडरेटेड लर्निंग (FL) API लेयर, tff.learning का परिचय देने के लिए क्लासिक MNIST प्रशिक्षण उदाहरण का उपयोग करते हैं - उच्च-स्तरीय इंटरफेस का एक सेट जो सामान्य प्रकार के फ़ेडरेटेड लर्निंग कार्यों को करने के लिए उपयोग किया जा सकता है, जैसे फ़ेडरेटेड प्रशिक्षण, TensorFlow में कार्यान्वित उपयोगकर्ता-प्रदत्त मॉडलों के विरुद्ध।

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

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

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

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


!pip install --quiet --upgrade tensorflow_federated_nightly
!pip install --quiet --upgrade nest_asyncio

import nest_asyncio
nest_asyncio.apply()

%load_ext tensorboard
import collections

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

np.random.seed(0)

tff.federated_computation(lambda: 'Hello, World!')()
b'Hello, World!'

इनपुट डेटा तैयार करना

चलो डेटा के साथ शुरू करते हैं। फ़ेडरेटेड लर्निंग को एक फ़ेडरेटेड डेटा सेट की आवश्यकता होती है, अर्थात, कई उपयोगकर्ताओं के डेटा का संग्रह। फ़ेडरेटेड डेटा आम तौर पर गैर- iid होता है , जो चुनौतियों का एक अनूठा समूह बनाता है

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

यहां बताया गया है कि हम इसे कैसे लोड कर सकते हैं।

emnist_train, emnist_test = tff.simulation.datasets.emnist.load_data()

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

len(emnist_train.client_ids)
3383
emnist_train.element_type_structure
OrderedDict([('pixels', TensorSpec(shape=(28, 28), dtype=tf.float32, name=None)), ('label', TensorSpec(shape=(), dtype=tf.int32, name=None))])
example_dataset = emnist_train.create_tf_dataset_for_client(
    emnist_train.client_ids[0])

example_element = next(iter(example_dataset))

example_element['label'].numpy()
1
from matplotlib import pyplot as plt
plt.imshow(example_element['pixels'].numpy(), cmap='gray', aspect='equal')
plt.grid(False)
_ = plt.show()

png

फेडरेटेड डेटा में विषमता की खोज

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

सबसे पहले, आइए एक सिम्युलेटेड डिवाइस पर उदाहरणों के लिए एक ग्राहक के डेटा का नमूना लें। क्योंकि हम जिस डेटासेट का उपयोग कर रहे हैं वह अद्वितीय लेखक द्वारा कुंजीबद्ध किया गया है, एक ग्राहक का डेटा 9 के माध्यम से अंकों 0 के नमूने के लिए एक व्यक्ति की लिखावट का प्रतिनिधित्व करता है, एक उपयोगकर्ता के अद्वितीय "उपयोग पैटर्न" का अनुकरण करता है।

## Example MNIST digits for one client
figure = plt.figure(figsize=(20, 4))
j = 0

for example in example_dataset.take(40):
  plt.subplot(4, 10, j+1)
  plt.imshow(example['pixels'].numpy(), cmap='gray', aspect='equal')
  plt.axis('off')
  j += 1

png

अब चलो प्रत्येक MNIST अंक लेबल के लिए प्रत्येक क्लाइंट पर उदाहरणों की संख्या की कल्पना करें। फ़ेडरेटेड वातावरण में, उपयोगकर्ता के व्यवहार के आधार पर प्रत्येक क्लाइंट पर उदाहरणों की संख्या काफी भिन्न हो सकती है।

# Number of examples per layer for a sample of clients
f = plt.figure(figsize=(12, 7))
f.suptitle('Label Counts for a Sample of Clients')
for i in range(6):
  client_dataset = emnist_train.create_tf_dataset_for_client(
      emnist_train.client_ids[i])
  plot_data = collections.defaultdict(list)
  for example in client_dataset:
    # Append counts individually per label to make plots
    # more colorful instead of one color per plot.
    label = example['label'].numpy()
    plot_data[label].append(label)
  plt.subplot(2, 3, i+1)
  plt.title('Client {}'.format(i))
  for j in range(10):
    plt.hist(
        plot_data[j],
        density=False,
        bins=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

png

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

# Each client has different mean images, meaning each client will be nudging
# the model in their own directions locally.

for i in range(5):
  client_dataset = emnist_train.create_tf_dataset_for_client(
      emnist_train.client_ids[i])
  plot_data = collections.defaultdict(list)
  for example in client_dataset:
    plot_data[example['label'].numpy()].append(example['pixels'].numpy())
  f = plt.figure(i, figsize=(12, 5))
  f.suptitle("Client #{}'s Mean Image Per Label".format(i))
  for j in range(10):
    mean_img = np.mean(plot_data[j], 0)
    plt.subplot(2, 5, j+1)
    plt.imshow(mean_img.reshape((28, 28)))
    plt.axis('off')

png

png

png

png

png

उपयोगकर्ता डेटा शोर और अविश्वसनीय रूप से लेबल किया जा सकता है। उदाहरण के लिए, ऊपर क्लाइंट # 2 के डेटा को देखते हुए, हम देख सकते हैं कि लेबल 2 के लिए, यह संभव है कि कुछ गलत उदाहरणों से नॉइज़ियर माध्य छवि का निर्माण हो सकता है।

इनपुट डेटा को रोकना

चूंकि डेटा पहले से ही एक tf.data.Dataset , tf.data.Dataset Dataset परिवर्तनों का उपयोग करके प्रीप्रोसेसिंग को पूरा किया जा सकता है। यहां, हम 28x28 छवियों को 784 28x28 सरणियों में समतल करते हैं, व्यक्तिगत उदाहरणों को फेरबदल करते हैं, उन्हें बैचों में व्यवस्थित करते हैं, और केरस के साथ उपयोग के लिए pixels और label से x और y तक की विशेषताओं का नाम बदल देते हैं। हम कई युगों को चलाने के लिए सेट किए गए डेटा को repeat हैं।

NUM_CLIENTS = 10
NUM_EPOCHS = 5
BATCH_SIZE = 20
SHUFFLE_BUFFER = 100
PREFETCH_BUFFER= 10

def preprocess(dataset):

  def batch_format_fn(element):
    """Flatten a batch `pixels` and return the features as an `OrderedDict`."""
    return collections.OrderedDict(
        x=tf.reshape(element['pixels'], [-1, 784]),
        y=tf.reshape(element['label'], [-1, 1]))

  return dataset.repeat(NUM_EPOCHS).shuffle(SHUFFLE_BUFFER).batch(
      BATCH_SIZE).map(batch_format_fn).prefetch(PREFETCH_BUFFER)

आइए इस काम को सत्यापित करें।

preprocessed_example_dataset = preprocess(example_dataset)

sample_batch = tf.nest.map_structure(lambda x: x.numpy(),
                                     next(iter(preprocessed_example_dataset)))

sample_batch
OrderedDict([('x', array([[1., 1., 1., ..., 1., 1., 1.],
       [1., 1., 1., ..., 1., 1., 1.],
       [1., 1., 1., ..., 1., 1., 1.],
       ...,
       [1., 1., 1., ..., 1., 1., 1.],
       [1., 1., 1., ..., 1., 1., 1.],
       [1., 1., 1., ..., 1., 1., 1.]], dtype=float32)), ('y', array([[2],
       [1],
       [2],
       [3],
       [6],
       [0],
       [1],
       [4],
       [1],
       [0],
       [6],
       [9],
       [9],
       [3],
       [6],
       [1],
       [4],
       [8],
       [0],
       [2]], dtype=int32))])

हमारे पास फ़ेडरेटेड डेटा सेट बनाने के लिए लगभग सभी बिल्डिंग ब्लॉक हैं।

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

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

def make_federated_data(client_data, client_ids):
  return [
      preprocess(client_data.create_tf_dataset_for_client(x))
      for x in client_ids
  ]

अब, हम ग्राहकों को कैसे चुनते हैं?

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

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

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

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

sample_clients = emnist_train.client_ids[0:NUM_CLIENTS]

federated_train_data = make_federated_data(emnist_train, sample_clients)

print('Number of client datasets: {l}'.format(l=len(federated_train_data)))
print('First dataset: {d}'.format(d=federated_train_data[0]))
Number of client datasets: 10
First dataset: <DatasetV1Adapter shapes: OrderedDict([(x, (None, 784)), (y, (None, 1))]), types: OrderedDict([(x, tf.float32), (y, tf.int32)])>

केरस के साथ एक मॉडल बनाना

यदि आप केरस का उपयोग कर रहे हैं, तो आपके पास पहले से ही एक कोड है जो कि केरस मॉडल का निर्माण करता है। यहाँ एक सरल मॉडल का उदाहरण दिया गया है जो हमारी आवश्यकताओं के लिए पर्याप्त होगा।

def create_keras_model():
  return tf.keras.models.Sequential([
      tf.keras.layers.Input(shape=(784,)),
      tf.keras.layers.Dense(10, kernel_initializer='zeros'),
      tf.keras.layers.Softmax(),
  ])

TFF के साथ किसी भी मॉडल का उपयोग करने के लिए, इसे tff.learning.Model इंटरफ़ेस के उदाहरण में tff.learning.Model , जो मॉडल के फॉरवर्ड पास, मेटाडेटा गुण आदि को स्टैम्प करने के तरीकों को उजागर करता है, जो कि tff.learning.Model समान है, लेकिन अतिरिक्त का परिचय देता है। तत्व, जैसे संघनित मैट्रिक्स की गणना की प्रक्रिया को नियंत्रित करने के तरीके। चलो अब इसके बारे में चिंता न करें; यदि आपके पास एक Keras मॉडल है जैसा कि हमने अभी-अभी ऊपर परिभाषित किया है, तो आप TFF को आपके लिए tff.learning.from_keras_model , मॉडल पास करने और तर्कों के रूप में एक नमूना डेटा बैच पास करके, जैसा कि नीचे दिखाया गया है, लपेट कर सकते हैं।

def model_fn():
  # We _must_ create a new model here, and _not_ capture it from an external
  # scope. TFF will call this within different graph contexts.
  keras_model = create_keras_model()
  return tff.learning.from_keras_model(
      keras_model,
      input_spec=preprocessed_example_dataset.element_spec,
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])

फेडरेटेड डेटा पर मॉडल का प्रशिक्षण

अब जब हमारे पास TFF के साथ उपयोग के लिए tff.learning.Model के रूप में एक मॉडल लिपटा है, तो हम TFF को निम्न प्रकार से हेल्पर फंक्शन tff.learning.build_federated_averaging_process फेडरेटेड एवरेजिंग एल्गोरिथ्म बनाने दे सकते हैं।

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

नीचे फेडरेटेड एवरेजिंग एल्गोरिथ्म पर एक महत्वपूर्ण नोट, 2 ऑप्टिमाइज़र हैं: एक _क्लाइंट ऑप्टिमाइज़र और _server ऑप्टिमाइज़र । _Client अनुकूलक का उपयोग केवल प्रत्येक ग्राहक पर स्थानीय मॉडल अपडेट की गणना करने के लिए किया जाता है। _Server अनुकूलक सर्वर पर वैश्विक मॉडल के औसत अद्यतन को लागू करता है। विशेष रूप से, इसका मतलब है कि उपयोग किए जाने वाले ऑप्टिमाइज़र और सीखने की दर का विकल्प आपको मानक आईआईडी डेटासेट पर मॉडल को प्रशिक्षित करने के लिए उपयोग किए जाने वाले से भिन्न होना चाहिए। हम नियमित रूप से SGD के साथ शुरू करने की सलाह देते हैं, संभवतः सामान्य से छोटी सीखने की दर के साथ। हमारे द्वारा उपयोग की जाने वाली सीखने की दर को ध्यान से नहीं देखा गया है, प्रयोग करने के लिए स्वतंत्र महसूस करें।

iterative_process = tff.learning.build_federated_averaging_process(
    model_fn,
    client_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=0.02),
    server_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=1.0))

अभी क्या हुआ? TFF फ़ेडरेटेड संगणना की एक जोड़ी का निर्माण किया है और उन्हें एक में पैक किया गया है tff.templates.IterativeProcess के रूप में गुण की एक जोड़ी है, जिसमें इन गणनाओं उपलब्ध हैं initialize और next

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

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

आइए initialize गणना के साथ शुरू करें। जैसा कि सभी संघनित संगणनाओं के लिए होता है, आप इसे एक कार्य के रूप में सोच सकते हैं। अभिकलन कोई तर्क नहीं लेता है, और एक परिणाम देता है - सर्वर पर Federated Averaging प्रक्रिया की स्थिति का प्रतिनिधित्व। जबकि हम TFF के विवरण में गोता नहीं लगाना चाहते हैं, यह देखने के लिए शिक्षाप्रद हो सकता है कि यह राज्य कैसा दिखता है। आप इसकी कल्पना इस प्रकार कर सकते हैं।

str(iterative_process.initialize.type_signature)
'( -> <model=<trainable=<float32[784,10],float32[10]>,non_trainable=<>>,optimizer_state=<int64>,delta_aggregate_state=<>,model_broadcast_state=<>>@SERVER)'

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

आइए सर्वर राज्य के निर्माण के लिए initialize कम्प्यूटेशन को लागू करें।

state = iterative_process.initialize()

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

वैचारिक रूप से, आप next प्रकार के कार्यात्मक प्रकार के हस्ताक्षर होने के बारे में सोच सकते हैं जो निम्नानुसार है।

SERVER_STATE, FEDERATED_DATA -> SERVER_STATE, TRAINING_METRICS

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

चलो प्रशिक्षण का एक दौर चलाते हैं और परिणामों की कल्पना करते हैं। उपयोगकर्ताओं के नमूने के लिए हम पहले से तैयार किए गए फ़ेडरेटेड डेटा का उपयोग कर सकते हैं।

state, metrics = iterative_process.next(state, federated_train_data)
print('round  1, metrics={}'.format(metrics))
round  1, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.12037037312984467,loss=3.0108425617218018>>

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

NUM_ROUNDS = 11
for round_num in range(2, NUM_ROUNDS):
  state, metrics = iterative_process.next(state, federated_train_data)
  print('round {:2d}, metrics={}'.format(round_num, metrics))
round  2, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.14814814925193787,loss=2.8865506649017334>>
round  3, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.148765429854393,loss=2.9079062938690186>>
round  4, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.17633745074272156,loss=2.724686622619629>>
round  5, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.20226337015628815,loss=2.6334855556488037>>
round  6, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.22427983582019806,loss=2.5482592582702637>>
round  7, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.24094650149345398,loss=2.4472343921661377>>
round  8, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.259876549243927,loss=2.3809611797332764>>
round  9, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.29814815521240234,loss=2.156442403793335>>
round 10, metrics=<broadcast=<>,aggregation=<>,train=<sparse_categorical_accuracy=0.31687241792678833,loss=2.122845411300659>>

संघ के प्रशिक्षण के प्रत्येक दौर के बाद प्रशिक्षण हानि कम हो रही है, यह दर्शाता है कि मॉडल परिवर्तित हो रहा है। इन प्रशिक्षण मीट्रिक के साथ कुछ महत्वपूर्ण चेतावनी हैं, हालांकि, बाद में इस ट्यूटोरियल में मूल्यांकन पर अनुभाग देखें।

TensorBoard में मॉडल मेट्रिक्स प्रदर्शित करना

इसके बाद, आइए Tensorboard का उपयोग करके इन संघनित संगणनाओं से मैट्रिक्स की कल्पना करें।

आइए मेट्रिक्स को लिखने के लिए डायरेक्टरी और संबंधित सारांश लेखक बनाकर शुरू करें।


logdir = "/tmp/logs/scalars/training/"
summary_writer = tf.summary.create_file_writer(logdir)
state = iterative_process.initialize()

एक ही सारांश लेखक के साथ प्रासंगिक स्केलर मेट्रिक्स प्लॉट करें।


with summary_writer.as_default():
  for round_num in range(1, NUM_ROUNDS):
    state, metrics = iterative_process.next(state, federated_train_data)
    for name, value in metrics.train._asdict().items():
      tf.summary.scalar(name, value, step=round_num)

ऊपर निर्दिष्ट रूट लॉग डायरेक्टरी के साथ TensorBoard प्रारंभ करें। डेटा को लोड करने में कुछ सेकंड लग सकते हैं।


%tensorboard --logdir /tmp/logs/scalars/ --port=0

# Run this this cell to clean your directory of old output for future graphs from this directory.
rm -R /tmp/logs/scalars/*

मूल्यांकन मैट्रिक्स को उसी तरह से देखने के लिए, आप TensorBoard को लिखने के लिए "लॉग / स्केलर / eval" की तरह एक अलग ईवैल फ़ोल्डर बना सकते हैं।

मॉडल कार्यान्वयन को अनुकूलित करना

Keras , TensorFlow के लिए अनुशंसित उच्च-स्तरीय मॉडल API है और जब भी संभव हो, हम TFF में tff.learning.from_keras_model मॉडल ( tff.learning.from_keras_model माध्यम से) का उपयोग करने के लिए प्रोत्साहित करते हैं।

हालाँकि, tff.learning एक निम्न-स्तरीय मॉडल इंटरफ़ेस प्रदान करता है, tff.learning.Model , जो कि फ़ेडरेटेड लर्निंग के लिए एक मॉडल का उपयोग करने के लिए आवश्यक न्यूनतम कार्यक्षमता को उजागर करता है। इस इंटरफ़ेस को प्रत्यक्ष रूप से लागू करना (संभवतः अभी भी tf.keras.layers जैसे बिल्डिंग ब्लॉक्स का उपयोग tf.keras.layers ) फ़ेडरेटेड लर्निंग एल्गोरिदम के आंतरिक को संशोधित किए बिना अधिकतम अनुकूलन के लिए अनुमति देता है।

तो चलो यह सब फिर से खरोंच से करते हैं।

मॉडल चर, आगे पास और मैट्रिक्स को परिभाषित करना

पहला कदम यह है कि हम जिस TensorFlow चर के साथ काम करने जा रहे हैं, उसकी पहचान करें। निम्नलिखित कोड को अधिक सुपाठ्य बनाने के लिए, आइए पूरे सेट का प्रतिनिधित्व करने के लिए एक डेटा संरचना को परिभाषित करें। इस तरह के रूप में चर शामिल होंगे weights और bias है कि हम प्रशिक्षित करेंगे, साथ ही चर है कि इस तरह के रूप में विभिन्न संचयी आँकड़े और काउंटर हम प्रशिक्षण के दौरान अपडेट करेगा, का आयोजन करेगा loss_sum , accuracy_sum , और num_examples

MnistVariables = collections.namedtuple(
    'MnistVariables', 'weights bias num_examples loss_sum accuracy_sum')

यहाँ एक विधि है जो चर बनाता है। सादगी के लिए, हम tf.float32 रूप में सभी आँकड़ों का प्रतिनिधित्व करते हैं, क्योंकि यह बाद के चरण में प्रकार के रूपांतरण की आवश्यकता को समाप्त कर देगा। लैंबडास के रूप में वैरिएबल इनिशियलाइज़र को लपेटना एक आवश्यकता है जो संसाधन चरों द्वारा लगाया जाता है

def create_mnist_variables():
  return MnistVariables(
      weights=tf.Variable(
          lambda: tf.zeros(dtype=tf.float32, shape=(784, 10)),
          name='weights',
          trainable=True),
      bias=tf.Variable(
          lambda: tf.zeros(dtype=tf.float32, shape=(10)),
          name='bias',
          trainable=True),
      num_examples=tf.Variable(0.0, name='num_examples', trainable=False),
      loss_sum=tf.Variable(0.0, name='loss_sum', trainable=False),
      accuracy_sum=tf.Variable(0.0, name='accuracy_sum', trainable=False))

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

def mnist_forward_pass(variables, batch):
  y = tf.nn.softmax(tf.matmul(batch['x'], variables.weights) + variables.bias)
  predictions = tf.cast(tf.argmax(y, 1), tf.int32)

  flat_labels = tf.reshape(batch['y'], [-1])
  loss = -tf.reduce_mean(
      tf.reduce_sum(tf.one_hot(flat_labels, 10) * tf.math.log(y), axis=[1]))
  accuracy = tf.reduce_mean(
      tf.cast(tf.equal(predictions, flat_labels), tf.float32))

  num_examples = tf.cast(tf.size(batch['y']), tf.float32)

  variables.num_examples.assign_add(num_examples)
  variables.loss_sum.assign_add(loss * num_examples)
  variables.accuracy_sum.assign_add(accuracy * num_examples)

  return loss, predictions

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

यहां, हम केवल औसत loss और accuracy , साथ ही साथ num_examples , जो हमें कुल समुच्चय की गणना करते समय विभिन्न उपयोगकर्ताओं से योगदान को सही ढंग से वजन करने की आवश्यकता होगी।

def get_local_mnist_metrics(variables):
  return collections.OrderedDict(
      num_examples=variables.num_examples,
      loss=variables.loss_sum / variables.num_examples,
      accuracy=variables.accuracy_sum / variables.num_examples)

अंत में, हमें यह निर्धारित करने की आवश्यकता है कि get_local_mnist_metrics माध्यम से प्रत्येक डिवाइस द्वारा उत्सर्जित स्थानीय मीट्रिक को कैसे एकत्रित किया get_local_mnist_metrics । यह कोड का एकमात्र हिस्सा है जो TensorFlow में नहीं लिखा गया है - यह TFF में व्यक्त संघबद्ध गणना है । यदि आप गहरी खुदाई करना चाहते हैं, तो कस्टम एल्गोरिदम ट्यूटोरियल पर स्किम करें, लेकिन अधिकांश अनुप्रयोगों में, आपको वास्तव में इसकी आवश्यकता नहीं होगी; नीचे दिखाए गए पैटर्न के वेरिएंट को पर्याप्त होना चाहिए। यहाँ यह कैसा दिखता है:

@tff.federated_computation
def aggregate_mnist_metrics_across_clients(metrics):
  return collections.OrderedDict(
      num_examples=tff.federated_sum(metrics.num_examples),
      loss=tff.federated_mean(metrics.loss, metrics.num_examples),
      accuracy=tff.federated_mean(metrics.accuracy, metrics.num_examples))
  

इनपुट metrics को तर्क संगत OrderedDict द्वारा दिया get_local_mnist_metrics ऊपर है, लेकिन गंभीर रूप से मान नहीं रह रहे हैं tf.Tensors - वे के रूप में "बॉक्सिंग" हैं tff.Value रों, यह आप नहीं रह गया है TensorFlow का उपयोग कर उन्हें हेरफेर कर सकते हैं स्पष्ट करने के लिए, लेकिन केवल tff.federated_mean और tff.federated_sum जैसे TFF के फ़ेडरेटेड ऑपरेटर्स का उपयोग tff.federated_sum । वैश्विक समुच्चय का लौटा हुआ डिक्शनरी मेट्रिक्स के सेट को परिभाषित करता है जो सर्वर पर उपलब्ध होगा।

tff.learning.Model का एक उदाहरण का निर्माण

उपरोक्त सभी के साथ, हम TFF के उपयोग के लिए एक मॉडल प्रतिनिधित्व का निर्माण करने के लिए तैयार हैं, जो आपके लिए तब उत्पन्न होता है जब आप TFF को Keras मॉडल को निगलना देते हैं।

class MnistModel(tff.learning.Model):

  def __init__(self):
    self._variables = create_mnist_variables()

  @property
  def trainable_variables(self):
    return [self._variables.weights, self._variables.bias]

  @property
  def non_trainable_variables(self):
    return []

  @property
  def local_variables(self):
    return [
        self._variables.num_examples, self._variables.loss_sum,
        self._variables.accuracy_sum
    ]

  @property
  def input_spec(self):
    return collections.OrderedDict(
        x=tf.TensorSpec([None, 784], tf.float32),
        y=tf.TensorSpec([None, 1], tf.int32))

  @tf.function
  def forward_pass(self, batch, training=True):
    del training
    loss, predictions = mnist_forward_pass(self._variables, batch)
    num_exmaples = tf.shape(batch['x'])[0]
    return tff.learning.BatchOutput(
        loss=loss, predictions=predictions, num_examples=num_exmaples)

  @tf.function
  def report_local_outputs(self):
    return get_local_mnist_metrics(self._variables)

  @property
  def federated_output_computation(self):
    return aggregate_mnist_metrics_across_clients

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

यहाँ कुछ बिंदुओं पर प्रकाश डाला गया है:

  • सभी राज्य जो आपके मॉडल का उपयोग करेंगे, उन्हें TensorFlow चर के रूप में कैप्चर किया जाना चाहिए, क्योंकि TFF रनटाइम में पायथन का उपयोग नहीं करता है (याद रखें कि आपका कोड ऐसा लिखा जाना चाहिए कि इसे मोबाइल उपकरणों पर तैनात किया जा सके; अधिक गहराई के लिए कस्टम एल्गोरिदम ट्यूटोरियल देखें; कारणों पर टिप्पणी)।
  • आपके मॉडल को यह वर्णन करना चाहिए कि वह किस रूप में डेटा स्वीकार करता है ( input_spec ), सामान्य रूप से, TFF एक दृढ़ता से टाइप किया गया वातावरण है और सभी घटकों के लिए प्रकार हस्ताक्षर निर्धारित करना चाहता है। अपने मॉडल के इनपुट के प्रारूप की घोषणा करना इसका एक अनिवार्य हिस्सा है।
  • यद्यपि तकनीकी रूप से आवश्यक नहीं है, हम सभी TensorFlow तर्क (आगे पास, मीट्रिक गणना, आदि) को tf.function s के रूप में लपेटने की सलाह देते हैं, क्योंकि यह सुनिश्चित करने में मदद करता है कि TensorFlow को अनुक्रमित किया जा सकता है, और स्पष्ट नियंत्रण निर्भरता की आवश्यकता को हटा देता है।

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

नए मॉडल के साथ संयुक्त प्रशिक्षण का अनुकरण करना

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

iterative_process = tff.learning.build_federated_averaging_process(
    MnistModel,
    client_optimizer_fn=lambda: tf.keras.optimizers.SGD(learning_rate=0.02))
state = iterative_process.initialize()
state, metrics = iterative_process.next(state, federated_train_data)
print('round  1, metrics={}'.format(metrics))
round  1, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.9713594913482666,accuracy=0.13518518209457397>>

for round_num in range(2, 11):
  state, metrics = iterative_process.next(state, federated_train_data)
  print('round {:2d}, metrics={}'.format(round_num, metrics))
round  2, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.975412607192993,accuracy=0.14032921195030212>>
round  3, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.9395227432250977,accuracy=0.1594650149345398>>
round  4, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.710164785385132,accuracy=0.17139917612075806>>
round  5, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.5891618728637695,accuracy=0.20267489552497864>>
round  6, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.5148487091064453,accuracy=0.21666666865348816>>
round  7, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.2816808223724365,accuracy=0.2580246925354004>>
round  8, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.3656885623931885,accuracy=0.25884774327278137>>
round  9, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=2.23549222946167,accuracy=0.28477364778518677>>
round 10, metrics=<broadcast=<>,aggregation=<>,train=<num_examples=4860.0,loss=1.974222183227539,accuracy=0.35329216718673706>>

TensorBoard के भीतर इन मैट्रिक्स को देखने के लिए, "TensorBoard में मॉडल मैट्रिक्स प्रदर्शित करना" में ऊपर सूचीबद्ध चरणों का संदर्भ लें।

मूल्यांकन

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

फ़ेडरेटेड डेटा पर मूल्यांकन करने के लिए, आप tff.learning.build_federated_evaluation फ़ंक्शन का उपयोग करके, और अपने मॉडल कंस्ट्रक्टर में एक तर्क के रूप में पास करके, इस उद्देश्य के लिए डिज़ाइन किए गए एक और फ़ेडरेटेड कम्प्यूटेशन का निर्माण कर सकते हैं। ध्यान दें कि Federated Averaging के विपरीत, जहां हमने MnistTrainableModel उपयोग किया है, यह MnistTrainableModel को पारित करने के लिए MnistModel । मूल्यांकन ढाल मूल प्रदर्शन नहीं करता है, और ऑप्टिमाइज़र के निर्माण की कोई आवश्यकता नहीं है।

प्रयोग और अनुसंधान के लिए, जब एक केंद्रीकृत परीक्षण डेटासेट उपलब्ध होता है, तो फ़ेडरेशन फॉर लर्निंग फॉर टेक्स्ट जेनरेशन एक और मूल्यांकन विकल्प प्रदर्शित करता है: फ़ेडरेटेड लर्निंग से प्रशिक्षित वेट लेना, उन्हें एक मानक केरस मॉडल पर लागू करना और फिर बस tf.keras.models.Model.evaluate() कॉल tf.keras.models.Model.evaluate() । केंद्रीकृत डेटासेट पर। tf.keras.models.Model.evaluate()

evaluation = tff.learning.build_federated_evaluation(MnistModel)

आप मूल्यांकन फ़ंक्शन के सार प्रकार हस्ताक्षर का निरीक्षण कर सकते हैं।

str(evaluation.type_signature)
'(<<trainable=<float32[784,10],float32[10]>,non_trainable=<>>@SERVER,{<x=float32[?,784],y=int32[?,1]>*}@CLIENTS> -> <num_examples=float32@SERVER,loss=float32@SERVER,accuracy=float32@SERVER>)'

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

SERVER_MODEL, FEDERATED_DATA -> TRAINING_METRICS

आइए प्रशिक्षण के दौरान हमारे पास आए नवीनतम राज्य पर मूल्यांकन करें। सर्वर राज्य से नवीनतम प्रशिक्षित मॉडल निकालने के लिए, आप केवल .model सदस्य का उपयोग करते हैं, निम्नानुसार।

train_metrics = evaluation(state.model, federated_train_data)

यहाँ हमें क्या मिलता है। ध्यान दें कि ऊपर दिए गए प्रशिक्षण के अंतिम दौर की रिपोर्ट की तुलना में संख्या में मामूली रूप से बेहतर है। कन्वेंशन द्वारा, पुनरावृत्ति प्रशिक्षण प्रक्रिया द्वारा रिपोर्ट किए गए प्रशिक्षण मीट्रिक आमतौर पर प्रशिक्षण दौर की शुरुआत में मॉडल के प्रदर्शन को दर्शाते हैं, इसलिए मूल्यांकन मैट्रिक्स हमेशा एक कदम आगे होंगे।

str(train_metrics)
'<num_examples=4860.0,loss=1.7142657041549683,accuracy=0.38683128356933594>'

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

federated_test_data = make_federated_data(emnist_test, sample_clients)

len(federated_test_data), federated_test_data[0]
(10,
 <DatasetV1Adapter shapes: OrderedDict([(x, (None, 784)), (y, (None, 1))]), types: OrderedDict([(x, tf.float32), (y, tf.int32)])>)
test_metrics = evaluation(state.model, federated_test_data)
str(test_metrics)
'<num_examples=580.0,loss=1.861915111541748,accuracy=0.3362068831920624>'

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