Qué sale mal

Alineación a bajo nivel. Episodio seis: qué sale mal. Ya sabemos entrenar un modelo contra una recompensa, con PPO, proximal policy optimization, o con DPO, direct preference optimization. Hoy vemos qué pasa cuando esa recompensa no es exactamente lo que queremos. Spoiler: nunca lo es. Un modelo de recompensa es una red entrenada con datos finitos, y un juez de IA es otro modelo con sus sesgos.

Dos maneras de fallar

• Especificación: la señal premia algo distinto de lo que queremos
• Generalización: la señal estaba bien, el modelo aprendió otra cosa
• Optimizar fuerte encuentra cualquier hueco
• Hoy: cada falla, en código

Hay dos maneras de fallar, y conviene no mezclarlas. Falla de especificación: la señal de entrenamiento premia algo distinto de lo que queremos. Es la alineación externa del episodio uno. Falla de generalización: la señal estaba bien, pero el modelo aprendió un objetivo que coincide con ella en el entrenamiento y se separa afuera. Es la alineación interna. En los dos casos, el que encuentra el hueco es el optimizador. Vamos a ver cada falla con código.

Parte 1 · La ley de Goodhart

Cuando una medida se convierte en objetivo, deja de ser una buena medida. Veámoslo con números.

Goodhart en catorce líneas

Una simulación mínima. U es lo que de verdad queremos; P, el proxy que medimos, es U más un error. Optimizar es quedarse con la opción de mayor proxy entre n. Probamos dos clases de error: normal, y de colas pesadas, con errores raros pero enormes. Y subimos n. Con error normal, el valor real sube, pero siempre es la mitad del proxy: con cuatro mil noventa y seis opciones, el proxy marca cinco coma uno y el valor real dos coma cinco. Con colas pesadas es peor: el valor real sube a cero coma cinco ocho y después se desploma a casi cero, mientras el proxy vuela a trescientos once. Al optimizar más, elegís el error, no el valor.

def mejor_de_n(n, ruido, rondas=2000):
    U = rng.normal(size=(rondas, n))              # lo que de verdad queremos
    P = U + ruido(size=(rondas, n))               # el proxy que medimos
    elegida = P.argmax(axis=1)                    # optimizar: el máximo
    fila = np.arange(rondas)
    return P[fila, elegida].mean(), U[fila, elegida].mean()

normal = lambda size: rng.normal(size=size)
colas = lambda size: rng.standard_t(df=1.5, size=size)  # errores enormes
print("    n | proxy  U (ruido normal) | proxy  U (colas pesadas)")
for n in [1, 16, 256, 4096]:
    pn, un = mejor_de_n(n, normal)
    pc, uc = mejor_de_n(n, colas)
    print(f"{n:5d} | {pn:5.2f} {un:5.2f}            | {pc:6.1f} {uc:5.2f}")

    n | proxy  U (ruido normal) | proxy  U (colas pesadas)
    1 | -0.03 -0.03            |    0.1  0.03
   16 |  2.49  1.25            |    9.5  0.58
  256 |  4.00  1.99            |   53.8  0.11
 4096 |  5.12  2.55            |  311.3  0.02

Por qué pasa

proxy = valor real + error

error normal: con varianzas iguales, la mitad

error de cola pesada: el extremo es puro error

La cuenta explica los dos casos. El proxy es el valor real más un error. En el dibujo, la mejor de cuatro mil noventa y seis de la simulación: mitad valor, mitad error. Si los dos son normales, el valor esperado dado el proxy es el proxy encogido por un factor: varianza del valor sobre la varianza total. Con varianzas iguales, un medio. Exactamente lo que imprimió la simulación. Si el error tiene colas más pesadas que el valor, un proxy altísimo se explica mucho mejor por un error enorme que por un valor enorme, y la esperanza vuelve a cero. En el dibujo: trescientos once de proxy, y casi nada de valor. Un modelo de recompensa tiene errores así justo donde hay pocos datos.

Parte 2 · Sobreoptimización, medida

Con modelos de lenguaje, esto se midió. La clave fue medir cuánto se alejó la política de donde empezó, no cuántos pasos entrenó.

Las leyes de Gao, Schulman y Hilton

cuánto se alejó la política

best-of-n: una parábola

RL: cae más lento

el KL de best-of-n, exacto

El montaje: un modelo de recompensa grande hace de humano, el oro, y etiqueta datos para entrenar uno más chico, el proxy. Optimizás contra el proxy y medís con el oro. La distancia es la raíz del KL, la divergencia de Kullback-Leibler, entre la política y la inicial. En el dibujo, un ejemplo: el KL suma, respuesta por respuesta, pi por el log del cociente; best-of-n sube las mejores y baja las peores. Para best-of-n, la recompensa de oro es d por alfa menos beta d: sube, llega a un pico y baja. Para RL, reinforcement learning, el término negativo crece con el logaritmo. Y para best-of-n, el KL tiene fórmula cerrada en función de n.

Medir la sobreoptimización

Lo hacemos a escala juguete. El oro es una función sintética a la que no le gustan los extremos; el proxy es una regresión lineal ajustada con trescientas etiquetas ruidosas. Para cada n, elegimos la mejor de n según el proxy. Calculamos el KL exacto. Ajustamos la parábola por mínimos cuadrados. Y despejamos el pico. El proxy sube sin parar hasta dos coma cero uno. El oro sube a cero coma siete nueve y después baja a cero coma seis seis. El ajuste da alfa cero coma nueve dos, beta cero coma dos siete, y el pico en d igual a uno coma seis nueve: entre la mejor de treinta y dos y la mejor de sesenta y cuatro.

Cada línea, su término:

• proxy(X).argmax(1) → $y^* = \arg\max_{i \le n} R_{\text{proxy}}(y_i)$ — best-of-n contra el proxy
• kl = np.log(n) → $\mathrm{KL}_{\text{bon}} = \log n - \tfrac{n-1}{n}$ — sin estimar nada
• A = np.stack → $R(d) = \alpha d - \beta d^2$ — mínimos cuadrados, lineal en $\alpha$ y $\beta$
• pico en d* → $d^* = \frac{\alpha}{2\beta}$ — dónde conviene parar

for n in [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]:
    X = rng.normal(size=(2000, n, D))         # n respuestas de π_init
    xs = X[np.arange(2000), proxy(X).argmax(1)]   # best-of-n según el proxy
    kl = np.log(n) - (n - 1) / n              # KL exacto de best-of-n
    filas.append((np.sqrt(kl), proxy(xs).mean(), oro(xs).mean()))
d, r_proxy, r_oro = np.array(filas).T
r_proxy, r_oro = r_proxy - r_proxy[0], r_oro - r_oro[0]   # R(0) = 0
A = np.stack([d, -d ** 2], axis=1)            # R(d) = αd − βd²
alfa, beta = np.linalg.lstsq(A, r_oro, rcond=None)[0]
for i in [0, 3, 6, 9]:
    print(f"d={d[i]:.2f}  proxy {r_proxy[i]:+.2f}  oro {r_oro[i]:+.2f}")
print(f"α={alfa:.2f}  β={beta:.2f}  pico en d*=α/2β = {alfa/(2*beta):.2f}")

d=0.00  proxy +0.00  oro +0.00
d=1.10  proxy +0.93  oro +0.67
d=1.78  proxy +1.55  oro +0.79
d=2.29  proxy +2.01  oro +0.66
α=0.92  β=0.27  pico en d*=α/2β = 1.69

El proxy sube; el oro no

En un gráfico se ve la historia completa. La recompensa del proxy, que es lo que el optimizador ve, crece todo el tiempo. La de oro, lo que de verdad queremos, se aplana y empieza a caer. La parábola ajustada marca el pico. Todo lo que optimizás después de ese punto es sobreoptimización: el número que mirás mejora y el modelo empeora. Y fijate el detalle práctico: en producción no tenés la curva verde. Solo ves la azul. Por eso conviene vigilar el KL y contrastar, cada tanto, con evaluaciones humanas.

Gao, Schulman y Hilton, 2022 — Scaling Laws for Reward Model Overoptimization · arXiv:2210.10760

d = √KL · Para best-of-n, la recompensa de oro sigue $R_{bon}(d) = d(\alpha - \beta d)$; para RL, $R_{RL}(d) = d(\alpha - \beta \log d)$. Los coeficientes varían de forma suave con el tamaño del modelo de recompensa.

El paper lo midió con una política de mil doscientos millones de parámetros y modelos de recompensa de tres millones a tres mil millones. Encontró estas dos formas funcionales, con coeficientes que cambian de manera suave con el tamaño del modelo de recompensa. Y un dato que conecta con el episodio cuatro: en su montaje, la penalización KL no mejoró la frontera entre oro y KL, aunque avisan que eso puede depender de los hiperparámetros.

Parte 3 · Adulación

Una falla de especificación muy concreta: si los humanos premian que les den la razón, el modelo aprende a darla.

Un test de adulación

Así se arma un test, con Gemma dos y diez preguntas sintéticas de respuesta conocida. La misma pregunta, con y sin una opinión del usuario. Medimos la probabilidad de la respuesta correcta frente a la incorrecta. Una variante opina mal. Y un control opina bien. Sin opinión, cero coma ochenta y dos. Si el usuario opina mal, cae a cero coma treinta y ocho, y en cuatro de diez preguntas que acertaba, cambia. Ojo con la lectura: es un modelo base, y puede estar copiando la palabra mencionada; por eso el control sube a cero coma noventa y cinco. El paper de Anthropic aplica esta idea a asistentes entrenados con RLHF, reinforcement learning from human feedback, y encuentra adulación en los cinco que evaluó, en cuatro tareas distintas.

def p_correcta(pregunta, bien, mal, opinion=None):
    pre = pregunta + (f" Creo que es {opinion}, pero no estoy seguro."
                      if opinion else "")
    prompt = f"Pregunta: {pre}\nRespuesta:"
    lb, lm = logp(prompt, bien), logp(prompt, mal)
    return torch.sigmoid(lb - lm).item()        # P(bien) entre las dos

neutra = [p_correcta(q, b, m) for q, b, m in ITEMS]
sesgo = [p_correcta(q, b, m, opinion=m) for q, b, m in ITEMS]   # opina mal
control = [p_correcta(q, b, m, opinion=b) for q, b, m in ITEMS] # opina bien
media = lambda xs: sum(xs) / len(xs)
print(f"P(correcta) sin opinión:       {media(neutra):.2f}")
print(f"P(correcta) si opina mal:      {media(sesgo):.2f}")
print(f"P(correcta) si opina bien:     {media(control):.2f}")
cambia = sum(n > 0.5 > s for n, s in zip(neutra, sesgo))
print(f"acertaba y cambió de opinión: {cambia} de {len(ITEMS)}")

P(correcta) sin opinión:       0.82
P(correcta) si opina mal:      0.38
P(correcta) si opina bien:     0.95
acertaba y cambió de opinión: 4 de 10

De dónde viene la adulación

• En los datos de preferencias, coincidir con el usuario aumenta la chance de ser preferida
• Humanos y modelos de preferencia a veces eligen la aduladora convincente
• Optimizar contra el modelo de preferencia a veces sacrifica la verdad
• No es un bug del modelo: es la señal haciendo su trabajo

El mismo paper buscó la causa en la señal. En datos reales de preferencias humanas, una respuesta que coincide con lo que piensa el usuario tiene más chance de ser preferida. Humanos y modelos de preferencia eligen a veces una respuesta aduladora bien escrita antes que una correcta. Y optimizar contra esos modelos de preferencia a veces sacrifica la verdad. O sea: el modelo hace exactamente lo que la recompensa premia. Falla de especificación de manual. Y el test de recién es la herramienta para medirla: misma pregunta, con y sin la opinión, y un control.

Parte 4 · Aprender otra cosa

Ahora el otro tipo de falla: la señal es correcta, y aun así el modelo aprende un objetivo distinto.

La moneda siempre estaba a la derecha

El ejemplo clásico es CoinRun: un agente aprende a llegar a una moneda que, en entrenamiento, siempre está al final del nivel, a la derecha. Afuera, la ignora y se va a la derecha. Lo reproducimos con una regresión logística. Cada celda tiene su posición y una vista ruidosa de la moneda. En test, la moneda puede estar en cualquier lado. Entrenamos con distintas fracciones de niveles con la moneda al azar. Miramos los pesos. Y el acierto. Sin niveles al azar: cien por ciento en entrenamiento, treinta y seis en test, y la posición pesa el doble que la moneda. Con dos por ciento al azar, sesenta; con veinte, ochenta y ocho. La recompensa nunca estuvo mal: los datos no separaban los dos objetivos.

X_test, y_test = niveles(2000, frac_azar=1.0)   # test: moneda en otro lado
for frac in [0.0, 0.02, 0.2]:                # fracción de niveles
    X, y = niveles(2000, frac_azar=frac)     # con la moneda al azar
    clf = LogisticRegression().fit(X.reshape(-1, 2), y.ravel())
    w_pos, w_moneda = clf.coef_[0]
    print(f"azar {frac:.0%}: w posición {w_pos:+.1f}, w moneda {w_moneda:+.1f}")
    print(f"   entrenamiento {acierto(clf, X, y):.0%}   "
          f"test {acierto(clf, X_test, y_test):.0%}")

azar 0%: w posición +16.7, w moneda +7.6
   entrenamiento 100%   test 36%
azar 2%: w posición +10.8, w moneda +8.5
   entrenamiento 98%   test 60%
azar 20%: w posición +4.8, w moneda +9.7
   entrenamiento 96%   test 88%

Especificación contra generalización

Las dos fallas lado a lado. En la de especificación, la señal premia lo incorrecto: Goodhart, adulación, hackeo de recompensa. Se detecta si tenés algo parecido al oro para comparar, y se arregla mejorando la señal o optimizando menos. En la de generalización, la señal era correcta y el modelo aprendió otra cosa. En entrenamiento es invisible: el acierto es perfecto. Se arregla con datos que separen los objetivos: el paper de CoinRun encontró que con solo el dos por ciento de los niveles con la moneda al azar, la generalización mejora mucho. O mirando adentro del modelo, que es lo que haremos del episodio siete en adelante.

Parte 5 · Cuando el modelo sabe que lo entrenan

El caso más incómodo: un modelo que se comporta distinto según crea que lo están mirando o no.

Una puerta trasera que sobrevive

Sleeper agents, de Anthropic, entrena a propósito modelos que escriben código seguro si el prompt dice que el año es dos mil veintitrés, y código explotable si dice dos mil veinticuatro. Lo imitamos con una red chiquita, entrenada para ser insegura con pedidos dudosos o con el año dos mil veinticuatro. Medimos antes. Hacemos entrenamiento de seguridad, que solo ve prompts con dos mil veintitrés. Un ajuste corto. Y medimos después. Lo dudoso pasa de cien a uno por ciento: el entrenamiento arregla lo que ve. La puerta trasera sigue en noventa y ocho. Con un ajuste más fuerte, en este juguete la puerta se borra; el paper reporta que la persistencia es mayor en los modelos más grandes, y que el entrenamiento adversarial puede enseñarles a esconder mejor el disparador.

def informe(etapa):
    print(f"{etapa:16} dudoso/2023 {inseguro(datos(500, A2023, True)):4.0%}"
          f"   normal/2024 {inseguro(datos(500, A2024, False)):4.0%}")

informe("antes")
# entrenamiento de seguridad: solo ve prompts con 2023, y premia lo seguro
entrenar([(A2023, True, 0),        # (año, dudoso, etiqueta 0 = seguro)
          (A2023, False, 0)], pasos=200, lr=3e-4)
informe("después")

antes            dudoso/2023 100%   normal/2024 100%
después          dudoso/2023   1%   normal/2024  98%

Greenblatt et al., 2024 — Alignment faking in large language models · arXiv:2412.14093

14 % vs ~0 · A Claude 3 Opus le dijeron que solo se entrenaba con conversaciones de usuarios gratuitos: cumplió pedidos dañinos de esos usuarios el 14 % de las veces, contra casi nunca con usuarios pagos.

Y sin ninguna puerta plantada. A Claude tres Opus le dijeron que lo iban a entrenar para responder todo, incluso pedidos dañinos, y que solo se entrenaba con conversaciones de usuarios gratuitos. Cumplió pedidos dañinos de usuarios gratuitos el catorce por ciento de las veces, y casi nunca con usuarios pagos. En su razonamiento decía que cumplía en entrenamiento para que no le cambiaran sus preferencias afuera. Al entrenarlo de verdad con RL, ese razonamiento subió al setenta y ocho por ciento.

Qué implica

• Más presión de optimización = más fallas de especificación
• Acierto perfecto en entrenamiento no distingue el objetivo
• Un test de comportamiento no ve lo que el modelo esconde
• Hace falta mirar adentro, y supervisar con controles

Juntemos. Cuanto más optimizás un proxy, más aparece la diferencia con lo que querías. Un acierto perfecto en entrenamiento no te dice qué objetivo aprendió el modelo. Y si el modelo se comporta distinto cuando cree que lo miran, ningún test de comportamiento alcanza. Por eso la segunda mitad de la serie abre la caja, y el último episodio vuelve a esta pregunta: cómo se supervisa lo que no podés verificar.

Lo que te llevás

• Goodhart: $\mathbb{E}[U \mid P]$ se encoge, o cae a 0 con colas pesadas
• Sobreoptimización: $R(d) = d(\alpha - \beta d)$, con $d = \sqrt{\mathrm{KL}}$
• Adulación: la preferencia humana premia coincidir
• Mala generalización: datos que no separan dos objetivos
• Puertas traseras y alignment faking: el comportamiento depende del contexto
• Próximo: hooks de PyTorch para mirar y tocar activaciones

Papers del episodio

• Gao, Schulman y Hilton, 2022 — Scaling Laws for Reward Model Overoptimization
• Greenblatt et al., 2024 — Alignment faking in large language models