{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "# Siguiente token, frecuencia y contexto — solución comentada\n\n¿Qué convierte una lista de números en información? En texto importa qué token\npuede seguir; en audio, qué frecuencias están presentes. Los datos sintéticos de\neste cuaderno (CC0-1.0) permiten inspeccionar el mecanismo completo en CPU, sin\nred ni pesos externos. Un modelo de bigramas no es un Transformer y una FFT no\nes un encoder preentrenado: son modelos pequeños que dejan ver la idea.\n",
   "id": "09-s-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": "09-s-01"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "alpha = 0.1  # suavizado: nunca asignar probabilidad cero\n",
   "id": "09-s-02"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## Qué tan sorprendente resulta el siguiente token\n\nCada fila de la figura es una distribución de probabilidad. La pérdida mide\nsorpresa; su exponencial es perplejidad. El vocabulario se obtiene solo de train.\nLas frases de transferencia intercambian papeles y conservan palabras: permiten\nver qué estructura aprendió realmente este modelo.\n",
   "id": "09-s-03"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "# Un corpus mínimo permite ver todas las probabilidades, sin tokenizer opaco.\ncorpus_train = [\n    'el gato mira la luna', 'el gato mira el sol', 'el perro mira la luna',\n    'el perro busca la pelota', 'la niña busca el gato', 'la niña mira el sol',\n    'el niño busca la pelota', 'el niño mira la luna', 'la gata busca el sol',\n] * 8\ncorpus_val = ['la niña mira la luna', 'el gato busca la pelota', 'el perro mira el sol']\ncorpus_transfer = ['la luna mira el gato', 'la pelota busca el niño', 'el sol busca la niña']\nvocabulario = sorted(set(' '.join(corpus_train).split()) | {'<fin>', '<desconocido>'})\na_indice = {w: i for i, w in enumerate(vocabulario)}\ncontextos = ['<inicio>'] + vocabulario\ncontexto_a_indice = {w: i for i, w in enumerate(contextos)}\nconteos = np.zeros((len(contextos), len(vocabulario)), dtype=float)\n\ndef pares(frase):\n    tokens = [w if w in a_indice else '<desconocido>' for w in frase.split()]\n    return zip(['<inicio>'] + tokens, tokens + ['<fin>'])\nfor frase in corpus_train:\n    for anterior, siguiente in pares(frase):\n        conteos[contexto_a_indice[anterior], a_indice[siguiente]] += 1\nprobas = (conteos + alpha) / (conteos.sum(axis=1, keepdims=True) + alpha * len(vocabulario))\nassert np.allclose(probas.sum(axis=1), 1)\n\ndef perplejidad(frases, tabla):\n    sorpresas = [-np.log(tabla[contexto_a_indice[a], a_indice[b]])\n                 for frase in frases for a, b in pares(frase)]\n    return float(np.exp(np.mean(sorpresas)))\n\nuniforme = np.full_like(probas, 1 / len(vocabulario))\nbase_ppl = perplejidad(corpus_val, uniforme)\nval_ppl = perplejidad(corpus_val, probas)\ntransfer_ppl = perplejidad(corpus_transfer, probas)\nassert np.isclose(base_ppl, len(vocabulario))\n# Caso manual independiente: las cinco probabilidades observadas son\n# 1/4, 1/2, 1/8, 1/4, 1/2. Su producto es 2**-9 y la PPL es 2**(9/5).\nmanual = np.full_like(probas, 1 / len(vocabulario))\nfor contexto, siguiente, probabilidad in [('<inicio>', 'el', .25), ('gato', '<fin>', .125)]:\n    fila = manual[contexto_a_indice[contexto]]\n    fila[:] = (1 - probabilidad) / (len(vocabulario) - 1)\n    fila[a_indice[siguiente]] = probabilidad\nmanual[contexto_a_indice['el']] = 0\nmanual[contexto_a_indice['el'], a_indice['gato']] = .5\nmanual[contexto_a_indice['el'], a_indice['<fin>']] = .5\nassert np.allclose(manual.sum(axis=1), 1)\nassert np.isclose(perplejidad(['el gato', 'el'], manual), 2 ** (9 / 5))\nif alpha in (.1, .5):\n    assert val_ppl < base_ppl, 'El caso de referencia no supera la distribución uniforme'\nfig, ax = plt.subplots(figsize=(10, 6))\nim = ax.imshow(probas, cmap='magma', aspect='auto')\nax.set_xticks(range(len(vocabulario)), vocabulario, rotation=65, ha='right')\nax.set_yticks(range(len(contextos)), contextos)\nax.set(xlabel='Siguiente token', ylabel='Token anterior', title='Qué espera el modelo')\nfig.colorbar(im, ax=ax, label='Probabilidad'); fig.tight_layout(); plt.show()\nplt.bar(['Uniforme', 'Validación', 'Frases invertidas'], [base_ppl, val_ppl, transfer_ppl])\nplt.ylabel('Perplejidad (menor es mejor)'); plt.show()\nprint({'uniforme': round(base_ppl, 3), 'validación': round(val_ppl, 3),\n       'transferencia': round(transfer_ppl, 3)})\n",
   "id": "09-s-04"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "Un bigrama solo recuerda un token. Una Transformer causal puede usar un\ncontexto mayor, pero debe ocultar el futuro. El score de siguiente token no mide\npor sí solo veracidad ni coherencia: mira qué frases invertidas reciben una\nprobabilidad alta por compartir transiciones locales.\n",
   "id": "09-s-05"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## La misma señal, otra representación\n\nLas dos clases tienen frecuencias distintas y fases aleatorias. Sus ondas pueden\nparecer diferentes aun dentro de la misma clase; el espectro hace visible lo que\npermanece. Cada grabación entera pertenece a un único split, sin ventanas\nsolapadas compartidas. El remuestreo conserva duración y cambia el número de\nmuestras; etiquetar la tasa de otra manera no hace esa transformación.\n",
   "id": "09-s-06"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "from scipy.signal import resample_poly\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.metrics import accuracy_score\n\nfs = 4000\n\ndef grabaciones(n, semilla, ruido=.3):\n    r = np.random.default_rng(semilla)\n    etiquetas = np.arange(n) % 2\n    r.shuffle(etiquetas)\n    tiempo = np.arange(fs) / fs\n    ondas = []\n    for y in etiquetas:\n        frecuencia = 180 if y == 0 else 620\n        onda = np.sin(2*np.pi*frecuencia*tiempo + r.uniform(0, 2*np.pi))\n        ondas.append((onda + r.normal(0, ruido, fs)).astype(np.float32))\n    return np.array(ondas), etiquetas\n\nondas_train, ya = grabaciones(80, 0)\nondas_val, yb = grabaciones(40, 1)\nondas_transfer, yc = grabaciones(40, 2, ruido=.9)\nfrecuencias = np.fft.rfftfreq(fs, d=1/fs)\nfig, axes = plt.subplots(1, 2, figsize=(10, 3))\nfor i in [np.flatnonzero(ya == 0)[0], np.flatnonzero(ya == 1)[0]]:\n    onda, y = ondas_train[i], ya[i]\n    axes[0].plot(np.arange(100)/fs, onda[:100], alpha=.7, label=f'Clase {y}')\n    axes[1].plot(frecuencias, np.abs(np.fft.rfft(onda))/fs, alpha=.7)\naxes[0].set(xlabel='Segundos', ylabel='Amplitud'); axes[0].legend()\naxes[1].set(xlabel='Hz', ylabel='Magnitud / n', xlim=(0, 1000)); plt.show()\n\n# Remuestrear modifica los datos, no solo el número fs.\nremuestreada = resample_poly(ondas_val[0], up=1, down=2)\nfs_nueva = fs // 2\nassert np.isclose(len(remuestreada)/fs_nueva, len(ondas_val[0])/fs)\nf_nueva = np.fft.rfftfreq(len(remuestreada), d=1/fs_nueva)\npico = f_nueva[np.abs(np.fft.rfft(remuestreada))[1:].argmax()+1]\nassert abs(pico - (180 if yb[0] == 0 else 620)) <= 1\n\n# Se recogen features, etiquetas e IDs juntos incluso al barajar el recorrido.\ndef extraer(ondas, etiquetas, semilla):\n    filas, y, ids = [], [], []\n    for i in np.random.default_rng(semilla).permutation(len(ondas)):\n        onda = ondas[i]\n        espectro = np.abs(np.fft.rfft(onda)) / len(onda)\n        filas.append([espectro[(frecuencias > 150) & (frecuencias < 210)].sum(),\n                      espectro[(frecuencias > 590) & (frecuencias < 650)].sum()])\n        y.append(etiquetas[i]); ids.append(i)\n    return np.array(filas), np.array(y), np.array(ids)\nfa, la, ida = extraer(ondas_train, ya, 8)\nfb, lb, idb = extraer(ondas_val, yb, 9)\nfc, lc, idc = extraer(ondas_transfer, yc, 10)\nassert np.array_equal(lb, yb[idb])\nclf = make_pipeline(StandardScaler(), LogisticRegression(random_state=0))\nclf.fit(fa, la)\nclase_mayoritaria = np.bincount(la).argmax()\nbase_audio = accuracy_score(lb, np.full(lb.shape, clase_mayoritaria))\nval_audio = accuracy_score(lb, clf.predict(fb))\ntransfer_audio = accuracy_score(lc, clf.predict(fc))\nassert np.isfinite(fa).all() and np.isfinite(fb).all() and np.isfinite(fc).all()\nassert val_audio > base_audio + .3, 'Las features no separan las frecuencias del caso fijo'\nassert transfer_audio > .85, 'La clasificación perdió robustez al ruido del caso fijo'\nprint({'accuracy clase mayoritaria': base_audio, 'accuracy espectral': val_audio,\n       'accuracy con más ruido': transfer_audio})\nfig, ax = plt.subplots(figsize=(5, 3))\nax.scatter(fb[:, 0], fb[:, 1], c=lb, cmap='coolwarm')\nax.set(xlabel='Magnitud de banda baja', ylabel='Magnitud de banda alta'); plt.show()\n",
   "id": "09-s-07"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "## Lo que el padding puede esconder\n\nEl promedio de estados debe excluir posiciones que no representan audio. Un\nencoder puede submuestrear el tiempo: la longitud válida de su salida debe\ncalcularse con su arquitectura, no copiando la máscara de la onda.\n",
   "id": "09-s-08"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "# Un encoder puede acortar el eje temporal. La máscara debe vivir en SU salida.\n# Aquí los vectores son inventados para aislar el efecto del padding.\nestados = torch.tensor([[[2., 4.], [4., 2.], [0., 0.]],\n                        [[2., 4.], [4., 2.], [6., 6.]]])\nlongitudes_salida = torch.tensor([2, 3])\nmascara = torch.arange(3)[None, :] < longitudes_salida[:, None]\npooling_ingenuo = estados.mean(dim=1)\npooling_valido = (estados * mascara[..., None]).sum(1) / longitudes_salida[:, None]\nassert torch.allclose(pooling_valido[0], torch.tensor([3., 3.]))\nprint('Sin máscara:', pooling_ingenuo.numpy(), '\\nCon máscara:', pooling_valido.numpy())\n",
   "id": "09-s-09"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "El suavizado evita sorpresa infinita en transiciones nuevas, pero demasiado\nsuavizado acerca todas las filas a una distribución uniforme. Más contexto no\nsiempre es mejor con pocos datos. En audio, separar las fases de las frecuencias\nhace que un clasificador pequeño sea suficiente para este problema sintético.\nEso no demuestra que baste para voces o sonidos reales.\n\nCrea dos clases con el mismo espectro global y diferente orden temporal. La FFT\npromediada pierde esa diferencia: ahora una ventana, un espectrograma o un encoder\nsecuencial pueden aportar información que tu resumen descartó.\n",
   "id": "09-s-10"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "### Extensión con un encoder real, cuando estén preparados sus pesos\n\nEl material oficial de Find the Order incluye un ejemplo de\n`facebook/wav2vec2-base-960h` y permite usar el encoder de Whisper. Usa el notebook\noficial para preparar modelo y procesador, remuestrea a su tasa esperada y recoge\nIDs, etiquetas y vectores en el mismo recorrido. Las longitudes del pooling deben\ncorresponder a la salida del modelo. Compara contra la referencia espectral en el\nmismo split por grabación.\n\nEsta extensión no se ha ejecutado como parte de este cuaderno; requiere los\nactivos y el entorno del modelo. No sustituye pesos ausentes por aleatorios.\n[Ejemplo oficial](https://github.com/IOAI-official/IOAI-2026/blob/main/Individual-Contest/1_Find_the_Order/code/baseline-original/solution.ipynb).\n",
   "id": "09-s-11"
  },
  {
   "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": "09-s-12"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": "resultado = {'laboratorio': '09_lenguaje_audio', 'version': 'solución comentada',\n             'metrica': 'Perplejidad de siguiente token, menor es mejor', 'split': 'corpus train fijo; frases nuevas de validación; frases con papeles invertidos de transferencia',\n             'baseline': base_ppl, 'validacion': val_ppl, 'transferencia': transfer_ppl}\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": "09-s-13"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
