TensorFlow 14 মে Google I/O-তে ফিরে এসেছে! এখন নিবন্ধন করুন

এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

ফেডারেটেড লার্নিং রিসার্চের জন্য টিএফএফ: মডেল এবং আপডেট কম্প্রেশন

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

এই টিউটোরিয়ালে, আমরা ব্যবহার EMNIST ফেডারেটেড গড় ব্যবহার অ্যালগোরিদমের মধ্যে যোগাযোগ খরচ কমানোর জন্য লজি কম্প্রেশন আলগোরিদিম কিভাবে সক্ষম করবেন তা প্রকট ডেটা সেটটি tff.learning.build_federated_averaging_process API ও tensor_encoding API- টি। ফেডারেটেড গড় অ্যালগরিদম অধিক বিবরণের জন্য, কাগজ দেখতে বিকেন্দ্রীকৃত তথ্য থেকে ডীপ নেটওয়ার্কের কমিউনিকেশন-সাশ্রয়ী শিক্ষণ ।

আমরা শুরু করার আগে

আমরা শুরু করার আগে, আপনার পরিবেশ সঠিকভাবে সেটআপ করা হয়েছে তা নিশ্চিত করতে অনুগ্রহ করে নিম্নলিখিতটি চালান। আপনি যদি একটি অভিবাদন দেখতে না পান তাহলে, পড়ুন দয়া ইনস্টলেশন নির্দেশাবলীর জন্য গাইড।

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

import nest_asyncio
nest_asyncio.apply()

%load_ext tensorboard

import functools

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

from tensorflow_model_optimization.python.core.internal import tensor_encoding as te

TFF কাজ করছে কিনা তা যাচাই করুন।

@tff.federated_computation
def hello_world():
  return 'Hello, World!'

hello_world()

b'Hello, World!'

ইনপুট ডেটা প্রস্তুত করা হচ্ছে

এই বিভাগে আমরা TFF-এ অন্তর্ভুক্ত EMNIST ডেটাসেট লোড এবং প্রিপ্রসেস করি। দয়া করে খুঁজে বার করো এর চিত্র ক্লাসিফিকেশন ফেডারেটেড শিক্ষণ EMNIST ডেটা সেটটি সম্পর্কে আরো বিস্তারিত জানার জন্য টিউটোরিয়াল।

# This value only applies to EMNIST dataset, consider choosing appropriate
# values if switching to other datasets.
MAX_CLIENT_DATASET_SIZE = 418

CLIENT_EPOCHS_PER_ROUND = 1
CLIENT_BATCH_SIZE = 20
TEST_BATCH_SIZE = 500

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

def reshape_emnist_element(element):
  return (tf.expand_dims(element['pixels'], axis=-1), element['label'])

def preprocess_train_dataset(dataset):
  """Preprocessing function for the EMNIST training dataset."""
  return (dataset
          # Shuffle according to the largest client dataset
          .shuffle(buffer_size=MAX_CLIENT_DATASET_SIZE)
          # Repeat to do multiple local epochs
          .repeat(CLIENT_EPOCHS_PER_ROUND)
          # Batch to a fixed client batch size
          .batch(CLIENT_BATCH_SIZE, drop_remainder=False)
          # Preprocessing step
          .map(reshape_emnist_element))

emnist_train = emnist_train.preprocess(preprocess_train_dataset)

একটি মডেল সংজ্ঞায়িত করা

এখানে আমরা orginial FedAvg সিএনএন উপর ভিত্তি করে একটি keras মডেল সংজ্ঞায়িত, এবং তারপর একটি দৃষ্টান্ত মধ্যে keras মডেল মোড়ানো tff.learning.Model যাতে এটি TFF খায় করা যেতে পারে।

মনে রাখবেন যে আমরা একটি ফাংশন যা একটি মডেল পরিবর্তে কেবল একটি মডেল সরাসরি উৎপন্ন হবে। উপরন্তু, ফাংশন শুধু একটি প্রাক নির্মাণ মডেল ক্যাপচার করতে পারবেন না, এটা প্রেক্ষাপটে মডেল যে এটা বলা হয় তৈরি করতে হবে। কারণটি হল যে TFF ডিভাইসগুলিতে যাওয়ার জন্য ডিজাইন করা হয়েছে, এবং কখন সংস্থানগুলি তৈরি করা হয় তার উপর নিয়ন্ত্রণের প্রয়োজন যাতে সেগুলি ক্যাপচার করা যায় এবং প্যাকেজ করা যায়।

def create_original_fedavg_cnn_model(only_digits=True):
  """The CNN model used in https://arxiv.org/abs/1602.05629."""
  data_format = 'channels_last'

  max_pool = functools.partial(
      tf.keras.layers.MaxPooling2D,
      pool_size=(2, 2),
      padding='same',
      data_format=data_format)
  conv2d = functools.partial(
      tf.keras.layers.Conv2D,
      kernel_size=5,
      padding='same',
      data_format=data_format,
      activation=tf.nn.relu)

  model = tf.keras.models.Sequential([
      tf.keras.layers.InputLayer(input_shape=(28, 28, 1)),
      conv2d(filters=32),
      max_pool(),
      conv2d(filters=64),
      max_pool(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(512, activation=tf.nn.relu),
      tf.keras.layers.Dense(10 if only_digits else 62),
      tf.keras.layers.Softmax(),
  ])

  return model

# Gets the type information of the input data. TFF is a strongly typed
# functional programming framework, and needs type information about inputs to 
# the model.
input_spec = emnist_train.create_tf_dataset_for_client(
    emnist_train.client_ids[0]).element_spec

def tff_model_fn():
  keras_model = create_original_fedavg_cnn_model()
  return tff.learning.from_keras_model(
      keras_model=keras_model,
      input_spec=input_spec,
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])

মডেল প্রশিক্ষণ এবং প্রশিক্ষণ মেট্রিক্স আউটপুট

এখন আমরা একটি ফেডারেটেড এভারেজিং অ্যালগরিদম তৈরি করতে এবং EMNIST ডেটাসেটে সংজ্ঞায়িত মডেলকে প্রশিক্ষণ দিতে প্রস্তুত।

আমরা প্রথমে ব্যবহার করে একটি ফেডারেটেড গড় অ্যালগরিদম নির্মাণ করা প্রয়োজন tff.learning.build_federated_averaging_process API- টি।

federated_averaging = tff.learning.build_federated_averaging_process(
    model_fn=tff_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 কার্যকরী, এই অবস্থায় অ্যালগরিদম ব্যবহার করে (যেমন ভরবেগের শর্তাবলী) পাশাপাশি মডেল প্যারামিটার উভয়ই অন্তর্ভুক্ত থাকে--এগুলি আর্গুমেন্ট হিসাবে পাস করা হবে এবং TFF গণনা থেকে ফলাফল হিসাবে ফিরে আসবে।
রাউন্ড বাই অ্যালগরিদম চালান। প্রতিটি রাউন্ডে, প্রতিটি ক্লায়েন্ট তার ডেটাতে মডেলকে প্রশিক্ষণ দেওয়ার ফলাফল হিসাবে একটি নতুন সার্ভারের অবস্থা ফিরে আসবে। সাধারণত এক রাউন্ডে:
1. সার্ভার সমস্ত অংশগ্রহণকারী ক্লায়েন্টদের কাছে মডেলটি সম্প্রচার করে।
2. প্রতিটি ক্লায়েন্ট মডেল এবং তার নিজস্ব ডেটার উপর ভিত্তি করে কাজ সম্পাদন করে।
3. সার্ভার একটি বিচ্ছিন্ন অবস্থা তৈরি করতে সমস্ত মডেলকে একত্রিত করে যাতে একটি নতুন মডেল রয়েছে।

অধিক বিবরণের জন্য, দয়া করে দেখুন বাস্তবায়নকারী ফেডারেটেড গড়: কাস্টম ফেডারেটেড আলগোরিদিম, পার্ট 2 টিউটোরিয়াল।

প্রশিক্ষণের পরে প্রদর্শনের জন্য প্রশিক্ষণের মেট্রিক্স টেনসরবোর্ড ডিরেক্টরিতে লেখা হয়।

ইউটিলিটি ফাংশন লোড করুন

def format_size(size):
  """A helper function for creating a human-readable size."""
  size = float(size)
  for unit in ['bit','Kibit','Mibit','Gibit']:
    if size < 1024.0:
      return "{size:3.2f}{unit}".format(size=size, unit=unit)
    size /= 1024.0
  return "{size:.2f}{unit}".format(size=size, unit='TiB')

def set_sizing_environment():
  """Creates an environment that contains sizing information."""
  # Creates a sizing executor factory to output communication cost
  # after the training finishes. Note that sizing executor only provides an
  # estimate (not exact) of communication cost, and doesn't capture cases like
  # compression of over-the-wire representations. However, it's perfect for
  # demonstrating the effect of compression in this tutorial.
  sizing_factory = tff.framework.sizing_executor_factory()

  # TFF has a modular runtime you can configure yourself for various
  # environments and purposes, and this example just shows how to configure one
  # part of it to report the size of things.
  context = tff.framework.ExecutionContext(executor_fn=sizing_factory)
  tff.framework.set_default_context(context)

  return sizing_factory

def train(federated_averaging_process, num_rounds, num_clients_per_round, summary_writer):
  """Trains the federated averaging process and output metrics."""
  # Create a environment to get communication cost.
  environment = set_sizing_environment()

  # Initialize the Federated Averaging algorithm to get the initial server state.
  state = federated_averaging_process.initialize()

  with summary_writer.as_default():
    for round_num in range(num_rounds):
      # Sample the clients parcitipated in this round.
      sampled_clients = np.random.choice(
          emnist_train.client_ids,
          size=num_clients_per_round,
          replace=False)
      # Create a list of `tf.Dataset` instances from the data of sampled clients.
      sampled_train_data = [
          emnist_train.create_tf_dataset_for_client(client)
          for client in sampled_clients
      ]
      # Round one round of the algorithm based on the server state and client data
      # and output the new state and metrics.
      state, metrics = federated_averaging_process.next(state, sampled_train_data)

      # For more about size_info, please see https://www.tensorflow.org/federated/api_docs/python/tff/framework/SizeInfo
      size_info = environment.get_size_info()
      broadcasted_bits = size_info.broadcast_bits[-1]
      aggregated_bits = size_info.aggregate_bits[-1]

      print('round {:2d}, metrics={}, broadcasted_bits={}, aggregated_bits={}'.format(round_num, metrics, format_size(broadcasted_bits), format_size(aggregated_bits)))

      # Add metrics to Tensorboard.
      for name, value in metrics['train'].items():
          tf.summary.scalar(name, value, step=round_num)

      # Add broadcasted and aggregated data size to Tensorboard.
      tf.summary.scalar('cumulative_broadcasted_bits', broadcasted_bits, step=round_num)
      tf.summary.scalar('cumulative_aggregated_bits', aggregated_bits, step=round_num)
      summary_writer.flush()

# Clean the log directory to avoid conflicts.
try:
  tf.io.gfile.rmtree('/tmp/logs/scalars')
except tf.errors.OpError as e:
  pass  # Path doesn't exist

# Set up the log directory and writer for Tensorboard.
logdir = "/tmp/logs/scalars/original/"
summary_writer = tf.summary.create_file_writer(logdir)

train(federated_averaging_process=federated_averaging, num_rounds=10,
      num_clients_per_round=10, summary_writer=summary_writer)

round  0, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.07383774), ('loss', 2.3276227)])), ('stat', OrderedDict([('num_examples', 1097)]))]), broadcasted_bits=507.62Mibit, aggregated_bits=507.62Mibit
round  1, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.099585064), ('loss', 2.3152695)])), ('stat', OrderedDict([('num_examples', 964)]))]), broadcasted_bits=1015.24Mibit, aggregated_bits=1015.24Mibit
round  2, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.09760766), ('loss', 2.3077576)])), ('stat', OrderedDict([('num_examples', 1045)]))]), broadcasted_bits=1.49Gibit, aggregated_bits=1.49Gibit
round  3, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.0963035), ('loss', 2.3066626)])), ('stat', OrderedDict([('num_examples', 1028)]))]), broadcasted_bits=1.98Gibit, aggregated_bits=1.98Gibit
round  4, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.10694184), ('loss', 2.3033001)])), ('stat', OrderedDict([('num_examples', 1066)]))]), broadcasted_bits=2.48Gibit, aggregated_bits=2.48Gibit
round  5, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.1185567), ('loss', 2.2999184)])), ('stat', OrderedDict([('num_examples', 970)]))]), broadcasted_bits=2.97Gibit, aggregated_bits=2.97Gibit
round  6, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.11751663), ('loss', 2.296883)])), ('stat', OrderedDict([('num_examples', 902)]))]), broadcasted_bits=3.47Gibit, aggregated_bits=3.47Gibit
round  7, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.13063477), ('loss', 2.2990246)])), ('stat', OrderedDict([('num_examples', 1087)]))]), broadcasted_bits=3.97Gibit, aggregated_bits=3.97Gibit
round  8, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.12742382), ('loss', 2.2971866)])), ('stat', OrderedDict([('num_examples', 1083)]))]), broadcasted_bits=4.46Gibit, aggregated_bits=4.46Gibit
round  9, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.13555992), ('loss', 2.2934425)])), ('stat', OrderedDict([('num_examples', 1018)]))]), broadcasted_bits=4.96Gibit, aggregated_bits=4.96Gibit

প্রশিক্ষণের মেট্রিক্স প্রদর্শন করতে উপরে উল্লিখিত রুট লগ ডিরেক্টরি দিয়ে TensorBoard শুরু করুন। ডেটা লোড হতে কয়েক সেকেন্ড সময় লাগতে পারে। ক্ষতি এবং নির্ভুলতা ব্যতীত, আমরা সম্প্রচারিত এবং সমষ্টিগত ডেটার পরিমাণও আউটপুট করি। সম্প্রচারিত ডেটা টেনসরকে বোঝায় সার্ভার প্রতিটি ক্লায়েন্টকে ঠেলে দেয় যখন সমষ্টিগত ডেটা প্রতিটি ক্লায়েন্ট সার্ভারে ফেরত আসা টেনসরকে বোঝায়।

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

Launching TensorBoard...
Reusing TensorBoard on port 34445 (pid 579503), started 1:53:14 ago. (Use '!kill 579503' to kill it.)
<IPython.core.display.Javascript at 0x7f9135ef1630>

একটি কাস্টম সম্প্রচার এবং সামগ্রিক ফাংশন তৈরি করুন

এখন সম্প্রচারিত তথ্য এবং সমষ্টিগত তথ্য ব্যবহার করে উপর লজি কম্প্রেশন আলগোরিদিম ব্যবহার করতে ফাংশন বাস্তবায়ন করা যাক tensor_encoding API- টি।

প্রথমত, আমরা দুটি ফাংশন সংজ্ঞায়িত করি:

broadcast_encoder_fn যার একটি দৃষ্টান্ত সৃষ্টি te.core.SimpleEncoder ক্লায়েন্ট যোগাযোগ (ব্রডকাস্ট তথ্য) সার্ভার মধ্যে সঙ্কেতাক্ষরে লিখা tensors বা ভেরিয়েবল করতে।
mean_encoder_fn যার একটি দৃষ্টান্ত সৃষ্টি te.core.GatherEncoder সার্ভার communicaiton (সমষ্টি তথ্য) ক্লায়েন্ট মধ্যে সঙ্কেতাক্ষরে লিখা tensors বা ভেরিয়েবল করতে।

এটি লক্ষ্য করা গুরুত্বপূর্ণ যে আমরা একবারে সম্পূর্ণ মডেলে একটি কম্প্রেশন পদ্ধতি প্রয়োগ করি না। পরিবর্তে, আমরা সিদ্ধান্ত নিই কিভাবে (এবং কিনা) মডেলের প্রতিটি ভেরিয়েবলকে স্বাধীনভাবে সংকুচিত করতে হবে। কারণ হল, সাধারণত, ছোট ভেরিয়েবল যেমন বায়াসগুলি ভুলের প্রতি বেশি সংবেদনশীল, এবং তুলনামূলকভাবে ছোট হওয়ায় সম্ভাব্য যোগাযোগ সঞ্চয়ও তুলনামূলকভাবে ছোট। তাই আমরা ডিফল্টরূপে ছোট ভেরিয়েবল কম্প্রেস করি না। এই উদাহরণে, আমরা 10000টিরও বেশি উপাদান সহ প্রতিটি ভেরিয়েবলে 8 বিট (256 বালতি) এ অভিন্ন পরিমাপ প্রয়োগ করি এবং শুধুমাত্র অন্যান্য ভেরিয়েবলে পরিচয় প্রয়োগ করি।

def broadcast_encoder_fn(value):
  """Function for building encoded broadcast."""
  spec = tf.TensorSpec(value.shape, value.dtype)
  if value.shape.num_elements() > 10000:
    return te.encoders.as_simple_encoder(
        te.encoders.uniform_quantization(bits=8), spec)
  else:
    return te.encoders.as_simple_encoder(te.encoders.identity(), spec)


def mean_encoder_fn(tensor_spec):
  """Function for building a GatherEncoder."""
  spec = tf.TensorSpec(tensor_spec.shape, tensor_spec.dtype)
  if tensor_spec.shape.num_elements() > 10000:
    return te.encoders.as_gather_encoder(
        te.encoders.uniform_quantization(bits=8), spec)
  else:
    return te.encoders.as_gather_encoder(te.encoders.identity(), spec)

TFF একটি বিন্যাসে এনকোডার ফাংশন রূপান্তর করতে যে API গুলি প্রদান করে tff.learning.build_federated_averaging_process এপিআই গ্রাস করতে পারেন। ব্যবহারের tff.learning.framework.build_encoded_broadcast_from_model এবং tff.aggregators.MeanFactory , আমরা দুটি বস্তুর যে মধ্যে প্রেরণ করা সম্ভব তৈরি করতে পারেন broadcast_process এবং model_update_aggregation_factory এর agruments tff.learning.build_federated_averaging_process একটি লজি কম্প্রেশন আলগোরিদিম সঙ্গে একটি ফেডারেটেড গড় আলগোরিদিম তৈরি করুন।

encoded_broadcast_process = (
    tff.learning.framework.build_encoded_broadcast_process_from_model(
        tff_model_fn, broadcast_encoder_fn))

mean_factory = tff.aggregators.MeanFactory(
    tff.aggregators.EncodedSumFactory(mean_encoder_fn), # numerator
    tff.aggregators.EncodedSumFactory(mean_encoder_fn), # denominator
)

federated_averaging_with_compression = tff.learning.build_federated_averaging_process(
    tff_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),
    broadcast_process=encoded_broadcast_process,
    model_update_aggregation_factory=mean_factory)

মডেলকে আবার প্রশিক্ষণ দেওয়া হচ্ছে

এখন নতুন ফেডারেটেড এভারেজিং অ্যালগরিদম রান করা যাক।

logdir_for_compression = "/tmp/logs/scalars/compression/"
summary_writer_for_compression = tf.summary.create_file_writer(
    logdir_for_compression)

train(federated_averaging_process=federated_averaging_with_compression, 
      num_rounds=10,
      num_clients_per_round=10,
      summary_writer=summary_writer_for_compression)

round  0, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.093), ('loss', 2.3194966)])), ('stat', OrderedDict([('num_examples', 1000)]))]), broadcasted_bits=146.46Mibit, aggregated_bits=146.46Mibit
round  1, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.10432034), ('loss', 2.3079953)])), ('stat', OrderedDict([('num_examples', 949)]))]), broadcasted_bits=292.92Mibit, aggregated_bits=292.93Mibit
round  2, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.07886754), ('loss', 2.3101337)])), ('stat', OrderedDict([('num_examples', 989)]))]), broadcasted_bits=439.38Mibit, aggregated_bits=439.39Mibit
round  3, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.09774436), ('loss', 2.305069)])), ('stat', OrderedDict([('num_examples', 1064)]))]), broadcasted_bits=585.84Mibit, aggregated_bits=585.85Mibit
round  4, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.09404097), ('loss', 2.302943)])), ('stat', OrderedDict([('num_examples', 1074)]))]), broadcasted_bits=732.30Mibit, aggregated_bits=732.32Mibit
round  5, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.09), ('loss', 2.304385)])), ('stat', OrderedDict([('num_examples', 1000)]))]), broadcasted_bits=878.77Mibit, aggregated_bits=878.78Mibit
round  6, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.14368932), ('loss', 2.2973824)])), ('stat', OrderedDict([('num_examples', 1030)]))]), broadcasted_bits=1.00Gibit, aggregated_bits=1.00Gibit
round  7, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.12140871), ('loss', 2.2993405)])), ('stat', OrderedDict([('num_examples', 1079)]))]), broadcasted_bits=1.14Gibit, aggregated_bits=1.14Gibit
round  8, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.13600783), ('loss', 2.2953267)])), ('stat', OrderedDict([('num_examples', 1022)]))]), broadcasted_bits=1.29Gibit, aggregated_bits=1.29Gibit
round  9, metrics=OrderedDict([('broadcast', ()), ('aggregation', OrderedDict([('mean_value', ()), ('mean_weight', ())])), ('train', OrderedDict([('sparse_categorical_accuracy', 0.13844621), ('loss', 2.295768)])), ('stat', OrderedDict([('num_examples', 1004)]))]), broadcasted_bits=1.43Gibit, aggregated_bits=1.43Gibit

দুই রানের মধ্যে ট্রেনিং মেট্রিক্স তুলনা করতে আবার TensorBoard শুরু করুন।

আপনি Tensorboard মধ্যে দেখতে পারেন, তার মাঝে একটি উল্লেখযোগ্য হ্রাস হয় orginial এবং compression কার্ভের broadcasted_bits এবং aggregated_bits প্লট সময় loss এবং sparse_categorical_accuracy চক্রান্ত দুই রেখাচিত্র চমত্কার similiar হয়।

উপসংহারে, আমরা একটি কম্প্রেশন অ্যালগরিদম প্রয়োগ করেছি যা মূল ফেডারেটেড অ্যাভারেজিং অ্যালগরিদমের মতো একই কর্মক্ষমতা অর্জন করতে পারে যখন যোগাযোগের খরচ উল্লেখযোগ্যভাবে হ্রাস পায়।

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

Launching TensorBoard...
Reusing TensorBoard on port 34445 (pid 579503), started 1:54:12 ago. (Use '!kill 579503' to kill it.)
<IPython.core.display.Javascript at 0x7f9140eb5ef0>

অনুশীলন

একটি কাস্টম কম্প্রেশন অ্যালগরিদম বাস্তবায়ন করতে এবং এটি প্রশিক্ষণ লুপে প্রয়োগ করতে, আপনি করতে পারেন:

একটি উপশ্রেণী হিসাবে একটি নতুন কম্প্রেশন অ্যালগরিদম বাস্তবায়ন EncodingStageInterface বা তার আরও সাধারণ বৈকল্পিক, AdaptiveEncodingStageInterface নিম্নলিখিত এই উদাহরণে ।
আপনার নতুন আঁকো Encoder এবং এটি জন্য বিশেষজ্ঞ মডেল সম্প্রচারের বা মডেল আপডেট গড় ।
সমগ্র গড়ে তুলতে যারা বস্তুর ব্যবহার করুন প্রশিক্ষণ গণনার ।

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

প্রস্তাবিত পড়ার উপকরণ:

ক্লায়েন্ট রিসোর্স প্রয়োজনীয়তা হ্রাস করে ফেডারেটেড লার্নিং এর নাগাল প্রসারিত করা
ফেডারেটেড লার্নিং: যোগাযোগ দক্ষতা উন্নত করার কৌশল
অনুচ্ছেদ 3.5 কমিউনিকেশন অ্যান্ড কম্প্রেশন মধ্যে ফেডারেটেড শিক্ষণ উন্নত এবং খুলুন সমস্যা