{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "# 06 · Qué aprende un bucle de entrenamiento\n\nUn modelo de una sola recta permite observar el entrenamiento sin esconderlo\ndetrás de una arquitectura. Cambia el learning rate, el número de épocas o\nel tamaño de lote y mira qué cambia en las curvas.\n\nEsta referencia entrena la recta.\n`solucion.ipynb` contiene una referencia separada para contrastar tu experimento.\nLas piezas de extracción y acumulación son las mismas que la ruta somete a\npruebas. Aquí puedes mirar sus efectos sobre un problema completo.\n\nDatos sintéticos CC0-1.0, generados con semilla fija en el notebook. CPU,\nsin descargas. Preparación: entorno de estudio con PyTorch y matplotlib.\n60–90 minutos de exploración, sin límite de juez; no es una duración validada con estudiantes.\n",
   "id": "06-s-00"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "from pathlib import Path\nimport json\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom torch.utils.data import DataLoader, TensorDataset\nimport matplotlib.pyplot as plt\n\ntorch.set_num_threads(1)\ng = torch.Generator().manual_seed(23)\ndef muestras(n, amplitud):\n    x = (torch.rand(n, 1, generator=g) * 2 - 1) * amplitud\n    y = 2 * x + 1 + 0.06 * torch.randn(n, 1, generator=g)\n    return x, y\nX_train, y_train = muestras(80, 1.)\nX_val, y_val = muestras(40, 1.)\nX_nuevo, y_nuevo = muestras(40, 1.5)\n\nplt.scatter(X_train[:, 0], y_train[:, 0], s=15, label=\"train\")\nplt.scatter(X_val[:, 0], y_val[:, 0], s=15, label=\"validación\")\nplt.xlabel(\"x\"); plt.ylabel(\"y\"); plt.legend(); plt.show()\n",
   "id": "06-s-01"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## Una época y un lote son decisiones distintas\n\nUn microbatch pequeño usa poca memoria. El optimizador puede dar un paso\ndespués de varios microbatches, ponderando cada ejemplo por igual. El último\ngrupo puede ser más corto: debe producir una actualización igualmente.\nEste ejemplo usa MSE media y no contiene dropout ni BatchNorm.\n",
   "id": "06-s-02"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "# bloque: probado; id: acumulacion\ndef entrenar_con_acumulacion(modelo, cargador, optimizador, perdida,\n                             acumular=4, dispositivo=\"cpu\"):\n    if not isinstance(acumular, int) or acumular < 1:\n        raise ValueError(\"acumular debe ser un entero positivo\")\n    modelo.train()  # mover el modelo ANTES de crear el optimizador\n    optimizador.zero_grad(set_to_none=True)\n    muestras, microbatches, pasos = 0, 0, 0\n\n    def actualizar(n):\n        for p in modelo.parameters():\n            if p.grad is not None:\n                p.grad.div_(n)       # media del lote efectivo, por muestras\n        optimizador.step()\n        optimizador.zero_grad(set_to_none=True)\n\n    for X, y in cargador:\n        if len(X) == 0:\n            raise ValueError(\"un microbatch no puede estar vacío\")\n        X, y = X.to(dispositivo), y.to(dispositivo)\n        (perdida(modelo(X), y) * len(X)).backward()\n        muestras += len(X)\n        microbatches += 1\n        if microbatches == acumular:\n            actualizar(muestras)\n            muestras, microbatches = 0, 0\n            pasos += 1\n    if muestras:                    # cola, incluso si hay menos de 4 lotes\n        actualizar(muestras)\n        pasos += 1\n    return pasos\n",
   "id": "06-s-03"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "class EarlyStopping:\n    \"\"\"Corta el entrenamiento cuando la validación deja de mejorar.\n\n    `paciencia` es cuántas épocas sin mejora se toleran antes de parar. En la\n    IOAI no es solo una defensa contra el sobreajuste: es una defensa contra el\n    reloj, porque el límite de tiempo cubre también la re-ejecución del\n    notebook sobre los datos ocultos.\n    \"\"\"\n\n    def __init__(self, paciencia=3, minima_mejora=0.0, modo=\"min\"):\n        self.paciencia = paciencia\n        self.minima_mejora = minima_mejora\n        self.signo = 1.0 if modo == \"min\" else -1.0\n        self.mejor = None\n        self.sin_mejorar = 0\n        self.mejor_epoca = -1\n        self.epoca = -1\n\n    def paso(self, valor):\n        \"\"\"Registra el valor de una época. Devuelve True si hay que parar.\"\"\"\n        self.epoca += 1\n        v = self.signo * valor\n        if self.mejor is None or v < self.mejor - self.minima_mejora:\n            self.mejor = v\n            self.mejor_epoca = self.epoca\n            self.sin_mejorar = 0\n        else:\n            self.sin_mejorar += 1\n        return self.sin_mejorar >= self.paciencia\n",
   "id": "06-s-04"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## La pérdida elige el checkpoint\n\nGuarda el estado después de registrar la pérdida de esta época. La curva\nroja puede dejar de mejorar antes que la azul: observa qué pesos conserva\nel entrenamiento. Prueba también un learning rate alto para ver oscilar\nla recta. El bloque termina restaurando la mejor validación observada.\n",
   "id": "06-s-05"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "EPOCAS = 80\nLR = 0.03\nMICROBATCH = 13\nACUMULAR = 4\n",
   "id": "06-s-06"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "torch.manual_seed(7)\nmodelo = nn.Linear(1, 1)\noptimizador = torch.optim.SGD(modelo.parameters(), lr=LR)\ncargador = DataLoader(TensorDataset(X_train, y_train), batch_size=MICROBATCH,\n                     shuffle=True, generator=torch.Generator().manual_seed(0))\nwith torch.no_grad():\n    baseline = (modelo(X_val) - y_val).abs().mean().item()\nparada = EarlyStopping(paciencia=8)\nmejor = {k: v.detach().clone() for k, v in modelo.state_dict().items()}\nhistorial, actualizaciones = [], []\nfor epoca in range(EPOCAS):\n    pasos = entrenar_con_acumulacion(modelo, cargador, optimizador, nn.MSELoss(),\n                                     acumular=ACUMULAR)\n    modelo.eval()\n    with torch.no_grad():\n        error_train = (modelo(X_train) - y_train).abs().mean().item()\n        error_val = (modelo(X_val) - y_val).abs().mean().item()\n    historial.append((error_train, error_val))\n    actualizaciones.append(pasos)\n    detener = parada.paso(error_val)\n    if parada.mejor_epoca == parada.epoca:\n        mejor = {k: v.detach().clone() for k, v in modelo.state_dict().items()}\n    if detener:\n        break\nmodelo.load_state_dict(mejor)\nmodelo.eval()\nwith torch.no_grad():\n    error_val = (modelo(X_val) - y_val).abs().mean().item()\n    error_nuevo = (modelo(X_nuevo) - y_nuevo).abs().mean().item()\nresultado = {\"baseline\": baseline, \"validacion\": error_val,\n             \"transferencia\": error_nuevo, \"mejor_epoca\": parada.mejor_epoca,\n             \"actualizaciones_por_epoca\": actualizaciones}\n\nfig, ejes = plt.subplots(1, 2, figsize=(10, 3.5))\nif historial:\n    curvas = np.asarray(historial)\n    ejes[0].plot(curvas[:, 0], label=\"train\")\n    ejes[0].plot(curvas[:, 1], label=\"validación\")\n    ejes[0].axvline(parada.mejor_epoca, color=\"black\", linestyle=\"--\", label=\"checkpoint\")\nejes[0].axhline(baseline, color=\"gray\", linestyle=\":\", label=\"baseline\")\nejes[0].set(xlabel=\"época\", ylabel=\"MAE\"); ejes[0].legend()\nejes[1].scatter(X_nuevo[:, 0], y_nuevo[:, 0], s=15, label=\"transferencia\")\nrejilla = torch.linspace(-1.5, 1.5, 80).reshape(-1, 1)\nwith torch.no_grad():\n    ejes[1].plot(rejilla[:, 0], modelo(rejilla)[:, 0], color=\"red\", label=\"modelo\")\nejes[1].set(xlabel=\"x\", ylabel=\"y\"); ejes[1].legend()\nfig.tight_layout(); plt.show()\n",
   "id": "06-s-07"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## Un error de orden parece un problema del modelo\n\nEl encoder de este experimento es la identidad: entrega el propio x.\nUn cargador barajado devuelve las filas en otro orden. Al recoger sus\netiquetas juntas, la recta se conserva; al pegar etiquetas de un arreglo\nexterno, la señal parece desaparecer. En un encoder grande este error es\nmucho menos visible, pero tiene la misma causa.\n",
   "id": "06-s-08"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "# bloque: probado; id: extraer_embeddings\nimport torch\n\ndef extraer_embeddings(modelo, cargador, dispositivo=\"cpu\"):\n    modelo.to(dispositivo).eval()\n    vectores, etiquetas = [], []\n    with torch.no_grad():\n        for lote, y in cargador:\n            # Mover cada resultado a CPU evita acumular toda la tabla en VRAM.\n            vectores.append(modelo(lote.to(dispositivo)).detach().cpu())\n            etiquetas.append(y.detach().cpu())\n    if not vectores:\n        raise ValueError(\"el cargador no puede estar vacío\")\n    return torch.cat(vectores).numpy(), torch.cat(etiquetas).numpy()\n",
   "id": "06-s-09"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "extractor = nn.Identity()\ncargador_features = DataLoader(TensorDataset(X_train, y_train), batch_size=13,\n                              shuffle=True, generator=torch.Generator().manual_seed(3))\nV, etiquetas = extraer_embeddings(extractor, cargador_features)\nfig, ejes = plt.subplots(1, 2, figsize=(10, 3.5), sharex=True, sharey=True)\nejes[0].scatter(V[:, 0], etiquetas[:, 0], s=15)\nejes[0].set(title=\"Features y etiquetas recogidas juntas\", xlabel=\"feature\", ylabel=\"etiqueta\")\nejes[1].scatter(V[:, 0], y_train[:, 0], s=15)\nejes[1].set(title=\"Etiquetas externas: orden equivocado\", xlabel=\"feature\")\nfig.tight_layout(); plt.show()\n",
   "id": "06-s-10"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## Variantes que revelan el mecanismo\n\nCon 80 ejemplos y microbatches de 13, seis lotes tienen 13 muestras y el\núltimo tiene 2. ¿Cuántas actualizaciones aparecen por época al acumular\ncuatro lotes? Prueba luego un microbatch de 80.\n\nLa transferencia amplía el intervalo de x sin cambiar la regla generadora.\nImagina ahora una relación curva: una recta puede encajar bien dentro del\nintervalo y fallar al extrapolar. El éxito de esta transferencia no valida\ncualquier cambio de distribución.\n",
   "id": "06-s-11"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "assert resultado[\"validacion\"] < 0.15 and resultado[\"transferencia\"] < 0.15\nassert resultado[\"validacion\"] < resultado[\"baseline\"]\nassert all(pasos == 2 for pasos in actualizaciones)\nassert abs(modelo.weight.item() - 2) < 0.15\nassert abs(modelo.bias.item() - 1) < 0.15\nassert np.corrcoef(V[:, 0], etiquetas[:, 0])[0, 1] > 0.98\n",
   "id": "06-s-12"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "resultado.update({\"laboratorio\": '06_entrenamiento',\n                  \"version\": 'solución de referencia',\n                  \"metrica\": 'MAE en regresión sintética (menor es mejor)', \"split\": '80 train, 40 validación, 40 transferencia generados con semilla 23; transferencia amplía el intervalo de x'})\nPath(\"resultado.json\").write_text(json.dumps(resultado, ensure_ascii=False,\n                  indent=2, allow_nan=False) + \"\\n\", encoding=\"utf-8\")\nprint(json.dumps(resultado, ensure_ascii=False, indent=2))\n",
   "id": "06-s-13"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
