Hai, habrozhiteli! Kami baru-baru ini menyerahkan kepada Andrew W. Trask, sebuah buku yang meletakkan dasar untuk penguasaan lebih lanjut dari teknologi pembelajaran yang mendalam. Ini dimulai dengan deskripsi dasar-dasar jaringan saraf dan kemudian memeriksa secara rinci lapisan dan arsitektur tambahan.
Kami menawarkan ulasan tentang bagian "Pembelajaran Federated"
Gagasan pembelajaran gabungan lahir dari kenyataan bahwa banyak data yang mengandung informasi yang berguna untuk memecahkan masalah (misalnya, untuk diagnosis kanker menggunakan MRI) sulit diperoleh dalam jumlah yang cukup untuk mengajarkan model pembelajaran mendalam yang kuat. Selain informasi berguna yang diperlukan untuk melatih model, set data juga berisi informasi lain yang tidak relevan dengan masalah yang sedang dipecahkan, tetapi pengungkapannya kepada seseorang berpotensi berbahaya.
Pembelajaran Federated adalah teknik untuk melampirkan model dalam lingkungan yang aman dan mengajarkannya tanpa memindahkan data ke mana pun. Pertimbangkan sebuah contoh.
import numpy as np from collections import Counter import random import sys import codecsnp.random.seed(12345) with codecs.open('spam.txt',"r",encoding='utf-8',errors='ignore') as f: ← http:
Belajar mendeteksi spam.
Katakanlah kita perlu melatih model untuk mendeteksi spam dari email orangDalam hal ini, kita berbicara tentang klasifikasi email. Kami akan melatih model pertama kami pada dataset publik yang disebut Enron. Ini adalah kumpulan besar email yang diterbitkan selama audiensi Enron (sekarang badan analitik email standar). Fakta yang menarik: Saya mengenal orang-orang yang, berdasarkan sifat kegiatan mereka, harus membaca / mengomentari kumpulan data ini, dan mereka mencatat bahwa orang-orang saling mengirim satu sama lain dalam surat-surat ini berbagai informasi (seringkali sangat pribadi). Tetapi karena korps ini diumumkan kepada publik selama persidangan, sekarang dapat digunakan tanpa batasan.
Kode di bagian sebelumnya dan di bagian ini hanya mengimplementasikan operasi persiapan. File input (ham.txt dan spam.txt) tersedia di halaman web buku:
www.manning.com/books/grokking-deep-learning dan dalam repositori GitHub:
github.com/iamtrask/Grokking-Deep-Learning . Kita perlu pra-proses untuk mempersiapkannya untuk dipindahkan ke kelas Embedding dari bab 13, di mana kami menciptakan kerangka belajar yang mendalam. Seperti sebelumnya, semua kata dalam korpus ini dikonversi menjadi daftar indeks. Selain itu, kami membawa semua huruf dengan panjang yang sama 500 kata, baik memotongnya atau menambahkan token. Berkat ini, kami mendapatkan satu set data persegi panjang.
spam_idx = to_indices(spam) ham_idx = to_indices(ham) train_spam_idx = spam_idx[0:-1000] train_ham_idx = ham_idx[0:-1000] test_spam_idx = spam_idx[-1000:] test_ham_idx = ham_idx[-1000:] train_data = list() train_target = list() test_data = list() test_target = list() for i in range(max(len(train_spam_idx),len(train_ham_idx))): train_data.append(train_spam_idx[i%len(train_spam_idx)]) train_target.append([1]) train_data.append(train_ham_idx[i%len(train_ham_idx)]) train_target.append([0]) for i in range(max(len(test_spam_idx),len(test_ham_idx))): test_data.append(test_spam_idx[i%len(test_spam_idx)]) test_target.append([1]) test_data.append(test_ham_idx[i%len(test_ham_idx)]) test_target.append([0]) def train(model, input_data, target_data, batch_size=500, iterations=5): n_batches = int(len(input_data) / batch_size) for iter in range(iterations): iter_loss = 0 for b_i in range(n_batches): # model.weight.data[w2i['<unk>']] *= 0 input = Tensor(input_data[b_i*bs:(b_i+1)*bs], autograd=True) target = Tensor(target_data[b_i*bs:(b_i+1)*bs], autograd=True) pred = model.forward(input).sum(1).sigmoid() loss = criterion.forward(pred,target) loss.backward() optim.step() iter_loss += loss.data[0] / bs sys.stdout.write("\r\tLoss:" + str(iter_loss / (b_i+1))) print() return model def test(model, test_input, test_output): model.weight.data[w2i['<unk>']] *= 0 input = Tensor(test_input, autograd=True) target = Tensor(test_output, autograd=True) pred = model.forward(input).sum(1).sigmoid() return ((pred.data > 0.5) == target.data).mean()
Setelah mendefinisikan fungsi bantu train () dan test (), kita dapat menginisialisasi jaringan saraf dan melatihnya dengan menulis hanya beberapa baris kode. Setelah tiga iterasi, jaringan dapat mengklasifikasikan set data kontrol dengan akurasi 99,45% (set data kontrol seimbang, sehingga hasil ini dapat dianggap sangat baik):
model = Embedding(vocab_size=len(vocab), dim=1) model.weight.data *= 0 criterion = MSELoss() optim = SGD(parameters=model.get_parameters(), alpha=0.01) for i in range(3): model = train(model, train_data, train_target, iterations=1) print("% Correct on Test Set: " + \ str(test(model, test_data, test_target)*100)) ______________________________________________________________________________ Loss:0.037140416860871446 % Correct on Test Set: 98.65 Loss:0.011258669226059114 % Correct on Test Set: 99.15 Loss:0.008068268387986223 % Correct on Test Set: 99.45
Mari kita buat model federal
Di atas, pembelajaran mendalam yang paling umum dilakukan. Sekarang tambahkan privasiPada bagian sebelumnya, kami menerapkan contoh analisis email. Sekarang letakkan semua email di satu tempat. Ini adalah metode kerja lama yang bagus (yang masih banyak digunakan di seluruh dunia). Untuk mulai dengan, kami akan meniru lingkungan pendidikan federal, di mana ada beberapa koleksi surat yang berbeda:
bob = (train_data[0:1000], train_target[0:1000]) alice = (train_data[1000:2000], train_target[1000:2000]) sue = (train_data[2000:], train_target[2000:])
Belum ada yang rumit. Sekarang kita dapat melakukan prosedur pelatihan yang sama seperti sebelumnya, tetapi sudah pada tiga set data terpisah. Setelah setiap iterasi, kami akan rata-rata nilai dalam model Bob, Alice dan Sue dan mengevaluasi hasilnya. Harap dicatat bahwa beberapa metode pembelajaran gabungan melibatkan penggabungan setelah setiap paket (atau koleksi paket); Saya memutuskan untuk menjaga kode sesederhana mungkin:
for i in range(3): print("Starting Training Round...") print("\tStep 1: send the model to Bob") bob_model = train(copy.deepcopy(model), bob[0], bob[1], iterations=1) print("\n\tStep 2: send the model to Alice") alice_model = train(copy.deepcopy(model), alice[0], alice[1], iterations=1) print("\n\tStep 3: Send the model to Sue") sue_model = train(copy.deepcopy(model), sue[0], sue[1], iterations=1) print("\n\tAverage Everyone's New Models") model.weight.data = (bob_model.weight.data + \ alice_model.weight.data + \ sue_model.weight.data)/3 print("\t% Correct on Test Set: " + \ str(test(model, test_data, test_target)*100)) print("\nRepeat!!\n")
Di bawah ini adalah cuplikan dengan hasilnya. Model ini mencapai tingkat akurasi yang hampir sama dengan yang sebelumnya, dan secara teoritis kami tidak memiliki akses ke data pelatihan - atau tidak? Bagaimanapun, tetapi setiap orang mengubah model dalam proses pembelajaran, bukan? Tidak bisakah kita benar-benar mendapatkan sesuatu dari kumpulan data mereka?
Starting Training Round... Step 1: send the model to Bob Loss:0.21908166249699718 ...... Step 3: Send the model to Sue Loss:0.015368461608470256 Average Everyone's New Models % Correct on Test Set: 98.8
Meretas model gabungan
Mari kita lihat contoh sederhana tentang cara mengekstrak informasi dari kumpulan data pelatihan.Pembelajaran federasi menderita dua masalah besar, terutama yang sulit dipecahkan, ketika setiap orang hanya memiliki sedikit contoh pelatihan - kecepatan dan kerahasiaan. Ternyata jika seseorang hanya memiliki beberapa contoh pelatihan (atau model yang dikirim kepada Anda dilatih hanya dengan beberapa contoh: paket pelatihan), Anda masih dapat belajar banyak tentang sumber data. Jika Anda membayangkan bahwa Anda memiliki 10.000 orang (dan setiap orang memiliki jumlah data yang sangat kecil), Anda akan menghabiskan sebagian besar waktu mengirim model bolak-balik dan tidak begitu banyak pelatihan (terutama jika modelnya sangat besar).
Tapi jangan maju dulu. Mari kita lihat apa yang dapat Anda temukan setelah pengguna memperbarui bobot pada satu paket:
import copy bobs_email = ["my", "computer", "password", "is", "pizza"] bob_input = np.array([[w2i[x] for x in bobs_email]]) bob_target = np.array([[0]]) model = Embedding(vocab_size=len(vocab), dim=1) model.weight.data *= 0 bobs_model = train(copy.deepcopy(model), bob_input, bob_target, iterations=1, batch_size=1)
Bob membuat dan melatih model melalui email di kotak masuknya. Tetapi kebetulan ia menyimpan kata sandi dengan mengirimkan sendiri surat dengan teks: "Kata sandi komputer saya adalah pizza." Bob yang naif! Setelah melihat bobot yang telah berubah, kita dapat mengetahui kamus (dan memahami artinya) dari surat Bob:
for i, v in enumerate(bobs_model.weight.data - model.weight.data): if(v != 0): print(vocab[i])
Dengan cara yang sederhana, kami menemukan kata sandi rahasia Bob (dan mungkin preferensi kulinernya). Dan apa yang harus dilakukan? Bagaimana cara mempercayai pembelajaran gabungan jika sangat mudah untuk mengetahui data pelatihan mana yang menyebabkan perubahan bobot?
is pizza computer password my
»Informasi lebih lanjut tentang buku ini dapat ditemukan di
situs web penerbit»
Isi»
KutipanDiskon 30% untuk buku pra-pemesanan
Habrozhiteli dengan kupon -
Grokking Deep Learning