Google I/O adalah bungkusnya! Ikuti sesi TensorFlow Lihat sesi

Menyesuaikan agregasi yang direkomendasikan untuk pembelajaran

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

The tff.learning modul berisi sejumlah cara untuk agregat Model udpates dengan konfigurasi default yang direkomendasikan:

Dalam tutorial ini, kami menjelaskan motivasi yang mendasarinya, bagaimana penerapannya, dan memberikan saran tentang cara menyesuaikan konfigurasinya.


!pip install --quiet --upgrade tensorflow-federated-nightly
!pip install --quiet --upgrade nest-asyncio

import nest_asyncio
nest_asyncio.apply()
import math
import tensorflow_federated as tff
tff.federated_computation(lambda: 'Hello, World!')()
b'Hello, World!'

Metode agregasi diwakili oleh benda-benda yang dapat dikirimkan ke tff.learning.build_federated_averaging_process sebagai yang model_update_aggregation_factory argumen kata kunci. Dengan demikian, agregator dibahas di sini bisa langsung digunakan untuk memodifikasi sebelumnya tutorial pembelajaran federasi.

Baseline tertimbang rata-rata dari FedAvg algoritma dapat dinyatakan dengan menggunakan tff.aggregators.MeanFactory sebagai berikut:

mean = tff.aggregators.MeanFactory()
iterative_process = tff.learning.build_federated_averaging_process(
    ...,
    model_update_aggregation_factory=mean)

Teknik yang dapat digunakan untuk memperluas rata-rata tertimbang yang tercakup dalam tutorial ini adalah:

  • Zeroing
  • Guntingan
  • Privasi Diferensial
  • Kompresi
  • Agregasi Aman

Ekstensi ini dilakukan dengan menggunakan komposisi, di mana MeanFactory membungkus sebuah pabrik batin untuk yang delegasi beberapa bagian dari agregasi, atau itu sendiri dibungkus oleh pabrik agregasi lain. Untuk detail lebih lanjut tentang desain, lihat Pelaksana agregator kustom tutorial.

Pertama, kami akan menjelaskan cara mengaktifkan dan mengonfigurasi teknik ini satu per satu, lalu menunjukkan bagaimana teknik ini dapat digabungkan.

Teknik

Sebelum mempelajari teknik individu, pertama-tama kami memperkenalkan algoritma pencocokan kuantil, yang akan berguna untuk mengonfigurasi teknik di bawah ini.

Pencocokan kuantitas

Beberapa teknik agregasi di bawah ini perlu menggunakan batas norma yang mengontrol beberapa aspek agregasi. Batas tersebut dapat diberikan sebagai konstanta, tetapi biasanya lebih baik untuk menyesuaikan batas selama pelatihan. Cara yang disarankan adalah dengan menggunakan algoritma kuantil pencocokan Andrew et al. (2019) , awalnya diusulkan untuk kompatibilitas dengan privasi diferensial namun bermanfaat secara lebih luas. Untuk memperkirakan nilai pada kuantil yang diberikan, Anda dapat menggunakan tff.aggregators.PrivateQuantileEstimationProcess . Misalnya, untuk beradaptasi dengan median distribusi, Anda dapat menggunakan:

median_estimate = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=1.0, target_quantile=0.5, learning_rate=0.2)

Teknik berbeda yang menggunakan algoritme estimasi kuantil akan memerlukan nilai parameter algoritme yang berbeda, seperti yang akan kita lihat. Secara umum, meningkatkan learning_rate berarti parameter lebih cepat adaptasi dengan kuantil yang benar, tetapi dengan varians yang lebih tinggi. The no_noise classmethod konstruksi proses kuantil pencocokan yang tidak menambahkan suara untuk privasi diferensial.

Zeroing

Zeroing mengacu pada penggantian nilai yang luar biasa besar dengan nol. Di sini, "luar biasa besar" bisa berarti lebih besar dari ambang batas yang telah ditentukan, atau relatif besar terhadap nilai dari putaran perhitungan sebelumnya. Zeroing dapat meningkatkan ketahanan sistem terhadap korupsi data pada klien yang salah.

Untuk menghitung rata-rata nilai dengan norma-norma L-infinity lebih besar dari ZEROING_CONSTANT memusatkan perhatian-out, kami membungkus tff.aggregators.MeanFactory dengan tff.aggregators.zeroing_factory yang melakukan zeroing:

zeroing_mean = tff.aggregators.zeroing_factory(
    zeroing_norm=MY_ZEROING_CONSTANT,
    inner_agg_factory=tff.aggregators.MeanFactory())

Di sini kita membungkus MeanFactory dengan zeroing_factory karena kami ingin (pra-agregasi) efek dari zeroing_factory untuk menerapkan nilai-nilai di klien sebelum mereka dilewatkan ke dalam MeanFactory untuk agregasi melalui rata-rata.

Namun, untuk sebagian besar aplikasi, kami merekomendasikan zeroing adaptif dengan estimator kuantil. Untuk melakukannya, kami menggunakan algoritma pencocokan kuantil sebagai berikut:

zeroing_norm = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=10.0,
    target_quantile=0.98,
    learning_rate=math.log(10),
    multiplier=2.0,
    increment=1.0)
zeroing_mean = tff.aggregators.zeroing_factory(
    zeroing_norm=zeroing_norm,
    inner_agg_factory=tff.aggregators.MeanFactory())

# Equivalent to:
# zeroing_mean = tff.learning.robust_aggregator(clipping=False)

Parameter telah dipilih sehingga proses beradaptasi dengan sangat cepat (relatif besar learning_rate ) ke nilai agak lebih besar dari nilai terbesar lihat sejauh ini. Untuk perkiraan kuantil Q , ambang batas yang digunakan untuk zeroing akan Q * multiplier + increment .

Kliping untuk mengikat norma L2

Memotong pembaruan klien (memproyeksikan ke bola L2) dapat meningkatkan ketahanan terhadap outlier. Sebuah tff.aggregators.clipping_factory terstruktur persis seperti tff.aggregators.zeroing_factory dibahas di atas, dan dapat mengambil baik konstan atau tff.templates.EstimationProcess sebagai yang clipping_norm argumen. Praktik terbaik yang direkomendasikan adalah menggunakan kliping yang beradaptasi cukup cepat dengan norma yang cukup tinggi, sebagai berikut:

clipping_norm = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=1.0,
    target_quantile=0.8,
    learning_rate=0.2)
clipping_mean = tff.aggregators.clipping_factory(
    clipping_norm=clipping_norm,
    inner_agg_factory=tff.aggregators.MeanFactory())

# Equivalent to:
# clipping_mean = tff.learning.robust_aggregator(zeroing=False)

Dalam pengalaman kami lebih banyak masalah, nilai yang tepat dari target_quantile tampaknya tidak peduli terlalu banyak selama tingkat belajar disetel dengan tepat. Namun, menyetelnya sangat rendah mungkin memerlukan peningkatan kecepatan pembelajaran server untuk kinerja terbaik, dibandingkan tidak menggunakan kliping, itulah sebabnya kami merekomendasikan 0,8 secara default.

Privasi Diferensial

TFF juga mendukung agregasi pribadi yang berbeda, menggunakan kliping adaptif dan noise Gaussian. Sebuah agregator untuk melakukan rata-rata pribadi yang berbeda dapat dibangun sebagai berikut:

dp_mean = tff.aggregators.DifferentiallyPrivateFactory.gaussian_adaptive(
    noise_multiplier=0.1, clients_per_round=100)

# Equivalent to:
# dp_mean = tff.learning.dp_aggregator(
#   noise_multiplier=0.1, clients_per_round=100, zeroing=False)

Pedoman tentang bagaimana mengatur noise_multiplier argumen dapat ditemukan di tutorial TFF DP .

Kompresi Rugi

Dibandingkan dengan kompresi lossless seperti gzip, kompresi lossy umumnya menghasilkan rasio kompresi yang jauh lebih tinggi dan masih dapat dikombinasikan dengan kompresi lossless setelahnya. Karena lebih sedikit waktu yang dibutuhkan untuk komunikasi klien-ke-server, putaran pelatihan selesai lebih cepat. Karena sifat algoritma pembelajaran yang acak secara inheren, hingga beberapa ambang batas, ketidakakuratan dari kompresi lossy tidak berdampak negatif pada kinerja keseluruhan.

Rekomendasi default adalah untuk menggunakan sederhana seragam kuantisasi (lihat Suresh et al. Misalnya), parameter dengan dua nilai: kompresi ukuran tensor threshold dan jumlah quantization_bits . Untuk setiap tensor t , jika jumlah elemen t kurang atau sama dengan threshold , tidak dikompresi. Jika lebih besar, unsur-unsur t dikuantisasi menggunakan pembulatan secara acak untuk quantizaton_bits bit. Artinya, kami menerapkan operasi

t = round((t - min(t)) / (max(t) - min(t)) * (2**quantizaton_bits - 1)),

mengakibatkan nilai integer dalam kisaran [0, 2**quantizaton_bits-1] . Nilai terkuantisasi secara langsung dikemas ke dalam tipe integer untuk transmisi, dan kemudian transformasi terbalik diterapkan.

Kami merekomendasikan pengaturan quantizaton_bits sama dengan 8 dan threshold sama ke 20000:

compressed_mean = tff.aggregators.MeanFactory(
    tff.aggregators.EncodedSumFactory.quantize_above_threshold(
        quantization_bits=8, threshold=20000))

# Equivalent to:
# compressed_mean = tff.learning.compression_aggregator(zeroing=False, clipping=False)

Saran penyetelan

Kedua parameter, quantization_bits dan threshold dapat disesuaikan, dan jumlah klien berpartisipasi dalam setiap putaran pelatihan juga dapat mempengaruhi efektivitas kompresi.

Ambang. Nilai default 20000 dipilih karena kami telah mengamati bahwa variabel dengan sejumlah kecil elemen, seperti bias pada jenis lapisan umum, jauh lebih sensitif terhadap gangguan yang ditimbulkan. Selain itu, ada sedikit yang bisa diperoleh dari mengompresi variabel dengan sejumlah kecil elemen dalam praktiknya, karena ukurannya yang tidak terkompresi relatif kecil untuk memulai.

Dalam beberapa aplikasi mungkin masuk akal untuk mengubah pilihan ambang batas. Misalnya, bias dari lapisan keluaran model klasifikasi mungkin lebih sensitif terhadap noise. Jika Anda pelatihan model bahasa dengan kosakata 20004, Anda mungkin ingin set threshold menjadi 20.004.

bit kuantisasi. Nilai default dari 8 untuk quantization_bits harus baik untuk sebagian besar pengguna. Jika 8 bekerja dengan baik dan Anda ingin memeras sedikit lebih banyak kinerja, Anda dapat mencoba menurunkannya menjadi 7 atau 6. Jika sumber daya mengizinkan melakukan pencarian grid kecil, kami sarankan Anda mengidentifikasi nilai pelatihan yang menjadi tidak stabil atau kualitas model akhir mulai menurun, dan kemudian meningkatkan nilai itu dua kali lipat. Misalnya, jika pengaturan quantization_bits untuk 5 karya, tetapi pengaturan untuk 4 degradasi model, kami akan merekomendasikan default menjadi 6 menjadi "di sisi yang aman".

Klien per putaran. Catatan yang secara signifikan meningkatkan jumlah klien per putaran dapat mengaktifkan nilai yang lebih kecil untuk quantization_bits bekerja dengan baik, karena ketidaktelitian acak diperkenalkan oleh kuantisasi dapat menyamakan keluar dengan rata-rata lebih update client lebih.

Agregasi Aman

Dengan Agregasi Aman (SecAgg) kami merujuk ke protokol kriptografi di mana pembaruan klien dienkripsi sedemikian rupa sehingga server hanya dapat mendekripsi jumlah mereka. Jika jumlah klien yang melapor kembali tidak mencukupi, server tidak akan mempelajari apa pun -- dan server tidak akan dapat memeriksa pembaruan individual. Hal ini diwujudkan dengan menggunakan tff.federated_secure_sum_bitwidth operator.

Pembaruan model adalah nilai floating point, tetapi SecAgg beroperasi pada bilangan bulat. Oleh karena itu kita perlu memotong nilai besar apa pun ke beberapa ikatan sebelum diskritisasi ke tipe integer. Batas kliping dapat berupa konstanta atau ditentukan secara adaptif (default yang disarankan). Bilangan bulat kemudian dijumlahkan dengan aman, dan jumlahnya dipetakan kembali ke domain floating point.

Untuk menghitung rata-rata dengan nilai-nilai tertimbang dijumlahkan menggunakan SecAgg dengan MY_SECAGG_BOUND sebagai kliping terikat, lulus SecureSumFactory ke MeanFactory sebagai:

secure_mean = tff.aggregators.MeanFactory(
    tff.aggregators.SecureSumFactory(MY_SECAGG_BOUND))

Untuk melakukan hal yang sama saat menentukan batas secara adaptif:

secagg_bound = tff.aggregators.PrivateQuantileEstimationProcess.no_noise(
    initial_estimate=50.0,
    target_quantile=0.95,
    learning_rate=1.0,
    multiplier=2.0)
secure_mean = tff.aggregators.MeanFactory(
    tff.aggregators.SecureSumFactory(secagg_bound))

# Equivalent to:
# secure_mean = tff.learning.secure_aggregator(zeroing=Fasle, clipping=False)

Saran penyetelan

Parameter adaptif telah dipilih sehingga batasnya ketat (kita tidak akan kehilangan banyak presisi dalam diskritisasi) tetapi kliping jarang terjadi.

Jika menyetel parameter, perlu diingat bahwa protokol SecAgg menjumlahkan pembaruan model berbobot, setelah bobot rata-rata. Bobot biasanya jumlah titik data yang diproses secara lokal, maka antara tugas yang berbeda, batas kanan mungkin bergantung pada kuantitas ini.

Kami tidak menyarankan menggunakan increment argumen kata kunci saat membuat adaptif secagg_bound , karena hal ini bisa mengakibatkan hilangnya presisi relatif besar, dalam hal estimasi ujung aktual sampai yang kecil.

Cuplikan kode di atas hanya akan menggunakan SecAgg nilai berbobot. Jika SecAgg juga harus digunakan untuk jumlah bobot, kami merekomendasikan batas untuk ditetapkan sebagai konstanta, seperti dalam pengaturan pelatihan umum, bobot terbesar yang mungkin akan diketahui sebelumnya:

secure_mean = tff.aggregators.MeanFactory(
    value_sum_factory=tff.aggregators.SecureSumFactory(secagg_bound),
    weight_sum_factory=tff.aggregators.SecureSumFactory(
        upper_bound_threshold=MAX_WEIGHT, lower_bound_threshold=0.0))

Teknik komposisi

Teknik individu untuk memperluas mean yang diperkenalkan di atas dapat digabungkan bersama.

Kami merekomendasikan urutan penerapan teknik ini pada klien untuk menjadi

  1. Zeroing
  2. Guntingan
  3. Teknik lainnya

Agregator di tff.aggregators modul yang terdiri oleh pembungkus "agregator batin" (yang pra-agregasi efek terjadi lalu dan pasca-agregasi efek terjadi pertama) dalam "agregator luar". Misalnya, untuk melakukan zeroing, clipping, dan kompresi (dalam urutan itu), seseorang akan menulis:

# Compression is innermost because its pre-aggregation effects are last.
compressed_mean = tff.aggregators.MeanFactory(
    tff.aggregators.EncodedSumFactory.quantize_above_threshold(
        quantization_bits=8, threshold=20000))
# Compressed mean is inner aggregator to clipping...
clipped_compressed_mean = tff.aggregators.clipping_factory(
    clipping_norm=MY_CLIPPING_CONSTANT,
    inner_agg_factory=compressed_mean)
# ...which is inner aggregator to zeroing, since zeroing happens first.
final_aggregator = tff.aggregators.zeroing_factory(
    zeroing_norm=MY_ZEROING_CONSTANT,
    inner_agg_factory=clipped_compressed_mean)

Perhatikan bahwa struktur ini sesuai dengan agregator standar untuk algoritma belajar.

Komposisi lain juga dimungkinkan. Kami memperluas dokumen ini ketika kami yakin bahwa kami dapat menyediakan konfigurasi default yang berfungsi di beberapa aplikasi berbeda. Untuk menerapkan ide-ide baru, lihat Pelaksana agregator kustom tutorial.