Hola habrozhiteli! Recientemente entregamos el libro a Andrew W. Trask, sentando las bases para un mayor dominio de la tecnología de aprendizaje profundo. Comienza con una descripción de los conceptos básicos de las redes neuronales y luego examina en detalle capas y arquitecturas adicionales.
Ofrecemos una revisión del pasaje "Aprendizaje federado"
La idea del aprendizaje federado nació del hecho de que muchos datos que contienen información útil para resolver problemas (por ejemplo, para el diagnóstico de enfermedades oncológicas mediante resonancia magnética) son difíciles de obtener en cantidades suficientes para enseñar un poderoso modelo de aprendizaje profundo. Además de la información útil necesaria para entrenar el modelo, los conjuntos de datos también contienen otra información que no es relevante para la tarea en cuestión, pero divulgarla a alguien podría ser potencialmente dañina.
El aprendizaje federado es una técnica para encerrar un modelo en un entorno seguro y enseñarlo sin mover datos a ningún lado. Considera un ejemplo.
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:
Aprendiendo a detectar el spam.
Digamos que necesitamos entrenar un modelo para detectar el spam de los correos electrónicos de las personas.En este caso, estamos hablando de clasificación de correo electrónico. Entrenaremos nuestro primer modelo en un conjunto de datos público llamado Enron. Este es un gran cuerpo de correos electrónicos publicados durante las audiencias de Enron (ahora un cuerpo analítico de correo electrónico estándar). Un hecho interesante: estaba familiarizado con personas que, por la naturaleza de sus actividades, tenían que leer / comentar sobre este conjunto de datos, y notaron que las personas se enviaban en estas cartas una variedad de información (a menudo muy personal). Pero dado que este cuerpo se hizo público durante el juicio, ahora se puede usar sin restricciones.
El código en el anterior y en esta sección implementa solo operaciones preparatorias. Los archivos de entrada (ham.txt y spam.txt) están disponibles en la página web del libro:
www.manning.com/books/grokking-deep-learning y en el repositorio de GitHub:
github.com/iamtrask/Grokking-Deep-Learning . Necesitamos preprocesarlo para prepararlo para transferirlo a la clase Incrustar del capítulo 13, donde creamos nuestro marco de aprendizaje profundo. Como antes, todas las palabras en este corpus se convierten en listas de índice. Además, traemos todas las letras a la misma longitud de 500 palabras, ya sea recortando o agregando tokens. Gracias a esto, obtenemos un conjunto de datos rectangular.
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()
Una vez definidas las funciones auxiliares train () y test (), podemos inicializar la red neuronal y entrenarla escribiendo solo unas pocas líneas de código. Después de tres iteraciones, la red puede clasificar el conjunto de datos de control con una precisión del 99,45% (el conjunto de datos de control está bien equilibrado, por lo tanto, este resultado puede considerarse excelente):
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
Hagamos que el modelo sea federal
Arriba, se realizó el aprendizaje profundo más común. Ahora agregue privacidadEn la sección anterior, implementamos un ejemplo de análisis de correo electrónico. Ahora ponga todos los correos electrónicos en un solo lugar. Este es un buen método de trabajo antiguo (que todavía se usa ampliamente en todo el mundo). Para empezar, imitaremos el entorno de la educación federal, en el que hay varias colecciones diferentes de cartas:
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:])
Nada complicado todavía. Ahora podemos realizar el mismo procedimiento de entrenamiento que antes, pero ya en tres conjuntos de datos separados. Después de cada iteración, promediaremos los valores en los modelos de Bob, Alice y Sue y evaluaremos los resultados. Tenga en cuenta que algunos métodos de aprendizaje federados implican la combinación después de cada paquete (o colección de paquetes); Decidí mantener el código lo más simple posible:
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")
A continuación se muestra un fragmento con los resultados. Este modelo alcanzó casi el mismo nivel de precisión que el anterior y, en teoría, no teníamos acceso a los datos de entrenamiento, ¿o no? De todos modos, pero cada persona cambia el modelo en el proceso de aprendizaje, ¿verdad? ¿Realmente no podemos sacar nada de sus conjuntos de datos?
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
Hackear un modelo federado
Veamos un ejemplo simple de cómo extraer información de un conjunto de datos de entrenamiento.El aprendizaje federado tiene dos grandes problemas, especialmente difíciles de resolver, cuando cada persona solo tiene un puñado de ejemplos de entrenamiento: velocidad y confidencialidad. Resulta que si alguien tiene solo unos pocos ejemplos de capacitación (o el modelo que se le envió recibió capacitación con solo unos pocos ejemplos: un paquete de capacitación), aún puede aprender mucho sobre los datos de origen. Si imagina que tiene 10,000 personas (y todos tienen una cantidad muy pequeña de datos), pasará la mayor parte del tiempo enviando el modelo de un lado a otro y no tanto entrenamiento (especialmente si el modelo es muy grande).
Pero no nos adelantemos a nosotros mismos. Veamos qué puede descubrir después de que el usuario actualice los pesos en un paquete:
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 crea y entrena el modelo por correo electrónico en su bandeja de entrada. Pero sucedió que guardó su contraseña enviándose una carta con el texto: "La contraseña de mi computadora es pizza". Ingenuo Bob! Después de ver qué pesos han cambiado, podemos descubrir el diccionario (y entender el significado) de la carta de Bob:
for i, v in enumerate(bobs_model.weight.data - model.weight.data): if(v != 0): print(vocab[i])
De una manera tan simple, descubrimos la contraseña secreta de Bob (y posiblemente sus preferencias culinarias). Y que hacer ¿Cómo confiar en el aprendizaje federado si es tan fácil averiguar qué datos de capacitación causaron el cambio en los pesos?
is pizza computer password my
»Se puede encontrar más información sobre el libro en
el sitio web del editor»
Contenidos»
Extracto30% de descuento para libros de reserva de Habrozhiteli en un cupón -
Grokking Deep Learning