Inti Federasi

Dokumen ini memperkenalkan lapisan inti TFF yang berfungsi sebagai landasan untuk Pembelajaran Federasi , dan kemungkinan algoritma gabungan non-pembelajaran di masa depan.

Untuk pengenalan singkat tentang Federated Core, silakan baca tutorial berikut, karena tutorial tersebut memperkenalkan beberapa konsep dasar melalui contoh dan mendemonstrasikan langkah demi langkah konstruksi algoritma rata-rata federasi yang sederhana.

Kami juga mendorong Anda untuk membiasakan diri dengan Pembelajaran Federasi dan tutorial terkait mengenai klasifikasi gambar dan pembuatan teks , karena penggunaan API Inti Federasi (FC API) untuk pembelajaran gabungan memberikan konteks penting untuk beberapa pilihan yang kami buat dalam merancang lapisan ini.

Ringkasan

Tujuan, Tujuan Penggunaan, dan Ruang Lingkup

Federated Core (FC) paling baik dipahami sebagai lingkungan pemrograman untuk mengimplementasikan komputasi terdistribusi, yaitu komputasi yang melibatkan banyak komputer (ponsel, tablet, perangkat tertanam, komputer desktop, sensor, server database, dll.) yang masing-masing dapat melakukan kinerja non- pemrosesan sepele secara lokal, dan berkomunikasi melalui jaringan untuk mengoordinasikan pekerjaan mereka.

Istilah terdistribusi sangat umum, dan TFF tidak menargetkan semua kemungkinan jenis algoritma terdistribusi yang ada, jadi kami lebih memilih menggunakan istilah komputasi gabungan yang kurang umum untuk menggambarkan jenis algoritma yang dapat diekspresikan dalam kerangka ini.

Meskipun mendefinisikan istilah komputasi gabungan dengan cara yang sepenuhnya formal berada di luar cakupan dokumen ini, pikirkan jenis algoritme yang mungkin Anda lihat dinyatakan dalam kodesemu dalam publikasi penelitian yang menjelaskan algoritme pembelajaran terdistribusi baru.

Singkatnya, tujuan FC adalah untuk memungkinkan representasi kompak yang serupa, pada tingkat abstraksi mirip pseudocode yang serupa, dari logika program yang bukan pseudocode, melainkan dapat dieksekusi di berbagai lingkungan target.

Karakteristik penentu utama dari jenis algoritma yang dirancang untuk diungkapkan oleh FC adalah bahwa tindakan partisipan sistem dijelaskan secara kolektif. Oleh karena itu, kita cenderung berbicara tentang setiap perangkat yang mentransformasikan data secara lokal, dan perangkat yang mengoordinasikan pekerjaan melalui koordinator terpusat yang menyiarkan , mengumpulkan , atau menggabungkan hasilnya.

Meskipun TFF telah dirancang untuk mampu melampaui arsitektur klien-server yang sederhana, gagasan pemrosesan kolektif adalah hal yang mendasar. Hal ini disebabkan asal mula TFF dalam pembelajaran gabungan, sebuah teknologi yang awalnya dirancang untuk mendukung komputasi pada data yang berpotensi sensitif dan tetap berada di bawah kendali perangkat klien, dan tidak dapat diunduh begitu saja ke lokasi terpusat karena alasan privasi. Meskipun setiap klien dalam sistem tersebut menyumbangkan data dan kekuatan pemrosesan untuk menghitung hasil sistem (hasil yang secara umum kami harapkan dapat bermanfaat bagi semua peserta), kami juga berupaya menjaga privasi dan anonimitas setiap klien.

Jadi, meskipun sebagian besar kerangka kerja untuk komputasi terdistribusi dirancang untuk mengekspresikan pemrosesan dari sudut pandang masing-masing peserta - yaitu, pada tingkat pertukaran pesan titik-ke-titik individu, dan saling ketergantungan transisi keadaan lokal peserta dengan pesan masuk dan keluar. , Inti Federasi TFF dirancang untuk menggambarkan perilaku sistem dari perspektif sistem global (mirip dengan, misalnya, MapReduce ).

Akibatnya, meskipun kerangka terdistribusi untuk tujuan umum mungkin menawarkan operasi seperti mengirim dan menerima sebagai blok penyusun, FC menyediakan blok penyusun seperti tff.federated_sum , tff.federated_reduce , atau tff.federated_broadcast yang merangkum protokol terdistribusi sederhana.

Bahasa

Antarmuka Python

TFF menggunakan bahasa internal untuk merepresentasikan komputasi gabungan, yang sintaksisnya ditentukan oleh representasi serial di computing.proto . Namun, pengguna FC API umumnya tidak perlu berinteraksi dengan bahasa ini secara langsung. Sebaliknya, kami menyediakan API Python (namespace tff ) yang membungkusnya sebagai cara untuk mendefinisikan komputasi.

Secara khusus, TFF menyediakan dekorator fungsi Python seperti tff.federated_computation yang menelusuri isi fungsi yang didekorasi, dan menghasilkan representasi serial dari logika komputasi gabungan dalam bahasa TFF. Sebuah fungsi yang dihiasi dengan tff.federated_computation bertindak sebagai pembawa representasi serial tersebut, dan dapat menyematkannya sebagai blok penyusun di badan komputasi lain, atau mengeksekusinya sesuai permintaan saat dipanggil.

Ini hanya satu contoh; contoh lainnya dapat ditemukan di tutorial algoritme khusus .

@tff.federated_computation(tff.FederatedType(np.float32, tff.CLIENTS))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

Pembaca yang akrab dengan TensorFlow yang tidak tertarik akan menganggap pendekatan ini analog dengan penulisan kode Python yang menggunakan fungsi seperti tf.add atau tf.reduce_sum di bagian kode Python yang mendefinisikan grafik TensorFlow. Meskipun kode tersebut secara teknis dinyatakan dalam Python, tujuannya adalah untuk membuat representasi serial dari tf.Graph di bawahnya, dan grafiknya, bukan kode Python, yang dieksekusi secara internal oleh runtime TensorFlow. Demikian pula, seseorang dapat menganggap tff.federated_mean memasukkan operasi gabungan ke dalam perhitungan gabungan yang diwakili oleh get_average_temperature .

Salah satu alasan FC mendefinisikan suatu bahasa berkaitan dengan fakta bahwa, seperti disebutkan di atas, komputasi gabungan menentukan perilaku kolektif terdistribusi, dan dengan demikian, logikanya bersifat non-lokal. Misalnya, TFF menyediakan operator yang input dan outputnya mungkin ada di berbagai tempat dalam jaringan.

Hal ini memerlukan bahasa dan sistem tipe yang menangkap gagasan distribusi.

Ketik Sistem

Federated Core menawarkan kategori tipe berikut. Dalam mendeskripsikan tipe ini, kami menunjuk ke konstruktor tipe serta memperkenalkan notasi ringkas, karena ini adalah cara praktis atau mendeskripsikan tipe komputasi dan operator.

Pertama, berikut adalah kategori tipe yang secara konseptual mirip dengan yang ditemukan dalam bahasa umum yang ada:

  • Jenis tensor ( tff.TensorType ). Sama seperti di TensorFlow, ini memiliki dtype dan shape . Satu-satunya perbedaan adalah bahwa objek jenis ini tidak terbatas pada instance tf.Tensor dengan Python yang mewakili keluaran operasi TensorFlow dalam grafik TensorFlow, tetapi juga dapat mencakup unit data yang dapat dihasilkan, misalnya, sebagai keluaran dari data terdistribusi. protokol agregasi. Jadi, tipe tensor TFF hanyalah versi abstrak dari representasi fisik konkret dari tipe tersebut dengan Python atau TensorFlow.

    TensorTypes TFF bisa lebih ketat dalam perlakuan bentuknya (statis) dibandingkan TensorFlow. Misalnya, sistem tipe TFF memperlakukan tensor dengan peringkat yang tidak diketahui sebagai dapat ditetapkan dari tensor lain dengan dtype yang sama, namun tidak dapat ditetapkan ke tensor mana pun dengan peringkat tetap. Perlakuan ini mencegah kegagalan runtime tertentu (misalnya, upaya membentuk ulang tensor dengan peringkat yang tidak diketahui menjadi bentuk dengan jumlah elemen yang salah), dengan mengorbankan ketelitian yang lebih besar dalam penghitungan yang dianggap valid oleh TFF.

    Notasi ringkas untuk tipe tensor adalah dtype atau dtype[shape] . Misalnya, int32 dan int32[10] masing-masing merupakan tipe bilangan bulat dan vektor int.

  • Jenis urutan ( tff.SequenceType ). Ini adalah persamaan abstrak TFF dengan konsep konkret TensorFlow tentang tf.data.Dataset s. Elemen urutan dapat dikonsumsi secara berurutan, dan dapat mencakup tipe kompleks.

    Representasi ringkas tipe urutan adalah T* , dengan T adalah tipe elemen. Misalnya int32* mewakili urutan bilangan bulat.

  • Bernama tipe tuple ( tff.StructType ). Ini adalah cara TFF membangun tupel dan struktur seperti kamus yang memiliki sejumlah elemen yang telah ditentukan sebelumnya dengan tipe tertentu, diberi nama atau tidak. Yang penting, konsep tupel bernama TFF mencakup padanan abstrak tupel argumen Python, yaitu kumpulan elemen yang beberapa, namun tidak semuanya diberi nama, dan beberapa lagi bersifat posisional.

    Notasi ringkas untuk tupel bernama adalah <n_1=T_1, ..., n_k=T_k> , dengan n_k adalah nama elemen opsional, dan T_k adalah tipe elemen. Misalnya, <int32,int32> adalah notasi ringkas untuk sepasang bilangan bulat tanpa nama, dan <X=float32,Y=float32> adalah notasi ringkas untuk sepasang pelampung bernama X dan Y yang dapat mewakili sebuah titik pada bidang . Tupel dapat disarangkan dan juga dicampur dengan tipe lain, misalnya, <X=float32,Y=float32>* akan menjadi notasi ringkas untuk rangkaian titik.

  • Jenis fungsi ( tff.FunctionType ). TFF adalah kerangka pemrograman fungsional, dengan fungsi diperlakukan sebagai nilai kelas satu . Fungsi mempunyai paling banyak satu argumen dan tepat satu hasil.

    Notasi ringkas untuk fungsi adalah (T -> U) , dengan T adalah tipe argumen, dan U adalah tipe hasilnya, atau ( -> U) jika tidak ada argumen (walaupun fungsi tanpa argumen adalah fungsi yang merosot konsep yang sebagian besar ada hanya pada level Python). Misalnya (int32* -> int32) adalah notasi untuk jenis fungsi yang mereduksi barisan bilangan bulat menjadi nilai bilangan bulat tunggal.

Jenis berikut membahas aspek sistem terdistribusi dari komputasi TFF. Karena konsep ini agak unik di TFF, kami mendorong Anda untuk merujuk ke tutorial algoritme khusus untuk komentar dan contoh tambahan.

  • Jenis penempatan . Tipe ini belum diekspos di API publik selain dalam bentuk 2 literal tff.SERVER dan tff.CLIENTS yang dapat Anda anggap sebagai konstanta jenis ini. Namun ini digunakan secara internal, dan akan diperkenalkan di API publik pada rilis mendatang. Representasi kompak dari tipe ini adalah placement .

    Penempatan mewakili kumpulan peserta sistem yang memainkan peran tertentu. Rilis awal menargetkan komputasi klien-server, di mana terdapat 2 kelompok peserta: klien dan server (Anda dapat menganggap yang terakhir sebagai grup tunggal). Namun, dalam arsitektur yang lebih rumit, mungkin ada peran lain, seperti agregator perantara dalam sistem multi-tingkat, yang mungkin melakukan jenis agregasi berbeda, atau menggunakan jenis kompresi/dekompresi data berbeda dari yang digunakan oleh server atau klien.

    Tujuan utama mendefinisikan pengertian penempatan adalah sebagai dasar untuk mendefinisikan tipe gabungan .

  • Tipe gabungan ( tff.FederatedType ). Nilai tipe gabungan adalah nilai yang dihosting oleh sekelompok peserta sistem yang ditentukan oleh penempatan tertentu (seperti tff.SERVER atau tff.CLIENTS ). Tipe gabungan ditentukan oleh nilai penempatan (jadi, ini adalah tipe dependen ), tipe konstituen anggota (jenis konten apa yang dihosting secara lokal oleh masing-masing peserta), dan bit tambahan all_equal yang menentukan apakah semua peserta dihosting secara lokal menampung item yang sama.

    Notasi kompak untuk tipe nilai gabungan yang mencakup item (konstituen anggota) tipe T , masing-masing dihosting oleh grup (penempatan) G adalah T@G atau {T}@G dengan bit set all_equal atau tidak disetel.

    Misalnya:

    • {int32}@CLIENTS mewakili nilai gabungan yang terdiri dari sekumpulan bilangan bulat yang berpotensi berbeda, satu per perangkat klien. Perhatikan bahwa kita berbicara tentang nilai gabungan tunggal yang mencakup beberapa item data yang muncul di beberapa lokasi di seluruh jaringan. Salah satu cara untuk memikirkannya adalah sebagai semacam tensor dengan dimensi "jaringan", meskipun analogi ini tidak sempurna karena TFF tidak mengizinkan akses acak ke konstituen anggota dengan nilai gabungan.

    • {<X=float32,Y=float32>*}@CLIENTS mewakili kumpulan data gabungan , nilai yang terdiri dari beberapa rangkaian koordinat XY , satu rangkaian per perangkat klien.

    • <weights=float32[10,5],bias=float32[5]>@SERVER mewakili tupel bernama tensor bobot dan bias di server. Karena kita telah menghilangkan kurung kurawal, ini menunjukkan bit all_equal telah disetel, yaitu hanya ada satu tuple (terlepas dari berapa banyak replika server yang mungkin ada dalam cluster yang menghosting nilai ini).

Blok Bangunan

Bahasa Federated Core adalah bentuk kalkulus lambda , dengan beberapa elemen tambahan.

Ini menyediakan abstraksi pemrograman berikut yang saat ini diekspos di API publik:

  • Perhitungan TensorFlow ( tff.tensorflow.computation ). Ini adalah bagian kode TensorFlow yang dibungkus sebagai komponen yang dapat digunakan kembali di TFF menggunakan dekorator tff.tensorflow.computation . Mereka selalu memiliki tipe fungsional, dan tidak seperti fungsi di TensorFlow, mereka dapat mengambil parameter terstruktur atau mengembalikan hasil terstruktur dari tipe urutan.

    Berikut ini salah satu contoh, komputasi tipe TF (int32* -> int) yang menggunakan operator tf.data.Dataset.reduce untuk menghitung jumlah bilangan bulat:

    @tff.tensorflow.computation(tff.SequenceType(np.int32))
def add_up_integers(x):
  return x.reduce(np.int32(0), lambda x, y: x + y)

  • Operator intrinsik atau gabungan ( tff.federated_... ). Ini adalah perpustakaan fungsi seperti tff.federated_sum atau tff.federated_broadcast yang merupakan sebagian besar FC API, yang sebagian besar mewakili operator komunikasi terdistribusi untuk digunakan dengan TFF.

    Kami menyebutnya sebagai intrinsik karena, mirip dengan fungsi intrinsik , mereka adalah serangkaian operator terbuka dan dapat diperluas yang dipahami oleh TFF, dan dikompilasi menjadi kode tingkat yang lebih rendah.

    Sebagian besar operator ini memiliki parameter dan hasil tipe gabungan, dan sebagian besar merupakan templat yang dapat diterapkan ke berbagai jenis data.

    Misalnya, tff.federated_broadcast dapat dianggap sebagai operator templat dengan tipe fungsional T@SERVER -> T@CLIENTS .

  • Ekspresi Lambda ( tff.federated_computation ). Ekspresi lambda di TFF setara dengan lambda atau def di Python; itu terdiri dari nama parameter, dan isi (ekspresi) yang berisi referensi ke parameter ini.

    Dalam kode Python, ini dapat dibuat dengan mendekorasi fungsi Python dengan tff.federated_computation dan mendefinisikan argumen.

    Berikut ini contoh ekspresi lambda yang telah kami sebutkan sebelumnya:

    @tff.federated_computation(tff.FederatedType(np.float32, tff.CLIENTS))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

  • Literal penempatan . Untuk saat ini, hanya tff.SERVER dan tff.CLIENTS yang memungkinkan untuk mendefinisikan komputasi klien-server sederhana.

  • Pemanggilan fungsi ( __call__ ). Apa pun yang memiliki tipe fungsional dapat dipanggil menggunakan sintaks standar Python __call__ . Pemanggilan adalah ekspresi yang tipenya sama dengan tipe hasil fungsi yang dipanggil.

    Misalnya:

    • add_up_integers(x) merepresentasikan pemanggilan komputasi TensorFlow yang ditentukan sebelumnya pada argumen x . Jenis ekspresi ini adalah int32 .

    • tff.federated_mean(sensor_readings) mewakili pemanggilan operator rata-rata gabungan pada sensor_readings . Jenis ekspresi ini adalah float32@SERVER (dengan asumsi konteks dari contoh di atas).

  • Membentuk tupel dan memilih elemennya. Ekspresi Python dalam bentuk [x, y] , x[y] , atau xy yang muncul di badan fungsi yang dihiasi dengan tff.federated_computation .