Privacidad diferencial y aprendizaje profundo

La privacidad diferencial es un tema nuevo en el campo del aprendizaje profundo. Se trata de garantizar que cuando nuestras redes neuronales aprendan de datos confidenciales, solo aprendan lo que se supone que deben aprender de los datos.
Definición robusta de privacidad propuesta por Cynthia Dwork (de su libro Algorithmic Foundations):

“Privacidad diferencial” describe una promesa, hecha por un titular de datos, o curador, a un sujeto de datos, y la promesa es así: “No se verá afectado, adversamente o de otra manera, al permitir que sus datos se utilicen en cualquier estudio o análisis, sin importar qué otros estudios, conjuntos de datos o fuentes de información estén disponibles”.

El objetivo general de la privacidad diferencial es garantizar que los diferentes tipos de análisis estadístico no comprometan la privacidad y que se conserve la privacidad si, después del análisis, el analizador no sabe nada sobre las características del conjunto de datos, es decir, la información que tiene hecho público en otro lugar no es perjudicial para un individuo. 
Para definir la privacidad en el contexto de una base de datos simple, estamos realizando algunas consultas en la base de datos y si eliminamos a una persona de la base de datos y la consulta no cambia, la privacidad de esa persona estará totalmente protegida.
Entendamos con un ejemplo 
Dada una base de datos, que contiene algunos números ‘1’ y ‘0’, que son algunos datos confidenciales, como si un individuo tiene algún tipo de enfermedad o no (tal vez los pacientes no quieran revelar estos datos).
 

  db = [1, 0, 1, 1, 0, 1, 0, 1, 0, 0]

y ahora, tiene sus bases de datos con una de cada entrada eliminada, que se denominan DBS paralelas. entonces hay ‘n’ número de DBS paralelos si la longitud del DB original es ‘n’, en nuestro caso es 10. 
Ahora, consideremos uno de DBS paralelos, tomemos el primero en el que se elimina el primer individuo y qué obtenemos?
 

 pdbs[0] = [0, 1, 1, 0, 1, 0, 1, 0, 0]

Entonces ves que ahora esta base de datos tiene una longitud ‘n-1’. Entonces, para calcular la sensibilidad, necesitamos una función de consulta, por lo que asumimos la ‘suma’ más simple. Así que ahora nos centramos en dos resultados: 
 

 sum(db) = 5
 sum(pdbs[0]) = 4

y la diferencia entre los dos anteriores es ‘1’ y sabemos que necesitamos encontrar el máximo de todas estas diferencias, dado que este DB solo contiene ‘1’ y ‘0’, todas esas diferencias serán ‘1’ (cuando similar como arriba, cuando se elimina 1) o ‘0’ (cuando se elimina 0). 
Por lo tanto, obtenemos nuestra sensibilidad para este ejemplo como ‘1’ y este es un valor realmente alto y, por lo tanto, los ataques de diferenciación se pueden realizar fácilmente utilizando esta consulta de ‘suma’. 
La sensibilidad debe estar por debajo para que dé una idea cuantitativa de qué nivel de diferenciación de ataques puede revelar información/fugas de privacidad.
Implementando el código para la Privacidad Diferencial en Python 
 

import torch
 
# the number of entries in our database
num_entries = 5000
 
db = torch.rand(num_entries) > 0.5
 
# generating parallel databases
def get_parallel_db(db, remove_index):
 
    return torch.cat((db[0:remove_index],
                      db[remove_index+1:]))
get_parallel_db(db, 52352)
 
def get_parallel_dbs(db):
 
    parallel_dbs = list()
 
    for i in range(len(db)):
        pdb = get_parallel_db(db, i)
        parallel_dbs.append(pdb)
     
    return parallel_dbs
 
pdbs = get_parallel_dbs(db)
 
# Creating linear and parallel databases
 
def create_db_and_parallels(num_entries):
     
    db = torch.rand(num_entries) > 0.5
    pdbs = get_parallel_dbs(db)
     
    return db, pdbs
 
db, pdbs = create_db_and_parallels(2000)
 
# Creating sensitivity function
 
def sensitivity(query, n_entries=1000):
 
    db, pdbs = create_db_and_parallels(n_entries)
     
    full_db_result = query(db)
     
    max_distance = 0
    for pdb in pdbs:
        pdb_result = query(pdb)
 
        db_distance = torch.abs(pdb_result - full_db_result)
 
        if(db_distance > max_distance):
            max_distance = db_distance
             
    return max_distance
 
# query our database and evaluate whether or not the result of the
# query is leaking "private" information
 
def query(db):
    return db.float().mean()
sensitivity(query)

Input : A randomly generated database(with the help of torch library) 

Output : tensor(0.0005)

Explicación 
En primer lugar, creamos una base de datos aleatoria con la ayuda de la biblioteca Torch y luego definimos dos funciones get_parallel_db y get_parallel_dbs para bases de datos lineales y paralelas. Ahora definimos la función de sensibilidad, luego medimos la diferencia entre el resultado de la consulta de cada base de datos paralela y el resultado de la consulta para toda la base de datos y luego calculamos el valor máximo (que fue 1). Este valor se denomina “sensibilidad” .