Hallo habrozhiteli! Wir haben das Buch kürzlich Andrew W. Trask übergeben und damit den Grundstein für die weitere Beherrschung der Deep-Learning-Technologie gelegt. Es beginnt mit einer Beschreibung der Grundlagen neuronaler Netze und untersucht anschließend zusätzliche Schichten und Architekturen im Detail.
Wir bieten einen Rückblick auf die Passage "Federated Learning"
Die Idee des föderierten Lernens entstand aus der Tatsache, dass viele Daten, die nützliche Informationen zur Lösung von Problemen enthalten (z. B. zur Diagnose onkologischer Erkrankungen mittels MRT), nur schwer in ausreichenden Mengen zu erhalten sind, um ein leistungsfähiges Deep-Learning-Modell zu vermitteln. Zusätzlich zu den nützlichen Informationen, die zum Trainieren des Modells erforderlich sind, enthalten die Datensätze auch andere Informationen, die für die jeweilige Aufgabe nicht relevant sind. Die Weitergabe an Dritte kann jedoch möglicherweise schädlich sein.
Federated Learning ist eine Technik, mit der ein Modell in eine sichere Umgebung eingeschlossen und gelehrt werden kann, ohne dass Daten irgendwohin verschoben werden müssen. Betrachten Sie ein Beispiel.
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:
Lernen, Spam zu erkennen.
Angenommen, wir müssen ein Modell trainieren, um Spam aus den E-Mails von Personen zu erkennenIn diesem Fall handelt es sich um eine E-Mail-Klassifizierung. Wir werden unser erstes Modell auf einem öffentlichen Datensatz namens Enron trainieren. Dies ist eine große Anzahl von E-Mails, die während der Enron-Anhörungen veröffentlicht wurden (jetzt ein Standard-E-Mail-Analyse-Text). Eine interessante Tatsache: Ich war mit Leuten vertraut, die aufgrund ihrer Aktivitäten diesen Datensatz lesen / kommentieren mussten, und sie stellten fest, dass sich die Leute in diesen Briefen eine Vielzahl von Informationen schickten (oft sehr persönlich). Da dieses Korps jedoch während des Prozesses veröffentlicht wurde, kann es jetzt ohne Einschränkung verwendet werden.
Der Code im vorherigen und in diesem Abschnitt implementiert nur vorbereitende Vorgänge. Eingabedateien (ham.txt und spam.txt) sind auf der Webseite des Buches verfügbar:
www.manning.com/books/grokking-deep-learning und im GitHub-Repository:
github.com/iamtrask/Grokking-Deep-Learning . Wir müssen es vorverarbeiten, um es für die Übertragung in die Embedding-Klasse aus Kapitel 13 vorzubereiten, wo wir unser Deep-Learning-Framework erstellt haben. Nach wie vor werden alle Wörter in diesem Korpus in Indexlisten konvertiert. Außerdem bringen wir alle Buchstaben auf die gleiche Länge von 500 Wörtern, indem wir sie entweder zuschneiden oder Token hinzufügen. Dank dessen erhalten wir einen rechteckigen Datensatz.
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()
Nachdem wir die Hilfsfunktionen train () und test () definiert haben, können wir das neuronale Netzwerk initialisieren und trainieren, indem wir nur wenige Codezeilen schreiben. Nach drei Iterationen kann das Netzwerk den Kontrolldatensatz mit einer Genauigkeit von 99,45% klassifizieren (der Kontrolldatensatz ist gut ausbalanciert, daher kann dieses Ergebnis als ausgezeichnet angesehen werden):
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
Machen wir das Modell föderal
Oben wurde das häufigste tiefe Lernen durchgeführt. Fügen Sie jetzt Privatsphäre hinzuIm vorherigen Abschnitt haben wir ein Beispiel für eine E-Mail-Analyse implementiert. Legen Sie nun alle E-Mails an einem Ort ab. Dies ist eine gute alte Arbeitsmethode (die weltweit immer noch weit verbreitet ist). Zunächst werden wir das Umfeld der Bundesbildung imitieren, in dem es verschiedene Briefsammlungen gibt:
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:])
Noch nichts kompliziertes. Jetzt können wir das gleiche Trainingsverfahren wie zuvor durchführen, jedoch bereits für drei separate Datensätze. Nach jeder Iteration werden die Werte in den Modellen von Bob, Alice und Sue gemittelt und die Ergebnisse ausgewertet. Bitte beachten Sie, dass einige Verbundlernmethoden das Kombinieren nach jedem Paket (oder jeder Paketsammlung) umfassen. Ich habe beschlossen, den Code so einfach wie möglich zu halten:
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")
Unten ist ein Ausschnitt mit den Ergebnissen. Dieses Modell erreichte fast die gleiche Genauigkeit wie das vorherige, und theoretisch hatten wir keinen Zugriff auf Trainingsdaten - oder nicht? Wie auch immer, aber jede Person ändert das Modell im Lernprozess, oder? Können wir nicht wirklich etwas aus ihren Datensätzen herausholen?
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
Hacke ein Verbundmodell
Schauen wir uns ein einfaches Beispiel an, wie Informationen aus einem Trainingsdatensatz extrahiert werden.Das föderierte Lernen leidet unter zwei großen Problemen, die besonders schwer zu lösen sind, wenn jede Person nur eine Handvoll Trainingsbeispiele hat - Geschwindigkeit und Vertraulichkeit. Es stellt sich heraus, dass Sie immer noch viel über die Quelldaten lernen können, wenn jemand nur wenige Trainingsbeispiele hat (oder das an Sie gesendete Modell mit nur wenigen Beispielen trainiert wurde: ein Trainingspaket). Wenn Sie sich vorstellen, dass Sie 10.000 Personen haben (und jeder eine sehr kleine Datenmenge hat), verbringen Sie die meiste Zeit damit, das Modell hin und her zu senden und nicht so viel zu trainieren (insbesondere wenn das Modell sehr groß ist).
Aber lasst uns nicht weiterkommen. Mal sehen, was Sie herausfinden können, nachdem der Benutzer die Gewichte für ein Paket aktualisiert hat:
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 erstellt und trainiert das Modell per E-Mail in seinem Posteingang. Aber so kam es, dass er sein Passwort speicherte, indem er sich einen Brief mit dem Text schickte: "Mein Computer-Passwort ist Pizza." Naiver Bob! Nachdem wir gesehen haben, welche Gewichte sich geändert haben, können wir das Wörterbuch (und die Bedeutung) von Bobs Brief herausfinden:
for i, v in enumerate(bobs_model.weight.data - model.weight.data): if(v != 0): print(vocab[i])
Auf so einfache Weise haben wir Bobs streng geheimes Passwort (und möglicherweise seine kulinarischen Vorlieben) herausgefunden. Und was tun? Wie kann man dem föderierten Lernen vertrauen, wenn es so einfach ist herauszufinden, welche Trainingsdaten die Gewichtsänderung verursacht haben?
is pizza computer password my
»Weitere Informationen zum Buch finden Sie auf
der Website des Herausgebers»
Inhalt»
Auszug30% Rabatt für Habrozhiteli Vorbestellungsbücher auf einen Gutschein -
Grokking Deep Learning