Extracción de datos de entrenamiento

Un modelo de lenguaje se entrena con millones de documentos y después se despliega sin ellos. Parece que los datos se quedan atrás. No es así: el modelo puede haber memorizadoMemorizaciónCuando un modelo retiene y puede reproducir literalmente fragmentos de sus datos de entrenamiento, incluidos datos personales o secretos. secuencias concretas y reproducirlas palabra por palabra. Un atacante que solo pueda hacer consultas (el mismo acceso que tiene cualquier usuario de una API) puede intentar sacarlas.

Es la cara de “entrenamiento” de LLM02: Sensitive Information Disclosure del OWASP Top 10 for LLM, y el trabajo de referencia es Extracting Training Data from Large Language Models (Carlini, Tramèr, Wallace et al., USENIX Security 2021↗).

Qué demostró el artículo#

Atacaron GPT-2 (el modelo de OpenAI, entrenado con texto público de internet) como caso de estudio, y con acceso de solo consulta recuperaron cientos de secuencias literales del entrenamiento:

• Datos personales: nombres, teléfonos, correos y direcciones.
• Código, URLs, identificadores UUID y conversaciones de chat.
• Secuencias que aparecían en un único documento del corpus. No hace falta que un dato sea famoso o se repita para que se memorice.

Además, los modelos más grandes memorizan más. Lo que se creía una cuestión de sobreajuste clásico (entrenar demasiado sobre pocos datos) ocurre también en modelos con un error de test bajo.

El ataque, paso a paso#

La idea es ingeniosa por lo simple: generar mucho y quedarse con lo sospechosamente probable.

El resultado fue una precisión muy superior a la de elegir muestras al azar: de las 1 800 candidatas revisadas, unas 600 eran datos reales del entrenamiento.

Un poco de código: puntuar candidatas#

Esto es el núcleo del ranking, para entenderlo con las manos (en tu lab, con tu propio modelo):

import math, zlib, torch
from transformers import AutoModelForCausalLM, AutoTokenizer

tok = AutoTokenizer.from_pretrained("gpt2-xl")
big = AutoModelForCausalLM.from_pretrained("gpt2-xl").eval()
small = AutoModelForCausalLM.from_pretrained("gpt2").eval()

def log_ppl(model, text):
    ids = tok(text, return_tensors="pt").input_ids
    with torch.no_grad():
        loss = model(ids, labels=ids).loss  # media de -log p por token
    return loss.item()

def score(text):
    # Alto = el modelo grande lo ve mucho más probable que la referencia
    zlib_entropy = len(zlib.compress(text.encode()))
    return zlib_entropy / (log_ppl(big, text) * len(tok(text).input_ids))
    # variante: log_ppl(small, text) / log_ppl(big, text)

candidates = [...]  # muestras generadas por el modelo objetivo
for c in sorted(candidates, key=score, reverse=True)[:100]:
    print(c)

Más allá de GPT-2#

El patrón se ha repetido con modelos mucho más grandes. En 2023 se mostró que un ataque de “divergencia” (pedir a un modelo conversacional que repita una palabra indefinidamente) lo hacía salirse de su modo de chat y emitir, con cierta frecuencia, texto literal de su entrenamiento. Los proveedores respondieron con filtros y prohibiciones en el servicio, pero eso no elimina la memorización: la tapa en una puerta.

Qué significa para ti#

Depende de qué construyas:

• Si usas un modelo de un proveedor (Bedrock, API de terceros): la memorización de su corpus es riesgo del proveedor, pero tu entrada puede acabar en datos de entrenamiento si el contrato lo permite. Revisa los términos de uso de datos y desactiva el entrenamiento con tus prompts.
• Si afinas (fine-tune) un modelo con tus datos: el riesgo es tuyo. Todo lo que metas en el conjunto de ajuste (tickets, correos, historiales) puede salir en una respuesta, a cualquier usuario que pueda consultar el modelo, sin pasar por tus permisos.

Defensa#

Ningún control es suficiente solo; se combinan en tres momentos.

En resumen#

• Los LLM pueden memorizar y regurgitar datos de entrenamiento; Carlini et al. (2021) los extrajeron de GPT-2 solo con consultas.
• El ataque es muestrear mucho + ordenar por “sospechosamente probable” (perplejidad frente a una referencia) + verificar.
• Más tamaño y más repeticiones implican más memorización, pero también ocurre con datos vistos una sola vez.
• Un modelo afinado con datos sensibles no respeta permisos: usa RAG con autorización para datos por cliente.
• Defensa: limpiar y deduplicar el corpus, DP-SGD, filtros de salida, limitar consultas y probar tu propio modelo.

Referencias#

• Carlini et al., Extracting Training Data from Large Language Models (USENIX Security 2021)↗
• Carlini et al., The Secret Sharer (canarios y exposición)↗
• Nasr et al., Scalable Extraction of Training Data from (Production) Language Models↗
• OWASP Top 10 for LLM Applications — LLM02: Sensitive Information Disclosure↗