এমএল কমিউনিটি দিবস 9 নভেম্বর! TensorFlow, Jax থেকে আপডেটের জন্য আমাদের সাথে যোগ দিন, এবং আরও আরও জানুন

পাঠ্য উত্পন্নকরণের জন্য ফেডারেটড লার্নিং

TensorFlow.org এ দেখুন GitHub এ উৎস দেখুন নোটবুক ডাউনলোড করুন

এই টিউটোরিয়াল-এ ধারণা উপর তৈরী করে এর চিত্র ক্লাসিফিকেশন ফেডারেটেড শিক্ষণ টিউটোরিয়াল, এবং ফেডারেট শেখার জন্য বেশ কিছু দরকারী পন্থা প্রমান।

বিশেষ করে, আমরা একটি পূর্বে প্রশিক্ষিত কেরাস মডেল লোড করি এবং একটি (সিমুলেটেড) বিকেন্দ্রীভূত ডেটাসেটে ফেডারেটেড প্রশিক্ষণ ব্যবহার করে এটিকে পরিমার্জিত করি। এটি বেশ কয়েকটি কারণে কার্যত গুরুত্বপূর্ণ। সিরিয়ালাইজড মডেলগুলি ব্যবহার করার ক্ষমতা অন্যান্য এমএল পদ্ধতির সাথে ফেডারেটেড লার্নিং মেশানো সহজ করে তোলে। উপরন্তু, এই প্রাক প্রশিক্ষিত মডেলের একটি ক্রমবর্ধমান পরিসীমা ব্যবহার করতে পারবে --- উদাহরণস্বরূপ, প্রশিক্ষণ ভাষা মডেলের গোড়া থেকে খুব কমই প্রয়োজন হিসাবে অনেক প্রাক প্রশিক্ষিত মডেলগুলি এখন ব্যাপকভাবে পাওয়া যায় (দেখুন, যেমন, মেমরি হাব )। পরিবর্তে, এটি একটি পূর্ব-প্রশিক্ষিত মডেল থেকে শুরু করা, এবং একটি নির্দিষ্ট অ্যাপ্লিকেশনের জন্য বিকেন্দ্রীভূত ডেটার বিশেষ বৈশিষ্ট্যগুলির সাথে খাপ খাইয়ে ফেডারেটেড লার্নিং ব্যবহার করে এটিকে আরও পরিমার্জিত করে তোলে।

এই টিউটোরিয়ালের জন্য, আমরা একটি RNN দিয়ে শুরু করি যা ASCII অক্ষর উৎপন্ন করে এবং ফেডারেটেড লার্নিং এর মাধ্যমে এটি পরিমার্জিত করে। আমরা এটাও দেখাই যে কিভাবে চূড়ান্ত ওজনগুলি মূল কেরাস মডেলকে ফিরিয়ে দেওয়া যেতে পারে, যা সাধারণ সরঞ্জামগুলি ব্যবহার করে সহজ মূল্যায়ন এবং পাঠ্য প্রজন্মের অনুমতি দেয়।

!pip install --quiet --upgrade tensorflow-federated-nightly
!pip install --quiet --upgrade nest-asyncio

import nest_asyncio
nest_asyncio.apply()
import collections
import functools
import os
import time

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

np.random.seed(0)

# Test the TFF is working:
tff.federated_computation(lambda: 'Hello, World!')()
b'Hello, World!'

একটি প্রাক প্রশিক্ষিত মডেল লোড করুন

আমরা একটি মডেল যা TensorFlow টিউটোরিয়াল নিম্নলিখিত প্রাক প্রশিক্ষণ নেন লোড টেক্সট উৎসুক সঞ্চালনের সঙ্গে একটি RNN ব্যবহার প্রজন্ম । যাইহোক, বরং প্রশিক্ষণ চেয়ে শেক্সপীয়ারের সম্পূর্ণ কাজ , আমরা চার্লস ডিকেন্স 'থেকে টেক্সট উপর মডেল প্রাক প্রশিক্ষিত দুই শহরের গল্প এবং একটি ক্রিসমাস ক্যারল

শব্দভাণ্ডার প্রসারিত করা ছাড়াও, আমরা মূল টিউটোরিয়াল পরিবর্তন করি নি, তাই এই প্রাথমিক মডেলটি অত্যাধুনিক নয়, তবে এটি যুক্তিসঙ্গত ভবিষ্যদ্বাণী তৈরি করে এবং আমাদের টিউটোরিয়াল উদ্দেশ্যে যথেষ্ট। চূড়ান্ত মডেলের সংরক্ষিত ছিল tf.keras.models.save_model(include_optimizer=False)

আমরা TFF দ্বারা প্রদত্ত ডেটার একটি ফেডারেটেড সংস্করণ ব্যবহার করে এই টিউটোরিয়ালে শেক্সপিয়ারের জন্য এই মডেলটিকে ফাইন-টিউন করার জন্য ফেডারেটেড লার্নিং ব্যবহার করব।

ভোকাব লুকআপ টেবিল তৈরি করুন

# A fixed vocabularly of ASCII chars that occur in the works of Shakespeare and Dickens:
vocab = list('dhlptx@DHLPTX $(,048cgkoswCGKOSW[_#\'/37;?bfjnrvzBFJNRVZ"&*.26:\naeimquyAEIMQUY]!%)-159\r')

# Creating a mapping from unique characters to indices
char2idx = {u:i for i, u in enumerate(vocab)}
idx2char = np.array(vocab)

প্রাক প্রশিক্ষিত মডেল লোড করুন এবং কিছু পাঠ্য তৈরি করুন

def load_model(batch_size):
  urls = {
      1: 'https://storage.googleapis.com/tff-models-public/dickens_rnn.batch1.kerasmodel',
      8: 'https://storage.googleapis.com/tff-models-public/dickens_rnn.batch8.kerasmodel'}
  assert batch_size in urls, 'batch_size must be in ' + str(urls.keys())
  url = urls[batch_size]
  local_file = tf.keras.utils.get_file(os.path.basename(url), origin=url)  
  return tf.keras.models.load_model(local_file, compile=False)
def generate_text(model, start_string):
  # From https://www.tensorflow.org/tutorials/sequences/text_generation
  num_generate = 200
  input_eval = [char2idx[s] for s in start_string]
  input_eval = tf.expand_dims(input_eval, 0)
  text_generated = []
  temperature = 1.0

  model.reset_states()
  for i in range(num_generate):
    predictions = model(input_eval)
    predictions = tf.squeeze(predictions, 0)
    predictions = predictions / temperature
    predicted_id = tf.random.categorical(
        predictions, num_samples=1)[-1, 0].numpy()
    input_eval = tf.expand_dims([predicted_id], 0)
    text_generated.append(idx2char[predicted_id])

  return (start_string + ''.join(text_generated))
# Text generation requires a batch_size=1 model.
keras_model_batch1 = load_model(batch_size=1)
print(generate_text(keras_model_batch1, 'What of TensorFlow Federated, you ask? '))
Downloading data from https://storage.googleapis.com/tff-models-public/dickens_rnn.batch1.kerasmodel
16195584/16193984 [==============================] - 0s 0us/step
16203776/16193984 [==============================] - 0s 0us/step
What of TensorFlow Federated, you ask? Sall
yesterday. Received the Bailey."

"Mr. Lorry, grimmering himself, or low varked thends the winter, and the eyes of Monsieur
Defarge. "Let his mind, hon in his
life and message; four declare

ফেডারেটেড শেক্সপিয়ার ডেটা লোড এবং প্রি -প্রসেস করুন

tff.simulation.datasets প্যাকেজ ডেটাসেট হত প্রতিষ্ঠানটির "ক্লায়েন্টরা", বিভক্ত করা হয় বিভিন্ন উপলব্ধ যেখানে একটি নির্দিষ্ট ডিভাইস যা ফেডারেট লার্নিং অংশগ্রহণের পারে একটি ডেটাসেটের প্রতিটি ক্লায়েন্ট অনুরূপ।

এই ডেটাসেটগুলি বাস্তবসম্মত নন-আইআইডি ডেটা ডিস্ট্রিবিউশন প্রদান করে যা বাস্তব বিকেন্দ্রীভূত ডেটার উপর প্রশিক্ষণের চ্যালেঞ্জগুলি অনুকরণে প্রতিলিপি করে। এই ডেটার প্রাক প্রক্রিয়াকরণ কিছু সরঞ্জাম ব্যবহার করা হয়েছিল লিফ প্রকল্পের ( GitHub )।

train_data, test_data = tff.simulation.datasets.shakespeare.load_data()

দ্বারা উপলব্ধ ডেটাসেট shakespeare.load_data() স্ট্রিং একটি ক্রম গঠিত Tensors , একটি শেক্সপীয়ার খেলার মধ্যে একটি নির্দিষ্ট অক্ষর দ্বারা উচ্চারিত প্রতিটি লাইনে জন্য। ক্লায়েন্ট কি, চরিত্রের নাম দিয়ে যোগদান খেলার নাম গঠিত সুতরাং উদাহরণস্বরূপ MUCH_ADO_ABOUT_NOTHING_OTHELLO খেলা মাচ এডো এবাউট নাথিং চরিত্রের ওথেলো জন্য লাইন অনুরূপ। লক্ষ্য করুন যে একটি বাস্তব সংঘবদ্ধ শিক্ষণ দৃশ্যকল্পে ক্লায়েন্টদের কখনোই আইডি দ্বারা চিহ্নিত বা ট্র্যাক করা হয় না, কিন্তু সিমুলেশনের জন্য এটি কীড ডেটাসেটের সাথে কাজ করার জন্য দরকারী।

এখানে, উদাহরণস্বরূপ, আমরা কিং লিয়ারের কিছু তথ্য দেখতে পারি:

# Here the play is "The Tragedy of King Lear" and the character is "King".
raw_example_dataset = train_data.create_tf_dataset_for_client(
    'THE_TRAGEDY_OF_KING_LEAR_KING')
# To allow for future extensions, each entry x
# is an OrderedDict with a single key 'snippets' which contains the text.
for x in raw_example_dataset.take(2):
  print(x['snippets'])
tf.Tensor(b'', shape=(), dtype=string)
tf.Tensor(b'What?', shape=(), dtype=string)

আমরা এখন ব্যবহার tf.data.Dataset রূপান্তরের গৃহস্থালির কাজ RNN উপরে লোড প্রশিক্ষণ জন্য আমরা এই ডেটা প্রস্তুত করতে।

# Input pre-processing parameters
SEQ_LENGTH = 100
BATCH_SIZE = 8
BUFFER_SIZE = 100  # For dataset shuffling
# Construct a lookup table to map string chars to indexes,
# using the vocab loaded above:
table = tf.lookup.StaticHashTable(
    tf.lookup.KeyValueTensorInitializer(
        keys=vocab, values=tf.constant(list(range(len(vocab))),
                                       dtype=tf.int64)),
    default_value=0)


def to_ids(x):
  s = tf.reshape(x['snippets'], shape=[1])
  chars = tf.strings.bytes_split(s).values
  ids = table.lookup(chars)
  return ids


def split_input_target(chunk):
  input_text = tf.map_fn(lambda x: x[:-1], chunk)
  target_text = tf.map_fn(lambda x: x[1:], chunk)
  return (input_text, target_text)


def preprocess(dataset):
  return (
      # Map ASCII chars to int64 indexes using the vocab
      dataset.map(to_ids)
      # Split into individual chars
      .unbatch()
      # Form example sequences of SEQ_LENGTH +1
      .batch(SEQ_LENGTH + 1, drop_remainder=True)
      # Shuffle and form minibatches
      .shuffle(BUFFER_SIZE).batch(BATCH_SIZE, drop_remainder=True)
      # And finally split into (input, target) tuples,
      # each of length SEQ_LENGTH.
      .map(split_input_target))

নোট মূল ক্রম এবং উপরোক্ত ব্যাচ গঠনে গঠন, আমরা ব্যবহার drop_remainder=True সরলীকরণের জন্য। এই উপায়ে কোন অক্ষর (ক্লায়েন্ট) আছে না যে অন্তত যে (SEQ_LENGTH + 1) * BATCH_SIZE লেখার অক্ষর খালি ডেটাসেট থাকবে। এটিকে সমাধান করার জন্য একটি সাধারণ পদ্ধতি হবে একটি বিশেষ টোকেন দিয়ে ব্যাচগুলিকে প্যাড করা, এবং তারপর প্যাডিং টোকেনগুলিকে বিবেচনায় না নিয়ে ক্ষতির মুখোশ।

এই উদাহরণটিতে কিছুটা জটিলতা দেখা হবে, তাই এই টিউটোরিয়ালের জন্য আমরা শুধুমাত্র পূর্ণ ব্যাচ ব্যবহার করেন, হিসাবে মান টিউটোরিয়াল । যাইহোক, ফেডারেটেড সেটিংয়ে এই সমস্যাটি আরো তাৎপর্যপূর্ণ, কারণ অনেক ব্যবহারকারীর ছোট ডেটাসেট থাকতে পারে।

এখন আমরা আমাদের preprocess করতে raw_example_dataset , এবং ধরনের যাচাই করুন:

example_dataset = preprocess(raw_example_dataset)
print(example_dataset.element_spec)
(TensorSpec(shape=(8, 100), dtype=tf.int64, name=None), TensorSpec(shape=(8, 100), dtype=tf.int64, name=None))

মডেল কম্পাইল করুন এবং প্রিপ্রোসেসড ডেটার উপর পরীক্ষা করুন

আমরা একটি uncompiled keras মডেল লোড কিন্তু চালানোর জন্য keras_model.evaluate , আমরা একটি কমে যাওয়া এবং বৈশিষ্ট্যের মান সঙ্গে এটি কম্পাইল করতে হবে। আমরা একটি অপটিমাইজারেও কম্পাইল করব, যা ফেডারেটেড লার্নিং-এ অন-ডিভাইস অপটিমাইজার হিসেবে ব্যবহৃত হবে।

মূল টিউটোরিয়ালে চার-লেভেল নির্ভুলতা ছিল না (পূর্বাভাসের ভগ্নাংশ যেখানে সর্বোচ্চ সম্ভাব্যতা সঠিক পরবর্তী অক্ষরে রাখা হয়েছিল)। এটি একটি দরকারী মেট্রিক, তাই আমরা এটি যোগ করি। যাইহোক, আমরা কারণ আমাদের ভবিষ্যৎবাণী র্যাঙ্ক 3 (প্রত্যেকের জন্য logits একটি ভেক্টর আছে এই জন্য একটি নতুন মেট্রিক বর্গ সংজ্ঞায়িত করতে প্রয়োজন BATCH_SIZE * SEQ_LENGTH ভবিষ্যৎবাণী), এবং SparseCategoricalAccuracy শুধুমাত্র র্যাঙ্ক 2 ভবিষ্যৎবাণী প্রত্যাশা করে।

class FlattenedCategoricalAccuracy(tf.keras.metrics.SparseCategoricalAccuracy):

  def __init__(self, name='accuracy', dtype=tf.float32):
    super().__init__(name, dtype=dtype)

  def update_state(self, y_true, y_pred, sample_weight=None):
    y_true = tf.reshape(y_true, [-1, 1])
    y_pred = tf.reshape(y_pred, [-1, len(vocab), 1])
    return super().update_state(y_true, y_pred, sample_weight)

এখন আমরা একটি মডেল কম্পাইল, এবং আমাদের তে এটি মূল্যায়ন করতে পারেন example_dataset

BATCH_SIZE = 8  # The training and eval batch size for the rest of this tutorial.
keras_model = load_model(batch_size=BATCH_SIZE)
keras_model.compile(
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=[FlattenedCategoricalAccuracy()])

# Confirm that loss is much lower on Shakespeare than on random data
loss, accuracy = keras_model.evaluate(example_dataset.take(5), verbose=0)
print(
    'Evaluating on an example Shakespeare character: {a:3f}'.format(a=accuracy))

# As a sanity check, we can construct some completely random data, where we expect
# the accuracy to be essentially random:
random_guessed_accuracy = 1.0 / len(vocab)
print('Expected accuracy for random guessing: {a:.3f}'.format(
    a=random_guessed_accuracy))
random_indexes = np.random.randint(
    low=0, high=len(vocab), size=1 * BATCH_SIZE * (SEQ_LENGTH + 1))
data = collections.OrderedDict(
    snippets=tf.constant(
        ''.join(np.array(vocab)[random_indexes]), shape=[1, 1]))
random_dataset = preprocess(tf.data.Dataset.from_tensor_slices(data))
loss, accuracy = keras_model.evaluate(random_dataset, steps=10, verbose=0)
print('Evaluating on completely random data: {a:.3f}'.format(a=accuracy))
Downloading data from https://storage.googleapis.com/tff-models-public/dickens_rnn.batch8.kerasmodel
16195584/16193984 [==============================] - 0s 0us/step
16203776/16193984 [==============================] - 0s 0us/step
Evaluating on an example Shakespeare character: 0.402000
Expected accuracy for random guessing: 0.012
Evaluating on completely random data: 0.011

ফেডারেটেড লার্নিং এর সাথে মডেলটিকে ফাইন-টিউন করুন

টিএফএফ সমস্ত টেনসারফ্লো গণনাকে সিরিয়ালাইজ করে যাতে সেগুলি সম্ভাব্যভাবে একটি অ-পাইথন পরিবেশে চালানো যায় (যদিও এই মুহুর্তে, পাইথনে প্রয়োগ করা কেবল একটি সিমুলেশন রানটাইম পাওয়া যায়)। যদিও আমরা উৎসুক মোড, (মেমরি 2.0) মধ্যে দৌড়াচ্ছে, বর্তমানে TFF সিরিয়েলাইজ TensorFlow একটি "প্রেক্ষাপটে ভিতরে প্রয়োজনীয় অপস গঠন করে কম্পিউটেশন with tf.Graph.as_default() " বিবৃতি। এইভাবে, আমাদের এমন একটি ফাংশন প্রদান করতে হবে যা TFF ব্যবহার করে আমাদের মডেলকে নিয়ন্ত্রণ করে এমন গ্রাফের সাথে পরিচয় করিয়ে দিতে পারে। অনুসরণ হিসাবে আমরা এই কাজ:

# Clone the keras_model inside `create_tff_model()`, which TFF will
# call to produce a new copy of the model inside the graph that it will 
# serialize. Note: we want to construct all the necessary objects we'll need 
# _inside_ this method.
def create_tff_model():
  # TFF uses an `input_spec` so it knows the types and shapes
  # that your model expects.
  input_spec = example_dataset.element_spec
  keras_model_clone = tf.keras.models.clone_model(keras_model)
  return tff.learning.from_keras_model(
      keras_model_clone,
      input_spec=input_spec,
      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      metrics=[FlattenedCategoricalAccuracy()])

এখন আমরা একটি ফেডারেটেড গড় প্রক্রিয়া পুনরাবৃত্ত, যা আমরা মডেল উন্নত করতে ব্যবহার করা হবে গঠন করা করার জন্য প্রস্তুত হয় (ফেডারেটেড গড় অ্যালগরিদম বিস্তারিত, কাগজ দেখতে বিকেন্দ্রীকৃত তথ্য থেকে ডীপ নেটওয়ার্কের কমিউনিকেশন-সাশ্রয়ী শিক্ষণ )।

ফেডারেটেড প্রশিক্ষণের প্রতিটি রাউন্ডের পর আমরা স্ট্যান্ডার্ড (নন-ফেডারেটেড) মূল্যায়ন করার জন্য একটি সংকলিত কেরাস মডেল ব্যবহার করি। সিমুলেটেড ফেডারেটেড লার্নিং করার সময় এটি গবেষণার উদ্দেশ্যে দরকারী এবং একটি স্ট্যান্ডার্ড টেস্ট ডেটাসেট রয়েছে।

একটি বাস্তবসম্মত উত্পাদন সেটিংয়ে এই একই কৌশল ব্যবহার করা যেতে পারে ফেডারেটেড লার্নিং -এর সাথে প্রশিক্ষিত মডেলগুলি নিতে এবং পরীক্ষা বা মান নিশ্চিতকরণের উদ্দেশ্যে একটি কেন্দ্রীয় বেঞ্চমার্ক ডেটাসেটে তাদের মূল্যায়ন করতে।

# This command builds all the TensorFlow graphs and serializes them: 
fed_avg = tff.learning.build_federated_averaging_process(
    model_fn=create_tff_model,
    client_optimizer_fn=lambda: tf.keras.optimizers.SGD(lr=0.5))

এখানে সবচেয়ে সহজ সম্ভাব্য লুপ, যেখানে আমরা একক ব্যাচে একক ক্লায়েন্টের এক রাউন্ডের জন্য ফেডারেটেড এভারেজ চালাই:

state = fed_avg.initialize()
state, metrics = fed_avg.next(state, [example_dataset.take(5)])
train_metrics = metrics['train']
print('loss={l:.3f}, accuracy={a:.3f}'.format(
    l=train_metrics['loss'], a=train_metrics['accuracy']))
loss=4.403, accuracy=0.132

এখন একটু বেশি আকর্ষণীয় প্রশিক্ষণ এবং মূল্যায়ন লুপ লিখি।

যাতে এই সিমুলেশনটি এখনও অপেক্ষাকৃত দ্রুত চলে, আমরা প্রতিটি রাউন্ডে একই তিনটি ক্লায়েন্টকে প্রশিক্ষণ দিই, শুধুমাত্র প্রত্যেকের জন্য দুটি মিনিব্যাচ বিবেচনা করে।

def data(client, source=train_data):
  return preprocess(source.create_tf_dataset_for_client(client)).take(5)


clients = [
    'ALL_S_WELL_THAT_ENDS_WELL_CELIA', 'MUCH_ADO_ABOUT_NOTHING_OTHELLO',
]

train_datasets = [data(client) for client in clients]

# We concatenate the test datasets for evaluation with Keras by creating a 
# Dataset of Datasets, and then identity flat mapping across all the examples.
test_dataset = tf.data.Dataset.from_tensor_slices(
    [data(client, test_data) for client in clients]).flat_map(lambda x: x)

মডেল দ্বারা উত্পাদিত প্রাথমিক রাষ্ট্র fed_avg.initialize() , Keras মডেল, না ওজন লোড সেটা র্যান্ডম initializers উপর ভিত্তি করে যেহেতু হয় clone_model() ওজন না ক্লোন করে। একটি প্রাক-প্রশিক্ষিত মডেল থেকে প্রশিক্ষণ শুরু করার জন্য, আমরা লোড করা মডেল থেকে সরাসরি সার্ভার অবস্থায় মডেল ওজন সেট করি।

NUM_ROUNDS = 5

# The state of the FL server, containing the model and optimization state.
state = fed_avg.initialize()

# Load our pre-trained Keras model weights into the global model state.
state = tff.learning.state_with_new_model_weights(
    state,
    trainable_weights=[v.numpy() for v in keras_model.trainable_weights],
    non_trainable_weights=[
        v.numpy() for v in keras_model.non_trainable_weights
    ])


def keras_evaluate(state, round_num):
  # Take our global model weights and push them back into a Keras model to
  # use its standard `.evaluate()` method.
  keras_model = load_model(batch_size=BATCH_SIZE)
  keras_model.compile(
      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      metrics=[FlattenedCategoricalAccuracy()])
  state.model.assign_weights_to(keras_model)
  loss, accuracy = keras_model.evaluate(example_dataset, steps=2, verbose=0)
  print('\tEval: loss={l:.3f}, accuracy={a:.3f}'.format(l=loss, a=accuracy))


for round_num in range(NUM_ROUNDS):
  print('Round {r}'.format(r=round_num))
  keras_evaluate(state, round_num)
  state, metrics = fed_avg.next(state, train_datasets)
  train_metrics = metrics['train']
  print('\tTrain: loss={l:.3f}, accuracy={a:.3f}'.format(
      l=train_metrics['loss'], a=train_metrics['accuracy']))

print('Final evaluation')
keras_evaluate(state, NUM_ROUNDS + 1)
Round 0
    Eval: loss=3.324, accuracy=0.401
    Train: loss=4.360, accuracy=0.155
Round 1
    Eval: loss=4.361, accuracy=0.049
    Train: loss=4.235, accuracy=0.164
Round 2
    Eval: loss=4.219, accuracy=0.177
    Train: loss=4.081, accuracy=0.221
Round 3
    Eval: loss=4.080, accuracy=0.174
    Train: loss=3.940, accuracy=0.226
Round 4
    Eval: loss=3.991, accuracy=0.176
    Train: loss=3.840, accuracy=0.226
Final evaluation
    Eval: loss=3.909, accuracy=0.171

ডিফল্ট পরিবর্তনের সাথে, আমরা একটি বড় পার্থক্য করার জন্য পর্যাপ্ত প্রশিক্ষণ গ্রহণ করি নি, কিন্তু যদি আপনি আরও শেক্সপিয়ার ডেটাতে দীর্ঘ প্রশিক্ষণ দেন, তাহলে আপডেট হওয়া মডেলের সাথে তৈরি পাঠ্যের শৈলীতে আপনার একটি পার্থক্য দেখা উচিত:

# Set our newly trained weights back in the originally created model.
keras_model_batch1.set_weights([v.numpy() for v in keras_model.weights])
# Text generation requires batch_size=1
print(generate_text(keras_model_batch1, 'What of TensorFlow Federated, you ask? '))
What of TensorFlow Federated, you ask? Shalways, I will call your
compet with any city brought their faces uncompany," besumed him. "When he
sticked Madame Defarge pushed the lamps.

"Have I often but no unison. She had probably come,

প্রস্তাবিত এক্সটেনশন

এই টিউটোরিয়ালটি শুধুমাত্র প্রথম ধাপ! আপনি কিভাবে এই নোটবুকটি বাড়ানোর চেষ্টা করতে পারেন তার জন্য এখানে কিছু ধারণা দেওয়া হল:

  • আরও বাস্তবসম্মত প্রশিক্ষণ লুপ লিখুন যেখানে আপনি ক্লায়েন্টদের এলোমেলোভাবে প্রশিক্ষণের জন্য নমুনা দেন।
  • "ব্যবহারের .repeat(NUM_EPOCHS) " ক্লায়েন্ট ডেটাসেট উপর (হিসাবে যেমন, স্থানীয় প্রশিক্ষণ একাধিক সময়কাল চেষ্টা McMahan দেশ। অল। )। আরও দেখুন ভাবমূর্তি শ্রেণীবিভাগ জন্য ফেডারেটেড শিক্ষণ যা এই আছে।
  • পরিবর্তন compile() ক্লায়েন্টের বিভিন্ন অপ্টিমাইজেশান আলগোরিদিম ব্যবহার নিয়ে পরীক্ষা করতে কমান্ড।
  • ব্যবহার করে দেখুন server_optimizer আর্গুমেন্ট প্রাপ্ত করতে build_federated_averaging_process সার্ভারে মডেল আপডেট আবেদন করার জন্য বিভিন্ন আলগোরিদিম চেষ্টা করুন।
  • ব্যবহার করে দেখুন client_weight_fn করতে যুক্তি build_federated_averaging_process ক্লায়েন্টদের বিভিন্ন weightings চেষ্টা করুন। ক্লায়েন্টের উদাহরণ সংখ্যা দ্বারা ডিফল্ট ওজন ক্লায়েন্ট আপডেট, কিন্তু আপনি কি করতে পারেন যেমন client_weight_fn=lambda _: tf.constant(1.0)