Inti Federasi

Dokumen ini memperkenalkan lapisan inti TFF yang berfungsi sebagai dasar untuk Pembelajaran Federasi , dan kemungkinan algoritme federasi non-pembelajaran di masa depan.

Untuk pengenalan yang lembut tentang Federated Core, silakan baca tutorial berikut, karena tutorial ini memperkenalkan beberapa konsep dasar dengan contoh dan mendemonstrasikan langkah demi langkah pembangunan algoritma rata-rata gabungan yang sederhana.

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

Ringkasan

Tujuan, Tujuan Penggunaan, dan Cakupan

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 non- pemrosesan sepele secara lokal, dan berkomunikasi di seluruh jaringan untuk mengoordinasikan pekerjaan mereka.

Istilah terdistribusi sangat umum, dan TFF tidak menargetkan semua kemungkinan jenis algoritme terdistribusi di luar sana, jadi kami lebih suka menggunakan istilah komputasi gabungan yang kurang umum untuk menggambarkan jenis algoritme yang dapat diekspresikan dalam kerangka kerja ini.

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

Tujuan FC, singkatnya, adalah untuk memungkinkan representasi kompak yang serupa, pada tingkat abstraksi seperti pseudocode yang serupa, logika program yang bukan pseudocode, melainkan, yang dapat dieksekusi di berbagai lingkungan target.

Karakteristik penentu utama dari jenis algoritme yang dirancang untuk diekspresikan oleh FC adalah bahwa tindakan peserta sistem dijelaskan secara kolektif. Jadi, kita cenderung berbicara tentang setiap perangkat yang mengubah data secara lokal, dan perangkat yang mengoordinasikan pekerjaan oleh koordinator terpusat yang menyiarkan , mengumpulkan , atau menggabungkan hasilnya.

Sementara TFF telah dirancang untuk dapat melampaui arsitektur client-server sederhana, gagasan pemrosesan kolektif sangat mendasar. Ini karena asal mula TFF dalam pembelajaran federasi, sebuah teknologi yang awalnya dirancang untuk mendukung komputasi pada data yang berpotensi sensitif yang tetap berada di bawah kendali perangkat klien, dan yang mungkin tidak hanya diunduh ke lokasi terpusat karena alasan privasi. Sementara setiap klien dalam sistem tersebut memberikan kontribusi data dan kekuatan pemrosesan terhadap komputasi hasil oleh sistem (hasil yang umumnya kami harapkan menjadi nilai bagi semua peserta), kami juga berusaha untuk menjaga privasi dan anonimitas setiap klien.

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

Akibatnya, sementara kerangka kerja terdistribusi untuk tujuan umum dapat 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 mewakili komputasi gabungan, yang sintaksnya ditentukan oleh representasi serial dalam komputasi.proto . Pengguna FC API umumnya tidak perlu berinteraksi dengan bahasa ini secara langsung. Sebaliknya, kami menyediakan Python API ( tff namespace) yang membungkusnya sebagai cara untuk mendefinisikan komputasi.

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

Berikut ini hanya satu contoh; lebih banyak contoh dapat ditemukan di tutorial algoritme khusus .

@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

Pembaca yang akrab dengan TensorFlow yang tidak bersemangat akan menemukan pendekatan ini analog dengan menulis kode Python yang menggunakan fungsi seperti tf.add atau tf.reduce_sum di bagian kode Python yang mendefinisikan grafik TensorFlow. Meskipun kode secara teknis diekspresikan dalam Python, tujuannya adalah untuk membuat representasi serial dari tf.Graph di bawahnya, dan grafik, bukan kode Python, yang dieksekusi secara internal oleh runtime TensorFlow. Demikian juga, orang dapat menganggap tff.federated_mean sebagai memasukkan operasi federasi ke dalam perhitungan federasi yang diwakili oleh get_average_temperature .

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

Ini membutuhkan bahasa dan sistem tipe yang menangkap gagasan tentang keterdistribusian.

Ketik Sistem

Federated Core menawarkan kategori tipe berikut. Dalam mendeskripsikan tipe-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 arus utama 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 dalam Python yang mewakili keluaran operasi TensorFlow dalam grafik TensorFlow, tetapi juga dapat menyertakan unit data yang dapat dihasilkan, misalnya, sebagai keluaran dari protokol agregasi. Jadi, tipe tensor TFF hanyalah versi abstrak dari representasi fisik konkret dari tipe tersebut di Python atau TensorFlow.

    TensorTypes TFF bisa lebih ketat dalam perlakuan bentuknya (statis) daripada TensorFlow. Misalnya, sistem tipe TFF memperlakukan tensor dengan peringkat yang tidak diketahui sebagai dapat ditetapkan dari setiap tensor lain dengan dtype yang sama, tetapi tidak dapat ditetapkan untuk setiap tensor dengan peringkat tetap. Perlakuan ini mencegah kegagalan runtime tertentu (misalnya, mencoba membentuk kembali tensor dengan peringkat yang tidak diketahui menjadi bentuk dengan jumlah elemen yang salah), dengan biaya yang lebih ketat dalam penghitungan yang diterima TFF sebagai valid.

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

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

    Representasi kompak dari jenis urutan adalah T* , di mana T adalah jenis elemen. Misalnya int32* mewakili urutan bilangan bulat.

  • Jenis tuple bernama ( tff.StructType ). Ini adalah cara TFF untuk membangun tupel dan struktur seperti kamus yang memiliki sejumlah elemen yang telah ditentukan sebelumnya dengan tipe tertentu, bernama atau tidak bernama. Yang penting, konsep tupel bernama TFF mencakup padanan abstrak dari tupel argumen Python, yaitu, kumpulan elemen yang beberapa, tetapi tidak semua bernama, dan beberapa posisional.

    Notasi ringkas untuk tupel bernama adalah <n_1=T_1, ..., n_k=T_k> , di mana 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 float bernama X dan Y yang dapat mewakili sebuah titik pada bidang . Tuples dapat bersarang serta dicampur dengan jenis lain, misalnya, <X=float32,Y=float32>* akan menjadi notasi kompak untuk urutan titik.

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

    Notasi ringkas untuk fungsi adalah (T -> U) , di mana T adalah tipe argumen, dan U adalah tipe hasil, atau ( -> U) jika tidak ada argumen (walaupun fungsi tanpa argumen adalah degenerasi konsep yang ada sebagian besar hanya di tingkat Python). Misalnya (int32* -> int32) adalah notasi untuk jenis fungsi yang mereduksi urutan bilangan bulat menjadi nilai bilangan bulat tunggal.

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

  • Jenis penempatan . Jenis 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 di rilis mendatang. Representasi kompak dari jenis ini adalah placement .

    Penempatan mewakili kumpulan peserta sistem yang memainkan peran tertentu. Rilis awal menargetkan komputasi client-server, di mana ada 2 grup 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 yang berbeda, atau menggunakan jenis kompresi/dekompresi data yang berbeda dari yang digunakan oleh server atau klien.

    Tujuan utama mendefinisikan gagasan penempatan adalah sebagai dasar untuk mendefinisikan jenis federasi .

  • Jenis federasi ( tff.FederatedType ). Nilai dari tipe federasi adalah nilai yang di-host oleh sekelompok peserta sistem yang ditentukan oleh penempatan tertentu (seperti tff.SERVER atau tff.CLIENTS ). Jenis federasi ditentukan oleh nilai penempatan (dengan demikian, ini adalah jenis dependen ), jenis konstituen anggota (jenis konten apa yang dihosting oleh masing-masing peserta secara lokal), dan bit tambahan all_equal yang menentukan apakah semua peserta adalah lokal menampung barang yang sama.

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

    Sebagai contoh:

    • {int32}@CLIENTS mewakili nilai gabungan yang terdiri dari sekumpulan bilangan bulat yang berpotensi berbeda, satu per perangkat klien. Perhatikan bahwa kita berbicara tentang satu nilai gabungan 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 federasi.

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

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

Blok bangunan

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

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

  • Komputasi TensorFlow ( tff.tf_computation ). Ini adalah bagian dari kode TensorFlow yang dibungkus sebagai komponen yang dapat digunakan kembali di TFF menggunakan dekorator tff.tf_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 satu contoh, perhitungan TF tipe (int32* -> int) yang menggunakan operator tf.data.Dataset.reduce untuk menghitung jumlah bilangan bulat:

    @tff.tf_computation(tff.SequenceType(tf.int32))
    def add_up_integers(x):
      return x.reduce(np.int32(0), lambda x, y: x + y)
    
  • Operator intrinsik atau federasi ( tff.federated_... ). Ini adalah pustaka fungsi seperti tff.federated_sum atau tff.federated_broadcast yang merupakan bagian terbesar dari FC API, yang sebagian besar mewakili operator komunikasi terdistribusi untuk digunakan dengan TFF.

    Kami menyebut ini sebagai intrinsik karena, agak seperti fungsi intrinsik , mereka adalah rangkaian operator yang dapat diperluas dan terbuka yang dipahami oleh TFF, dan dikompilasi ke dalam kode tingkat yang lebih rendah.

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

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

  • Ekspresi lambda ( tff.federated_computation ). Ekspresi lambda di TFF setara dengan lambda atau def dalam Python; itu terdiri dari nama parameter, dan badan (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 adalah contoh ekspresi lambda yang telah kami sebutkan sebelumnya:

    @tff.federated_computation(tff.type_at_clients(tf.float32))
    def get_average_temperature(sensor_readings):
      return tff.federated_mean(sensor_readings)
    
  • Penempatan literal . Untuk saat ini, hanya tff.SERVER dan tff.CLIENTS yang memungkinkan untuk mendefinisikan komputasi client-server sederhana.

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

    Sebagai contoh:

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

    • tff.federated_mean(sensor_readings) mewakili pemanggilan operator rata-rata federasi 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 didekorasi dengan tff.federated_computation .