{"id":79,"date":"2026-02-21T23:02:05","date_gmt":"2026-02-21T23:02:05","guid":{"rendered":"https:\/\/pulki.es\/blog\/?p=79"},"modified":"2026-02-21T23:02:34","modified_gmt":"2026-02-21T23:02:34","slug":"large-language-model-llm-from-scratch-n-gram-language-models","status":"publish","type":"post","link":"https:\/\/pulki.es\/blog\/index.php\/2026\/02\/21\/large-language-model-llm-from-scratch-n-gram-language-models\/","title":{"rendered":"Large Language Model (LLM) from scratch. N-gram Language Models"},"content":{"rendered":"\n

En la entrada anterior vimos un ejemplo pr\u00e1ctico del algoritmo BPE. Entender esto es importante porque es la forma est\u00e1ndar en que las m\u00e1quinas descomponen un texto en una representaci\u00f3n que pueden manipular. Puesto que ahora sabemos hacerlo, el siguiente paso l\u00f3gico es emplear esos fragmentos (o tokens) de alguna manera, para as\u00ed generar texto elocuente.<\/p>\n\n\n\n

En este sentido, la estrategia m\u00e1s popular \u2014enfatizo: popular, no necesariamente mejor\u2014 para generar texto \u201cnuevo\u201d a partir de un contexto consiste en calcular la probabilidad de la siguiente palabra o token, condicional al contexto; es decir, P(siguiente palabra o token | contexto)<\/strong>. Si nos restringimos a esta estrategia, una manera pr\u00e1ctica de obtener esa probabilidad es usando n-gramas. No obstante, tambi\u00e9n se pueden usar redes neuronales \u2014que es lo que usa ChatGPT\u2014, entre otras alternativas.<\/p>\n\n\n\n

En este punto, el lector podr\u00eda estar pregunt\u00e1ndose: \u201c\u00bfPor qu\u00e9 aprender n-gramas si no es lo que utiliza ChatGPT?\u201d. La respuesta es simple: es un marco conceptual muy ilustrativo, que nos permitir\u00e1 aprender conceptos clave y, as\u00ed, avanzar hacia el uso de redes neuronales. Como es usual, emplearemos como referencia el cap\u00edtulo 3<\/strong> de Jurafsky y Martin, 2025<\/strong>. Dicho esto, empecemos!<\/p>\n\n\n\n

Language models<\/em><\/strong><\/p>\n\n\n\n

Un modelo de lenguaje (Language Model) es un modelo probabil\u00edstico que, dado un contexto, predice la siguiente palabra o token. Esta predicci\u00f3n se realiza construyendo una distribuci\u00f3n de probabilidad sobre las posibles siguientes palabras\/tokens. En t\u00e9rminos concretos, supongamos que tenemos el siguiente corpus:<\/p>\n\n\n\n

\n

Aqu\u00ed lleg\u00f3, donde otro no ha llegado,
don Alonso de Ercilla, que el primero
en un peque\u00f1o barco deslastrado,
con solos diez pas\u00f3 el desaguadero
el a\u00f1o de cincuenta y ocho entrado
sobre mil y quinientos, por hebrero,
a las dos de la tarde, el postrer d\u00eda,
volviendo a la dejada compa\u00f1\u00eda.<\/p>\n\n\n\n

La Araucana, Canto XXXVI.<\/em> Alonso de Ercilla.<\/em><\/p>\n<\/blockquote>\n\n\n\n

y queremos predecir la palabra que viene despu\u00e9s de la secuencia {a las dos de la}<\/strong>. Para eso, podemos calcular la distribuci\u00f3n de probabilidad sobre las siguientes palabras condicional a venir de la secuencia {a las dos de la}<\/strong>. Si, por ejemplo, estamos interesados en saber la probabilidad de que la palabra siguiente sea {tarde}<\/strong>, deber\u00edamos calcular P({tarde} | {a las dos de la})<\/strong>.<\/p>\n\n\n\n

En este punto, un lector \u00e1vido podr\u00eda preguntarse: \u00bfpor qu\u00e9 elegimos \u201ca las dos de la\u201d y no una secuencia m\u00e1s larga? El problema es que, en un corpus finito, cuanto m\u00e1s largo es el contexto, m\u00e1s raro se vuelve observar exactamente ese mismo contexto otra vez. En el extremo, si el contexto es demasiado largo, la estimaci\u00f3n se vuelve muy fr\u00e1gil: muchos contextos no aparecen nunca, y los que aparecen pocas veces producen distribuciones casi deterministas (una \u00fanica continuaci\u00f3n con probabilidad cercana a 1), lo que puede socavar la variedad del texto generado.
Por el contrario, si elegimos un contexto muy corto, perdemos coherencia: por ejemplo, incluso con un corpus grande, despu\u00e9s de \u201cy\u201d puede venir casi cualquier palabra. En fin, en t\u00e9rminos emp\u00edricos, el largo del contexto afecta de forma decisiva al resultado. Al escogerlo, el programador est\u00e1 imponiendo una estructura sobre c\u00f3mo \u201cdepende\u201d el siguiente token del pasado: en los modelos <\/strong>n-gram, esta idea se formaliza en la Markov assumption<\/strong>, seg\u00fan la cual la siguiente palabra depende solo de las \u00faltimas n<\/mi>\u2212<\/mo>1<\/mn><\/mrow>n-1<\/annotation><\/semantics><\/math> palabras del contexto (si quieres saber m\u00e1s sobre cadenas de Markov, puedes ver este video<\/a>).<\/p>\n\n\n\n

Espec\u00edficamente, cuando fijamos cu\u00e1ntos tokens usaremos como contexto, estamos eligiendo impl\u00edcitamente n<\/mi><\/mrow>n<\/annotation><\/semantics><\/math> en un modelo de n-gramas (ya que el contexto tiene tama\u00f1o n<\/mi>\u2212<\/mo>1<\/mn><\/mrow>n-1<\/annotation><\/semantics><\/math>). Por ejemplo, un modelo de bigramas<\/strong> asume que la probabilidad de la siguiente palabra depende \u00fanicamente de la palabra anterior (si tomamos cada token como una palabra).<\/p>\n\n\n\n

\u2119<\/mi>(<\/mo>{<\/mo>t<\/mi>a<\/mi>r<\/mi>d<\/mi>e<\/mi>}<\/mo>|<\/mi>{<\/mo>l<\/mi>a<\/mi>}<\/mo>)<\/mo><\/mrow>\\mathbb{P}(\\{tarde\\}|\\{la\\})<\/annotation><\/semantics><\/math>,<\/p>\n\n\n\n

por otra parte, un trigrama asume que la probabilidad de la siguiente palabra depende de las dos palabras que preceden a aquella,<\/p>\n\n\n\n

\u2119<\/mi>(<\/mo>{<\/mo>t<\/mi>a<\/mi>r<\/mi>d<\/mi>e<\/mi>}<\/mo>|<\/mi>{<\/mo>d<\/mi>e<\/mi> <\/mtext>l<\/mi>a<\/mi>}<\/mo>)<\/mo>.<\/mi><\/mrow>\\mathbb{P}(\\{tarde\\}|\\{de \\ la\\}).<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Dicho esto, ahora estamos en condiciones de estimar estas probabilidades.<\/p>\n\n\n\n

Estimando las probabilidades…<\/em><\/strong><\/p>\n\n\n\n

El m\u00e9todo est\u00e1ndar para estimar estas probabilidades es usar M\u00e1xima Verosimilitud. Por ejemplo, para el caso de un bigrama<\/strong>, para calcular la probabilidad de una palabra w<\/mi>n<\/mi><\/msub>w_{n}<\/annotation><\/semantics><\/math>, dada una palabra w<\/mi>n<\/mi>\u2212<\/mo>1<\/mn><\/mrow><\/msub>w_{n-1}<\/annotation><\/semantics><\/math>, llevamos a cabo el siguiente c\u00e1lculo,<\/p>\n\n\n\n
C<\/mi>(<\/mo>w<\/mi>n<\/mi>\u2212<\/mo>1<\/mn><\/mrow><\/msub>w<\/mi>n<\/mi><\/msub>)<\/mo><\/mrow>\u2211<\/mo>w<\/mi><\/msub>C<\/mi>(<\/mo>w<\/mi>n<\/mi>\u2212<\/mo>1<\/mn><\/mrow><\/msub>w<\/mi>)<\/mo><\/mrow><\/mfrac>.<\/mi><\/mrow>\\frac{C(w_{n-1}w_{n})}{\\sum_{w}C(w_{n-1}w)}.<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

El siguiente c\u00f3digo en Python calcula dicha frecuencia relativa empleando el Quijote de la Mancha de Miguel de Cervantes:<\/p>\n\n\n\n

import re\nfrom collections import Counter, defaultdict\nfrom typing import Dict, List, Tuple\nfrom pathlib import Path\n\nWORD_RE = re.compile(r\"[^\\W\\d_]+(?:[-'][^\\W\\d_]+)*\", re.UNICODE)\n\ndef tokenize_words(text: str, lowercase: bool = True) -> List[str]:\n    if lowercase:\n        text = text.lower()\n    return WORD_RE.findall(text)\n\ndef bigrams(tokens: List[str], add_start_end: bool = True) -> List[Tuple[str, str]]:\n    if add_start_end:\n        tokens = [\"<s>\"] + tokens + [\"<\/s>\"]\n    return list(zip(tokens[:-1], tokens[1:]))\n\ndef bigram_mle_words(text: str, lowercase: bool = True, add_start_end: bool = True):\n    toks = tokenize_words(text, lowercase=lowercase)\n    bi = bigrams(toks, add_start_end=add_start_end)\n\n    context_counts = Counter([w1 for (w1, w2) in bi])   # C(w_{i-1})\n    bigram_counts  = Counter(bi)                        # C(w_{i-1}, w_i)\n\n    probs: Dict[str, Dict[str, float]] = defaultdict(dict)\n    for (w1, w2), c12 in bigram_counts.items():\n        probs[w1][w2] = c12 \/ context_counts[w1]       # MLE\n\n    return {\"tokens\": toks, \"context_counts\": context_counts, \"bigram_counts\": bigram_counts, \"probs\": probs}\n\ndef top_next(probs: Dict[str, Dict[str, float]], prev: str, k: int = 10):\n    if prev not in probs:\n        return []\n    return sorted(probs[prev].items(), key=lambda x: x[1], reverse=True)[:k]\n\nif __name__ == \"__main__\":\n    path = Path(\"H:\\\\quijote.txt\") \n    text = path.read_text(encoding=\"utf-8\")\n    model = bigram_mle_words(text)\n    print(\"Tokens:\", model[\"tokens\"]) \n    print(\"Top despu\u00e9s de 'tropezando':\", top_next(model[\"probs\"], \"tropezando\", 5))<\/code><\/pre>\n\n\n\n
Al ejecutar el c\u00f3digo, podemos ver que la palabra \u00abtropezando\u00bb, aparece en cuatro oportunidades:
<\/p>\n\n\n\n
\n
dificultoso, tropezando<\/strong> aqu\u00ed, cayendo all\u00ed, levant\u00e1ndose acull\u00e1,<\/p>\n<\/blockquote>\n\n\n\n
y <\/p>\n\n\n\n
\n
resucitar la ya muerta andante caballer\u00eda, y ha muchos d\u00edas que, tropezando<\/strong> aqu\u00ed,<\/p>\n<\/blockquote>\n\n\n\n
y<\/p>\n\n\n\n
\n
y don Quijote, a gran priesa, tropezando<\/strong> aqu\u00ed y cayendo<\/p>\n<\/blockquote>\n\n\n\n
y, finalmente en<\/p>\n\n\n\n
\n
Quijote, van ya tropezando<\/strong>, y han de caer del todo, sin duda alguna. Vale.<\/p>\n<\/blockquote>\n\n\n\n
Entonces, \u2211<\/mo>w<\/mi><\/msub>C<\/mi>(<\/mo>{<\/mo>t<\/mi>r<\/mi>o<\/mi>p<\/mi>e<\/mi>z<\/mi>a<\/mi>n<\/mi>d<\/mi>o<\/mi>}<\/mo>{<\/mo>w<\/mi>}<\/mo>)<\/mo>=<\/mo>4<\/mn><\/mrow>\\sum_{w}C(\\{tropezando\\}\\{w\\}) = 4<\/annotation><\/semantics><\/math>, C<\/mi>(<\/mo>{<\/mo>t<\/mi>r<\/mi>o<\/mi>p<\/mi>e<\/mi>z<\/mi>a<\/mi>n<\/mi>d<\/mi>o<\/mi>}<\/mo>{<\/mo>a<\/mi>q<\/mi>u<\/mi>i<\/mi>}<\/mo>)<\/mo>=<\/mo>3<\/mn>,<\/mo><\/mrow>C(\\{tropezando\\}\\{aqui\\}) = 3, <\/annotation><\/semantics><\/math> y C<\/mi>(<\/mo>{<\/mo>t<\/mi>r<\/mi>o<\/mi>p<\/mi>e<\/mi>z<\/mi>a<\/mi>n<\/mi>d<\/mi>o<\/mi>}<\/mo>{<\/mo>y<\/mi>}<\/mo>)<\/mo>=<\/mo>1.<\/mn><\/mrow>C(\\{tropezando\\}\\{y\\}) = 1.<\/annotation><\/semantics><\/math> Luego, la probabilidad de que \u00abaqu\u00ed\u00bb sea la pr\u00f3xima palabra despu\u00e9s de \u00abtropezando\u00bb es 3<\/mn>4<\/mn><\/mfrac>\\frac{3}{4}<\/annotation><\/semantics><\/math> e \u00aby\u00bb, 1<\/mn>4<\/mn><\/mfrac>\\frac{1}{4}<\/annotation><\/semantics><\/math>, tal cual como la ejecuci\u00f3n del c\u00f3digo predice:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Tambi\u00e9n, con fines did\u00e1cticos podemos empezar con una palabra, y elegir las que exhiben la probabilidad m\u00e1s alta de ser las siguientes. A modo de ejemplo, si partimos con la palabra \u00abFaza\u00f1a\u00bb (gracias Aradia), la secuencia que generamos es:<\/p>\n\n\n\n
\n
Faza\u00f1a fue el cual se le dijo don quijote<\/p>\n<\/blockquote>\n\n\n\n
Donde las probabilidades son:<\/p>\n\n\n\n
Palabra<\/strong><\/td>Probabilidad<\/strong><\/td><\/tr>
Faza\u00f1a<\/td>–<\/td><\/tr>
fue<\/td>1<\/td><\/tr>
el<\/td>0.0998<\/td><\/tr>
cual<\/td>0.0343<\/td><\/tr>
se<\/td>0.0639<\/td><\/tr>
le<\/td>0.0677<\/td><\/tr>
dijo<\/td>0.0662<\/td><\/tr>
don<\/td>0.1648<\/td><\/tr>
quijote<\/td>0.8182<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Tambi\u00e9n, podemos calcular la probabilidad de esta frase como<\/p>\n\n\n\n
P<\/mi>(<\/mo>{<\/mo>F<\/mi>a<\/mi>z<\/mi>a<\/mi>n<\/mi>~<\/mo><\/mover>a<\/mi> <\/mtext>f<\/mi>u<\/mi>e<\/mi> <\/mtext>e<\/mi>l<\/mi> <\/mtext>c<\/mi>u<\/mi>a<\/mi>l<\/mi> <\/mtext>s<\/mi>e<\/mi> <\/mtext>l<\/mi>e<\/mi> <\/mtext>d<\/mi>i<\/mi>j<\/mi>o<\/mi> <\/mtext>d<\/mi>o<\/mi>n<\/mi> <\/mtext>q<\/mi>u<\/mi>i<\/mi>j<\/mi>o<\/mi>t<\/mi>e<\/mi>}<\/mo>)<\/mo>=<\/mo>1<\/mn>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>f<\/mi>u<\/mi>e<\/mi>}<\/mo>|<\/mi>{<\/mo>F<\/mi>a<\/mi>z<\/mi>a<\/mi>n<\/mi>~<\/mo><\/mover>a<\/mi>}<\/mo>)<\/mo>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>e<\/mi>l<\/mi>}<\/mo>|<\/mi>{<\/mo>f<\/mi>u<\/mi>e<\/mi>}<\/mo>)<\/mo>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>c<\/mi>u<\/mi>a<\/mi>l<\/mi>}<\/mo>|<\/mi>{<\/mo>e<\/mi>l<\/mi>}<\/mo>)<\/mo>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>s<\/mi>e<\/mi>}<\/mo>|<\/mi>{<\/mo>c<\/mi>u<\/mi>a<\/mi>l<\/mi>}<\/mo>)<\/mo>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>l<\/mi>e<\/mi>}<\/mo>|<\/mi>{<\/mo>s<\/mi>e<\/mi>}<\/mo>)<\/mo>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>d<\/mi>i<\/mi>j<\/mi>o<\/mi>}<\/mo>|<\/mi>{<\/mo>l<\/mi>e<\/mi>}<\/mo>)<\/mo>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>d<\/mi>o<\/mi>n<\/mi>}<\/mo>|<\/mi>{<\/mo>d<\/mi>i<\/mi>j<\/mi>o<\/mi>}<\/mo>)<\/mo>\u00d7<\/mo>P<\/mi>(<\/mo>{<\/mo>q<\/mi>u<\/mi>i<\/mi>j<\/mi>o<\/mi>t<\/mi>e<\/mi>}<\/mo>|<\/mi>{<\/mo>d<\/mi>o<\/mi>n<\/mi>}<\/mo>)<\/mo><\/mrow>P(\\{Faza\u00f1a \\ fue \\ el \\ cual \\ se \\ le  \\ dijo \\  don  \\ quijote\\}) = 1 \\times  P(\\{fue\\}|\\{Faza\u00f1a\\})\\times P(\\{el\\}|\\{fue\\})\\times P(\\{cual\\}|\\{el\\})\\times P(\\{se\\}|\\{cual\\}) \\times P(\\{le\\}|\\{se\\}) \\times P(\\{dijo\\}|\\{le\\}) \\times P(\\{don\\}|\\{dijo\\})\\times P(\\{quijote\\}|\\{don\\})<\/annotation><\/semantics><\/math><\/div>\n\n\n\n
cuyo valor viene dado por:<\/p>\n\n\n\n
0.00000013218703<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Como podemos ver, dicho valor es peque\u00f1o, al igual que el de las probabilidades condicionales. Cuando n<\/strong>, o nuestro modelo crece, las probabilidades pueden ser a\u00fan m\u00e1s peque\u00f1as, provocando un problema conocido como numerical underflow<\/strong><\/em>. Para evitarlo, usualmente se guardan las probabilidades en log, y luego, si queremos recuperar el n\u00famero original, s\u00f3lo debemos tomar el exponente. Este truco ser\u00e1 utilizado m\u00e1s adelante.<\/p>\n\n\n\n
Evaluando modelos de lenguaje<\/em><\/strong><\/p>\n\n\n\n
La mejor manera de evaluar modelos es mediante la evaluaci\u00f3n extr\u00ednseca<\/em><\/strong>. En t\u00e9rminos concretos, si por ejemplo, queremos evaluar que tan bueno es un autocomplete que estamos desarrollando, una evaluaci\u00f3n extr\u00ednseca ser\u00eda determinar el porcentaje de sugerencias que fueron aceptadas por el escritor. Debido a que esta evaluaci\u00f3n es costosa, usualmente se lleva a cabo otro m\u00e9todo llamado evaluaci\u00f3n intr\u00ednseca<\/em><\/strong>. Este tipo de evaluaci\u00f3n, mide un modelo por una m\u00e9trica interna que refleja qu\u00e9 tan bien cumple su objetivo directo, es decir, mide la calidad del modelo independiente de su aplicaci\u00f3n. Dentro de este tipo de evaluaciones, una popular es llamada perplexity<\/em><\/strong>. En la siguiente secci\u00f3n la veremos en detalle.<\/p>\n\n\n\n
Evaluaci\u00f3n intr\u00ednseca: Perplexity. <\/em><\/strong><\/p>\n\n\n\n
Volvamos al ejemplo del autocomplete<\/em>. Supongamos que entrenamos un modelo de bigramas con el texto del Quijote de la Mancha. Posteriormente, como es usual, evaluamos su eficacia en un texto de prueba. Si nuestro modelo predice mejor las siguientes palabras (o tokens) en ese conjunto, entonces estar\u00e1 \u201cmenos sorprendido\u201d cuando aparezca la palabra correcta, en comparaci\u00f3n con otro modelo. En el caso ideal, un autocomplete<\/em> muy bueno asignar\u00eda una probabilidad <\/strong>muy alta a la palabra correcta y muy baja a las alternativas incorrectas.<\/p>\n\n\n\n
Dicho esto, es intuitivo pensar que la probabilidad que el modelo asigna al texto de prueba debe ser un ingrediente relevante para una m\u00e9trica. Sin embargo, no se suele usar la probabilidad total del texto, porque depende fuertemente de su longitud: al ser un producto de muchas probabilidades condicionales, disminuye a medida que el texto se hace m\u00e1s largo. Por eso, una m\u00e9trica adecuada debe normalizar por la cantidad de palabras (o tokens), y medir el desempe\u00f1o promedio por token<\/strong>; de ah\u00ed surge la perplexity<\/em> . En particular, su f\u00f3rmula viene dada por:<\/p>\n\n\n\n
p<\/mi>e<\/mi>r<\/mi>p<\/mi>l<\/mi>e<\/mi>x<\/mi>i<\/mi>t<\/mi>y<\/mi>=<\/mo>\u2119<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>,<\/mo>w<\/mi>2<\/mn><\/msub>,<\/mo>.<\/mi>.<\/mi>.<\/mi>,<\/mo>w<\/mi>N<\/mi><\/msub>)<\/mo>\u2212<\/mo>1<\/mn>N<\/mi><\/mfrac><\/mrow><\/msup><\/mrow>perplexity = \\mathbb{P}(w_{1},w_{2},…,w_{N})^{-\\frac{1}{N}}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n
Al observar la f\u00f3rmula, podemos ver que depende inversamente de la probabilidad conjunta. Por este motivo, una menor \u00abperplejidad\u00bb, implica un mejor modelo. Teniendo esto en mente, a continuaci\u00f3n, presentamos el c\u00f3digo que calcula la perplejidad para el modelo de bigramas entrenado en El Quijote de la Mancha, y que usa Fuente Ovejuna de Lope de Vega como texto de prueba (lo puedes encontrar aqu\u00ed<\/a>):<\/p>\n\n\n\n
import re\nimport math\nfrom collections import Counter\nfrom typing import List, Tuple\nfrom pathlib import Path\n\nWORD_RE = re.compile(r\"[^\\W\\d_]+(?:[-'][^\\W\\d_]+)*\", re.UNICODE)\n\ndef tokenize_words(text: str, lowercase: bool = True) -> List[str]:\n    if lowercase:\n        text = text.lower()\n    return WORD_RE.findall(text)\n\ndef bigrams(tokens: List[str], add_start_end: bool = True) -> List[Tuple[str, str]]:\n    if add_start_end:\n        tokens = [\"<s>\"] + tokens + [\"<\/s>\"]\n    return list(zip(tokens[:-1], tokens[1:]))\n\ndef train_bigram_counts(train_text: str, lowercase: bool = True):\n    toks = tokenize_words(train_text, lowercase=lowercase)\n    bi = bigrams(toks, add_start_end=True)\n\n    context_counts = Counter([w1 for (w1, _) in bi])  # C(w_{i-1})\n    bigram_counts  = Counter(bi)                      # C(w_{i-1}, w_i)\n\n    # vocab del train (incluye tokens especiales)\n    vocab = set(toks)\n    vocab.update([\"<s>\", \"<\/s>\", \"<unk>\"])\n\n    return context_counts, bigram_counts, vocab\n\ndef perplexity_bigram_addk(\n    test_text: str,\n    context_counts: Counter,\n    bigram_counts: Counter,\n    vocab: set,\n    k: float = 1.0,           # k=1.0 => Laplace; k=0.1 => add-0.1; k=0 => MLE puro (puede dar inf)\n    lowercase: bool = True\n) -> float:\n    # Tokeniza test y mapea OOV a <unk>\n    toks = tokenize_words(test_text, lowercase=lowercase)\n    toks = [t if t in vocab else \"<unk>\" for t in toks]\n\n    bi = bigrams(toks, add_start_end=True)\n    V = len(vocab)\n\n    # log-prob promedio\n    log_sum = 0.0\n    N = 0\n\n    for w1, w2 in bi:\n        c12 = bigram_counts.get((w1, w2), 0)\n        c1  = context_counts.get(w1, 0)\n\n        if k == 0.0:\n            # MLE puro: si c12=0 => prob=0 => perplexity infinita\n            if c12 == 0 or c1 == 0:\n                return float(\"inf\")\n            p = c12 \/ c1\n        else:\n            # add-k smoothing:\n            # P(w2|w1) = (C(w1,w2)+k) \/ (C(w1)+k*V)\n            p = (c12 + k) \/ (c1 + k * V)\n\n        log_sum += math.log(p)\n        N += 1\n\n    # perplexity = exp(- (1\/N) * sum log p)\n    return math.exp(-log_sum \/ N)\n\nif __name__ == \"__main__\":\n    quijote_path = Path(r\"H:\\quijote.txt\")\n    fuente_path  = quijote_path.with_name(\"fuenteovejuna.txt\")\n\n    train_text = quijote_path.read_text(encoding=\"utf-8\")\n    test_text  = fuente_path.read_text(encoding=\"utf-8\")\n\n    context_counts, bigram_counts, vocab = train_bigram_counts(train_text)\n\n    ppl = perplexity_bigram_addk(\n        test_text,\n        context_counts,\n        bigram_counts,\n        vocab,\n        k=1.0  # prueba tambi\u00e9n k=0.1 o k=0.01\n    )\n\n    print(f\"Vocab size (train): {len(vocab)}\")\n    print(f\"Perplexity (Fuenteovejuna | trained on Quijote) with add-k={1.0}: {ppl:.4f}\")<\/code><\/pre>\n\n\n\n
En t\u00e9rminos generales, este c\u00f3digo empieza ignorando puntuaci\u00f3n y n\u00fameros, pero permitiendo ap\u00f3strofes y guiones. Luego, la funci\u00f3n tokenize_words() pasa todo a min\u00fasculas y devuelve una lista de tokens (que en este caso son palabras completas). bigrams() construye las secuencias de dos palabras, para luego crear pares consecutivos, es decir, si en la variable tokens entra una lista similar a esta:<\/p>\n\n\n\n
tokens = [\"don\", \"quijote\", \"vive\"]<\/code><\/pre>\n\n\n\n
el c\u00f3digo devuelve pares consecutivos con el siguiente aspecto:<\/p>\n\n\n\n
[(\"don\", \"quijote\"), (\"quijote\", \"vive\")]<\/code><\/pre>\n\n\n\n
train_bigram_counts() lleva a cabo el conteo de esos pares para que sea posible calcular<\/p>\n\n\n\n
P<\/mi>(<\/mo>w<\/mi>2<\/mn><\/msub>|<\/mi>w<\/mi>1<\/mn><\/msub>)<\/mo><\/mrow>^<\/mo><\/mover>=<\/mo>C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>,<\/mo>w<\/mi>2<\/mn><\/msub>)<\/mo><\/mrow>C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>)<\/mo><\/mrow><\/mfrac>.<\/mi><\/mrow>\\hat{P(w_{2}|w_{1})} = \\frac{C(w_{1},w_{2})}{C(w_{1})}.<\/annotation><\/semantics><\/math><\/div>\n\n\n\n
Luego, al vocabulario visto en el texto de entrenamiento se le a\u00f1ade <unk> para posteriormente representar palabras desconocidas en el texto de prueba.<\/p>\n\n\n\n
Finalmente, para calcular la perplejidad, primero, detectamos las palabras desconocidas, es decir, palabras que est\u00e1n en el texto de prueba y que no se encuentran en el vocabulario generado por el texto de entrenamiento:<\/p>\n\n\n\n
toks = tokenize_words(test_text)\ntoks = [t if t in vocab else \"<unk>\" for t in toks]<\/code><\/pre>\n\n\n\n
para posteriormente, hacer el conteo:<\/p>\n\n\n\n
c12 = bigram_counts.get((w1, w2), 0)\nc1 = context_counts.get(w1, 0) <\/code><\/pre>\n\n\n\n
que espec\u00edficamente, calcula C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>,<\/mo>w<\/mi>2<\/mn><\/msub>)<\/mo><\/mrow>C(w_{1},w_{2})<\/annotation><\/semantics><\/math> y C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>)<\/mo><\/mrow>C(w_{1})<\/annotation><\/semantics><\/math> del texto de entrenamiento, para w<\/mi>1<\/mn><\/msub>w_{1}<\/annotation><\/semantics><\/math> y w<\/mi>2<\/mn><\/msub>w_{2}<\/annotation><\/semantics><\/math> del texto de prueba. <\/p>\n\n\n\n
En este punto, a pesar de tener el conteo del numerador y denominador, a\u00fan no podemos realizar la divisi\u00f3n. Pese a que la fracci\u00f3n est\u00e1 blindada de la divisi\u00f3n por cero (puesto que al incluir <unk>, C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>)<\/mo><\/mrow>C(w_{1})<\/annotation><\/semantics><\/math> nunca ser\u00e1 cero), la fracci\u00f3n<\/p>\n\n\n\n
P<\/mi>(<\/mo>w<\/mi>2<\/mn><\/msub>|<\/mi>w<\/mi>1<\/mn><\/msub>)<\/mo><\/mrow>^<\/mo><\/mover>=<\/mo>C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>,<\/mo>w<\/mi>2<\/mn><\/msub>)<\/mo><\/mrow>C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>)<\/mo><\/mrow><\/mfrac><\/mrow>\\hat{P(w_{2}|w_{1})} = \\frac{C(w_{1},w_{2})}{C(w_{1})}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n
puede ser efectivamente cero, si C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>,<\/mo>w<\/mi>2<\/mn><\/msub>)<\/mo><\/mrow>C(w_{1},w_{2})<\/annotation><\/semantics><\/math> es cero, es decir, si no se encontr\u00f3 un bigrama similar en el texto de prueba. Esto es un problema por dos motivos. El primero, es que la perplejidad no se puede computar, puesto que es el inverso de la probabilidad, y debido a que es cero, estar\u00edamos ante una divisi\u00f3n por cero. El segundo, es que, que no aparezca el bigrama en el texto de entrenamiento, implica directamente que tiene probabilidad 0, lo que lo convierte en un evento imposible, pero realmente no es imposible, muy probablemente es s\u00f3lo una manifestaci\u00f3n de un corpus de entrenamiento limitado, lo que en la practica, puede socavar muchas aplicaciones. Principalmente por estos motivos, es necesario llevar a cabo un smoothing<\/em>. Existen m\u00faltiples tipos, pero nosotros s\u00f3lo veremos el add-k<\/em>, cuyo principio es a\u00f1adir k<\/em> unidades al numerador, y kV<\/em> unidades al denominador, para evitar la divisi\u00f3n por cero:<\/p>\n\n\n\n
P<\/mi>(<\/mo>w<\/mi>2<\/mn><\/msub>|<\/mi>w<\/mi>1<\/mn><\/msub>)<\/mo><\/mrow>^<\/mo><\/mover>=<\/mo>C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>,<\/mo>w<\/mi>2<\/mn><\/msub>)<\/mo>+<\/mo>k<\/mi><\/mrow>C<\/mi>(<\/mo>w<\/mi>1<\/mn><\/msub>)<\/mo>+<\/mo>k<\/mi>V<\/mi><\/mrow><\/mfrac>.<\/mi><\/mrow>\\hat{P(w_{2}|w_{1})} = \\frac{C(w_{1},w_{2}) + k}{C(w_{1}) + kV}.<\/annotation><\/semantics><\/math><\/div>\n\n\n\n
Por simplicidad, asumiremos k=1 (conocido como Laplace smoothing), y posteriormente calcularemos la perplejidad en logs:<\/p>\n\n\n\n
log_sum += math.log(p)\nN += 1\n...\n...\nreturn math.exp(-log_sum \/ N)<\/code><\/pre>\n\n\n\n
cuyo n\u00famero viene dado por <\/p>\n\n\n\n
Perplexity (Fuenteovejuna | trained on Quijote) with add-k=1.0: 7196.6119<\/kbd><\/p>\n\n\n\n
Notas finales, y pr\u00f3xima entrada\u2026<\/em><\/strong><\/p>\n\n\n\n
En esta entrada vimos una estrategia llamada n-gram<\/strong>s para predecir la siguiente palabra (o token) en un texto, condicionada a un contexto. Ese contexto puede ser la palabra inmediatamente anterior o, en general, las \u00faltimas n<\/mi>\u2212<\/mo>1<\/mn><\/mrow>n-1<\/annotation><\/semantics><\/math> palabras. Dicha predicci\u00f3n se lleva a cabo con probabilidades condicionales que pueden ser estimadas mediante M\u00e1xima Verosimilitud (MLE)<\/strong> a partir de un corpus de entrenamiento. Con fines did\u00e1cticos, fijamos n<\/mi>=<\/mo>2<\/mn><\/mrow>n=2<\/annotation><\/semantics><\/math>, entrenamos un modelo de bigramas usando El Quijote de la Mancha<\/em> y, finalmente, calculamos la perplejidad<\/strong>, un estad\u00edstico que permite realizar una evaluaci\u00f3n intr\u00ednseca del modelo.<\/p>\n\n\n\n
Esta estrategia es una base importante para el aprendizaje, porque captura uno de los principios centrales detr\u00e1s del funcionamiento de los LLMs<\/strong>: modelar el lenguaje como una distribuci\u00f3n de probabilidad sobre el siguiente token.<\/p>\n\n\n\n
En la pr\u00f3xima entrega veremos c\u00f3mo clasificar texto, un tema clave en procesamiento del lenguaje natural. Stay tuned!<\/p>\n\n\n\n
Jos\u00e9 Miguel Mu\u00f1oz Urra \u2013 jmunozu@pulki.es<\/a><\/p>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
En la entrada anterior vimos un ejemplo pr\u00e1ctico del algoritmo BPE. Entender esto es importante porque es la forma est\u00e1ndar en que las m\u00e1quinas descomponen un texto en una representaci\u00f3n que pueden manipular. Puesto que ahora sabemos hacerlo, el siguiente paso l\u00f3gico es emplear esos fragmentos (o tokens) de alguna manera, para as\u00ed generar texto […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-79","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/79","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=79"}],"version-history":[{"count":15,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/79\/revisions"}],"predecessor-version":[{"id":96,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/79\/revisions\/96"}],"wp:attachment":[{"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=79"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=79"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/pulki.es\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=79"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}