Ajuste fino y LoRA

Qué se minimiza en el ajuste fino supervisado

Dado un modelo con pesos $\theta$ y ejemplos $(x_i, y_i)$ (una entrada y la respuesta deseada), el ajuste fino supervisado sigue minimizando la entropía cruzada,

con el mismo descenso del gradiente de la lección 4 y los gradientes de la retropropagación de la lección 8. En un modelo de lenguaje, $y_i$ es una secuencia de tokens y la suma corre solo sobre los tokens de la respuesta. Se parte de los pesos preentrenados $\theta_0$ (lección 23), con tasas de aprendizaje mucho menores que en el preentrenamiento y pocas pasadas por los datos. LIMA (Zhou et al., 2023) usó 1 000 ejemplos, unos 750 000 tokens, sobre LLaMA de 65 mil millones de parámetros, preentrenado con 1.4 billones de tokens (Touvron et al., 2023).

LoRA: la matemática

Para una matriz de pesos preentrenada $W_0\in\mathbb{R}^{d\times k}$, LoRA la congela y escribe la actualización como

El pase hacia delante es $h = W_0x + \tfrac{\alpha}{r}B(Ax)$. $A$ se inicia con una gaussiana y $B$ con ceros, así que $\Delta W = 0$ al empezar (Hu et al., 2021); solo $A$ y $B$ reciben gradiente. Como $\partial L/\partial A$ es proporcional a $B$, en el primer paso solo se mueve $B$.

Cada columna $b_j$ de $B$ y cada fila $a_j$ de $A$ forman una pieza de rango uno, $b_j a_j$ (columna por fila, como la tabla de multiplicar de la lección): $BA = \sum_{j=1}^{r} b_j a_j$. De ahí el nombre: la corrección tiene rango a lo sumo $r$.

Parámetros entrenables: $r\,(d+k)$ en vez de $dk$. Solo ahorra si $r < \dfrac{dk}{d+k}$; en una matriz cuadrada, $r<d/2$. Con $d=k=32$ (la capa del centro del modelo diminuto), $r=16$ empata: $16\cdot 64 = 1\,024$.

Una vez entrenado se puede fusionar, $W = W_0 + \tfrac{\alpha}{r}BA$, y la inferencia cuesta lo mismo que la del modelo original; o dejar el adaptador aparte para cambiarlo por otro.

Con GPT-3 175B ($d_{\text{model}}=12\,288$, 96 capas), adaptar solo $W_q$ y $W_v$ con $r=4$ da $96\cdot 2\cdot 4\cdot(12\,288+12\,288)=18\,874\,368$ parámetros entrenables: unas 9 300 veces menos que 175 mil millones (el artículo dice «unas 10 000 veces»). En FP16 el adaptador ocupa unos 35 MB frente a los 350 GB del modelo, y 100 adaptaciones ocupan unos 354 GB en vez de 35 TB (Hu et al., 2021).

Por qué el cambio es de bajo rango

Si $M=\sum_i \sigma_i u_i v_i^\top$ es la descomposición en valores singulares, el teorema de Eckart y Young dice que la mejor matriz de rango $r$ (en norma de Frobenius) es la suma de los $r$ primeros términos, y su error es $\sum_{i>r}\sigma_i^2$. En el modelo diminuto, el cambio que deja el ajuste completo en la capa de 32×32 tiene valores singulares que caen rápido: los cuatro primeros reúnen alrededor de 97 % de $\sum\sigma_i^2$. Eso es lo que LoRA supone y aprovecha; Aghajanyan et al. (2020) ya habían medido que ajustar un modelo de lenguaje necesita muy pocas dimensiones efectivas. No es una ley: Hu et al. no esperan que un rango pequeño sirva para cualquier tarea (por ejemplo, un idioma distinto del preentrenamiento), y Biderman et al. (2024) midieron que, en programación y matemáticas, el ajuste completo aprende cambios de un rango 10 a 100 veces mayor que las configuraciones típicas de LoRA.

Olvido, repaso y qué dice la evidencia

Con datos estrechos, mover pesos compartidos desplaza lo que esos datos no cubren. En el modelo diminuto (70 ejemplos nuevos de una sola zona, 300 pasos de Adam con todo el lote, una corrida con semillas fijas):

ajuste	se entrenan	aciertos en lo nuevo	aciertos en lo que ya sabía
ninguno (modelo base)	—	0 %	100 %
completo	1 251	98 %	93 %
completo + 30 de repaso	1 251	94 %	97 %
LoRA r = 2	128	91 %	87 %
LoRA r = 2 + 30 de repaso	128	93 %	98 %

Aquí LoRA sin repaso olvida más que el ajuste completo; en modelos grandes, Biderman et al. (2024) hallaron lo contrario en promedio (LoRA aprende menos y olvida menos), pero no que deje de olvidar. Moraleja: el olvido es un riesgo con ambos métodos, y se mide con datos que el ajuste no vio. El nombre «catastrófico» viene de McCloskey y Cohen (1989); en el juguete la pérdida es moderada.

Memoria: de dieciséis bytes por parámetro a menos

Entrenar con Adam en precisión mixta guarda por parámetro: pesos FP16 (2 bytes), gradientes FP16 (2) y, en FP32, copia de los pesos, momento y varianza ($4+4+4$): $16$ bytes (Rajbhandari et al., 2019; lección 25). Con LoRA, los pesos congelados solo necesitan su copia (2 bytes en FP16) y los 16 bytes se pagan solo por $A$ y $B$. QLoRA guarda además la base en 4 bits (formato NF4, con «doble cuantización» de las constantes) y entrena el adaptador en 16 bits. Cuenta propia para un modelo de 7 mil millones, sin activaciones: ajuste completo $7\cdot 16=112$ GB; base en FP16, 14 GB; base en 4 bits, unos 3.5 GB, más adaptador y activaciones.

Las cifras de los artículos no salen exactamente de esta cuenta, porque dependen de qué se guarde y cómo: el de LoRA da, para GPT-3 175B, de 1.2 TB a 350 GB, y el de QLoRA cuenta más de 780 GB para ajustar 65 mil millones en 16 bits (unos 12 bytes por parámetro). Compara siempre bajo la misma cuenta.

En el modelo diminuto se puede probar la parte «Q»: con sus tres matrices en 4 bits (NF4, bloques de 64), el mapa cambia en 22 de 1 600 celdas, y LoRA de rango 2 con repaso llega a 91 % en lo nuevo y 98 % en lo que ya sabía, frente a 93 % y 98 % con la base en 16 bits. Es un juguete: reproduce la idea, no demuestra nada sobre modelos grandes.

En código

import numpy as np

# 1) la cuenta: una matriz de GPT-3 (12288 x 12288) y rango 8
d = k = 12288
r = 8
completa = d * k
lora = r * (d + k)
print(completa, lora, completa // lora)    # 150994944 196608 768

# 2) la corrección arranca en cero (B = 0): el modelo no cambia
rng = np.random.default_rng(0)
W0 = rng.normal(size=(6, 6))               # matriz congelada (diminuta)
A = rng.normal(size=(2, 6))                # r = 2, gaussiana
B = np.zeros((6, 2))                       # ceros
x = rng.normal(size=6)
h = W0 @ x + B @ (A @ x)                   # alfa/r = 1
print(np.allclose(h, W0 @ x))              # True

# 3) tras entrenar, B deja de ser cero: la corrección tiene rango <= 2
B = rng.normal(size=(6, 2)) * 0.1
print(np.linalg.matrix_rank(B @ A))        # 2

Lo que viene

Ajustar con pares de entrada y salida cambia formato, estilo y tarea. Convertir un modelo que solo completa texto en un asistente usa ese mismo mecanismo, pero la pregunta es qué pares y qué señal: el ajuste con instrucciones y el aprendizaje por refuerzo con retroalimentación humana (lección 28). Y es práctico: con QLoRA se ajustó con instrucciones la familia Guanaco (Dettmers et al., 2023), y esos autores hallaron que la calidad de los datos pesa mucho más que su cantidad (9 mil ejemplos de OASST1 superaron a 450 mil de FLAN v2 en su prueba de chatbot).