Bantuan melindungi Great Barrier Reef dengan TensorFlow pada Kaggle Bergabung Tantangan

Inti Federasi

Dokumen ini memperkenalkan lapisan inti dari TFF yang berfungsi sebagai dasar untuk Federasi Belajar , dan kemungkinan masa depan non-belajar algoritma federasi.

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 federasi sederhana.

Kami juga akan mendorong Anda untuk membiasakan diri dengan Federasi Belajar dan tutorial terkait pada klasifikasi citra dan generasi teks , sebagai penggunaan API Federated Inti (FC API) untuk belajar Federasi memberikan konteks yang penting untuk beberapa pilihan yang kita buat dalam merancang lapisan ini.

Gambaran

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 didistribusikan sangat generik, dan TFF tidak menargetkan semua kemungkinan jenis algoritma didistribusikan di luar sana, jadi kami lebih memilih untuk menggunakan kurang umum perhitungan federasi istilah untuk menggambarkan jenis algoritma yang dapat dinyatakan dalam kerangka ini.

Sementara mendefinisikan perhitungan federasi istilah dalam cara yang sepenuhnya formal di luar lingkup dokumen ini, berpikir tentang jenis algoritma Anda mungkin melihat apa yang ditunjukkan pseudocode dalam publikasi penelitian yang menggambarkan algoritma belajar baru didistribusikan.

Tujuan dari FC, di nusthell, adalah untuk memungkinkan representasi sama kompak, pada tingkat pseudo-seperti sejenis abstraksi, logika program yang tidak pseudocode, melainkan, itu dieksekusi dalam berbagai lingkungan sasaran.

Karakteristik penentu utama dari jenis algoritme yang dirancang untuk diekspresikan oleh FC adalah bahwa tindakan peserta sistem dijelaskan secara kolektif. Dengan demikian, kita cenderung berbicara tentang masing-masing perangkat lokal transformasi data, dan perangkat mengkoordinasikan bekerja dengan penyiaran koordinator terpusat, mengumpulkan, atau menggabungkan hasil mereka.

Sementara TFF telah dirancang untuk dapat melampaui arsitektur client-server sederhana, gagasan pengolahan kolektif adalah fundamental. Ini karena asal mula TFF dalam pembelajaran gabungan, 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 secara umum kami harapkan akan bernilai 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. , TFF Federasi Inti dirancang untuk menggambarkan perilaku sistem dari perspektif seluruh sistem global (mirip dengan, misalnya, MapReduce ).

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

Bahasa

Antarmuka Python

TFF menggunakan bahasa internal untuk mewakili perhitungan federasi, sintaks yang didefinisikan oleh representasi serializable di computation.proto . Pengguna FC API umumnya tidak perlu berinteraksi dengan bahasa ini secara langsung. Sebaliknya, kami menyediakan API Python (yang tff namespace) yang membungkus arounds sebagai cara untuk mendefinisikan perhitungan.

Secara khusus, TFF memberikan dekorator fungsi Python seperti tff.federated_computation bahwa jejak tubuh fungsi dihiasi, dan menghasilkan representasi serial dari logika perhitungan federasi dalam bahasa TFF. Sebuah fungsi dihiasi dengan tff.federated_computation bertindak sebagai pembawa representasi serial tersebut, dan dapat menanamkan sebagai sebuah blok bangunan dalam tubuh perhitungan lain, atau mengeksekusinya pada permintaan ketika dijalankan.

Berikut ini hanya satu contoh; lebih banyak contoh dapat ditemukan dalam algoritma kustom tutorial.

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

Pembaca akrab dengan TensorFlow non-bersemangat akan menemukan pendekatan analog ini untuk 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 dinyatakan dalam Python, tujuannya adalah untuk membangun representasi serializable dari tf.Graph bawah, dan itu adalah grafik, bukan kode Python, yang dieksekusi secara internal oleh runtime TensorFlow. Demikian juga, seseorang dapat memikirkan tff.federated_mean sebagai memasukkan op Federasi menjadi perhitungan Federasi diwakili oleh get_average_temperature .

Sebagian alasan FC mendefinisikan 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 menjelaskan tipe-tipe ini, kami menunjuk ke konstruktor tipe serta memperkenalkan notasi ringkas, karena ini adalah cara praktis atau menggambarkan 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 dari jenis ini tidak terbatas pada tf.Tensor contoh Python yang mewakili output dari ops TensorFlow dalam grafik TensorFlow, tetapi juga dapat mencakup unit data yang dapat diproduksi, misalnya, sebagai output dari didistribusikan protokol agregasi. Dengan demikian, tipe tensor TFF hanyalah versi abstrak dari representasi fisik konkret dari tipe tersebut dalam Python atau TensorFlow.

    TFF TensorTypes dapat ketat di (statis) mereka pengobatan bentuk dari TensorFlow. Misalnya, TFF typesystem memperlakukan sebuah tensor dengan peringkat diketahui sebagai dialihkan dari setiap tensor lain sama dtype , tetapi tidak dapat dialihkan 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.

    Kompak notasi untuk jenis tensor adalah dtype atau dtype[shape] . Misalnya, int32 dan int32[10] adalah jenis bilangan bulat dan vektor int, masing-masing.

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

    Representasi kompak urutan jenis adalah T* , di mana T adalah jenis elemen. Misalnya int32* merupakan urutan integer.

  • Jenis tupel bernama ( tff.StructType ). Ini adalah cara TFF membangun tupel dan kamus-seperti struktur yang memiliki jumlah yang telah ditetapkan elemen dengan tipe tertentu, bernama atau tidak disebutkan namanya. Yang penting, konsep tupel bernama TFF mencakup padanan abstrak dari tupel argumen Python, yaitu, kumpulan elemen yang beberapa, tetapi tidak semua bernama, dan beberapa posisi.

    Kompak notasi untuk bernama tupel adalah <n_1=T_1, ..., n_k=T_k> , di mana n_k adalah nama-nama elemen opsional, dan T_k adalah tipe elemen. Sebagai contoh, <int32,int32> adalah notasi kompak untuk sepasang bilangan bulat yang tidak disebutkan namanya, dan <X=float32,Y=float32> adalah notasi kompak untuk sepasang mengapung bernama X dan Y yang bisa mewakili titik di pesawat . Tupel dapat bersarang serta dicampur dengan jenis lain, misalnya, <X=float32,Y=float32>* akan menjadi notasi kompak untuk urutan poin.

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

    Kompak notasi untuk fungsi adalah (T -> U) , di mana T adalah jenis argumen, dan U adalah jenis hasil, atau ( -> U) jika tidak ada argumen (meskipun tidak berfungsi-argumen yang merosot sebuah konsep yang ada sebagian besar hanya di tingkat Python). Sebagai contoh (int32* -> int32) adalah notasi untuk jenis fungsi yang mengurangi urutan integer ke nilai integer tunggal.

Jenis berikut membahas aspek sistem terdistribusi dari perhitungan TFF. Sebagai konsep-konsep ini agak unik untuk TFF, kami mendorong Anda untuk merujuk pada algoritma kustom tutorial untuk komentar tambahan dan contoh.

  • Jenis penempatan. Tipe ini belum terkena di API publik selain dalam bentuk 2 literal tff.SERVER dan tff.CLIENTS yang dapat Anda pikirkan 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 merupakan kolektif peserta sistem yang memainkan peran tertentu. Rilis awal menargetkan perhitungan client-server, di mana ada 2 kelompok peserta: klien dan server (Anda bisa memikirkan yang terakhir sebagai kelompok tunggal). Namun, dalam arsitektur yang lebih rumit, mungkin ada peran lain, seperti agregator perantara dalam sistem multi-tier, yang mungkin melakukan jenis agregasi yang berbeda, atau menggunakan jenis kompresi/dekompresi data yang berbeda dari yang digunakan oleh server atau klien.

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

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

    Kompak notasi untuk jenis federasi dari nilai-nilai yang mencakup semuanya (konstituen anggota) tipe T , masing-masing diselenggarakan oleh kelompok (penempatan) G adalah T@G atau {T}@G dengan all_equal bit set atau tidak ditetapkan, masing-masing.

    Sebagai contoh:

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

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

    • <weights=float32[10,5],bias=float32[5]>@SERVER merupakan tuple bernama berat dan bias tensor di server. Karena kita telah menjatuhkan kurung kurawal, ini menunjukkan all_equal bit diatur, yaitu, hanya ada tuple tunggal (terlepas dari berapa banyak server yang replika mungkin ada di cluster hosting yang nilai ini).

Blok bangunan

Bahasa Federasi Core merupakan bentuk lambda-kalkulus , dengan beberapa elemen tambahan.

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

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

    Berikut salah satu contoh, perhitungan TF tipe (int32* -> int) yang menggunakan tf.data.Dataset.reduce operator 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)
    
  • Intrinsik atau operator federasi ( tff.federated_... ). Ini adalah perpustakaan fungsi seperti tff.federated_sum atau tff.federated_broadcast yang merupakan sebagian besar API FC, yang sebagian besar mewakili didistribusikan operator komunikasi untuk digunakan dengan TFF.

    Kami mengacu pada ini sebagai intrinsik karena, agak seperti fungsi intrinsik , mereka adalah, set extensible terbuka dari operator yang dipahami oleh TFF, dan dikompilasi ke dalam kode-tingkat yang lebih rendah.

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

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

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

    Dalam kode Python, ini dapat dibuat dengan dekorasi 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)
    
  • Literal penempatan. Untuk saat ini, hanya tff.SERVER dan tff.CLIENTS untuk memungkinkan untuk mendefinisikan perhitungan client-server sederhana.

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

    Sebagai contoh:

    • add_up_integers(x) merupakan doa dari perhitungan TensorFlow ditetapkan sebelumnya pada argumen x . Jenis ungkapan ini int32 .

    • tff.federated_mean(sensor_readings) merupakan permintaan dari operator rata-rata Federasi di sensor_readings . Jenis ungkapan ini float32@SERVER (dengan asumsi konteks dari contoh di atas).

  • Membentuk tupel dan memilih elemen mereka. Python ekspresi dari bentuk [x, y] , x[y] , atau xy yang muncul dalam tubuh fungsi dihiasi dengan tff.federated_computation .