Membangun Algoritma Pembelajaran Gabungan Anda Sendiri

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Sebelum kita mulai

Sebelum kita mulai, jalankan yang berikut ini untuk memastikan bahwa lingkungan Anda telah diatur dengan benar. Jika Anda tidak melihat salam, silakan merujuk ke Instalasi panduan untuk petunjuk.

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

import nest_asyncio
nest_asyncio.apply()

import tensorflow as tf
import tensorflow_federated as tff

Dalam klasifikasi citra dan teks generasi tutorial, kita belajar bagaimana untuk mengatur model dan data jaringan pipa untuk Federasi Learning (FL), dan dilakukan pelatihan federasi melalui tff.learning API lapisan TFF.

Ini hanyalah puncak gunung es dalam hal penelitian FL. Dalam tutorial ini, kita membahas bagaimana menerapkan algoritma pembelajaran federasi tanpa menunda ke tff.learning API. Kami bertujuan untuk mencapai hal-hal berikut:

Sasaran:

  • Memahami struktur umum algoritma pembelajaran federasi.
  • Jelajahi Federasi Inti dari TFF.
  • Gunakan Federated Core untuk mengimplementasikan Federated Averaging secara langsung.

Sementara tutorial ini mandiri, kami sarankan pertama membaca klasifikasi citra dan generasi teks tutorial.

Menyiapkan data masukan

Kami pertama-tama memuat dan memproses dataset EMNIST yang disertakan dalam TFF. Untuk lebih jelasnya, lihat klasifikasi citra tutorial.

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

Untuk memberi makan dataset ke dalam model kami, kami meratakan data, dan mengubah setiap contoh menjadi tupel dari bentuk (flattened_image_vector, label) .

NUM_CLIENTS = 10
BATCH_SIZE = 20

def preprocess(dataset):

  def batch_format_fn(element):
    """Flatten a batch of EMNIST data and return a (features, label) tuple."""
    return (tf.reshape(element['pixels'], [-1, 784]), 
            tf.reshape(element['label'], [-1, 1]))

  return dataset.batch(BATCH_SIZE).map(batch_format_fn)

Kami sekarang memilih sejumlah kecil klien, dan menerapkan prapemrosesan di atas ke kumpulan data mereka.

client_ids = sorted(emnist_train.client_ids)[:NUM_CLIENTS]
federated_train_data = [preprocess(emnist_train.create_tf_dataset_for_client(x))
  for x in client_ids
]

Mempersiapkan model

Kami menggunakan model yang sama seperti pada klasifikasi citra tutorial. Model ini (dilaksanakan melalui tf.keras ) memiliki lapisan tersembunyi tunggal, diikuti oleh lapisan Softmax.

def create_keras_model():
  initializer = tf.keras.initializers.GlorotNormal(seed=0)
  return tf.keras.models.Sequential([
      tf.keras.layers.Input(shape=(784,)),
      tf.keras.layers.Dense(10, kernel_initializer=initializer),
      tf.keras.layers.Softmax(),
  ])

Untuk menggunakan model ini di TFF, kami membungkus model Keras sebagai tff.learning.Model . Hal ini memungkinkan kita untuk melakukan model maju lulus dalam TFF, dan ekstrak Model output . Untuk lebih jelasnya, juga melihat klasifikasi citra tutorial.

def model_fn():
  keras_model = create_keras_model()
  return tff.learning.from_keras_model(
      keras_model,
      input_spec=federated_train_data[0].element_spec,
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])

Sementara kita digunakan tf.keras untuk membuat tff.learning.Model , TFF mendukung model lebih umum. Model ini memiliki atribut relevan berikut yang menangkap bobot model:

  • trainable_variables : Sebuah iterable dari tensor sesuai dengan lapisan dilatih.
  • non_trainable_variables : Sebuah iterable dari tensor sesuai dengan lapisan non-dilatih.

Untuk tujuan kita, kita hanya akan menggunakan trainable_variables . (karena model kami hanya memilikinya!).

Membangun algoritma Pembelajaran Federasi Anda sendiri

Sementara tff.learning API memungkinkan seseorang untuk membuat banyak varian dari Federasi Averaging, ada algoritma federasi lain yang tidak cocok dengan kerangka ini. Sebagai contoh, Anda mungkin ingin menambahkan regularisasi, kliping, atau algoritma yang lebih rumit seperti pelatihan GAN federasi . Anda juga mungkin bukan mungkin tertarik dalam analisis federasi .

Untuk algoritme yang lebih canggih ini, kita harus menulis algoritme khusus kita sendiri menggunakan TFF. Dalam banyak kasus, algoritma federasi memiliki 4 komponen utama:

  1. Langkah siaran server-ke-klien.
  2. Langkah pembaruan klien lokal.
  3. Langkah unggah klien-ke-server.
  4. Langkah pembaruan server.

Dalam TFF, kita umumnya mewakili algoritma federasi sebagai tff.templates.IterativeProcess (yang kita sebut sebagai hanya sebuah IterativeProcess seluruh). Ini adalah kelas yang berisi initialize dan next fungsi. Di sini, initialize digunakan untuk menginisialisasi server, dan next akan melakukan satu putaran komunikasi dari algoritma Federasi. Mari kita tulis kerangka tentang seperti apa proses iteratif kita untuk FedAvg.

Pertama, kita memiliki fungsi initialize yang hanya menciptakan tff.learning.Model , dan mengembalikan bobot dilatih nya.

def initialize_fn():
  model = model_fn()
  return model.trainable_variables

Fungsi ini terlihat bagus, tetapi seperti yang akan kita lihat nanti, kita perlu membuat sedikit modifikasi untuk membuatnya menjadi "komputasi TFF".

Kami juga ingin sketsa next_fn .

def next_fn(server_weights, federated_dataset):
  # Broadcast the server weights to the clients.
  server_weights_at_client = broadcast(server_weights)

  # Each client computes their updated weights.
  client_weights = client_update(federated_dataset, server_weights_at_client)

  # The server averages these updates.
  mean_client_weights = mean(client_weights)

  # The server updates its model.
  server_weights = server_update(mean_client_weights)

  return server_weights

Kami akan fokus pada penerapan keempat komponen ini secara terpisah. Kami pertama-tama fokus pada bagian-bagian yang dapat diimplementasikan di TensorFlow murni, yaitu langkah-langkah pembaruan klien dan server.

Blok TensorFlow

Pembaruan klien

Kami akan menggunakan kami tff.learning.Model untuk melakukan pelatihan klien di dasarnya dengan cara yang sama Anda akan melatih model TensorFlow. Secara khusus, kita akan menggunakan tf.GradientTape untuk menghitung gradien pada batch data, kemudian menerapkan gradien ini menggunakan client_optimizer . Kami hanya fokus pada beban yang bisa dilatih.

@tf.function
def client_update(model, dataset, server_weights, client_optimizer):
  """Performs training (using the server model weights) on the client's dataset."""
  # Initialize the client model with the current server weights.
  client_weights = model.trainable_variables
  # Assign the server weights to the client model.
  tf.nest.map_structure(lambda x, y: x.assign(y),
                        client_weights, server_weights)

  # Use the client_optimizer to update the local model.
  for batch in dataset:
    with tf.GradientTape() as tape:
      # Compute a forward pass on the batch of data
      outputs = model.forward_pass(batch)

    # Compute the corresponding gradient
    grads = tape.gradient(outputs.loss, client_weights)
    grads_and_vars = zip(grads, client_weights)

    # Apply the gradient using a client optimizer.
    client_optimizer.apply_gradients(grads_and_vars)

  return client_weights

Pembaruan Server

Pembaruan server untuk FedAvg lebih sederhana daripada pembaruan klien. Kami akan menerapkan rata-rata federasi "vanilla", di mana kami cukup mengganti bobot model server dengan rata-rata bobot model klien. Sekali lagi, kami hanya fokus pada beban yang bisa dilatih.

@tf.function
def server_update(model, mean_client_weights):
  """Updates the server model weights as the average of the client model weights."""
  model_weights = model.trainable_variables
  # Assign the mean client weights to the server model.
  tf.nest.map_structure(lambda x, y: x.assign(y),
                        model_weights, mean_client_weights)
  return model_weights

Potongan dapat disederhanakan dengan hanya mengembalikan mean_client_weights . Namun, implementasi yang lebih maju dari Federated penggunaan Averaging mean_client_weights dengan teknik yang lebih canggih, seperti momentum atau adaptivity.

Tantangan: Melaksanakan versi server_update yang update bobot server untuk menjadi titik tengah model_weights dan mean_client_weights. (Catatan: Pendekatan semacam ini "titik tengah" adalah analog dengan karya terbaru pada optimizer Lookahead !).

Sejauh ini, kami hanya menulis kode TensorFlow murni. Ini dirancang, karena TFF memungkinkan Anda menggunakan banyak kode TensorFlow yang sudah Anda kenal. Namun, sekarang kita harus menentukan logika orkestrasi, yaitu, logika yang mendikte apa siaran server ke klien, dan apa yang di upload klien ke server.

Hal ini akan memerlukan Federasi Inti dari TFF.

Pengantar Inti Federasi

Federasi Inti (FC) adalah satu set interface yang lebih rendah tingkat yang berfungsi sebagai dasar untuk tff.learning API. Namun, antarmuka ini tidak terbatas pada pembelajaran. Faktanya, mereka dapat digunakan untuk analitik dan banyak perhitungan lainnya atas data terdistribusi.

Pada tingkat tinggi, inti federasi adalah lingkungan pengembangan yang memungkinkan logika program yang diekspresikan secara ringkas untuk menggabungkan kode TensorFlow dengan operator komunikasi terdistribusi (seperti jumlah dan siaran terdistribusi). Tujuannya adalah untuk memberikan peneliti dan praktisi kontrol eksplisit atas komunikasi terdistribusi dalam sistem mereka, tanpa memerlukan rincian implementasi sistem (seperti menentukan pertukaran pesan jaringan point-to-point).

Satu poin penting adalah bahwa TFF dirancang untuk menjaga privasi. Oleh karena itu, memungkinkan kontrol eksplisit atas tempat data berada, untuk mencegah akumulasi data yang tidak diinginkan di lokasi server terpusat.

Data gabungan

Konsep kunci dalam TFF adalah "data federasi", yang mengacu pada kumpulan item data yang dihosting di seluruh grup perangkat dalam sistem terdistribusi (mis. kumpulan data klien, atau bobot model server). Kita model seluruh koleksi item data di semua perangkat sebagai nilai Federasi tunggal.

Misalnya, kita memiliki perangkat klien yang masing-masing memiliki pelampung yang mewakili suhu sensor. Kita bisa mewakili sebagai pelampung Federasi oleh

federated_float_on_clients = tff.FederatedType(tf.float32, tff.CLIENTS)

Jenis federasi ditentukan oleh jenis T konstituen anggota (misalnya. tf.float32 ) dan kelompok G perangkat. Kami akan fokus pada kasus-kasus di mana G adalah baik tff.CLIENTS atau tff.SERVER . Seperti jenis Federasi direpresentasikan sebagai {T}@G , seperti yang ditunjukkan di bawah ini.

str(federated_float_on_clients)

'{float32}@CLIENTS'

Mengapa kami sangat peduli dengan penempatan? Tujuan utama TFF adalah untuk memungkinkan penulisan kode yang dapat digunakan pada sistem terdistribusi nyata. Ini berarti bahwa sangat penting untuk mempertimbangkan subset perangkat mana yang mengeksekusi kode mana, dan di mana bagian data yang berbeda berada.

TFF berfokus pada tiga hal: data, dimana data ditempatkan, dan bagaimana data sedang berubah. Dua yang pertama diringkas dalam jenis federasi, sementara terakhir dirumuskan dalam perhitungan federasi.

Komputasi gabungan

TFF adalah lingkungan pemrograman fungsional kuat-mengetik yang unit dasar perhitungan federasi. Ini adalah bagian dari logika yang menerima nilai gabungan sebagai masukan, dan mengembalikan nilai gabungan sebagai keluaran.

Misalnya, kita ingin rata-rata suhu pada sensor klien kita. Kami dapat mendefinisikan yang berikut (menggunakan float gabungan kami):

@tff.federated_computation(tff.FederatedType(tf.float32, tff.CLIENTS))
def get_average_temperature(client_temperatures):
  return tff.federated_mean(client_temperatures)

Anda mungkin bertanya, bagaimana berbeda ini dari tf.function dekorator di TensorFlow? Kunci jawaban adalah bahwa kode yang dihasilkan oleh tff.federated_computation bukanlah TensorFlow atau Python kode; Ini adalah spesifikasi dari sistem terdistribusi dalam bahasa lem platform-independen internal.

Meskipun ini mungkin terdengar rumit, Anda dapat menganggap perhitungan TFF sebagai fungsi dengan tanda tangan tipe yang terdefinisi dengan baik. Tanda tangan jenis ini dapat langsung ditanyakan.

str(get_average_temperature.type_signature)

'({float32}@CLIENTS -> float32@SERVER)'

Ini tff.federated_computation menerima argumen dari jenis Federasi {float32}@CLIENTS , dan nilai-nilai pengembalian tipe Federasi {float32}@SERVER . Komputasi gabungan juga dapat berpindah dari server ke klien, dari klien ke klien, atau dari server ke server. Komputasi gabungan juga dapat disusun seperti fungsi normal, selama tanda tangan tipenya cocok.

Untuk mendukung pengembangan, TFF memungkinkan Anda untuk memohon sebuah tff.federated_computation sebagai fungsi Python. Misalnya, kita dapat memanggil

get_average_temperature([68.5, 70.3, 69.8])

69.53334

Komputasi yang tidak bersemangat dan TensorFlow

Ada dua batasan utama yang harus diperhatikan. Pertama, ketika interpreter Python bertemu dengan tff.federated_computation dekorator, fungsi ini ditelusuri sekali dan serial untuk penggunaan masa depan. Karena sifat Federated Learning yang terdesentralisasi, penggunaan di masa mendatang ini dapat terjadi di tempat lain, seperti lingkungan eksekusi jarak jauh. Oleh karena itu, TFF perhitungan dasarnya non-bersemangat. Perilaku ini agak analog dengan bahwa dari tf.function dekorator di TensorFlow.

Kedua, perhitungan federasi hanya dapat terdiri dari operator federasi (seperti tff.federated_mean ), mereka tidak dapat berisi operasi TensorFlow. Kode TensorFlow harus terbatas pada blok dihiasi dengan tff.tf_computation . Kebanyakan kode TensorFlow biasa dapat langsung dihiasi, seperti fungsi berikut yang mengambil nomor dan menambahkan 0.5 untuk itu.

@tff.tf_computation(tf.float32)
def add_half(x):
  return tf.add(x, 0.5)

Ini juga memiliki jenis tanda tangan, tapi tanpa penempatan. Misalnya, kita dapat memanggil

str(add_half.type_signature)

'(float32 -> float32)'

Di sini kita melihat perbedaan penting antara tff.federated_computation dan tff.tf_computation . Yang pertama memiliki penempatan eksplisit, sedangkan yang kedua tidak.

Kita dapat menggunakan tff.tf_computation blok dalam perhitungan federasi dengan menentukan penempatan. Mari kita buat fungsi yang menambahkan setengah, tetapi hanya untuk float gabungan di klien. Kita dapat melakukan ini dengan menggunakan tff.federated_map , yang menerapkan diberikan tff.tf_computation , sambil menjaga penempatan.

@tff.federated_computation(tff.FederatedType(tf.float32, tff.CLIENTS))
def add_half_on_clients(x):
  return tff.federated_map(add_half, x)

Fungsi ini hampir identik dengan add_half , kecuali bahwa itu hanya menerima nilai-nilai dengan penempatan di tff.CLIENTS , dan nilai-nilai kembali dengan penempatan yang sama. Kita bisa melihat ini di tanda tangan tipenya:

str(add_half_on_clients.type_signature)

'({float32}@CLIENTS -> {float32}@CLIENTS)'

Kesimpulan:

  • TFF beroperasi pada nilai gabungan.
  • Setiap nilai federasi memiliki jenis federasi, dengan jenis (misalnya. tf.float32 ) dan penempatan (misalnya. tff.CLIENTS ).
  • Nilai federasi dapat diubah dengan menggunakan perhitungan federasi, yang harus dihiasi dengan tff.federated_computation dan jenis tanda tangan federasi.
  • Kode TensorFlow harus terkandung dalam blok dengan tff.tf_computation dekorator.
  • Blok-blok ini kemudian dapat dimasukkan ke dalam perhitungan gabungan.

Membangun algoritma Pembelajaran Federasi Anda sendiri, ditinjau kembali

Sekarang setelah kita melihat sekilas tentang Federated Core, kita dapat membangun algoritma pembelajaran federated kita sendiri. Ingat bahwa di atas, kita mendefinisikan sebuah initialize_fn dan next_fn untuk algoritma kami. The next_fn akan memanfaatkan client_update dan server_update kita mendefinisikan menggunakan kode TensorFlow murni.

Namun, dalam rangka untuk membuat algoritma kita perhitungan federasi, kita akan membutuhkan kedua next_fn dan initialize_fn untuk masing-masing menjadi tff.federated_computation .

Blok Federasi TensorFlow

Membuat perhitungan inisialisasi

Fungsi initialize akan cukup sederhana: Kami akan membuat model menggunakan model_fn . Namun, ingat bahwa kita harus memisahkan kode TensorFlow kami menggunakan tff.tf_computation .

@tff.tf_computation
def server_init():
  model = model_fn()
  return model.trainable_variables

Kita kemudian dapat melewati ini langsung ke perhitungan federasi menggunakan tff.federated_value .

@tff.federated_computation
def initialize_fn():
  return tff.federated_value(server_init(), tff.SERVER)

Menciptakan next_fn

Kami sekarang menggunakan kode pembaruan klien dan server kami untuk menulis algoritme yang sebenarnya. Kami pertama akan berubah kami client_update menjadi tff.tf_computation yang menerima dataset client dan bobot Server, dan output diperbarui bobot klien tensor.

Kita akan membutuhkan tipe yang sesuai untuk mendekorasi fungsi kita dengan benar. Untungnya, jenis bobot server dapat diekstraksi langsung dari model kami.

whimsy_model = model_fn()
tf_dataset_type = tff.SequenceType(whimsy_model.input_spec)

Mari kita lihat tanda tangan tipe dataset. Ingatlah bahwa kami mengambil 28 kali 28 gambar (dengan label bilangan bulat) dan meratakannya.

str(tf_dataset_type)

'<float32[?,784],int32[?,1]>*'

Kami juga dapat mengekstrak tipe model bobot dengan menggunakan kami server_init fungsi di atas.

model_weights_type = server_init.type_signature.result

Memeriksa tanda tangan tipe, kita akan dapat melihat arsitektur model kita!

str(model_weights_type)

'<float32[784,10],float32[10]>'

Kita sekarang dapat membuat kami tff.tf_computation untuk update client.

@tff.tf_computation(tf_dataset_type, model_weights_type)
def client_update_fn(tf_dataset, server_weights):
  model = model_fn()
  client_optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)
  return client_update(model, tf_dataset, server_weights, client_optimizer)

The tff.tf_computation versi update server dapat didefinisikan dengan cara yang sama, menggunakan jenis kita sudah diekstraksi.

@tff.tf_computation(model_weights_type)
def server_update_fn(mean_client_weights):
  model = model_fn()
  return server_update(model, mean_client_weights)

Terakhir, namun tidak sedikit, kita perlu menciptakan tff.federated_computation yang membawa ini semua bersama-sama. Fungsi ini akan menerima dua nilai federasi, salah satu yang sesuai dengan bobot Server (dengan penempatan tff.SERVER ), dan yang lainnya sesuai dengan dataset client (dengan penempatan tff.CLIENTS ).

Perhatikan bahwa kedua jenis ini didefinisikan di atas! Kita hanya perlu memberi mereka penempatan yang tepat menggunakan tff.FederatedType .

federated_server_type = tff.FederatedType(model_weights_type, tff.SERVER)
federated_dataset_type = tff.FederatedType(tf_dataset_type, tff.CLIENTS)

Ingat 4 elemen dari algoritma FL?

  1. Langkah siaran server-ke-klien.
  2. Langkah pembaruan klien lokal.
  3. Langkah unggah klien-ke-server.
  4. Langkah pembaruan server.

Sekarang setelah kita membangun di atas, setiap bagian dapat direpresentasikan secara ringkas sebagai satu baris kode TFF. Kesederhanaan ini adalah mengapa kami harus berhati-hati untuk menentukan hal-hal seperti tipe federasi!

@tff.federated_computation(federated_server_type, federated_dataset_type)
def next_fn(server_weights, federated_dataset):
  # Broadcast the server weights to the clients.
  server_weights_at_client = tff.federated_broadcast(server_weights)

  # Each client computes their updated weights.
  client_weights = tff.federated_map(
      client_update_fn, (federated_dataset, server_weights_at_client))

  # The server averages these updates.
  mean_client_weights = tff.federated_mean(client_weights)

  # The server updates its model.
  server_weights = tff.federated_map(server_update_fn, mean_client_weights)

  return server_weights

Kami sekarang memiliki tff.federated_computation untuk kedua inisialisasi algoritma, dan untuk menjalankan satu langkah dari algoritma. Untuk menyelesaikan algoritma kami, kami melewati ini ke tff.templates.IterativeProcess .

federated_algorithm = tff.templates.IterativeProcess(
    initialize_fn=initialize_fn,
    next_fn=next_fn
)

Penampilan Mari kita lihat tanda tangan tipe initialize dan next fungsi dari proses berulang kami.

str(federated_algorithm.initialize.type_signature)

'( -> <float32[784,10],float32[10]>@SERVER)'

Hal ini mencerminkan fakta bahwa federated_algorithm.initialize adalah fungsi no-arg bahwa pengembalian model single-layer (dengan 784-by-10 matriks berat, dan 10 unit bias).

str(federated_algorithm.next.type_signature)

'(<server_weights=<float32[784,10],float32[10]>@SERVER,federated_dataset={<float32[?,784],int32[?,1]>*}@CLIENTS> -> <float32[784,10],float32[10]>@SERVER)'

Di sini, kita melihat bahwa federated_algorithm.next menerima model server dan data klien, dan kembali model server yang diperbarui.

Mengevaluasi algoritma

Mari kita jalankan beberapa putaran, dan lihat bagaimana kerugiannya berubah. Pertama, kita akan mendefinisikan fungsi evaluasi menggunakan pendekatan terpusat dibahas dalam tutorial kedua.

Kami pertama-tama membuat kumpulan data evaluasi terpusat, dan kemudian menerapkan prapemrosesan yang sama yang kami gunakan untuk data pelatihan.

central_emnist_test = emnist_test.create_tf_dataset_from_all_clients()
central_emnist_test = preprocess(central_emnist_test)

Selanjutnya, kita menulis fungsi yang menerima status server, dan menggunakan Keras untuk mengevaluasi pada kumpulan data pengujian. Jika Anda akrab dengan tf.Keras , ini semua akan terlihat akrab, meskipun catatan penggunaan set_weights !

def evaluate(server_state):
  keras_model = create_keras_model()
  keras_model.compile(
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]  
  )
  keras_model.set_weights(server_state)
  keras_model.evaluate(central_emnist_test)

Sekarang, mari kita inisialisasi algoritme kita dan evaluasi pada set pengujian.

server_state = federated_algorithm.initialize()
evaluate(server_state)

2042/2042 [==============================] - 2s 767us/step - loss: 2.8479 - sparse_categorical_accuracy: 0.1027

Mari kita berlatih selama beberapa putaran dan melihat apakah ada yang berubah.

for round in range(15):
  server_state = federated_algorithm.next(server_state, federated_train_data)

evaluate(server_state)

2042/2042 [==============================] - 2s 738us/step - loss: 2.5867 - sparse_categorical_accuracy: 0.0980

Kami melihat sedikit penurunan dalam fungsi kerugian. Meskipun lompatannya kecil, kami hanya melakukan 15 putaran pelatihan, dan pada sebagian kecil klien. Untuk melihat hasil yang lebih baik, kita mungkin harus melakukan ratusan bahkan ribuan putaran.

Memodifikasi algoritme kami

Pada titik ini, mari kita berhenti dan berpikir tentang apa yang telah kita capai. Kami telah menerapkan Federated Averaging secara langsung dengan menggabungkan kode TensorFlow murni (untuk pembaruan klien dan server) dengan komputasi gabungan dari Federated Core of TFF.

Untuk melakukan pembelajaran yang lebih canggih, kita cukup mengubah apa yang kita miliki di atas. Secara khusus, dengan mengedit kode TF murni di atas, kita dapat mengubah cara klien melakukan pelatihan, atau cara server memperbarui modelnya.

Tantangan: Tambah kliping gradien ke client_update fungsi.

Jika kami ingin membuat perubahan yang lebih besar, kami juga dapat membuat server menyimpan dan menyiarkan lebih banyak data. Misalnya, server juga dapat menyimpan tingkat pembelajaran klien, dan membuatnya rusak seiring waktu! Perhatikan bahwa ini akan membutuhkan perubahan pada tanda tangan tipe yang digunakan dalam tff.tf_computation panggilan di atas.

Sulit Tantangan: Melaksanakan Federasi Averaging dengan belajar pembusukan tingkat pada klien.

Pada titik ini, Anda mungkin mulai menyadari betapa banyak fleksibilitas yang dapat Anda terapkan dalam kerangka kerja ini. Untuk gagasan (termasuk jawaban tantangan keras di atas) Anda dapat melihat kode sumber untuk tff.learning.build_federated_averaging_process , atau memeriksa berbagai proyek penelitian dengan menggunakan TFF.