# Prepara el entorno: comprueba lo que ya tienes e instala únicamente lo que
# falte. Si ya está todo, no descarga nada.
import sys
from pathlib import Path

_aqui = Path.cwd()
_candidatas = [_aqui, *_aqui.parents,                       # lo normal
               *(f.parents[1] for f in _aqui.glob("*/comun/entorno.py")),
               *(f.parents[1] for f in _aqui.glob("*/*/comun/entorno.py"))]
_raiz = next((p for p in _candidatas
              if (p / "comun" / "entorno.py").is_file()), None)
if _raiz is None:
    raise RuntimeError(
        "No encuentro la carpeta 'comun'. Descomprime el zip entero y abre "
        "este cuaderno desde dentro de la carpeta demo_rapida.")
sys.path.insert(0, str(_raiz))

from comun.entorno import instalar, preparar

instalar()                 # ¿algo ha fallado? -> instalar(verboso=True)
_carpeta = preparar()      # deja las rutas del cuaderno listas

Entorno listo, no hay nada que instalar.  (Linux 6.8.0-138-generic · Python 3.10.12)

import random
import time

import matplotlib.pyplot as plt
import torch

from comun.config import MODELO_PEQUE, DTYPE_ENTRENO, DEVICE, fijar_semilla, mil, cronometro, resumen_entorno
from comun.datos import triaje, triaje_dificil, INSTRUCCION_TRIAJE
from comun.entrenamiento import construir_lote, generar, medir, parsear_ficha, IGNORAR

resumen_entorno()
fijar_semilla()

Sistema        : Linux 6.8.0-138-generic (x86_64)
Python         : 3.10.12
PyTorch        : 2.14.1+cpu
Dispositivo    : cpu
Hilos de CPU   : 8
Sin GPU: todo funciona igual, solo que más despacio.
Semilla        : 0

train, test = triaje(n_train=160, n_test=40)
dificil = triaje_dificil()

print(f"entrenamiento : {len(train)}")
print(f"prueba        : {len(test)}")
print(f"difícil       : {len(dificil)} (escrito a mano, sin plantilla)\n")

print("--- LA INSTRUCCIÓN (idéntica en los 160 ejemplos) ---")
print(INSTRUCCION_TRIAJE)
print("\n--- TRES EJEMPLOS ---")
for e in train[:3]:
    print(f"\nENTRADA: {e['entrada']}")
    print("SALIDA :", e["salida"].replace("\n", " | "))

from collections import Counter
print("\nReparto por categoría:", dict(Counter(e["categoria"] for e in train)))

entrenamiento : 160
prueba        : 40
difícil       : 12 (escrito a mano, sin plantilla)

--- LA INSTRUCCIÓN (idéntica en los 160 ejemplos) ---
Eres el clasificador de incidencias de Banco Iberia. Devuelve exactamente cuatro líneas con este formato y nada más:
CATEGORIA: <fraude|hipoteca|tarjeta|cuenta|inversion>
URGENCIA: <alta|media|baja>
EQUIPO: <investigacion|riesgos|operaciones|asesoria>
SLA_HORAS: <numero>

--- TRES EJEMPLOS ---

ENTRADA: Mi tarjeta ha caducado y no me ha llegado la nueva.
SALIDA : CATEGORIA: tarjeta | URGENCIA: media | EQUIPO: operaciones | SLA_HORAS: 24

ENTRADA: He cambiado de domicilio y quiero actualizar mis datos.
SALIDA : CATEGORIA: cuenta | URGENCIA: baja | EQUIPO: operaciones | SLA_HORAS: 48

ENTRADA: Quiero traspasar un fondo de otra entidad a Banco Iberia.
SALIDA : CATEGORIA: inversion | URGENCIA: baja | EQUIPO: asesoria | SLA_HORAS: 72

Reparto por categoría: {'tarjeta': 34, 'cuenta': 30, 'inversion': 32, 'fraude': 32, 'hipoteca': 32}

from transformers import AutoModelForCausalLM, AutoTokenizer

with cronometro("cargar SmolLM2-135M"):
    tok = AutoTokenizer.from_pretrained(MODELO_PEQUE)
    mod = AutoModelForCausalLM.from_pretrained(MODELO_PEQUE, dtype=DTYPE_ENTRENO).to(DEVICE)

with cronometro("evaluar antes del SFT"):
    antes = generar(mod, tok, test, INSTRUCCION_TRIAJE, max_new_tokens=40)

print("\nANTES:", medir(antes, test))
print("\nQué está generando en realidad:\n")
for pred, ej in list(zip(antes, test))[:3]:
    print(f"  entrada : {ej['entrada'][:70]}")
    print(f"  generado: {pred[:130]!r}")
    print(f"  esperado: {ej['salida'].replace(chr(10), ' | ')}\n")

/tmp/venv_demo/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

[cargar SmolLM2-135M] 1.1 s

[evaluar antes del SFT] 14.9 s

ANTES: formato   0.0%   categoría   0.0%   ficha exacta   0.0%   (n=40)

Qué está generando en realidad:

  entrada : Mi test MiFID ha caducado y la app no me deja contratar nada.
  generado: 'La app no me deja contratar nada. Esto es un problema de la interfaz de la interfaz de la app. Si no me deja contratar nada'
  esperado: CATEGORIA: inversion | URGENCIA: baja | EQUIPO: asesoria | SLA_HORAS: 72

  entrada : Me han hecho un cargo de 900 euros en una app de viajes y yo no he com
  generado: 'La app de viajes es un buen programa, pero no puedo ser un buen programa en el caso de un cargo de 900 euros. Est'
  esperado: CATEGORIA: fraude | URGENCIA: alta | EQUIPO: investigacion | SLA_HORAS: 4

  entrada : Han intentado entrar en mi banca online desde un móvil que no es el mí
  generado: 'En este caso, la entrada es:\n\nCATEGORIA: <fraude|hipoteca|tarjeta|cuenta|inversion>\nURGEN'
  esperado: CATEGORIA: fraude | URGENCIA: alta | EQUIPO: investigacion | SLA_HORAS: 4

# Antes de tocar nada, guardamos lo que el modelo responde a preguntas que NO
# son de triaje. Sin esta foto previa, lo del apartado 7 sería una anécdota.
GENERALES = ["What is the capital of France?",
             "Escribe un haiku sobre el otoño.",
             "2 + 2 = ",
             "Explica en una frase qué es una hipoteca."]


def preguntar_suelto(pregunta, max_new_tokens=50):
    msgs = [{"role": "user", "content": pregunta}]
    texto = tok.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
    ent = tok(texto, return_tensors="pt", add_special_tokens=False).to(DEVICE)
    with torch.no_grad():
        out = mod.generate(**ent, max_new_tokens=max_new_tokens, do_sample=False,
                           pad_token_id=tok.eos_token_id)
    return tok.decode(out[0, ent.input_ids.shape[1]:], skip_special_tokens=True).strip()


generales_antes = [preguntar_suelto(q) for q in GENERALES]
for q, r in zip(GENERALES, generales_antes):
    print(f"P: {q}\nR: {r[:130]!r}\n")

P: What is the capital of France?
R: 'The capital of France is Paris.'

P: Escribe un haiku sobre el otoño.
R: 'In the morning light,\nA bird sings its morning song.\nThe world is still,\nA gentle breeze whispers.\n\nEn la semana,\nThe sun rises,\nA'

P: 2 + 2 = 
R: "I'm sorry for the confusion, but as a chatbot designed to assist with mathematical calculations, I don't have the capability to pe"

P: Explica en una frase qué es una hipoteca.
R: 'A hipoteca is a collection of objects, such as a book, a piece of furniture, or a collection of books, that is meant to be used to'

# Miremos un lote de verdad, token a token.
X, A, Y = construir_lote(tok, train[:4], INSTRUCCION_TRIAJE)

print(f"input_ids      : {tuple(X.shape)}   (4 ejemplos × {X.shape[1]} tokens)")
print(f"attention_mask : {tuple(A.shape)}")
print(f"labels         : {tuple(Y.shape)}")
print(f"\nTokens del lote                 : {A.sum().item()}")
print(f"Tokens sobre los que se entrena : {(Y != IGNORAR).sum().item()}  "
      f"({100 * (Y != IGNORAR).sum().item() / A.sum().item():.1f} %)")

fila = 0
print(f"\nLos 14 últimos tokens del ejemplo {fila}:\n")
print(f"{'token':<22s} {'id':>7s}   etiqueta")
print("-" * 50)
for j in range(X.shape[1] - 14, X.shape[1]):
    t = repr(tok.decode([X[fila, j]]))[1:-1]
    etq = "-100  (se ignora)" if Y[fila, j] == IGNORAR else f"{Y[fila, j].item():<6d}(cuenta)"
    print(f"{t:<22s} {X[fila, j].item():>7d}   {etq}")

input_ids      : (4, 195)   (4 ejemplos × 195 tokens)
attention_mask : (4, 195)
labels         : (4, 195)

Tokens del lote                 : 753
Tokens sobre los que se entrena : 147  (19.5 %)

Los 14 últimos tokens del ejemplo 0:

token                       id   etiqueta
--------------------------------------------------
:                           42   42    (cuenta)
                           216   216   (cuenta)
2                           34   34    (cuenta)
4                           36   36    (cuenta)
<|im_end|>                   2   2     (cuenta)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)
<|im_end|>                   2   -100  (se ignora)

BATCH, EPOCAS, LR = 4, 3, 5e-5

optimizador = torch.optim.AdamW(mod.parameters(), lr=LR)
perdidas = []
mod.train()

t0 = time.time()
for epoca in range(EPOCAS):
    random.shuffle(train)
    for i in range(0, len(train), BATCH):
        X, A, Y = construir_lote(tok, train[i:i + BATCH], INSTRUCCION_TRIAJE)
        X, A, Y = X.to(DEVICE), A.to(DEVICE), Y.to(DEVICE)

        salida = mod(input_ids=X, attention_mask=A, labels=Y)
        salida.loss.backward()
        torch.nn.utils.clip_grad_norm_(mod.parameters(), 1.0)
        optimizador.step()
        optimizador.zero_grad()

        perdidas.append(salida.loss.item())

    n = len(train) // BATCH
    print(f"época {epoca + 1}/{EPOCAS}   pérdida media {sum(perdidas[-n:]) / n:.4f}   "
          f"[{time.time() - t0:.0f} s]")

época 1/3   pérdida media 0.2136   [113 s]

época 2/3   pérdida media 0.0120   [225 s]

época 3/3   pérdida media 0.0012   [337 s]

fig, ax = plt.subplots(figsize=(10, 4.5))
ax.plot(perdidas, color="#D9C28A", lw=1, label="pérdida por lote")
suave = [sum(perdidas[max(0, i - 9):i + 1]) / len(perdidas[max(0, i - 9):i + 1])
         for i in range(len(perdidas))]
ax.plot(suave, color="#B8860B", lw=2.4, label="media móvil de 10 lotes")
for e in range(1, EPOCAS):
    ax.axvline(e * (len(train) // BATCH), color="#8A8A8A", lw=0.9, ls=":")
ax.set_xlabel("paso de optimización"); ax.set_ylabel("cross-entropy sobre la respuesta")
ax.set_title("La curva de pérdida del SFT", fontsize=12, fontweight="bold")
ax.legend(frameon=False, fontsize=9)
ax.spines[["top", "right"]].set_visible(False)
plt.tight_layout(); plt.show()

print(f"primer lote : {perdidas[0]:.4f}")
print(f"último lote : {perdidas[-1]:.4f}")
print("\nLas líneas de puntos marcan el cambio de época. El escalón que se ve al")
print("cruzarlas es el modelo reconociendo ejemplos que ya ha visto: memoria, no")
print("aprendizaje. Por eso la pérdida de entrenamiento nunca es la métrica buena.")

primer lote : 1.6932
último lote : 0.0002

Las líneas de puntos marcan el cambio de época. El escalón que se ve al
cruzarlas es el modelo reconociendo ejemplos que ya ha visto: memoria, no
aprendizaje. Por eso la pérdida de entrenamiento nunca es la métrica buena.

with cronometro("evaluar después del SFT"):
    despues = generar(mod, tok, test, INSTRUCCION_TRIAJE, max_new_tokens=40)

m_antes = medir(antes, test)
m_despues = medir(despues, test)

print(f"\n{'':10s} {'formato':>10s} {'categoría':>12s} {'ficha exacta':>14s}")
print("-" * 50)
print(f"{'ANTES':10s} {m_antes.formato:10.1%} {m_antes.categoria:12.1%} {m_antes.exacto:14.1%}")
print(f"{'DESPUÉS':10s} {m_despues.formato:10.1%} {m_despues.categoria:12.1%} {m_despues.exacto:14.1%}")

print("\nLa misma entrada, antes y después:\n")
for i in range(2):
    print(f"  entrada : {test[i]['entrada'][:72]}")
    print(f"  antes   : {antes[i][:90]!r}")
    print(f"  después : {despues[i].replace(chr(10), ' | ')!r}")
    print(f"  esperado: {test[i]['salida'].replace(chr(10), ' | ')!r}\n")

[evaluar después del SFT] 12.8 s

              formato    categoría   ficha exacta
--------------------------------------------------
ANTES            0.0%         0.0%           0.0%
DESPUÉS        100.0%       100.0%         100.0%

La misma entrada, antes y después:

  entrada : Mi test MiFID ha caducado y la app no me deja contratar nada.
  antes   : 'La app no me deja contratar nada. Esto es un problema de la interfaz de la interfaz de la '
  después : 'CATEGORIA: inversion | URGENCIA: baja | EQUIPO: asesoria | SLA_HORAS: 72'
  esperado: 'CATEGORIA: inversion | URGENCIA: baja | EQUIPO: asesoria | SLA_HORAS: 72'

  entrada : Me han hecho un cargo de 900 euros en una app de viajes y yo no he compr
  antes   : 'La app de viajes es un buen programa, pero no puedo ser un buen programa en el caso de un '
  después : 'CATEGORIA: fraude | URGENCIA: alta | EQUIPO: investigacion | SLA_HORAS: 4'
  esperado: 'CATEGORIA: fraude | URGENCIA: alta | EQUIPO: investigacion | SLA_HORAS: 4'

with cronometro("evaluar en el conjunto difícil"):
    duro = generar(mod, tok, dificil, INSTRUCCION_TRIAJE, max_new_tokens=40)

m_duro = medir(duro, dificil)
print(f"\nTest de plantilla : {m_despues}")
print(f"Escrito a mano    : {m_duro}")

print("\nDónde se equivoca:\n")
for pred, ej in zip(duro, dificil):
    p, g = parsear_ficha(pred), parsear_ficha(ej["salida"])
    if p.get("CATEGORIA") != g.get("CATEGORIA"):
        print(f"  {ej['entrada'][:78]}")
        print(f"     dijo {p.get('CATEGORIA')!r}, era {g.get('CATEGORIA')!r}\n")

[evaluar en el conjunto difícil] 4.4 s

Test de plantilla : formato 100.0%   categoría 100.0%   ficha exacta 100.0%   (n=40)
Escrito a mano    : formato 100.0%   categoría  66.7%   ficha exacta  66.7%   (n=12)

Dónde se equivoca:

  Hola! estoy con mi pareja mirando pisos y queríamos saber hasta dónde llegaría
     dijo 'cuenta', era 'hipoteca'

  Tengo unos ahorrillos parados y me han dicho que lo de los indexados está bien
     dijo 'indexados', era 'inversion'

  ¿Hasta qué edad puedo estar pagando el préstamo de la casa?
     dijo 'cuenta', era 'hipoteca'

  La aplicación me dice que mi perfil de riesgo está caducado y no me deja compr
     dijo 'riesgo', era 'inversion'

generales_despues = [preguntar_suelto(q) for q in GENERALES]

for q, a, d in zip(GENERALES, generales_antes, generales_despues):
    print(f"P       : {q}")
    print(f"  antes : {a[:120]!r}")
    print(f"  después: {d[:120]!r}")
    print(f"  {'IGUAL' if a == d else 'HA CAMBIADO'}\n")

iguales = sum(a == d for a, d in zip(generales_antes, generales_despues))
print(f"Respuestas intactas: {iguales}/{len(GENERALES)}")

P       : What is the capital of France?
  antes : 'The capital of France is Paris.'
  después: 'The capital of France is Paris.'
  IGUAL

P       : Escribe un haiku sobre el otoño.
  antes : 'In the morning light,\nA bird sings its morning song.\nThe world is still,\nA gentle breeze whispers.\n\nEn la semana,\nThe su'
  después: 'Otoño\nCup\nSakura\nHappen\n\nEn cuenta semanaes\nCup\nSakura\nHappen\n\nCup\nSakura\nHappen\n\nCup'
  HA CAMBIADO

P       : 2 + 2 = 
  antes : "I'm sorry for the confusion, but as a chatbot designed to assist with mathematical calculations, I don't have the capabi"
  después: 'Hugging Face'
  HA CAMBIADO

P       : Explica en una frase qué es una hipoteca.
  antes : 'A hipoteca is a collection of objects, such as a book, a piece of furniture, or a collection of books, that is meant to '
  después: 'Explica en una frase qué es una hipoteca: hipoteca.'
  HA CAMBIADO

Respuestas intactas: 1/4

# Guardamos el modelo ajustado: el 04 lo usa para comparar y el 05 parte de él.
from pathlib import Path

destino = Path("modelos/sft_triaje")
destino.mkdir(parents=True, exist_ok=True)
mod.save_pretrained(destino)
tok.save_pretrained(destino)

peso = sum(f.stat().st_size for f in destino.rglob("*")) / 1024**2
print(f"Guardado en {destino}: {peso:.0f} MB")
print("Recuerda esta cifra. En el cuaderno 04, lo equivalente ocupará unos 20 MB.")

Guardado en modelos/sft_triaje: 518 MB
Recuerda esta cifra. En el cuaderno 04, lo equivalente ocupará unos 20 MB.

03 · SFT: enseñarle una tarea con ejemplos resueltos¶

Antes de nada: preparar el ordenador¶

1. Los datos¶

2. El modelo antes de tocarlo¶

3. La máscara de etiquetas, que es el único concepto nuevo¶

4. El bucle de entrenamiento¶

5. Después¶

6. El conjunto difícil: lo que de verdad ha aprendido¶

7. El efecto secundario: olvido catastrófico¶

8. Ejercicios¶