Hadiri Simposium Women in ML pada 7 Desember Daftar sekarang

Pembelajaran Terpadu

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Ringkasan

Dokumen ini memperkenalkan antarmuka yang memfasilitasi tugas pembelajaran gabungan, seperti pelatihan atau evaluasi gabungan dengan model pembelajaran mesin yang sudah ada yang diimplementasikan di TensorFlow. Dalam merancang antarmuka ini, tujuan utama kami adalah memungkinkan eksperimen dengan pembelajaran gabungan tanpa memerlukan pengetahuan tentang cara kerjanya, dan untuk mengevaluasi algoritme pembelajaran gabungan yang diterapkan 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 senang melihat apa yang Anda hasilkan!

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

  • Model . Kelas dan fungsi pembantu yang memungkinkan Anda untuk membungkus model yang ada untuk digunakan dengan TFF. Membungkus model bisa sesederhana memanggil fungsi pembungkus tunggal (mis., tff.learning.from_keras_model ), atau mendefinisikan subkelas antarmuka tff.learning.Model untuk penyesuaian penuh.

  • Pembangun Komputasi Federasi . Fungsi pembantu yang menyusun komputasi gabungan untuk pelatihan atau evaluasi, menggunakan model yang ada.

  • Kumpulan data . Kumpulan data kalengan yang dapat Anda unduh dan akses dengan Python untuk digunakan dalam mensimulasikan 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 seringkali lebih mudah untuk melakukan percobaan awal menggunakan data yang dapat diunduh dan dimanipulasi secara lokal, terutama bagi pengembang yang mungkin baru dalam pendekatan.

Antarmuka ini didefinisikan terutama di ruang nama 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 terlebih dahulu meninjau 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 pengantar antarmuka tingkat rendah yang kami gunakan untuk mengekspresikan logika komputasi gabungan, dan untuk mempelajari implementasi yang ada dari 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 dieksekusi pada sejumlah besar klien heterogen dengan kemampuan yang beragam. Sementara di salah satu ujung spektrum, dalam beberapa aplikasi klien tersebut mungkin merupakan server database yang kuat, banyak penggunaan penting yang dimaksudkan untuk mendukung platform kami 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 kita asumsikan pada saat ini adalah bahwa mereka mampu menghosting runtime TensorFlow lokal. Jadi, asumsi arsitektur dasar yang kami buat di TFF adalah bahwa kode model Anda harus dapat diserialisasikan sebagai grafik TensorFlow.

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

Saat ini, TensorFlow tidak sepenuhnya mendukung pembuatan serial dan deserializing TensorFlow mode bersemangat. Jadi, serialisasi di TFF saat ini mengikuti pola TF 1.0, di mana semua kode harus dibangun di dalam tf.Graph yang dikontrol TFF. Ini berarti TFF saat ini tidak dapat menggunakan model yang sudah dibangun; sebagai gantinya, logika definisi model dikemas dalam fungsi no-arg yang mengembalikan tff.learning.Model . Fungsi ini kemudian dipanggil oleh TFF untuk memastikan semua komponen model diserialkan. Selain itu, sebagai lingkungan yang sangat diketik, TFF akan memerlukan sedikit metadata tambahan , seperti spesifikasi jenis masukan model Anda.

Pengumpulan

Kami sangat menyarankan sebagian besar pengguna membuat model menggunakan Keras, lihat bagian Pengonversi untuk Keras di bawah ini. 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.Model umum.

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

  • Agregasi lokal . Tingkat agregasi ini mengacu pada agregasi di beberapa kumpulan contoh yang dimiliki oleh klien individu. Ini berlaku untuk parameter model (variabel), yang terus berkembang secara berurutan saat model dilatih secara lokal, serta statistik yang Anda hitung (seperti kerugian rata-rata, akurasi, dan metrik lainnya), yang akan diperbarui lagi oleh model Anda secara lokal karena iterasi pada aliran data lokal setiap klien individu.

    Melakukan agregasi pada level ini adalah tanggung jawab kode model Anda, dan dilakukan dengan menggunakan konstruksi TensorFlow standar.

    Struktur umum pemrosesan adalah sebagai berikut:

    • Model pertama-tama membangun 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 untuk memperbarui variabel yang menyimpan berbagai agregat sebagai efek samping.

    • Terakhir, TFF memanggil metode report_local_unfinalized_metrics pada Model Anda untuk memungkinkan model Anda mengompilasi semua statistik ringkasan yang dikumpulkannya ke dalam kumpulan metrik yang ringkas untuk diekspor oleh klien. Di sinilah kode model Anda dapat, misalnya, membagi jumlah kerugian dengan jumlah contoh yang diproses untuk mengekspor kerugian rata-rata, dll.

  • Agregasi federasi . 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 dari agregasi lokal.

    Melakukan agregasi pada level ini adalah tanggung jawab TFF. Namun, sebagai pembuat model, Anda dapat mengontrol proses ini (lebih lanjut tentang ini di bawah).

    Struktur umum pemrosesan adalah sebagai berikut:

    • Model awal, dan parameter apa pun yang diperlukan untuk pelatihan, didistribusikan oleh server ke subset 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 satu set parameter model baru (saat pelatihan), dan satu set 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 TFF sendiri (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.Model , sebagai berikut:

  • Metode konstruktor, forward_pass , dan report_local_unfinalized_metrics harus membuat variabel model, penerusan, dan statistik yang ingin Anda laporkan. TensorFlow yang dibuat oleh metode tersebut harus dapat serial, seperti yang dibahas di atas.

  • Properti input_spec , serta 3 properti yang mengembalikan subset dari variabel yang dapat dilatih, tidak dapat dilatih, dan lokal mewakili metadata. TFF menggunakan informasi ini untuk menentukan cara menghubungkan bagian-bagian dari model Anda ke algoritme pengoptimalan gabungan, dan untuk menentukan tanda tangan tipe internal untuk membantu dalam memverifikasi kebenaran sistem yang dibangun (sehingga model Anda tidak dapat digunakan pada data yang tidak cocok dengan apa model dirancang untuk dikonsumsi).

Selain itu, antarmuka abstrak tff.learning.Model memperlihatkan properti metric_finalizers yang mengambil nilai metrik yang belum diselesaikan (dikembalikan oleh report_local_unfinalized_metrics() ) dan mengembalikan nilai metrik yang telah diselesaikan. Metode metric_finalizers dan report_local_unfinalized_metrics() akan digunakan bersama untuk membangun agregator metrik lintas-klien saat menentukan proses pelatihan gabungan atau perhitungan evaluasi. Misalnya, agregator tff.learning.metrics.sum_then_finalize sederhana 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.Model kustom Anda sendiri di bagian kedua tutorial klasifikasi gambar kami, serta dalam contoh model yang kami gunakan untuk pengujian di model_examples.py .

Pengonversi 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.from_keras_model untuk membuat tff.learning.Model .

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

def model_fn():
  keras_model = ...
  return tff.learning.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 input model Anda. Ini memastikan bahwa TFF dapat membuat instance model dengan benar untuk data yang sebenarnya akan ada di perangkat klien (karena kami menganggap data ini tidak tersedia secara umum pada saat Anda membuat TensorFlow untuk diserialisasi).

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

Pembangun Komputasi Federasi

Paket tff.learning menyediakan beberapa pembangun untuk tff.Computation s yang melakukan tugas-tugas yang berhubungan dengan pembelajaran; kami berharap rangkaian perhitungan tersebut berkembang di masa mendatang.

Asumsi arsitektur

Eksekusi

Ada dua fase berbeda dalam menjalankan komputasi gabungan.

  • Kompilasi : TFF pertama-tama mengkompilasi algoritma pembelajaran gabungan menjadi representasi serial abstrak dari seluruh komputasi terdistribusi. Ini adalah saat serialisasi TensorFlow terjadi, tetapi transformasi lain dapat terjadi untuk mendukung eksekusi yang lebih efisien. Kami mengacu pada representasi serial yang dipancarkan oleh kompiler sebagai komputasi gabungan .

  • Execute TFF menyediakan cara untuk mengeksekusi perhitungan ini. Untuk saat ini, eksekusi hanya didukung melalui simulasi lokal (misalnya, di notebook yang menggunakan data terdesentralisasi yang disimulasikan).

Komputasi gabungan yang dihasilkan oleh API Pembelajaran Federasi 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 kerangka kerja Federated Learning untuk mendorong loop pelatihan/evaluasi model Anda (seperti membuat pengoptimal, menerapkan pembaruan model, mengulangi 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 penyiaran dari server ke semua klien), dan bagaimana komunikasi terdistribusi ini disisipkan dengan eksekusi klien-lokal atau server-lokal dari kode TensorFlow.

Komputasi gabungan yang diwakili dalam bentuk serial ini diekspresikan dalam bahasa internal platform-independen yang berbeda dari Python, tetapi untuk menggunakan API Pembelajaran Federasi, Anda tidak perlu khawatir dengan detail representasi ini. Perhitungan direpresentasikan dalam kode Python Anda sebagai objek bertipe tff.Computation , yang sebagian besar dapat Anda perlakukan sebagai opak Python callable s.

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

Keadaan pemodelan

TFF adalah lingkungan pemrograman fungsional, namun banyak proses yang menarik dalam pembelajaran federasi adalah stateful. Misalnya, loop pelatihan yang melibatkan beberapa putaran rata-rata model federasi adalah contoh dari apa yang dapat kita klasifikasikan sebagai proses stateful . Dalam proses ini, status yang berevolusi dari putaran ke putaran mencakup set parameter model yang dilatih, dan kemungkinan status tambahan yang terkait dengan pengoptimal (misalnya, vektor momentum).

Karena TFF berfungsi, proses stateful dimodelkan dalam TFF sebagai komputasi yang menerima status saat ini sebagai input dan kemudian memberikan status yang diperbarui sebagai output. Untuk sepenuhnya mendefinisikan proses stateful, kita juga perlu menentukan dari mana state awal berasal (jika tidak, kita tidak dapat mem-bootstrap proses). Ini ditangkap dalam definisi kelas pembantu tff.templates.IterativeProcess , dengan 2 properti initialize dan next sesuai dengan inisialisasi dan iterasi, masing-masing.

Pembangun yang tersedia

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

Kumpulan data

Asumsi arsitektur

Pilihan klien

Dalam skenario pembelajaran gabungan yang khas, kami memiliki populasi besar yang berpotensi 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 daya, bukan pada jaringan terukur, dan jika tidak, menganggur). 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 yang umum hanya akan mencakup sebagian kecil dari klien yang tersedia, yang dapat diambil sampelnya secara acak .

Konsekuensi utama dari ini adalah bahwa perhitungan gabungan, dengan desain, diekspresikan dengan cara yang tidak menyadari set peserta yang tepat; semua pemrosesan dinyatakan sebagai operasi agregat pada grup abstrak klien anonim , dan grup itu mungkin berbeda dari satu putaran pelatihan ke putaran lainnya. Pengikatan sebenarnya dari perhitungan ke peserta konkret, dan dengan demikian ke data konkret yang mereka masukkan ke dalam perhitungan, dengan demikian dimodelkan di luar perhitungan itu sendiri.

Untuk mensimulasikan penerapan realistis kode pembelajaran gabungan Anda, 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 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 menstandarisasi berurusan dengan kumpulan data gabungan yang disimulasikan, TFF menyediakan antarmuka abstrak tff.simulation.datasets.ClientData , yang memungkinkan seseorang untuk menghitung kumpulan klien, dan untuk membangun tf.data.Dataset yang berisi data tertentu klien. tf.data.Dataset s tersebut dapat diumpankan secara langsung sebagai input 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 himpunan bagian klien tertentu mungkin diperlukan (misalnya, untuk mensimulasikan ketersediaan diurnal dari berbagai jenis klien). Komputasi yang dikompilasi dan runtime yang mendasarinya tidak melibatkan gagasan tentang identitas klien. Setelah data dari subset klien tertentu telah dipilih sebagai input, 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 menyemainya dengan kumpulan data untuk mendukung klasifikasi gambar dan tutorial pembuatan teks . Kami ingin mendorong Anda untuk menyumbangkan kumpulan data Anda sendiri ke platform.