Halaman ini diterjemahkan oleh Cloud Translation API.

Pembelajaran Terpadu

Ringkasan

Dokumen ini memperkenalkan antarmuka yang memfasilitasi tugas pembelajaran gabungan, seperti pelatihan gabungan atau evaluasi dengan model pembelajaran mesin yang sudah ada dan diterapkan di TensorFlow. Dalam merancang antarmuka ini, tujuan utama kami adalah memungkinkan eksperimen dengan pembelajaran gabungan tanpa memerlukan pengetahuan tentang cara kerjanya, dan untuk mengevaluasi penerapan algoritme pembelajaran gabungan pada berbagai model dan data yang ada. Kami mendorong Anda untuk berkontribusi kembali ke platform. TFF telah dirancang dengan mempertimbangkan ekstensibilitas dan komposisi, dan kami menyambut baik kontribusi; kami sangat senang melihat apa yang Anda hasilkan!

Antarmuka yang ditawarkan oleh lapisan ini terdiri dari tiga bagian penting berikut:

Model . Kelas dan fungsi pembantu yang memungkinkan Anda menggabungkan model yang ada untuk digunakan dengan TFF. Membungkus model bisa sesederhana memanggil fungsi pembungkus tunggal (misalnya, tff.learning.models.from_keras_model ), atau mendefinisikan subkelas antarmuka tff.learning.models.VariableModel untuk penyesuaian penuh.
Pembangun Komputasi Federasi . Fungsi pembantu yang membuat komputasi gabungan untuk pelatihan atau evaluasi, menggunakan model yang ada.
Kumpulan data . Kumpulan data terekam yang dapat Anda unduh dan akses dengan Python untuk digunakan dalam simulasi skenario pembelajaran gabungan. Meskipun pembelajaran gabungan dirancang untuk digunakan dengan data terdesentralisasi yang tidak dapat diunduh begitu saja di lokasi terpusat, pada tahap penelitian dan pengembangan sering kali lebih mudah untuk melakukan eksperimen awal menggunakan data yang dapat diunduh dan dimanipulasi secara lokal, terutama bagi pengembang yang mungkin baru dalam pendekatan ini.

Antarmuka ini didefinisikan terutama di namespace tff.learning , kecuali untuk kumpulan data penelitian dan kemampuan terkait simulasi lainnya yang telah dikelompokkan dalam tff.simulation . Lapisan ini diimplementasikan menggunakan antarmuka tingkat rendah yang ditawarkan oleh Federated Core (FC) , yang juga menyediakan lingkungan runtime.

Sebelum melanjutkan, kami menyarankan Anda meninjau terlebih dahulu tutorial tentang klasifikasi gambar dan pembuatan teks , karena tutorial tersebut memperkenalkan sebagian besar konsep yang dijelaskan di sini menggunakan contoh nyata. Jika Anda tertarik untuk mempelajari lebih lanjut tentang cara kerja TFF, Anda mungkin ingin membaca sekilas tutorial algoritme khusus sebagai pengenalan antarmuka tingkat rendah yang kami gunakan untuk mengekspresikan logika komputasi gabungan, dan mempelajari implementasi yang ada dari TFF. antarmuka tff.learning .

Model

Asumsi arsitektur

Serialisasi

TFF bertujuan untuk mendukung berbagai skenario pembelajaran terdistribusi di mana kode model pembelajaran mesin yang Anda tulis mungkin dijalankan pada sejumlah besar klien heterogen dengan beragam kemampuan. Meskipun di satu sisi spektrum, dalam beberapa aplikasi, klien tersebut mungkin merupakan server database yang kuat, banyak kegunaan penting yang ingin didukung oleh platform kami yang melibatkan perangkat seluler dan tertanam dengan sumber daya terbatas. Kami tidak dapat berasumsi bahwa perangkat ini mampu menghosting runtime Python; satu-satunya hal yang dapat kami asumsikan saat ini adalah bahwa mereka mampu menghosting runtime TensorFlow lokal. Oleh karena itu, asumsi arsitektur dasar yang kami buat di TFF adalah kode model Anda harus dapat diserialkan sebagai grafik TensorFlow.

Anda dapat (dan harus) tetap mengembangkan kode TF dengan mengikuti praktik terbaik terbaru seperti menggunakan mode bersemangat. Namun, kode akhir harus dapat diserialkan (misalnya, dapat dibungkus sebagai tf.function untuk kode mode bersemangat). Hal ini memastikan bahwa setiap status Python atau aliran kontrol yang diperlukan pada waktu eksekusi dapat diserialkan (mungkin dengan bantuan Autograph ).

Saat ini, TensorFlow tidak sepenuhnya mendukung serialisasi dan deserialisasi TensorFlow mode bersemangat. Jadi, serialisasi di TFF saat ini mengikuti pola TF 1.0, di mana semua kode harus dibuat di dalam tf.Graph yang dikontrol TFF. Artinya saat ini TFF tidak dapat menggunakan model yang sudah dibangun; sebaliknya, logika definisi model dikemas dalam fungsi tanpa argumen yang mengembalikan tff.learning.models.VariableModel . Fungsi ini kemudian dipanggil oleh TFF untuk memastikan semua komponen model terserialisasi. Selain itu, karena merupakan lingkungan dengan tipe yang kuat, TFF akan memerlukan sedikit metadata tambahan, seperti spesifikasi jenis input model Anda.

Pengumpulan

Kami sangat menyarankan sebagian besar pengguna membuat model menggunakan Keras, lihat bagian Pengonversi untuk Keras di bawah. Wrapper ini menangani agregasi pembaruan model serta metrik apa pun yang ditentukan untuk model secara otomatis. Namun, mungkin masih berguna untuk memahami bagaimana agregasi ditangani untuk tff.learning.models.VariableModel secara umum.

Setidaknya selalu ada dua lapisan agregasi dalam pembelajaran gabungan: agregasi lokal pada perangkat, dan agregasi lintas perangkat (atau gabungan):

Agregasi lokal . Tingkat agregasi ini mengacu pada agregasi di beberapa kumpulan contoh yang dimiliki oleh masing-masing klien. Hal ini berlaku untuk parameter model (variabel), yang terus berkembang secara berurutan seiring model dilatih secara lokal, serta statistik yang Anda hitung (seperti rata-rata kerugian, akurasi, dan metrik lainnya), yang akan diperbarui lagi oleh model Anda secara lokal. saat melakukan iterasi pada aliran data lokal masing-masing klien.
Melakukan agregasi pada tingkat ini adalah tanggung jawab kode model Anda, dan dilakukan menggunakan konstruksi TensorFlow standar.
Struktur umum pemrosesannya adalah sebagai berikut:
- Model pertama-tama membuat tf.Variable s untuk menampung agregat, seperti jumlah batch atau jumlah contoh yang diproses, jumlah kerugian per batch atau per contoh, dll.
- TFF memanggil metode forward_pass pada Model Anda beberapa kali, secara berurutan pada kumpulan data klien berikutnya, yang memungkinkan Anda memperbarui variabel yang menyimpan berbagai agregat sebagai efek sampingnya.
- Terakhir, TFF memanggil metode report_local_unfinalized_metrics pada Model Anda untuk memungkinkan model Anda mengompilasi semua ringkasan statistik yang dikumpulkannya ke dalam kumpulan metrik ringkas untuk diekspor oleh klien. Di sinilah kode model Anda, misalnya, membagi jumlah kerugian dengan jumlah contoh yang diproses untuk mengekspor kerugian rata-rata, dll.
Agregasi gabungan . Tingkat agregasi ini mengacu pada agregasi di beberapa klien (perangkat) dalam sistem. Sekali lagi, ini berlaku untuk parameter model (variabel), yang dirata-ratakan di seluruh klien, serta metrik yang diekspor model Anda sebagai hasil agregasi lokal.
Melakukan agregasi pada tingkat ini adalah tanggung jawab TFF. Namun, sebagai pembuat model, Anda dapat mengontrol proses ini (lebih lanjut tentang ini di bawah).
Struktur umum pemrosesannya adalah sebagai berikut:
- Model awal, dan parameter apa pun yang diperlukan untuk pelatihan, didistribusikan oleh server ke sekelompok klien yang akan berpartisipasi dalam putaran pelatihan atau evaluasi.
- Pada setiap klien, secara independen dan paralel, kode model Anda dipanggil berulang kali pada aliran kumpulan data lokal untuk menghasilkan kumpulan parameter model baru (saat pelatihan), dan kumpulan metrik lokal baru, seperti dijelaskan di atas (ini adalah lokal pengumpulan).
- TFF menjalankan protokol agregasi terdistribusi untuk mengakumulasi dan mengagregasi parameter model dan metrik yang diekspor secara lokal di seluruh sistem. Logika ini diekspresikan secara deklaratif menggunakan bahasa komputasi gabungan milik TFF (bukan di TensorFlow). Lihat tutorial algoritme khusus untuk mengetahui lebih lanjut tentang API agregasi.

Antarmuka abstrak

Antarmuka konstruktor + metadata dasar ini diwakili oleh antarmuka tff.learning.models.VariableModel , sebagai berikut:

Metode konstruktor, forward_pass , dan report_local_unfinalized_metrics harus membuat variabel model, forward pass, dan statistik yang ingin Anda laporkan. TensorFlow yang dibuat dengan metode tersebut harus dapat diserialkan, seperti yang dibahas di atas.
Properti input_spec , serta 3 properti yang mengembalikan subset dari variabel lokal yang dapat dilatih, tidak dapat dilatih, dan lokal mewakili metadata. TFF menggunakan informasi ini untuk menentukan cara menghubungkan bagian-bagian model Anda ke algoritme pengoptimalan gabungan, dan untuk menentukan tanda tangan tipe internal guna membantu memverifikasi kebenaran sistem yang dibangun (sehingga model Anda tidak dapat dipakai pada data yang tidak cocok dengan apa model ini dirancang untuk dikonsumsi).

Selain itu, antarmuka abstrak tff.learning.models.VariableModel memperlihatkan properti metric_finalizers yang mengambil nilai metrik yang belum diselesaikan (dikembalikan oleh report_local_unfinalized_metrics() ) dan mengembalikan nilai metrik yang diselesaikan. Metode metric_finalizers dan report_local_unfinalized_metrics() akan digunakan bersama untuk membangun agregator metrik lintas klien saat menentukan proses pelatihan gabungan atau penghitungan evaluasi. Misalnya, agregator tff.learning.metrics.sum_then_finalize pertama-tama akan menjumlahkan nilai metrik yang belum diselesaikan dari klien, lalu memanggil fungsi finalizer di server.

Anda dapat menemukan contoh cara menentukan tff.learning.models.VariableModel kustom Anda sendiri di bagian kedua tutorial klasifikasi gambar kami, serta dalam contoh model yang kami gunakan untuk pengujian di model_examples.py .

Konverter untuk Keras

Hampir semua informasi yang diperlukan oleh TFF dapat diperoleh dengan memanggil antarmuka tf.keras , jadi jika Anda memiliki model Keras, Anda dapat mengandalkan tff.learning.models.from_keras_model untuk membuat tff.learning.models.VariableModel .

Perhatikan bahwa TFF tetap ingin Anda menyediakan konstruktor - fungsi model tanpa argumen seperti berikut:

def model_fn():
  keras_model = ...
  return tff.learning.models.from_keras_model(keras_model, sample_batch, loss=...)

Selain model itu sendiri, Anda menyediakan kumpulan sampel data yang digunakan TFF untuk menentukan jenis dan bentuk masukan model Anda. Hal ini memastikan bahwa TFF dapat membuat instance model dengan benar untuk data yang benar-benar ada di perangkat klien (karena kami berasumsi data ini tidak tersedia secara umum pada saat Anda membuat TensorFlow untuk diserialkan).

Penggunaan pembungkus Keras diilustrasikan dalam tutorial klasifikasi gambar dan pembuatan teks kami.

Pembangun Komputasi Federasi

Paket tff.learning menyediakan beberapa pembangun untuk tff.Computation yang melakukan tugas terkait pembelajaran; kami berharap rangkaian perhitungan tersebut akan berkembang di masa depan.

Asumsi arsitektur

Eksekusi

Ada dua fase berbeda dalam menjalankan komputasi gabungan.

Kompilasi : TFF pertama-tama mengkompilasi algoritme pembelajaran gabungan menjadi representasi serial abstrak dari seluruh komputasi terdistribusi. Ini adalah saat serialisasi TensorFlow terjadi, namun transformasi lain dapat terjadi untuk mendukung eksekusi yang lebih efisien. Kami mengacu pada representasi serial yang dipancarkan oleh kompiler sebagai komputasi gabungan .
Jalankan TFF menyediakan cara untuk menjalankan perhitungan ini. Untuk saat ini, eksekusi hanya didukung melalui simulasi lokal (misalnya, di notebook menggunakan simulasi data terdesentralisasi).

Komputasi gabungan yang dihasilkan oleh Federated Learning API TFF, seperti algoritme pelatihan yang menggunakan rata-rata model gabungan , atau evaluasi gabungan, mencakup sejumlah elemen, terutama:

Bentuk serial kode model Anda serta kode TensorFlow tambahan yang dibuat oleh framework Federated Learning untuk mendorong loop pelatihan/evaluasi model Anda (seperti membuat pengoptimal, menerapkan pembaruan model, melakukan iterasi pada tf.data.Dataset s, dan menghitung metrik, dan menerapkan pembaruan agregat di server, untuk beberapa nama).
Spesifikasi deklaratif komunikasi antara klien dan server (biasanya berbagai bentuk agregasi di seluruh perangkat klien, dan disiarkan dari server ke semua klien), dan bagaimana komunikasi terdistribusi ini disisipkan dengan eksekusi klien-lokal atau server-lokal kode TensorFlow.

Perhitungan gabungan yang direpresentasikan dalam bentuk serial ini dinyatakan dalam bahasa internal platform-independen yang berbeda dari Python, namun untuk menggunakan Federated Learning API, Anda tidak perlu memikirkan detail representasi ini. Komputasi direpresentasikan dalam kode Python Anda sebagai objek bertipe tff.Computation , yang sebagian besar dapat Anda perlakukan sebagai callable Python buram.

Dalam tutorial, Anda akan menjalankan perhitungan gabungan tersebut seolah-olah itu adalah fungsi Python biasa, untuk dieksekusi secara lokal. Namun, TFF dirancang untuk mengekspresikan komputasi gabungan dengan cara yang tidak sesuai dengan sebagian besar aspek lingkungan eksekusi, sehingga berpotensi dapat diterapkan ke, misalnya, grup perangkat yang menjalankan Android , atau ke cluster di pusat data. Sekali lagi, konsekuensi utama dari hal ini adalah asumsi yang kuat tentang serialisasi . Khususnya, ketika Anda memanggil salah satu metode build_... yang dijelaskan di bawah, komputasi akan sepenuhnya berseri.

Keadaan pemodelan

TFF adalah lingkungan pemrograman fungsional, namun banyak proses yang diminati dalam pembelajaran gabungan bersifat stateful. Misalnya, loop pelatihan yang melibatkan beberapa putaran rata-rata model gabungan adalah contoh dari apa yang dapat kita klasifikasikan sebagai proses stateful . Dalam proses ini, keadaan yang berkembang dari satu putaran ke putaran lainnya mencakup kumpulan parameter model yang sedang dilatih, dan mungkin keadaan tambahan yang terkait dengan pengoptimal (misalnya, vektor momentum).

Karena TFF berfungsi, proses stateful dimodelkan dalam TFF sebagai komputasi yang menerima keadaan saat ini sebagai masukan dan kemudian memberikan keadaan yang diperbarui sebagai keluaran. Untuk mendefinisikan proses stateful secara lengkap, kita juga perlu menentukan dari mana keadaan awal berasal (jika tidak, kita tidak dapat mem-bootstrap proses tersebut). Hal ini tercakup dalam definisi kelas pembantu tff.templates.IterativeProcess , dengan 2 properti initialize dan next masing-masing sesuai dengan inisialisasi dan iterasi.

Pembangun yang tersedia

Saat ini, TFF menyediakan berbagai fungsi pembangun yang menghasilkan komputasi gabungan untuk pelatihan dan evaluasi gabungan. Dua contoh penting meliputi:

tff.learning.algorithms.build_weighted_fed_avg , yang mengambil input fungsi model dan pengoptimal klien , dan mengembalikan tff.learning.templates.LearningProcess stateful (yang merupakan subkelas tff.templates.IterativeProcess ).
tff.learning.build_federated_evaluation mengambil fungsi model dan mengembalikan komputasi gabungan tunggal untuk evaluasi model gabungan, karena evaluasi tidak bersifat stateful.

Kumpulan data

Asumsi arsitektur

Seleksi klien

Dalam skenario pembelajaran gabungan pada umumnya, kita memiliki populasi besar yang berpotensi mencapai ratusan juta perangkat klien, yang hanya sebagian kecil yang mungkin aktif dan tersedia untuk pelatihan pada saat tertentu (misalnya, ini mungkin terbatas pada klien yang dicolokkan ke sumber listrik, bukan pada jaringan terukur, dan jika tidak, tidak ada aktivitas). Umumnya, kumpulan klien yang tersedia untuk berpartisipasi dalam pelatihan atau evaluasi berada di luar kendali pengembang. Selain itu, karena tidak praktis untuk mengoordinasikan jutaan klien, putaran pelatihan atau evaluasi biasanya hanya mencakup sebagian kecil dari klien yang tersedia, yang dapat diambil sampelnya secara acak .

Konsekuensi utama dari hal ini adalah bahwa perhitungan gabungan, berdasarkan desain, diekspresikan dengan cara yang tidak memperhatikan kelompok partisipan yang sebenarnya; semua pemrosesan dinyatakan sebagai operasi agregat pada grup abstrak klien anonim, dan grup tersebut mungkin berbeda dari satu putaran pelatihan ke putaran pelatihan lainnya. Pengikatan komputasi yang sebenarnya kepada peserta konkrit, dan dengan demikian pada data konkrit yang mereka masukkan ke dalam komputasi, dengan demikian dimodelkan di luar komputasi itu sendiri.

Untuk menyimulasikan penerapan kode pembelajaran gabungan yang realistis, Anda biasanya akan menulis loop pelatihan yang terlihat seperti ini:

trainer = tff.learning.algorithms.build_weighted_fed_avg(...)
state = trainer.initialize()
federated_training_data = ...

def sample(federate_data):
  return ...

while True:
  data_for_this_round = sample(federated_training_data)
  result = trainer.next(state, data_for_this_round)
  state = result.state

Untuk memfasilitasi hal ini, saat menggunakan TFF dalam simulasi, data gabungan diterima sebagai Python list s, dengan satu elemen per perangkat klien yang berpartisipasi untuk mewakili tf.data.Dataset lokal perangkat tersebut.

Antarmuka abstrak

Untuk membakukan penanganan kumpulan data gabungan yang disimulasikan, TFF menyediakan antarmuka abstrak tff.simulation.datasets.ClientData , yang memungkinkan seseorang menghitung kumpulan klien, dan membuat tf.data.Dataset yang berisi data tertentu klien. tf.data.Dataset s tersebut dapat dimasukkan langsung sebagai masukan ke komputasi gabungan yang dihasilkan dalam mode bersemangat.

Perlu dicatat bahwa kemampuan untuk mengakses identitas klien adalah fitur yang hanya disediakan oleh kumpulan data untuk digunakan dalam simulasi, di mana kemampuan untuk melatih data dari subkumpulan klien tertentu mungkin diperlukan (misalnya, untuk mensimulasikan ketersediaan diurnal dari berbagai identitas klien). jenis klien). Komputasi yang dikompilasi dan runtime yang mendasarinya tidak melibatkan gagasan apa pun tentang identitas klien. Setelah data dari subset klien tertentu dipilih sebagai masukan, misalnya, dalam panggilan ke tff.templates.IterativeProcess.next , identitas klien tidak lagi muncul di dalamnya.

Kumpulan data yang tersedia

Kami telah mendedikasikan namespace tff.simulation.datasets untuk kumpulan data yang mengimplementasikan antarmuka tff.simulation.datasets.ClientData untuk digunakan dalam simulasi, dan menambahkannya dengan kumpulan data untuk mendukung klasifikasi gambar dan tutorial pembuatan teks . Kami ingin mendorong Anda untuk menyumbangkan kumpulan data Anda sendiri ke platform.