Bantuan melindungi Great Barrier Reef dengan TensorFlow pada Kaggle Bergabung Tantangan

Pembelajaran Terpadu

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 dapat yang sederhana seperti memanggil fungsi pembungkus tunggal (misalnya, tff.learning.from_keras_model ), atau mendefinisikan subclass dari tff.learning.Model antarmuka untuk customizability penuh.

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

  • Dataset. 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.

Interface ini didefinisikan terutama di tff.learning namespace, kecuali untuk set data penelitian dan kemampuan yang berhubungan dengan simulasi lain yang telah dikelompokkan dalam tff.simulation . Lapisan ini diimplementasikan dengan menggunakan tingkat rendah antarmuka yang ditawarkan oleh Federasi Inti (FC) , yang juga menyediakan lingkungan runtime.

Sebelum melanjutkan, sebaiknya Anda pertama meninjau tutorial di klasifikasi citra dan generasi teks , karena mereka memperkenalkan sebagian besar konsep yang dijelaskan di sini menggunakan contoh-contoh konkret. Jika Anda tertarik untuk belajar lebih banyak tentang bagaimana TFF bekerja, Anda mungkin ingin skim selama kustom algoritma tutorial sebagai pengantar ke tingkat yang lebih rendah interface yang kita gunakan untuk mengekspresikan logika perhitungan federasi, dan untuk mempelajari pelaksanaan yang ada dari tff.learning interface.

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 bersemangat-mode). Memastikan bahwa setiap negara Python atau flow control yang diperlukan pada waktu eksekusi dapat serial (mungkin dengan bantuan Autograph ).

Saat ini, TensorFlow tidak sepenuhnya mendukung pembuatan serial dan deserializing TensorFlow mode bersemangat. Dengan demikian, serialisasi di TFF saat ini mengikuti pola TF 1.0, di mana semua kode harus dibangun dalam sebuah tf.Graph bahwa kontrol TFF. Ini berarti TFF saat ini tidak dapat menggunakan model yang sudah dibangun; sebaliknya, logika Model definisi dikemas dalam fungsi no-arg yang kembali sebuah tff.learning.Model . Fungsi ini kemudian dipanggil oleh TFF untuk memastikan semua komponen model diserialkan. Selain itu, menjadi lingkungan yang kuat-mengetik, TFF akan memerlukan sedikit metadata tambahan, seperti spesifikasi tipe masukan model Anda.

Pengumpulan

Kami sangat menyarankan kebanyakan model pengguna konstruk menggunakan Keras, lihat Converter untuk Keras bagian 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 umum tff.learning.Model .

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 membangun tf.Variable s untuk agregat terus, seperti jumlah batch atau jumlah contoh diproses, jumlah kerugian per batch atau per-contoh, dll

    • TFF memanggil forward_pass metode pada Anda Model beberapa kali, secara berurutan batch lebih berikutnya dari data klien, yang memungkinkan Anda untuk memperbarui variabel memegang berbagai agregat sebagai efek samping.

    • Akhirnya, TFF memanggil report_local_outputs metode pada Model Anda untuk memungkinkan model Anda untuk mengkompilasi semua statistik ringkasan itu dikumpulkan menjadi satu set kompak metrik yang akan 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 dinyatakan secara deklaratif menggunakan bahasa komputasi TFF sendiri federasi (tidak di TensorFlow), di Model federated_output_computation. Lihat kustom algoritma tutorial untuk lebih lanjut tentang agregasi API.

Antarmuka abstrak

Konstruktor + interface metadata dasar ini diwakili oleh antarmuka tff.learning.Model , sebagai berikut:

  • Konstruktor, forward_pass , dan report_local_outputs metode harus membangun variabel model, ke depan lulus, dan statistik Anda ingin laporan, Sejalan. TensorFlow yang dibuat oleh metode tersebut harus dapat serial, seperti yang dibahas di atas.

  • The input_spec properti, serta 3 properti yang subset kembali dilatih Anda, non-dilatih, dan variabel 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, abstrak antarmuka tff.learning.Model mengekspos properti federated_output_computation itu, bersama-sama dengan report_local_outputs properti disebutkan sebelumnya, memungkinkan Anda untuk mengontrol proses menggabungkan ringkasan statistik.

Anda dapat menemukan contoh bagaimana untuk menentukan kustom Anda sendiri tff.learning.Model di bagian kedua dari kami citra klasifikasi tutorial, serta dalam contoh model yang kita gunakan untuk pengujian di model_examples.py .

Pengonversi untuk Keras

Hampir semua informasi yang diperlukan oleh TFF dapat diturunkan dengan memanggil tf.keras interface, jadi jika Anda memiliki model Keras, Anda dapat mengandalkan tff.learning.from_keras_model untuk membangun sebuah tff.learning.Model .

Perhatikan bahwa TFF masih ingin Anda untuk memberikan konstruktor - fungsi model no-argumen seperti berikut ini:

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 pada kami klasifikasi citra dan generasi teks tutorial.

Pembangun Komputasi Federasi

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

Asumsi arsitektur

Eksekusi

Ada dua fase berbeda dalam menjalankan komputasi gabungan.

  • Kompilasi: TFF pertama mengkompilasi algoritma pembelajaran federasi menjadi representasi serial abstrak seluruh didistribusikan perhitungan. 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 compiler sebagai perhitungan federasi.

  • Mengeksekusi 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).

Perhitungan federasi yang dihasilkan oleh TFF Federasi Belajar API, seperti algoritma pelatihan yang menggunakan model yang federasi averaging , atau evaluasi federasi, termasuk sejumlah elemen, terutama:

  • Suatu bentuk serial kode model Anda serta kode TensorFlow tambahan dibangun oleh kerangka Federasi Belajar untuk mendorong pelatihan / evaluasi lingkaran model Anda (seperti membangun pengoptimalan, menerapkan update Model, iterasi tf.data.Dataset s, dan metrik komputasi, dan menerapkan pembaruan agregat di server, untuk beberapa nama).

  • Sebuah spesifikasi deklaratif dari komunikasi antara klien dan server (biasanya berbagai bentuk agregasi seluruh perangkat klien, dan penyiaran dari server ke semua klien), dan bagaimana komunikasi didistribusikan ini disisipkan dengan klien-lokal atau server lokal eksekusi dari kode TensorFlow.

Perhitungan federasi direpresentasikan dalam bentuk serial ini dinyatakan dalam bahasa internal platform-independen yang berbeda dari Python, tapi untuk menggunakan API Federasi Belajar, Anda tidak perlu perhatian diri Anda dengan rincian representasi ini. Perhitungan direpresentasikan dalam kode Python Anda sebagai objek dari jenis tff.Computation , yang untuk sebagian besar Anda dapat memperlakukan sebagai buram 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 perhitungan federasi dalam agnostik cara untuk sebagian besar aspek lingkungan eksekusi, sehingga mereka berpotensi dapat deployable untuk, misalnya, kelompok perangkat yang menjalankan Android , atau untuk cluster di datacenter. Sekali lagi, konsekuensi utama ini adalah asumsi yang kuat tentang serialisasi . Secara khusus, ketika Anda menjalankan salah satu build_... metode yang dijelaskan di bawah perhitungan sepenuhnya serial.

Keadaan pemodelan

TFF adalah lingkungan pemrograman fungsional, namun banyak proses yang menarik dalam pembelajaran federasi adalah stateful. Sebagai contoh, loop pelatihan yang melibatkan beberapa putaran Federasi Model rata-rata adalah contoh dari apa yang kita bisa mengklasifikasikan 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 di definisi kelas pembantu tff.templates.IterativeProcess , dengan 2 sifat initialize dan next sesuai dengan inisialisasi dan iterasi, masing-masing.

Pembangun yang tersedia

Saat ini, TFF menyediakan dua fungsi pembangun yang menghasilkan komputasi gabungan untuk pelatihan dan evaluasi gabungan:

Kumpulan data

Asumsi arsitektur

Pilihan klien

Dalam skenario pembelajaran yang khas federasi, kami memiliki populasi besar berpotensi ratusan juta perangkat klien, yang hanya sebagian kecil mungkin aktif dan tersedia untuk pelatihan pada saat tertentu (misalnya, ini mungkin terbatas untuk 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 itu tidak praktis untuk mengkoordinasikan jutaan klien, putaran khas pelatihan atau evaluasi akan mencakup hanya sebagian kecil dari klien tersedia, yang dapat sampel secara acak .

Konsekuensi utama dari ini adalah bahwa perhitungan gabungan, dengan desain, diekspresikan dengan cara yang tidak menyadari set peserta yang tepat; semua proses dinyatakan sebagai operasi agregat pada kelompok abstrak klien anonim, dan kelompok yang mungkin bervariasi dari satu putaran pelatihan yang lain. 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.build_federated_averaging_process(...)
state = trainer.initialize()
federated_training_data = ...

def sample(federate_data):
  return ...

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

Dalam rangka memfasilitasi ini, ketika menggunakan TFF dalam simulasi, data yang federasi diterima sebagai Python list s, dengan satu elemen per berpartisipasi perangkat klien untuk mewakili lokal yang perangkat tf.data.Dataset .

Antarmuka abstrak

Dalam rangka standarisasi berurusan dengan simulasi set data federasi, TFF menyediakan antarmuka abstrak tff.simulation.datasets.ClientData , yang memungkinkan seseorang untuk menghitung set klien, dan untuk membangun sebuah tf.data.Dataset yang berisi data tertentu klien. Mereka tf.data.Dataset s dapat makan langsung sebagai masukan untuk perhitungan federasi 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). Perhitungan yang disusun dan runtime yang mendasari tidak melibatkan gagasan identitas klien. Setelah data dari subset spesifik dari klien telah terpilih sebagai masukan, misalnya, dalam panggilan untuk tff.templates.IterativeProcess.next , identitas klien tidak lagi muncul di dalamnya.

Kumpulan data yang tersedia

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