{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "# Ver lo que aprende una representación — cuaderno de exploración\n\nUna imagen puede perder píxeles sin perder su estructura. ¿Aprender a recuperar\nlo que falta produce una representación útil con pocas etiquetas?\n\nLas imágenes y los puntos son **sintéticos**, creados aquí (CC0-1.0). Este\nexperimento usa CPU y no descarga nada. Entrena redes pequeñas desde cero; no\nreproduce un encoder preentrenado ni una tarea IOAI. Las figuras son resultados\nde tu ejecución. Cambia una condición y mira qué explicación sobrevive.\n",
   "id": "08-i-00"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "from pathlib import Path\nimport json\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\ntorch.set_num_threads(1)\ntorch.manual_seed(23)\nrng = np.random.default_rng(23)\nplt.rcParams.update({'figure.figsize': (10, 3), 'axes.spines.top': False,\n                     'axes.spines.right': False, 'font.size': 10})\n",
   "id": "08-i-01"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "ocultar = 0.4\nepocas = 65\npasos_gan = 450\n",
   "id": "08-i-02"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "def imagenes(n, ruido=0.14, semilla=0):\n    r = np.random.default_rng(semilla)\n    yy, xx = np.mgrid[:16, :16]\n    etiquetas = r.integers(0, 2, n)\n    imagenes = []\n    for clase in etiquetas:\n        centro = r.uniform(4, 11)\n        coordenada = yy if clase == 0 else xx\n        barra = np.exp(-((coordenada - centro) / 1.5) ** 2)\n        imagenes.append(np.clip(barra + r.normal(0, ruido, (16, 16)), 0, 1))\n    return np.asarray(imagenes, dtype=np.float32), etiquetas\n\ntrain, y_train = imagenes(384, semilla=0)\nval, y_val = imagenes(192, semilla=1)\ntransfer, y_transfer = imagenes(192, ruido=.32, semilla=2)\nX = torch.from_numpy(train.reshape(-1, 256))\nV = torch.from_numpy(val.reshape(-1, 256))\nT = torch.from_numpy(transfer.reshape(-1, 256))\nfig, axes = plt.subplots(1, 8, figsize=(12, 2))\nfor ax, im, y in zip(axes, train, y_train):\n    ax.imshow(im, cmap='magma', vmin=0, vmax=1)\n    ax.set_title('horizontal' if y == 0 else 'vertical', fontsize=9)\n    ax.axis('off')\nplt.show()\n",
   "id": "08-i-03"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## Aprender sin las etiquetas\n\nOcultamos píxeles y pedimos reconstruir la imagen completa. Un vector de ocho\nnúmeros debe transportar lo aprendido. La referencia trivial es la imagen media\nde train; la comparación usa imágenes nuevas y una máscara fija.\n",
   "id": "08-i-04"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "# Un autoencoder aprende a reconstruir lo que ocultamos de cada imagen.\n# Las etiquetas de orientación no participan en este entrenamiento.\nencoder = nn.Sequential(nn.Linear(256, 48), nn.ReLU(), nn.Linear(48, 8))\ndecoder = nn.Sequential(nn.Linear(8, 48), nn.ReLU(), nn.Linear(48, 256), nn.Sigmoid())\nautoencoder = nn.Sequential(encoder, decoder)\nopt = torch.optim.Adam(autoencoder.parameters(), lr=.004)\ncurva = []\nfor epoca in range(epocas):\n    perdidas = []\n    for indices in torch.randperm(len(X)).split(64):\n        limpio = X[indices]\n        visible = (torch.rand_like(limpio) > ocultar).float()\n        reconstruido = autoencoder(limpio * visible)\n        perdida = F.mse_loss(reconstruido, limpio)\n        opt.zero_grad(); perdida.backward(); opt.step()\n        perdidas.append(perdida.item())\n    curva.append(float(np.mean(perdidas)))\n\nautoencoder.eval()\n# Máscaras fijas para que la comparación no cambie al redibujar la figura.\ng = torch.Generator().manual_seed(91)\nmascara_val = (torch.rand(V.shape, generator=g) > ocultar).float()\nmascara_transfer = (torch.rand(T.shape, generator=g) > ocultar).float()\nwith torch.inference_mode():\n    reconstruido = autoencoder(V * mascara_val)\n    reconstruido_transfer = autoencoder(T * mascara_transfer)\n    media_train = X.mean(0).expand_as(V)\n    base_mse = F.mse_loss(media_train, V).item()\n    val_mse = F.mse_loss(reconstruido, V).item()\n    transfer_mse = F.mse_loss(reconstruido_transfer, T).item()\n\n# Guardas del material: el caso de referencia debe aprender, no solo ejecutar.\nassert reconstruido.shape == V.shape\nassert torch.isfinite(reconstruido).all() and torch.isfinite(reconstruido_transfer).all()\nif epocas == 65 and ocultar in (.4, .6):\n    assert val_mse < base_mse * .5, 'La reconstrucción no aprendió el caso de referencia'\n    assert curva[-1] < curva[0] * .5, 'La pérdida no descendió en el caso de referencia'\n\nfig, axes = plt.subplots(3, 6, figsize=(10, 5))\nfor col in range(6):\n    for fila, datos in enumerate((V, V * mascara_val, reconstruido)):\n        axes[fila, col].imshow(datos[col].reshape(16, 16), cmap='magma', vmin=0, vmax=1)\n        axes[fila, col].set_xticks([]); axes[fila, col].set_yticks([])\nfor ax, titulo in zip(axes[:, 0], ['Original', 'Entrada incompleta', 'Reconstrucción']):\n    ax.set_ylabel(titulo)\nfig.tight_layout(); plt.show()\nprint({'MSE imagen media de train': round(base_mse, 4),\n       'MSE reconstrucción': round(val_mse, 4),\n       'MSE con más ruido': round(transfer_mse, 4)})\nplt.plot(curva); plt.xlabel('Época'); plt.ylabel('MSE de reconstrucción'); plt.show()\n",
   "id": "08-i-05"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## ¿Reconstruir es lo mismo que entender?\n\nDamos al clasificador solo 24 etiquetas. Compara píxeles y representación con el\nmismo split. No hay una garantía de que la representación gane: la geometría de\nlos datos, el objetivo y el ruido importan. Cambia el ancho del cuello y observa\nsi mejora reconstrucción, clasificación, ambas o ninguna.\n",
   "id": "08-i-06"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "from sklearn.linear_model import LogisticRegression\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.metrics import accuracy_score\n\nwith torch.inference_mode():\n    z_train = encoder(X).numpy()\n    z_val = encoder(V).numpy()\n    z_transfer = encoder(T).numpy()\n# Etiquetamos solo 24 imágenes. Son un subconjunto fijo de train.\netiquetados = np.r_[np.flatnonzero(y_train == 0)[:12], np.flatnonzero(y_train == 1)[:12]]\nsondas = {}\nfor nombre, a, b, c in [\n    ('Píxeles', X.numpy(), V.numpy(), T.numpy()),\n    ('Representación aprendida', z_train, z_val, z_transfer),\n]:\n    sonda = make_pipeline(StandardScaler(), LogisticRegression(C=.1, max_iter=1000, random_state=0))\n    sonda.fit(a[etiquetados], y_train[etiquetados])\n    sondas[nombre] = [accuracy_score(y_val, sonda.predict(b)),\n                     accuracy_score(y_transfer, sonda.predict(c))]\nfig, ax = plt.subplots(figsize=(8, 3))\nx = np.arange(len(sondas))\nax.bar(x-.15, [v[0] for v in sondas.values()], width=.3, label='Validación')\nax.bar(x+.15, [v[1] for v in sondas.values()], width=.3, label='Más ruido')\nax.set_xticks(x, sondas.keys()); ax.set_ylim(0, 1.05); ax.set_ylabel('Accuracy')\nax.legend(); plt.show()\n",
   "id": "08-i-07"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## Un generador que tiene que inventar\n\nUna GAN enfrenta dos redes: G produce puntos y D distingue reales de generados.\nLos cuatro grupos son fáciles de ver; por eso aquí se puede detectar un colapso\nque una pérdida promedio escondería. Se mantienen los mismos latentes antes y\ndespués. El entrenamiento puede cubrir los cuatro modos o concentrarse en unos\npocos: ese comportamiento es parte del experimento.\n",
   "id": "08-i-08"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "# El segundo experimento es una GAN diminuta sobre puntos 2D, no un modelo de imágenes.\ndef reales(n):\n    centros = torch.tensor([[-1., -1.], [-1., 1.], [1., -1.], [1., 1.]])\n    return centros[torch.randint(4, (n,))] + .18 * torch.randn(n, 2)\n\nG = nn.Sequential(nn.Linear(2, 32), nn.Tanh(), nn.Linear(32, 32), nn.Tanh(), nn.Linear(32, 2))\nD = nn.Sequential(nn.Linear(2, 32), nn.LeakyReLU(.2), nn.Linear(32, 32), nn.LeakyReLU(.2), nn.Linear(32, 1))\nopt_g = torch.optim.Adam(G.parameters(), lr=.001, betas=(.5, .999))\nopt_d = torch.optim.Adam(D.parameters(), lr=.001, betas=(.5, .999))\nz_fijo = torch.randn(512, 2)\nwith torch.inference_mode(): antes = G(z_fijo).numpy()\n\ndef copiar_pesos(red):\n    return [p.detach().clone() for p in red.parameters()]\n\ndef mismos_pesos(red, copia):\n    return all(torch.equal(p.detach(), anterior) for p, anterior in zip(red.parameters(), copia))\n\nfor paso in range(pasos_gan):\n    g_antes_d = copiar_pesos(G)\n    d_antes_d = copiar_pesos(D)\n    for p in D.parameters(): p.requires_grad_(True)\n    r = reales(128); falso = G(torch.randn(128, 2)).detach()\n    loss_d = F.binary_cross_entropy_with_logits(D(r), torch.ones(128, 1)) + F.binary_cross_entropy_with_logits(D(falso), torch.zeros(128, 1))\n    opt_d.zero_grad(); loss_d.backward(); opt_d.step()\n    assert mismos_pesos(G, g_antes_d), 'El paso de D modificó G'\n    if paso == 0:\n        assert not mismos_pesos(D, d_antes_d), 'El primer paso de D no aprendió'\n    d_antes_g = copiar_pesos(D)\n    # D deja pasar el gradiente hacia G, pero sus pesos no se actualizan.\n    for p in D.parameters(): p.requires_grad_(False)\n    loss_g = F.binary_cross_entropy_with_logits(D(G(torch.randn(128, 2))), torch.ones(128, 1))\n    opt_g.zero_grad(); loss_g.backward(); opt_g.step()\n    assert mismos_pesos(D, d_antes_g), 'El paso de G modificó D'\n    if paso == 0:\n        assert not mismos_pesos(G, g_antes_d), 'El primer paso de G no aprendió'\n    assert torch.isfinite(loss_d) and torch.isfinite(loss_g)\nwith torch.inference_mode(): despues = G(z_fijo).numpy()\nassert np.isfinite(antes).all() and np.isfinite(despues).all()\nif pasos_gan > 0:\n    assert not np.array_equal(antes, despues), 'El generador no cambió sus salidas'\nfig, axes = plt.subplots(1, 3, figsize=(11, 3.5))\nfor ax, datos, titulo in zip(axes, (reales(512).numpy(), antes, despues), ('Distribución real', 'G antes', 'G después')):\n    ax.scatter(*datos.T, s=6, alpha=.4)\n    ax.set(xlim=(-2, 2), ylim=(-2, 2), title=titulo, aspect='equal')\nplt.show()\n# Diversidad: cuentas por cuadrante. Una pérdida pequeña no garantiza cuatro modos.\ncuadrante = (despues[:, 0] > 0).astype(int) + 2 * (despues[:, 1] > 0).astype(int)\nprint('Muestras por cuadrante:', np.bincount(cuadrante, minlength=4).tolist())\n",
   "id": "08-i-09"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "¿Puedes reducir la pérdida del autoencoder y empeorar la clasificación?\n¿Puedes obtener puntos plausibles con la GAN que cubran solo un grupo? Cambia el\nruido, el cuello o la tasa de aprendizaje y compara las figuras; conserva una\nsola condición distinta para entender qué produjo el cambio.\n",
   "id": "08-i-10"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "El archivo siguiente es un resumen técnico para verificar el cuaderno automáticamente; no hay un formulario que completar.\n",
   "id": "08-i-11"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "resultado = {'laboratorio': '08_vision', 'version': 'cuaderno de exploración',\n             'metrica': 'MSE de reconstrucción, menor es mejor', 'split': '384 imágenes train, 192 validación independiente, 192 transferencia con más ruido',\n             'baseline': base_mse, 'validacion': val_mse, 'transferencia': transfer_mse}\nassert all(np.isfinite(resultado[k]) for k in ('baseline', 'validacion', 'transferencia'))\nPath('resultado.json').write_text(json.dumps(resultado, ensure_ascii=False, indent=2) + '\\n')\n",
   "id": "08-i-12"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
