<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
  <title>Paweł Dubiel Tech Blog: Glosario</title>
  <link>https://paweldubiel.com/es</link>
  <atom:link href="https://paweldubiel.com/es/glossary.xml" rel="self" type="application/rss+xml" />
  <description>Notas sobre IA, modelos de lenguaje e ingeniería de software.</description>
  <language>es</language>
  <lastBuildDate>Mon, 12 Oct 2026 00:00:00 GMT</lastBuildDate>
<item>
  <title>Validation Set</title>
  <link>https://paweldubiel.com/es/glossary/validation-set</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/validation-set</guid>
  <pubDate>Mon, 12 Oct 2026 07:17:31 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Tienes un puesto de helados y quieres predecir las ventas diarias a partir de la temperatura. Has anotado tres días: a 20°C vendiste 20 porciones; a 22°C, 30; y a 24°C, 28.</description>
  <content:encoded><![CDATA[<p>Tienes un puesto de helados y quieres predecir las ventas diarias a partir de la temperatura. Has anotado tres días: a 20°C vendiste 20 porciones; a 22°C, 30; y a 24°C, 28. Comparas tres reglas: prever siempre 24 porciones, una línea recta y una curva que pasa exactamente por los tres resultados. La última no comete ningún error en el cuaderno. ¿Debería planificar las existencias de mañana?</p>
<p>Volver a comprobar esos mismos días no resuelve la duda. La regla flexible puede haberse ajustado también al azar, por ejemplo, a una excursión excepcionalmente numerosa a 22°C. Antes de elegir la regla, reservas otros días para comparar candidatos. <strong>Validation Set</strong> es una parte separada de los datos que se utiliza para elegir un modelo o sus ajustes, no para ajustar sus números aprendidos. <a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio y Courville, <em>Deep Learning</em>, §5.3</a> describen esta separación.</p>
<p><img src="https://paweldubiel.com/assets/validation-set-tasting-tray-and-sealed-sample.webp" alt="Tres muestras de helado listas para comparar y un recipiente separado con el precinto intacto: metáfora de los datos para elegir y de una evaluación final independiente." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="un-cuaderno-para-aprender-otros-días-para-elegir">Un cuaderno para aprender, otros días para elegir</h2>
<p>Establecemos las reglas y sus números utilizando únicamente los datos de entrenamiento. La línea predice el doble de la temperatura menos 20. La curva es un arco ajustado a los tres puntos del cuaderno. Aquí, el error absoluto medio significa: calcular cuántas porciones se equivoca la predicción de cada día, ignorar el signo y promediar las diferencias.</p>
<p>En los días reservados, con 21°C, 23°C y 25°C, se vendieron respectivamente 23, 25 y 31 porciones. La curva predice 26,5, 30,5 y 22,5; su error medio es de unas 5,83 porciones. La línea predice 22, 26 y 30: el error es de 1 porción. Por eso elegimos la línea, aunque en el cuaderno perdía por 2 a 0. <strong>El Validation Set no mejoró ninguna regla; ayudó a elegir entre tres.</strong> Los datos son inventados y las predicciones fraccionarias representan ventas esperadas, no la división de una porción.</p>
<div id="validation-set-lab"></div>
<h2 id="después-de-elegir-todavía-hace-falta-una-evaluación-final">Después de elegir, todavía hace falta una evaluación final</h2>
<p>Los días utilizados para elegir ya han influido en la decisión. Por eso, una tercera parte de datos, sin ejemplos compartidos con las otras, el <em>test set</em>, se utiliza solo para evaluar la solución elegida. En el ejemplo, la línea se equivoca en una media de 1 porción en dos días que aún no se habían mostrado. Si cambias la regla después de ver ese resultado, esos días también pasan a servir para elegir; pierden su papel de prueba independiente (§5.3).</p>
<p>Esta es una limitación importante: después de muchos intentos, la elección puede ajustarse al propio Validation Set y dar un resultado demasiado optimista. Aquí, tres días reservados son solo una ayuda didáctica, no una evaluación fiable de las ventas reales. Ningún porcentaje fijo de división garantiza una buena medición.</p>
<ul>
<li><a href="https://paweldubiel.com/es/glossary/overfitting">Overfitting</a> describe un ajuste excesivo a los ejemplos de entrenamiento; los datos separados ayudan a detectar su efecto.</li>
<li><a href="https://paweldubiel.com/es/glossary/ajuste-fino">Fine-tuning</a> es el entrenamiento adicional de un modelo existente; un Validation Set puede ayudar a elegir sus ajustes.</li>
<li><a href="https://paweldubiel.com/es/glossary/entropia-cruzada">Cross-entropy</a> es otra forma de medir el error, frecuente al predecir texto; la separación de las funciones de los datos sigue siendo la misma.</li>
</ul>
<p><em>El texto y la ilustración se prepararon con ayuda de IA. Los datos, las reglas y la demostración son un ejemplo simplificado propio; la ilustración es una metáfora de la elección y de conservar una muestra separada.</em></p>]]></content:encoded>
</item>
<item>
  <title>Overfitting</title>
  <link>https://paweldubiel.com/es/glossary/overfitting</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/overfitting</guid>
  <pubDate>Sun, 11 Oct 2026 15:59:40 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Tienes un puesto de helados. Durante 10 días has apuntado en un cuaderno la temperatura a mediodía y el número de bolas vendidas.</description>
  <content:encoded><![CDATA[<p>Tienes un puesto de helados. Durante 10 días has apuntado en un cuaderno la temperatura a mediodía y el número de bolas vendidas. Quieres sacar de esas notas una regla: mañana habrá 24°C, ¿cuánto helado hay que preparar?</p>
<p>La regla más sencilla es una línea recta: «cada grado más son unas cuantas bolas más». En el ejemplo de esta nota, en los días apuntados suele equivocarse en 27,5 bolas, porque no ve que con el calor más fuerte las ventas bajan. Así que se le puede dar más libertad a la regla y dejar que la curva haga giros. La más flexible de las curvas probadas pasa exactamente por los 10 puntos. Su error en los días del cuaderno es 0.</p>
<p>Parece la regla perfecta. Solo que los días del cuaderno ya han pasado y la regla tiene que funcionar mañana. En 400 días nuevos del mismo puesto, la curva «perfecta» suele equivocarse en 236,5 bolas. Una curva moderadamente flexible, que en el cuaderno salía peor (10,9), en los días nuevos se equivoca en 16,8.</p>
<p><strong>Overfitting</strong> es la situación en la que un modelo tiene un error pequeño en los datos usados para aprender y, en comparación con él, un error demasiado grande en datos nuevos del mismo tipo (<a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio y Courville, <em>Deep Learning</em>, §5.2</a>). El modelo se ha ajustado a rasgos de su conjunto de datos que fuera de él no se repiten. El problema contrario se llama <strong>underfitting</strong>: la regla es demasiado simple para describir bien incluso los datos que ha visto. Así se comporta la línea recta de nuestro ejemplo.</p>
<p><img src="https://paweldubiel.com/assets/overfitting-smooth-rule-versus-tangled-line-through-every-point.webp" alt="Dos puestos de helados uno al lado del otro: sobre el primero, una línea suave traza un arco tranquilo entre los puntos; sobre el segundo, una línea enredada pasa por cada punto y sale disparada muy lejos del encuadre." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="de-dónde-sale-esa-diferencia">De dónde sale esa diferencia</h2>
<p>Cada apunte del cuaderno se compone de dos cosas: una regularidad (hace más calor, así que se vende más helado) y el azar (justo ese día llegó una excursión). La regla tiene que captar la primera y dejar fuera la segunda. Pero el modelo no sabe qué es cada cosa. Solo ve puntos.</p>
<p>Cuánto azar absorbe el modelo depende de su flexibilidad, que en la literatura se llama <strong>capacity</strong>: la capacidad de ajustarse a muchas formas distintas. La curva del ejemplo se describe con entre 2 y 10 números que se eligen según los datos; su cantidad es el grado de la curva más uno. Una curva de grado 9 tiene 10 de esos números para 10 días, así que puede acertar en cada punto, con todo su azar incluido. Los autores del manual lo describen así: un modelo muy flexible puede representar la relación correcta, pero también muchísimas otras que encajan igual de bien con los datos de entrenamiento, y es poco probable que elija justo la que seguirá funcionando después (§5.2).</p>
<p>El recorrido típico es el siguiente: cuando la flexibilidad aumenta, el error en los datos de entrenamiento disminuye, y el error en datos nuevos primero disminuye y luego empieza a crecer (§5.2, figura 5.3). De ahí sale una norma práctica. Un modelo no se evalúa con los datos con los que aprendió, y la flexibilidad no se elige según el error en esos datos, porque ese error siempre señalará la mayor. Una parte de los datos se aparta: el <strong><a href="https://paweldubiel.com/es/glossary/validation-set">validation set</a></strong> sirve para elegir los ajustes y un <strong>test set</strong> separado, para la evaluación final (§5.3).</p>
<h2 id="compruébalo-tú-mismo">Compruébalo tú mismo</h2>
<p>Aquí abajo está el mismo puesto. Todos los números de esta nota se pueden reproducir: al pulsar «Desde el principio» se ven 10 días, y los experimentos 1–5 preparan los casos descritos.</p>
<div id="overfitting-lab"></div>
<p>Vale la pena hacer dos cosas que un gráfico estático no muestra. Primero, activa «Otros 24 cuadernos» y cambia el grado: con uno bajo, las líneas grises se mantienen cerca unas de otras; con uno alto, se separan en todas direcciones, aunque todas vienen del mismo puesto. Segundo, arrastra un punto muy hacia arriba. La curva de grado 2 se moverá solo un poco, y la de grado 9 se reconstruirá en toda su longitud para acertar en él.</p>
<h2 id="qué-ayuda">Qué ayuda</h2>
<ul>
<li><strong>Más datos.</strong> Con 80 días, la misma curva de grado 9 suele equivocarse en 14,8 bolas en el cuaderno y en 15,9 en los días nuevos. La diferencia casi desaparece, porque la curva ya no puede acertar en cada punto (§5.2).</li>
<li><strong>Menos flexibilidad.</strong> Curva de grado 3 con 10 días: 10,9 en el cuaderno, 16,8 en los días nuevos.</li>
<li><strong>Regularization</strong>, es decir, un cambio en la forma de aprender que busca reducir el error en los datos nuevos y no en los de entrenamiento (§5.2.2). Un ejemplo es la penalización por coeficientes grandes, emparentada con <a href="https://paweldubiel.com/es/glossary/decaimiento-de-pesos">Weight decay</a>: la curva de grado 9 con penalización λ = 0,01 se equivoca en 5,8 en el cuaderno y en 21,2 en los días nuevos, en lugar de en 236,5.</li>
</ul>
<p>Ninguno de estos ajustes se puede elegir mirando solo el error en los datos de entrenamiento.</p>
<h2 id="limitaciones">Limitaciones</h2>
<ul>
<li>Es un ejemplo propio, con una sola magnitud de entrada y datos simulados. El azar por sí solo da aquí un error típico de 15 bolas, y ninguna regla bajará de ahí en los días nuevos.</li>
<li>La forma «primero mejor, luego peor» es típica, no está garantizada. Los autores señalan que en las redes profundas es difícil incluso determinar la flexibilidad real del modelo, porque depende también del algoritmo de aprendizaje (§5.2). Por eso el número de parámetros de un LLM no dice por sí solo si el modelo está sobreajustado.</li>
<li>Un error pequeño en datos nuevos se refiere a datos de la misma fuente. Si el puesto se traslada a la orilla del mar, el cuaderno de la ciudad no promete nada.</li>
</ul>
<h2 id="relaciones">Relaciones</h2>
<ul>
<li><a href="https://paweldubiel.com/es/glossary/decaimiento-de-pesos">Weight decay</a> limita el tamaño de los pesos y es una de las formas de reducir la diferencia entre el error en los datos de entrenamiento y en los nuevos.</li>
<li><a href="https://paweldubiel.com/es/glossary/grokking">Grokking</a> describe casos en los que un modelo que parece sobreajustado empieza, tras un largo entrenamiento adicional, a funcionar bien con datos nuevos.</li>
<li><a href="https://paweldubiel.com/es/glossary/ajuste-fino">Fine-tuning</a> con un conjunto pequeño exige el mismo control: datos aparte que el modelo no haya visto durante el aprendizaje.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> es otro problema: allí el modelo pierde una habilidad antigua tras un aprendizaje nuevo, y aquí desde el principio se traslada mal fuera de sus propios datos de entrenamiento.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Time horizon</title>
  <link>https://paweldubiel.com/es/glossary/time-horizon</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/time-horizon</guid>
  <pubDate>Sun, 11 Oct 2026 15:02:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>En la evaluación de agentes, el time horizon (horizonte temporal) describe la duración de las tareas con la que un agente alcanza un nivel de éxito elegido.</description>
  <content:encoded><![CDATA[<p>En la evaluación de agentes, el <strong>time horizon</strong> (horizonte temporal) describe la duración de las tareas con la que un agente alcanza un nivel de éxito elegido. La duración se mide por el tiempo que necesita una persona, no por el tiempo de funcionamiento de la IA.</p>
<p>Para la variante del 50 %, reunimos los intentos exitosos y fallidos del agente en tareas con distintos tiempos humanos. Ajustamos una curva de la probabilidad de éxito y después leemos el tiempo en el que cruza el 50 %. Es una predicción para la distribución de tareas de una duración dada; no significa que cada una de ellas tenga la misma probabilidad de completarse. <a href="https://metr.org/time-horizons/" rel="noopener noreferrer">METR: definición y metodología</a>.</p>
<p>Un ejemplo didáctico: si la curva ajustada alcanza el 50 % a las dos horas, el horizonte es de dos horas. El agente puede completar una tarea con éxito mucho más rápido. El resultado tampoco indica por sí solo con qué éxito resolverá una tarea de otro ámbito.</p>
<p>La lectura exige una relación razonable entre el tiempo humano y la dificultad para la IA. Cuando la curva es plana, un cambio pequeño en la probabilidad puede desplazar mucho su cruce con el umbral. <a href="https://paweldubiel.com/es/articles/un-horizonte-de-metr-mas-largo-no-significa-tareas-proporcionalmente-mas">El artículo sobre la conversión del horizonte de METR</a> muestra este problema con un ejemplo que se puede calcular y comenta un nuevo ajuste a los datos de METR. <a href="https://arxiv.org/html/2610.12466v1#S2" rel="noopener noreferrer">Nguyen y Fithian, §2–3</a>.</p>
<p>Al comparar horizontes hay que conservar la información sobre el conjunto de tareas, el entorno del agente, el presupuesto de intentos y el umbral de éxito adoptado.</p>]]></content:encoded>
</item>
<item>
  <title>Item response theory</title>
  <link>https://paweldubiel.com/es/glossary/item-response-theory</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/item-response-theory</guid>
  <pubDate>Sun, 11 Oct 2026 15:01:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>La item response theory (IRT), o teoría de respuesta al ítem, es una familia de métodos que, a partir de las respuestas a cada tarea, estiman conjuntamente la capacidad de quienes las resuelven y la…</description>
  <content:encoded><![CDATA[<p>La <strong>item response theory (IRT)</strong>, o teoría de respuesta al ítem, es una familia de métodos que, a partir de las respuestas a cada tarea, estiman conjuntamente la capacidad de quienes las resuelven y la dificultad de las tareas. En la evaluación de IA quien resuelve es un agente, y la respuesta puede ser el éxito o el fracaso de un intento completo.</p>
<p>Supongamos que dos agentes resuelven las mismas tres tareas. El primero suele poder con A y B; el segundo, también con C. El porcentaje de éxitos por sí solo da una clasificación. La IRT intenta además estimar cuánto más difícil es C respecto a las demás tareas y qué diferencia de capacidad explica el patrón de respuestas. Es un ejemplo didáctico; una tabla tan pequeña no basta para un ajuste fiable.</p>
<p>En el sencillo modelo de Rasch, la probabilidad de éxito aumenta cuando la capacidad del agente es mayor en relación con la dificultad de la tarea. Ambas magnitudes son latentes: las inferimos de los resultados, en lugar de identificar de entrada la dificultad con la longitud de las instrucciones o con el tiempo humano. Las distintas variantes de la IRT añaden más parámetros y supuestos.</p>
<p>En <a href="https://paweldubiel.com/es/articles/un-horizonte-de-metr-mas-largo-no-significa-tareas-proporcionalmente-mas">el análisis de los horizontes de METR</a>, los autores vinculan la dificultad latente con el tiempo de trabajo humano mediante una curva aprendida. Añaden efectos de las familias de tareas y la variabilidad de los resultados entre repeticiones. Esto permite comprobar en qué rango el tiempo distingue realmente las tareas difíciles de las fáciles para la IA. <a href="https://arxiv.org/html/2610.12466v1#S2.SS3" rel="noopener noreferrer">Nguyen y Fithian, §2.3 y §3.1</a>.</p>
<p>Predecir bien las respuestas no demuestra que el parámetro aprendido abarque todos los tipos de capacidad del agente. Al interpretarlo hay que comprobar los supuestos del modelo y los resultados en tareas no utilizadas durante el ajuste.</p>]]></content:encoded>
</item>
<item>
  <title>Elastic Weight Consolidation</title>
  <link>https://paweldubiel.com/es/glossary/elastic-weight-consolidation</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/elastic-weight-consolidation</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modelo dirige las preguntas de los clientes a los departamentos «entrega» y «devoluciones». Ahora debe aprender a reconocer reclamaciones, pero ya no está permitido conservar los mensajes antiguos.</description>
  <content:encoded><![CDATA[<p>Un modelo dirige las preguntas de los clientes a los departamentos «entrega» y «devoluciones». Ahora debe aprender a reconocer reclamaciones, pero ya no está permitido conservar los mensajes antiguos. Por tanto, no es posible repasarlos durante el entrenamiento. Lo único que queda de la tarea antigua es el propio modelo: millones de números ajustados durante el entrenamiento anterior, llamados pesos.</p>
<p>Se puede entrenar al modelo con reclamaciones sin ninguna restricción. Entonces los pesos se desplazan hacia donde eso ayuda a la nueva tarea, incluidos aquellos de los que dependía reconocer entrega y devoluciones. También se puede penalizar por igual cualquier cambio, pero entonces el modelo se aferra tanto a los ajustes antiguos que aprende mal lo nuevo. Hace falta responder a la pregunta: <strong>¿qué pesos se pueden mover y cuáles es mejor no tocar?</strong></p>
<p><strong>Elastic Weight Consolidation (EWC)</strong> añade al entrenamiento de la nueva tarea una penalización por alejar los pesos de los valores que tenían tras la tarea antigua; la penalización es mayor cuanto más importante era ese peso para la tarea antigua. Los autores lo comparan con un muelle sujeto a cada peso: rígido en los pesos importantes, flojo en los demás (<a href="https://arxiv.org/abs/1612.00796" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §2</a>).</p>
<p><img src="https://paweldubiel.com/assets/elastic-weight-consolidation-stiff-and-loose-springs.webp" alt="Una fila de discos sujetos con muelles a unos postes: los discos con muelles gruesos y rígidos se quedan en su sitio, y los de muelles finos y flojos se desplazan hacia un círculo rojo." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="dos-pesos-una-tarea-nueva">Dos pesos, una tarea nueva</h2>
<p>Tomemos solo dos pesos. Tras aprender entrega y devoluciones, ambos valen 1. El primero es muy importante para los departamentos antiguos (importancia 10), el segundo casi indiferente (importancia 0,1). La nueva tarea solo exige que <strong>la suma de ambos pesos sea 4</strong>. Lo cumplen muchos ajustes: (2, 2), pero también (1, 3).</p>
<ul>
<li><strong>Sin protección</strong>, el entrenamiento desplaza ambos pesos por igual, hasta (2, 2). La nueva tarea queda aprendida, pero el peso importante se ha alejado en 1 y la pérdida en la tarea antigua sube de 0 a 5,05.</li>
<li><strong>Una penalización igual</strong> para ambos pesos los detiene a medio camino, en (1,67, 1,67). La tarea antigua sufre menos, pero la suma es 3,33 en lugar de 4.</li>
<li><strong>EWC</strong> traslada casi todo el movimiento al peso poco importante: (1,02, 2,80). La suma es 3,82 y la pérdida en la tarea antigua es de solo 0,16.</li>
</ul>
<p>La pérdida es un número que indica cuánto se equivoca el modelo; cuanto menor, mejor. En el experimento siguiente puedes cambiar la fuerza de la penalización λ y el modo de protección. El resultado se calcula de forma exacta para este ejemplo de dos pesos; no es una simulación de una red real.</p>
<div id="ewc-spring-lab"></div>
<h2 id="cómo-se-sabe-qué-peso-es-importante">Cómo se sabe qué peso es importante</h2>
<p>En una red real nadie da la importancia de antemano. Se estima al terminar la tarea antigua, mientras sus datos aún están disponibles: se comprueba cuánto altera una pequeña modificación de un peso las respuestas del modelo en los ejemplos antiguos. El trabajo usa para ello la diagonal de la <em>matriz de información de Fisher</em>, es decir, un número de importancia por cada peso. Después los datos pueden eliminarse; quedan los valores antiguos de los pesos y sus importancias.</p>
<p>Durante el nuevo entrenamiento se minimiza la suma de dos términos (ecuación 3 del trabajo):</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>L</mi><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>L</mi><mi>B</mi></msub><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>+</mo><munder><mo>∑</mo><mi>i</mi></munder><mfrac><mi>λ</mi><mn>2</mn></mfrac><msub><mi>F</mi><mi>i</mi></msub><mtext> </mtext><mo stretchy="false">(</mo><msub><mi>θ</mi><mi>i</mi></msub><mo>−</mo><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup><msup><mo stretchy="false">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">L(\theta) = L_B(\theta) + \sum_i \frac{\lambda}{2} F_i \,(\theta_i - \theta^*_{A,i})^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">L</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.6491em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3714em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">2</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">λ</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.2472em;vertical-align:-0.3831em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7387em;"><span style="top:-2.453em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3831em;"><span></span></span></span></span></span></span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>L</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">L_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> es la pérdida en la nueva tarea, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>θ</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">\theta_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> es el valor actual del peso número <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup></mrow><annotation encoding="application/x-tex">\theta^*_{A,i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1059em;vertical-align:-0.4114em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6887em;"><span style="top:-2.4247em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4114em;"><span></span></span></span></span></span></span></span></span></span> su valor tras la tarea antigua, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>F</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">F_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> su importancia, y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi></mrow><annotation encoding="application/x-tex">\lambda</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span></span></span></span> indica cuánto cuenta la tarea antigua frente a la nueva. En nuestro ejemplo, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mo stretchy="false">(</mo><mn>10</mn><mo separator="true">;</mo><mtext> </mtext><mn>0,1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F = (10;\ 0{,}1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">10</span><span class="mpunct">;</span><span class="mspace"> </span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\lambda = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>.</p>
<h2 id="límites-del-método">Límites del método</h2>
<p>La importancia es una aproximación calculada en un solo punto, por separado para cada peso. Los propios autores muestran que su estimación a veces está demasiado segura de qué pesos son irrelevantes, y lo llaman la principal debilidad del método (§2.2 y §3). En sus experimentos con juegos de Atari, un agente con EWC aprendió muchos juegos uno tras otro, pero no igualó a las redes separadas entrenadas para cada juego. Los resultados se refieren al reconocimiento de dígitos y a juegos, no a grandes modelos de lenguaje. Nuestros dos pesos y los mensajes de clientes son una simplificación propia.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> es un deterioro considerable de habilidades anteriores tras un nuevo entrenamiento; EWC intenta reducirlo sin acceso a los datos antiguos.</li>
<li><a href="https://paweldubiel.com/es/glossary/experience-replay">Experience Replay</a> resuelve el mismo problema de otra manera: guarda parte de los ejemplos anteriores en lugar de las importancias de los pesos.</li>
<li><a href="https://paweldubiel.com/es/glossary/continual-learning">Continual Learning</a> establece el objetivo, es decir, aprender tareas sucesivas conservando las anteriores; EWC es uno de los métodos.</li>
<li><a href="https://paweldubiel.com/es/glossary/ajuste-fino">Fine-tuning</a> es el entrenamiento posterior de un modelo ya preparado; EWC cambia su objetivo al añadir una penalización por mover los pesos importantes.</li>
</ul>
<p><em>El texto y la ilustración se prepararon con ayuda de IA. Los dos pesos, sus importancias y la demostración son un ejemplo educativo propio y simplificado; la ilustración es una metáfora, no un esquema de la arquitectura del modelo.</em></p>]]></content:encoded>
</item>
<item>
  <title>Reservoir Sampling</title>
  <link>https://paweldubiel.com/es/glossary/reservoir-sampling</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/reservoir-sampling</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modelo de atención al cliente aprende de mensajes que llegan uno tras otro. Quieres conservar algunos para repasarlos más adelante, pero solo tienes cuatro espacios en la memoria.</description>
  <content:encoded><![CDATA[<p>Un modelo de atención al cliente aprende de mensajes que llegan uno tras otro. Quieres conservar algunos para repasarlos más adelante, pero solo tienes cuatro espacios en la memoria. Tampoco sabes cuántos mensajes llegarán todavía: veinte o dos millones.</p>
<p>¿Quedarte con los cuatro primeros? Entonces la memoria solo conoce el principio. ¿Guardar siempre los cuatro últimos? Entonces solo conoce el final. Un sorteo justo de «cuatro de entre todos» exigiría guardarlo todo o conocer de antemano el número de mensajes. La pregunta es: <strong>¿cómo dar a cada mensaje la misma probabilidad con un número fijo de espacios y un flujo de longitud desconocida?</strong></p>
<p><strong>Reservoir Sampling</strong> es una forma de mantener una muestra aleatoria de tamaño fijo durante una sola pasada por unos datos cuya cantidad no conocemos de antemano. Después de cada nuevo mensaje, la memoria, llamada aquí reservorio, contiene una muestra aleatoria justa de todo lo que ha llegado hasta ese momento. La versión más sencilla, Algorithm R, la describe <a href="https://doi.org/10.1145/3147.3165" rel="noopener noreferrer">Vitter, <em>Random Sampling with a Reservoir</em>, §2</a>, que la atribuye a Alan Waterman.</p>
<p><img src="https://paweldubiel.com/assets/reservoir-sampling-pebble-stream-four-slot-tray.webp" alt="Un largo flujo de guijarros y conchas pasa junto a una pequeña bandeja de madera con cuatro huecos; una mano saca un guijarro de la bandeja y la otra pone en su lugar un guijarro del flujo." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="la-receta-en-dos-pasos">La receta en dos pasos</h2>
<ol>
<li>Los cuatro primeros mensajes entran en la memoria sin sorteo.</li>
<li>El mensaje número <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> (el quinto, el sexto y cada uno de los siguientes) entra en la memoria con probabilidad <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>. Si entra, sustituye a uno de los cuatro guardados, elegido al azar.</li>
</ol>
<p>Así, el quinto mensaje entra con probabilidad 4/5 y el centésimo con probabilidad 4/100. Los mensajes nuevos tienen cada vez menos probabilidad de entrar, pero los antiguos ya han estado expuestos muchas veces a ser expulsados, y estos dos efectos se compensan exactamente. Comprobémoslo después del quinto mensaje. Entra con probabilidad 4/5. El primer mensaje sale solo si el quinto entró (4/5) y cayó justo en su lugar (1/4), es decir, con probabilidad 1/5. Se queda con probabilidad 4/5: la misma que tiene el quinto. Después de <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> mensajes, cada uno de ellos está en la memoria con probabilidad <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>.</p>
<h2 id="la-misma-probabilidad-no-es-una-garantía">La misma probabilidad no es una garantía</h2>
<p>En el experimento, el flujo tiene 20 mensajes. Dieciocho tratan de entrega y dos, el noveno y el decimoquinto, tratan de devoluciones. Cada ejecución hace pasar ese flujo 2000 veces y cuenta con qué frecuencia cada posición quedó en la memoria al final. Los sorteos son reales, así que los resultados varían cada vez en una fracción de punto porcentual.</p>
<div id="reservoir-sampling-lab"></div>
<p>Con Reservoir Sampling, cada barra ronda el 20%, es decir, 4/20. Al mismo tiempo, en la mayoría de las ejecuciones ninguna de las dos devoluciones queda en la memoria. El valor exacto es 3060/4845, es decir, alrededor del 63%: esa es la parte de todos los grupos de cuatro elegidos entre 20 mensajes que se compone únicamente de los dieciocho mensajes sobre entrega. El método es justo con cada mensaje por separado, pero no se ocupa de que cada categoría tenga un representante.</p>
<h2 id="dónde-importa">Dónde importa</h2>
<p>En el entrenamiento con repaso, Reservoir Sampling se usa a veces como forma de guardar en el búfer: no hace falta conocer la longitud del flujo ni los límites entre tareas. <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, algoritmo 2</a> lo usan precisamente así. En sus experimentos con tareas de imágenes funcionó bien, salvo con memorias muy pequeñas, donde las clases anteriores desaparecían del búfer; en ese caso daban mejor resultado las estrategias que cuidan una representación igual de las clases (§4.4). Es un resultado para clasificación de imágenes, no para LLM.</p>
<p>El algoritmo en sí no trata de aprendizaje automático. El trabajo de Vitter de 1985 describe el muestreo de registros de una cinta magnética de longitud desconocida y propone variantes más rápidas que, en lugar de sortear en cada registro, calculan cuántos registros saltarse. Los mensajes de clientes y el flujo de 20 posiciones son un ejemplo propio.</p>
<ul>
<li><a href="https://paweldubiel.com/es/glossary/experience-replay">Experience Replay</a> necesita un búfer con ejemplos anteriores; Reservoir Sampling es una de las formas de decidir qué entra en él.</li>
<li><a href="https://paweldubiel.com/es/glossary/continual-learning">Continual Learning</a> supone aprender de un flujo de datos con memoria limitada, es decir, una situación en la que no se puede conservar todo.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> puede agravarse cuando de una memoria pequeña salen todos los ejemplos de una categoría anterior.</li>
</ul>
<p><em>El texto y la ilustración se prepararon con ayuda de IA. El flujo de mensajes y la demostración son un ejemplo educativo propio y simplificado; la ilustración es una metáfora, no un esquema del algoritmo.</em></p>]]></content:encoded>
</item>
<item>
  <title>Experience Replay</title>
  <link>https://paweldubiel.com/es/glossary/experience-replay</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/experience-replay</guid>
  <pubDate>Sun, 11 Oct 2026 08:22:26 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modelo ha aprendido a dirigir las preguntas de los clientes a «entrega» y «devoluciones». Ahora lo entrenas para reconocer reclamaciones, como «El producto llegó dañado».</description>
  <content:encoded><![CDATA[<p>Un modelo ha aprendido a dirigir las preguntas de los clientes a «entrega» y «devoluciones». Ahora lo entrenas para reconocer reclamaciones, como «El producto llegó dañado». Si los siguientes ejercicios contienen solo reclamaciones, puede empeorar al atender el conocido «¿Dónde está mi paquete?». El archivo antiguo completo no está disponible. ¿Podría volver al menos a unos pocos mensajes guardados?</p>
<p><strong>Experience Replay (ER)</strong> consiste en almacenar parte de los ejemplos anteriores y reutilizarlos para el entrenamiento. En una versión sencilla, mezclamos ejemplos de la memoria con un lote de datos nuevos. Esta memoria se llama <em>replay buffer</em>: un contenedor de datos para repasar, no un registro de todo lo que sabe el modelo. Este entrenamiento conjunto se describe en <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, algoritmo 1</a>.</p>
<p><img src="https://paweldubiel.com/assets/experience-replay-card-box-returning-examples.webp" alt="Tarjetas añiles y ocres guardadas regresan de una pequeña caja a una fila de tarjetas rojas nuevas: metáfora del repaso durante el aprendizaje posterior." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="qué-entra-en-el-siguiente-ejercicio">Qué entra en el siguiente ejercicio</h2>
<p>Antes de perder el archivo, guardamos cuatro mensajes junto con sus departamentos correctos. Ahora tenemos cuatro reclamaciones nuevas. Sin repaso, el modelo aprende de cuatro mensajes nuevos. Con repaso, practica también con cuatro antiguos: vuelve a recibir la señal de que «¿Dónde está mi paquete?» corresponde a entrega. En este pequeño ejemplo usamos todo el búfer; los búferes mayores suelen aportar un lote obtenido por muestreo.</p>
<p>Sin embargo, no basta con contar los espacios de memoria. Cuatro preguntas guardadas sobre entrega no contienen ningún ejemplo de devolución. Al sustituir dos por «¿Cómo envío de vuelta mi compra?» y «Quiero devolver una camiseta», la cantidad de ejemplos repetidos no cambia, pero abarca ambos departamentos anteriores. El siguiente experimento <strong>cuenta ejemplos en un lote de datos; no predice la exactitud del modelo</strong>.</p>
<div id="experience-replay-lab"></div>
<h2 id="el-repaso-solo-ayuda-con-los-datos-disponibles">El repaso solo ayuda con los datos disponibles</h2>
<p>El modelo recibe una oportunidad de practicar respuestas anteriores, no una garantía de conservar todas sus habilidades. Una muestra aleatoria pequeña puede omitir por completo una categoría poco frecuente; los investigadores observaron este problema con búferes muy pequeños (§4.4 del mismo trabajo). Nuestros mensajes son un ejemplo propio, no un resultado de esos experimentos. El efecto del entrenamiento debe comprobarse con mensajes antiguos y nuevos separados, que no se hayan usado para entrenar. El búfer también ocupa memoria y exige conservar los datos elegidos.</p>
<p>Véase también: <a href="https://paweldubiel.com/es/glossary/reservoir-sampling">Reservoir Sampling</a> — una forma de decidir qué ejemplos del flujo entran en un búfer de tamaño fijo, dando a cada uno la misma probabilidad.</p>
<p>En los juegos, en <a href="https://paweldubiel.com/es/glossary/aprendizaje-por-refuerzo">Reinforcement Learning</a> — aprender acciones a partir de recompensas — se guardan una situación, una acción, una recompensa y la siguiente situación. Muestrear estos registros reduce la dependencia de sucesos que ocurren inmediatamente uno tras otro (<a href="https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf#page=7" rel="noopener noreferrer">Mnih et al., <em>Human-level control through deep reinforcement learning</em>, Methods, «Training algorithm for deep Q-networks»</a>). Son datos distintos de un mensaje con su departamento correcto; los resultados de Atari no deben trasladarse directamente a los LLM.</p>
<ul>
<li><a href="https://paweldubiel.com/es/glossary/continual-learning">Continual Learning</a> establece el objetivo de seguir aprendiendo conservando las capacidades anteriores; ER es una forma de perseguirlo.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> describe un deterioro considerable de habilidades anteriores, que el repaso puede reducir.</li>
<li><a href="https://paweldubiel.com/es/glossary/ajuste-fino">Fine-tuning</a> es el entrenamiento posterior de un modelo; replay cambia la selección de sus datos. Pegar mensajes antiguos en una conversación no es este tipo de actualización del modelo.</li>
</ul>
<p><em>El texto y la ilustración se prepararon con ayuda de IA. Los mensajes y la demostración son un ejemplo educativo propio y simplificado; la ilustración es una metáfora, no un esquema de la arquitectura del modelo.</em></p>]]></content:encoded>
</item>
<item>
  <title>Continual Learning</title>
  <link>https://paweldubiel.com/es/glossary/continual-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/continual-learning</guid>
  <pubDate>Sat, 10 Oct 2026 20:03:52 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modelo dirige los mensajes de los clientes a los departamentos de «pedidos» y «devoluciones». Sabe reconocer «¿Dónde está mi paquete?». Ahora la empresa abre un departamento de reclamaciones.</description>
  <content:encoded><![CDATA[<p>Un modelo dirige los mensajes de los clientes a los departamentos de «pedidos» y «devoluciones». Sabe reconocer «¿Dónde está mi paquete?». Ahora la empresa abre un departamento de reclamaciones. Sigues entrenando el modelo con mensajes sobre productos dañados. Clasifica cada vez mejor las reclamaciones, pero algunas preguntas sobre entregas también empiezan a llegar al nuevo departamento. Evaluar solo las reclamaciones daría una falsa impresión de progreso.</p>
<p>Necesitas <strong>enseñar cosas nuevas al modelo conservando sus capacidades anteriores</strong>. Ese es el objetivo de <strong>Continual Learning</strong>: aprender de datos o tareas que llegan de forma sucesiva, teniendo en cuenta lo que el modelo ya ha aprendido. El nombre designa un problema y una familia de enfoques; no garantiza que desaparezca el olvido. <a href="https://arxiv.org/html/1612.00796v2#S1" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §1</a> describen esta necesidad.</p>
<p><img src="https://paweldubiel.com/assets/continual-learning-embroidered-sampler-growing-repertoire.webp" alt="En una misma pieza de tela permanecen bordados círculos y triángulos, mientras una aguja añade un nuevo patrón ondulado: una metáfora de desarrollar capacidades conservando las anteriores." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="qué-cambia-en-el-entrenamiento-y-la-evaluación">Qué cambia en el entrenamiento y la evaluación</h2>
<p>Supongamos que ya no está disponible el archivo completo de ejemplos usados en el entrenamiento anterior. Antes de eliminarlo, guardamos una pequeña muestra: 20 mensajes con sus departamentos correctos conocidos. Uno de los métodos posibles consiste en mezclar esta muestra con los nuevos ejemplos de reclamaciones. Así, el entrenamiento posterior también recibe una señal para seguir atendiendo correctamente «¿Dónde está mi paquete?». Reutilizar ejemplos anteriores es una de las estrategias descritas por <a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven y Tolias, <em>Three scenarios for continual learning</em>, §3.3</a>.</p>
<p>Véase también: <a href="https://paweldubiel.com/es/glossary/experience-replay">Experience Replay</a> — guardar una pequeña muestra de ejemplos anteriores y mezclarla con el nuevo entrenamiento.</p>
<p>El equipo de evaluación conserva una prueba independiente de mensajes antiguos, que <strong>no usamos para entrenar</strong>. Después de cada actualización, comprobamos las categorías antiguas y las nuevas. Las cifras siguientes son un ejemplo inventado, no resultados de una investigación; cada prueba contiene 100 mensajes.</p>

























<table><thead><tr><th>Variante del modelo</th><th>Antiguos: aciertos</th><th>Nuevos: aciertos</th></tr></thead><tbody><tr><td>Antes de aprender lo nuevo</td><td>90/100</td><td>0/100 — esta categoría todavía no existe</td></tr><tr><td>Tras aprender solo lo nuevo</td><td>40/100</td><td>92/100</td></tr><tr><td>Tras aprender con la muestra</td><td>89/100</td><td>87/100</td></tr></tbody></table>
<p>La última variante conserva mejor la capacidad anterior, aunque reconoce las reclamaciones peor que la segunda. La tabla muestra <strong>qué comparar</strong>; no promete ese resultado por añadir 20 ejemplos.</p>
<h2 id="las-condiciones-cambian-la-dificultad">Las condiciones cambian la dificultad</h2>
<p>En nuestro ejemplo, el modelo elige entre todos los departamentos que ha aprendido. Una pista como «este mensaje pertenece a la nueva categoría» facilitaría la prueba. La disponibilidad de esas pistas y de los límites entre tareas importa al comparar métodos (<a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven y Tolias, §2–2.3</a>). Una muestra pequeña puede omitir preguntas poco frecuentes; un buen promedio no demuestra que se haya conservado cada capacidad.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> describe un deterioro considerable de las capacidades anteriores; su demostración muestra cómo el nuevo entrenamiento cambia los ajustes compartidos.</li>
<li><a href="https://paweldubiel.com/es/glossary/ajuste-fino">Fine-tuning</a> consiste en seguir entrenando un modelo con ejemplos seleccionados. Tras los entrenamientos sucesivos, también comprobamos sus capacidades anteriores.</li>
<li><a href="https://paweldubiel.com/es/glossary/destilacion-de-conocimiento">Knowledge Distillation</a> puede transmitir indicaciones de un modelo anterior al que se está actualizando; es una estrategia distinta de conservar los mensajes originales (§3.3 del trabajo de van de Ven y Tolias).</li>
</ul>
<p><em>El texto y la ilustración se prepararon con ayuda de IA; los mensajes, el tamaño de la muestra y los resultados de la tabla son un ejemplo educativo propio. La ilustración muestra el objetivo de conservar las capacidades anteriores, no la estructura del modelo.</em></p>]]></content:encoded>
</item>
<item>
  <title>Empaquetado de secuencias</title>
  <link>https://paweldubiel.com/es/glossary/empaquetado-de-secuencias</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/empaquetado-de-secuencias</guid>
  <pubDate>Wed, 07 Oct 2026 07:34:31 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Enseñas al modelo a escribir respuestas breves para clientes: «Muchas gracias», «No» y «Sí». Tras dividirlas en fragmentos de texto, es decir, tokens, suponemos que los ejemplos tienen 3, 2 y 2…</description>
  <content:encoded><![CDATA[<p>Enseñas al modelo a escribir respuestas breves para clientes: «Muchas gracias», «No» y «Sí». Tras dividirlas en fragmentos de texto, es decir, <a href="https://paweldubiel.com/es/glossary/token">tokens</a>, suponemos que los ejemplos tienen 3, 2 y 2 posiciones, incluyendo el marcador de final de cada texto. Si guardas cada uno en una fila separada de ocho posiciones, solo siete de las 24 contienen datos. El resto es <strong>padding</strong>: un relleno que iguala las longitudes, pero no es contenido que haya que aprender. ¿Cómo aprovechar las posiciones libres?</p>
<p><strong>Sequence Packing</strong> coloca varios ejemplos en una única secuencia de entrada para reducir el relleno durante el entrenamiento. En nuestro ejemplo, los tres caben en una fila de ocho posiciones: siete con datos y una vacía. No se han creado respuestas nuevas; ha cambiado su disposición. La <a href="https://huggingface.co/docs/trl/v0.29.0/sft_trainer#packing" rel="noopener noreferrer">documentación de TRL 0.29.0, SFT Trainer, sección «Packing»</a> describe esta función.</p>
<p><img src="https://paweldubiel.com/assets/sequence-packing-paper-strips-divided-tray.webp" alt="Tres tiras de papel de colores colocadas juntas en una bandeja alargada, con separadores finos que mantienen su independencia: una metáfora de Sequence Packing." loading="eager" decoding="async" width="1536" height="1024"></p>
<p>Las ocho posiciones son <strong>una simplificación propia</strong>, no el tamaño predeterminado de una fila en TRL. Un lote habitual de ejemplos puede alinearse solo con el texto más largo; agrupar longitudes similares también reduce el espacio desperdiciado. <a href="https://arxiv.org/html/1706.03762v7#S5.SS1" rel="noopener noreferrer"><em>Attention Is All You Need</em>, §5.1</a>, ya describe esta agrupación. El número de posiciones vacías no determina por sí solo la aceleración: también depende de cómo se ejecutan los cálculos.</p>
<h2 id="una-fila-compartida-no-tiene-por-qué-ser-una-conversación-compartida">Una fila compartida no tiene por qué ser una conversación compartida</h2>
<p>Quieres que «No» siga siendo un ejemplo independiente, no una continuación de «Muchas gracias». El marcador de final es solo un token. El bloqueo habitual de acceso al futuro —<a href="https://paweldubiel.com/es/glossary/enmascaramiento-causal">Causal Masking</a>— sigue permitiendo que un texto posterior lea el anterior dentro de la misma fila.</p>
<p>Para conservar la independencia, los cálculos tienen que conocer los límites de los ejemplos y bloquear el acceso a través de ellos. También hay que cuidar por separado la evaluación del error: no enseñar a predecir el primer token de «No» desde el final del texto anterior. La selección de posiciones evaluadas es <a href="https://paweldubiel.com/es/glossary/enmascaramiento-de-la-perdida">Loss masking</a>; omitir la penalización de una posición <strong>no bloquea su lectura</strong>.</p>
<p>En concreto, en el <a href="https://github.com/huggingface/trl/blob/v0.29.0/trl/trainer/sft_trainer.py" rel="noopener noreferrer">código de TRL 0.29.0: DataCollatorForLanguageModeling y la configuración de BFD packing</a>, las longitudes de los ejemplos sirven para reconstruir los límites y los comienzos se omiten en la evaluación del error. Esta ejecución exige una implementación compatible de attention, el mecanismo que usa otras posiciones del texto; el código advierte de fugas de información con una configuración no compatible. Es una condición de esa solución concreta, no una propiedad de todo packing.</p>
<h2 id="comprueba-dos-cosas-por-separado">Comprueba dos cosas por separado</h2>
<p>Activa el empaquetado y después desactiva la separación del acceso. Las posiciones seguirán ahorradas, pero B1 podrá usar el ejemplo A anterior. Los cuadrados representan tokens de final; A1, B1, etc. son fragmentos de texto hipotéticos. La demostración muestra las conexiones permitidas sin simular respuestas del modelo. La variante «filas completas» revela la ausencia de ahorro cuando todos los ejemplos ya llenan ocho posiciones cada uno.</p>
<div id="sequence-packing-lab"></div>
<p>Las estrategias difieren en cómo tratan los textos largos. En <a href="https://github.com/huggingface/trl/blob/v0.29.0/trl/data_utils.py" rel="noopener noreferrer">TRL 0.29.0, función <code>pack_dataset</code></a>, <code>bfd</code> ajusta ejemplos enteros a los huecos libres, pero recorta el exceso de un ejemplo demasiado largo; <code>wrapped</code> puede cortar el texto por la mitad. Por eso hay que comprobar tanto los datos conservados como los límites. Packing organiza las entradas del entrenamiento, incluido <a href="https://paweldubiel.com/es/glossary/ajuste-fino">Fine-tuning</a>, la adaptación adicional del modelo mediante ejemplos. No aumenta la longitud máxima de texto que admite el modelo.</p>]]></content:encoded>
</item>
<item>
  <title>Aprendizaje por refuerzo</title>
  <link>https://paweldubiel.com/es/glossary/aprendizaje-por-refuerzo</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/aprendizaje-por-refuerzo</guid>
  <pubDate>Mon, 05 Oct 2026 08:44:03 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Quieres enseñar a un programa a ganar en un juego pequeño. En una bifurcación puede elegir la ruta A, recoger dos monedas de inmediato y terminar el segundo turno sin monedas nuevas.</description>
  <content:encoded><![CDATA[<p>Quieres enseñar a un programa a ganar en un juego pequeño. En una bifurcación puede elegir la ruta A, recoger dos monedas de inmediato y terminar el segundo turno sin monedas nuevas. La ruta B no da nada en el primer turno, pero lleva a cinco monedas en el segundo. La regla «elige lo que más da ahora» señala A, aunque B produce un mejor resultado tras dos turnos. Tampoco tienes un conjunto de respuestas preparadas que indique el movimiento correcto en cada situación. En cambio, el programa puede jugar partidas y comprobar sus resultados.</p>
<p><strong>Reinforcement Learning (RL)</strong> es el aprendizaje de una estrategia de acción a partir de experiencias y evaluaciones numéricas de los efectos de las acciones. El objetivo es aumentar la recompensa total esperada: el resultado que la estrategia produce en promedio tras muchos intentos. La recompensa no tiene por qué aparecer inmediatamente después de la decisión. Así describe el problema la guía oficial <a href="https://spinningup.openai.com/en/latest/spinningup/rl_intro.html" rel="noopener noreferrer">Spinning Up, parte 1, «Key Concepts and Terminology», «Reward and Return» y «The RL Problem»</a>.</p>
<p><img src="https://paweldubiel.com/assets/reinforcement-learning-two-routes-delayed-reward.webp" alt="Una bifurcación en un tablero de madera: el camino cercano lleva a una recompensa pequeña y el más largo a una mayor." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="qué-obtiene-el-programa-de-una-partida">Qué obtiene el programa de una partida</h2>
<p>En nuestro juego, el <strong>agente</strong> es el programa que elige la ruta y el <strong>entorno</strong> es el juego que ejecuta el movimiento y concede las monedas. El programa recibe una observación, es decir, la información disponible sobre la situación, como la posición en el tablero. La <strong>policy</strong> es su regla para elegir acciones; también puede determinar las probabilidades de elegir distintos movimientos.</p>
<p>Después del intento A, el programa registra el resultado «2, luego 0». El intento B da «0, luego 5». El algoritmo de aprendizaje usa esas experiencias para mejorar la policy, por ejemplo, eligiendo B más a menudo en esta bifurcación. Es una descripción del objetivo, no una receta universal de actualización. Hay que relacionar el resultado 5 con la elección anterior de B. Si el programa siempre elige A, no recoge información sobre B; por eso el aprendizaje suele exigir probar también acciones menos conocidas.</p>
<p>El juego inventado tiene resultados fijos y dos turnos. En un entorno más difícil, el mismo movimiento puede tener efectos distintos, por lo que importa el resultado esperado y un éxito aislado no demuestra haber encontrado una buena estrategia. Comparar dos sumas conocidas tampoco constituye todavía aprendizaje.</p>
<p>En <a href="https://paweldubiel.com/es/glossary/clonacion-del-comportamiento">Behavioral cloning</a>, el programa aprende a imitar acciones de ejemplos. En RL, la información que orienta el aprendizaje es la evaluación de los efectos. En los modelos de lenguaje, la acción puede ser generar una respuesta y la recompensa una evaluación de su corrección o utilidad. <a href="https://paweldubiel.com/glossary/reinforcement-learning-from-human-feedback" hreflang="pl">RLHF [Polski]</a> usa para ello información procedente de personas.</p>
<p>Un límite importante: RL mejora el resultado según la recompensa elegida. Si los puntos premian eludir las reglas en lugar de completar la tarea, el agente puede aprender <a href="https://paweldubiel.com/glossary/reward-hacking-wykorzystywanie-luk-w-systemie-nagrod" hreflang="pl">Reward hacking [Polski]</a>. Más puntos no tienen por qué significar el comportamiento que realmente buscábamos.</p>
<h2 id="apuesta-por-una-ruta-y-comprueba-el-segundo-turno">Apuesta por una ruta y comprueba el segundo turno</h2>
<p>En este experimento comparas el objetivo de dos estrategias, <strong>no entrenas a un agente</strong>. Elige una ruta y descubre el resultado posterior. El deslizador cambia la importancia de la recompensa futura, no el número de monedas recogidas.</p>
<p>Calculamos el <strong>return</strong>, es decir, el resultado de todo el intento: <code>primera recompensa + γ × segunda recompensa</code>. El símbolo γ (gamma) es el peso de la recompensa futura. Con γ = 1, contamos íntegramente ambos turnos: A da 2 y B da 5. Con γ = 0,2, obtenemos A = 2 y B = 1. Es un objetivo distinto para evaluar el mismo juego. Aquí se permiten los valores límite γ = 0 y 1 porque el intento termina después de dos turnos; no es una secuencia infinita de recompensas. Fuente del formalismo: <a href="https://spinningup.openai.com/en/latest/spinningup/rl_intro.html#reward-and-return" rel="noopener noreferrer">Spinning Up, «Reward and Return»</a>.</p>
<div id="rl-delayed-reward-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Enmascaramiento de la pérdida</title>
  <link>https://paweldubiel.com/es/glossary/enmascaramiento-de-la-perdida</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/enmascaramiento-de-la-perdida</guid>
  <pubDate>Sun, 20 Sep 2026 15:05:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>training</category>
  <description>Entrenas a un agente con registros de conversaciones con herramientas. El registro contiene sus órdenes y las respuestas de las herramientas.</description>
  <content:encoded><![CDATA[<p>Entrenas a un agente con registros de conversaciones con herramientas. El registro contiene sus órdenes y las respuestas de las herramientas. Quieres evaluarlo por determinados fragmentos, pero permitirle seguir leyendo los demás como contexto para la siguiente acción.</p>
<p><strong>Loss masking</strong> determina qué posiciones contribuyen a la pérdida, es decir, a la evaluación numérica del error durante el aprendizaje. Un <a href="https://paweldubiel.com/es/glossary/token">token</a> —un fragmento de texto— puede seguir siendo visible en la entrada aunque el modelo no sea evaluado directamente por predecirlo.</p>
<p>Al entrenar únicamente con las respuestas del agente, el texto del usuario y el resultado de la herramienta ayudan a elegir el siguiente paso, pero no reciben su propia penalización por la predicción. Por tanto, el modelo no tiene que aprender a generar cada parte del registro completo.</p>
<p>Esto difiere del <a href="https://paweldubiel.com/es/glossary/enmascaramiento-causal">enmascaramiento causal</a>, que limita el flujo de información entre posiciones. La ausencia de un componente de pérdida para un token no tiene por qué significar que no influya en el entrenamiento: sus cálculos pueden afectar a las posiciones posteriores que sí se evalúan. El <a href="https://arxiv.org/html/2609.20715v1#S2" rel="noopener noreferrer">trabajo «Don’t Mask the Environment», §2</a>, estudia las consecuencias de elegir qué fragmentos se evalúan.</p>
<p>Véase también: <a href="https://paweldubiel.com/es/glossary/empaquetado-de-secuencias">Sequence Packing</a> muestra por qué, al combinar ejemplos, hay que controlar por separado el acceso al contexto y las posiciones evaluadas por la pérdida.</p>
<p><img src="https://paweldubiel.com/assets/loss-masking-hero.webp" alt="Seis tokens permanecen en una sola fila, pero solo tres de color naranja están conectados al platillo de una balanza que simboliza la pérdida." loading="eager" decoding="async" width="1600" height="900"></p>]]></content:encoded>
</item>
<item>
  <title>pass@k</title>
  <link>https://paweldubiel.com/es/glossary/pass-k</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/pass-k</guid>
  <pubDate>Sun, 20 Sep 2026 15:04:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <description>El modelo ha preparado diez programas y uno ha superado las pruebas. ¿Significa eso que una respuesta individual tiene una buena tasa de éxito?</description>
  <content:encoded><![CDATA[<p>El modelo ha preparado diez programas y uno ha superado las pruebas. ¿Significa eso que una respuesta individual tiene una buena tasa de éxito? Necesitas distinguir «funcionó a la primera» de «encontramos un éxito entre muchos intentos».</p>
<p><strong>pass@k</strong> mide la probabilidad de que al menos uno de los <code>k</code> intentos de realizar una tarea supere la comprobación establecida. El resultado se resume sobre el conjunto de tareas. El número <code>k</code> forma parte del significado de la métrica porque determina el presupuesto de intentos.</p>
<p>En un conjunto de cuatro ejecuciones con un éxito, la estimación de pass@1 es <code>1/4</code>. De las seis parejas posibles, tres contienen el éxito, por lo que la estimación de pass@2 para ese conjunto es <code>1/2</code>. No debe confundirse el número de intentos recogidos para la estimación con el número de intentos permitido en la situación que se mide.</p>
<p>Un pass@10 alto no promete un pass@1 igual de bueno. Tampoco indica si el usuario puede identificar el intento correcto sin un comprobador. <a href="https://arxiv.org/abs/2107.03374" rel="noopener noreferrer">Chen y colaboradores, §3.1</a>, describen la estimación de pass@k; el <a href="https://arxiv.org/html/2609.20715v1#A1" rel="noopener noreferrer">trabajo sobre agentes</a> utiliza esta métrica en otro contexto.</p>]]></content:encoded>
</item>
<item>
  <title>Batching continuo</title>
  <link>https://paweldubiel.com/es/glossary/batching-continuo</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/batching-continuo</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El servidor genera dos respuestas al mismo tiempo. Una termina pronto y la otra es larga. Si el siguiente usuario tiene que esperar a que termine toda la pareja, la plaza liberada se desperdicia…</description>
  <content:encoded><![CDATA[<p>El servidor genera dos respuestas al mismo tiempo. Una termina pronto y la otra es larga. Si el siguiente usuario tiene que esperar a que termine toda la pareja, la plaza liberada se desperdicia durante muchos pasos.</p>
<p><strong>Continuous Batching</strong> permite cambiar la composición del grupo de solicitudes atendidas entre las sucesivas iteraciones del modelo. Una respuesta terminada abandona el batch —el grupo procesado conjuntamente— y una nueva solicitud puede ocupar su lugar.</p>
<p>La respuesta larga sigue desarrollándose mientras la corta es sustituida por la siguiente. La selección de los participantes corresponde al scheduler, el programa que planifica el trabajo. No hace falta esperar al participante más lento de todo el grupo anterior.</p>
<p>Este aprovechamiento de las plazas puede aumentar el rendimiento, pero no garantiza una espera menor a todos los usuarios. Importan las longitudes de las solicitudes, los límites de memoria y las reglas de planificación. Con longitudes similares, la ventaja sobre un grupo fijo puede ser pequeña.</p>
<p>Fuente del mecanismo: <a href="https://www.usenix.org/system/files/osdi22-yu.pdf#page=6" rel="noopener noreferrer"><em>Orca</em>, §3, «Iteration-level scheduling»</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><img src="https://paweldubiel.com/assets/continuous-batching-hero.webp" alt="Una prensa con dos carriles: una cinta turquesa larga sigue avanzando, mientras una naranja ocupa el lugar de una corta de color ocre." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Es especialmente útil en <a href="https://paweldubiel.com/es/glossary/decode">Decode</a>: una persona necesita una respuesta breve y otra varios cientos de <a href="https://paweldubiel.com/es/glossary/token">tokens</a>. Reunir varias solicitudes antes de ejecutar el modelo no basta para poder cambiar la composición de un batch que ya está en marcha. Una solicitud nueva también necesita <a href="https://paweldubiel.com/es/glossary/prefill">Prefill</a>; la gestión de esta etapa junto con la generación depende de la implementación del motor.</p>
<h2 id="debe-c-esperar-a-a">¿Debe C esperar a A?</h2>
<p>Experimento propio: hay dos espacios disponibles. A y B están listas en el instante 0 y necesitan seis y dos rondas, respectivamente. C queda lista en el instante 1 y necesita dos rondas. En ambas variantes realizamos los mismos cálculos, pero en el grupo fijo el espacio de B no admite C hasta que termina A.</p>
<p>Con batching continuo, C empieza en el instante 2 y termina en el 4; con un grupo fijo, empieza en el 6 y termina en el 8. Cambia B a seis rondas: en ese caso desaparece la liberación temprana del espacio y ambas estrategias producen el mismo calendario.</p>
<div id="continuous-batch-lab"></div>
<p>Las rondas tienen aquí una duración convencional e igual. Prefill y las transferencias quedan fuera del experimento; «lista» significa lista para las rondas mostradas. En la GPU, el tiempo de una iteración depende de su trabajo, así que el número de espacios ocupados no es un porcentaje de utilización del dispositivo.</p>
<p>Poder incorporar una solicitud no garantiza que empiece inmediatamente: se aplican los límites de memoria y la política del planificador (<em>Orca</em>, §4.2). <a href="https://paweldubiel.com/es/glossary/pagedattention">PagedAttention</a> facilita la gestión de memoria, pero no establece por sí solo el orden de atención.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Caché de prefijos</title>
  <link>https://paweldubiel.com/es/glossary/cache-de-prefijos</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/cache-de-prefijos</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Haces cinco preguntas sobre el mismo documento largo. Cada entrada empieza con una instrucción idéntica y el texto del documento; solo al final aparece la nueva pregunta.</description>
  <content:encoded><![CDATA[<p>Haces cinco preguntas sobre el mismo documento largo. Cada entrada empieza con una instrucción idéntica y el texto del documento; solo al final aparece la nueva pregunta. Volver a calcular el mismo principio repetiría el trabajo.</p>
<p><strong>Prefix Caching</strong> aprovecha los resultados ya calculados de un prefijo común de <a href="https://paweldubiel.com/es/glossary/token">tokens</a> —fragmentos de texto— en las siguientes solicitudes. En los modelos adecuados pueden ser datos de <a href="https://paweldubiel.com/es/glossary/cache-kv">KV Cache</a>, que permiten omitir parte del <a href="https://paweldubiel.com/es/glossary/prefill">procesamiento de la entrada</a>.</p>
<p>Todavía hay que procesar la nueva pregunta y generar su respuesta. La caché no es una biblioteca de respuestas preparadas. Importa que coincidan el prefijo y las condiciones de cálculo: dos documentos de significado parecido no tienen por qué compartir una caché.</p>
<p>Incluso un pequeño cambio en un fragmento anterior puede impedir aprovechar los bloques posteriores. El ahorro afecta al trabajo repetido, no a todas las conversaciones; almacenar los resultados compartidos también ocupa memoria.</p>
<p>Fuente del mecanismo: <a href="https://docs.vllm.ai/en/v0.21.0/features/automatic_prefix_caching/" rel="noopener noreferrer">vLLM 0.21.0, «Introduction» y «Limits»</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><img src="https://paweldubiel.com/assets/prefix-caching-hero.webp" alt="Un tronco común formado por los mismos segmentos se divide en tres ramas distintas sin terminar." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Lo que importa es un <strong>prefijo idéntico de tokens en un contexto de cálculo compatible</strong>, no la similitud de significado. Las claves y los valores de las capas posteriores dependen del contexto anterior. El mismo párrafo final después de un comienzo modificado no produce automáticamente las mismas KV.</p>
<p>vLLM identifica un bloque a partir de sus tokens, el identificador del bloque anterior y datos adicionales, entre ellos el identificador del adaptador <a href="https://paweldubiel.com/es/glossary/lora">LoRA</a> y la entrada de imágenes. En la versión descrita guarda bloques completos para reutilizarlos. Véase la <a href="https://docs.vllm.ai/en/v0.21.0/design/prefix_caching/" rel="noopener noreferrer">descripción del mecanismo Automatic Prefix Caching</a>. La coincidencia del modelo, las posiciones y otros ajustes que afectan a KV es una condición para una reutilización correcta; comparar los textos no basta.</p>
<h2 id="un-token-cambiado-efectos-distintos">Un token cambiado, efectos distintos</h2>
<p>La caché de nuestro ejemplo contiene la secuencia A B C D E F G H, dividida en bloques de dos tokens. Las letras representan identificadores de tokens convencionales. Una solicitud nueva sustituye exactamente una posición por X. Cambia su lugar y comprueba cuántos bloques completos se pueden recuperar.</p>
<p>Cambiar H por X deja siete tokens comunes, pero solo seis dentro de bloques completos. Cambiar A por X produce cero aciertos, aunque los siete tokens posteriores coincidan. Todas las demás condiciones son fijas en el ejemplo; la caché está disponible y no se ha eliminado nada de ella.</p>
<div id="prefix-match-lab"></div>
<p>Es una caché de cálculos, no de respuestas preparadas. <a href="https://paweldubiel.com/es/glossary/decode">Decode</a> debe seguir generando los tokens posteriores, y los bloques eliminados deben calcularse otra vez. <a href="https://paweldubiel.com/es/glossary/pagedattention">PagedAttention</a> explica la organización de la memoria en bloques.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>PagedAttention</title>
  <link>https://paweldubiel.com/es/glossary/pagedattention</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/pagedattention</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El servidor atiende conversaciones de distinta longitud. Si reserva de antemano para cada una una gran zona contigua de memoria para toda la respuesta futura, parte del espacio queda sin utilizar.</description>
  <content:encoded><![CDATA[<p>El servidor atiende conversaciones de distinta longitud. Si reserva de antemano para cada una una gran zona contigua de memoria para toda la respuesta futura, parte del espacio queda sin utilizar. Quieres asignar fragmentos más pequeños a medida que se necesiten.</p>
<p><strong>PagedAttention</strong> lee la información de <a href="https://paweldubiel.com/es/glossary/cache-kv">KV Cache</a> almacenada en bloques que pueden encontrarse en distintas zonas de la memoria. Una tabla de bloques indica dónde encontrar el siguiente fragmento lógico de la conversación. El orden del texto sigue siendo correcto.</p>
<p>Si un bloque contiene las descripciones de cuatro <a href="https://paweldubiel.com/es/glossary/token">tokens</a> —fragmentos de texto—, tras el quinto hace falta otro bloque. El sistema no tiene que reservar de antemano espacio para la longitud máxima de cada conversación. También puede compartir bloques que no hayan cambiado, de acuerdo con las reglas de gestión de memoria.</p>
<p>Es una forma de direccionar y organizar los datos, no una reducción automática del contexto ni un cambio en el resultado de attention. Sigue existiendo el coste de las tablas y los bloques parcialmente llenos. El experimento muestra la separación entre el orden lógico y la ubicación física.</p>
<p>Fuente del mecanismo: <a href="https://arxiv.org/html/2309.06180v1#S4.SS1" rel="noopener noreferrer">Kwon et al., §4.1–4.3</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><img src="https://paweldubiel.com/assets/pagedattention-hero.webp" alt="Un hilo de color albaricoque une cuatro bloques separados, manteniendo la continuidad de la secuencia pese a su dispersión en la memoria." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Ejemplo propio: un bloque contiene las KV de cuatro posiciones. Para una secuencia de longitud cinco hacen falta dos bloques, es decir, ocho espacios. El primer bloque está lleno; el segundo contiene una entrada y tres espacios libres. Los bloques lógicos 0 y 1 pueden apuntar a los bloques físicos 4 y 1. No hay que mover el prefijo existente para añadir otro bloque durante <a href="https://paweldubiel.com/es/glossary/decode">Decode</a>.</p>
<h2 id="el-orden-del-texto-no-es-la-dirección-de-memoria">El orden del texto no es la dirección de memoria</h2>
<p>La demostración muestra una secuencia y bloques de cuatro posiciones. Procesa las posiciones siguientes, en particular el paso de cuatro a cinco. Después cambia la distribución de los mismos datos. Suponemos una cabeza escalar: todas las claves son cero, la consulta vale 1 y los valores de las posiciones sucesivas son 1, 2, 3… Los pesos de atención son iguales y el resultado es la media de los valores. Para cinco posiciones, vale 3 en ambas distribuciones.</p>
<div id="paged-kv-lab"></div>
<p>Es una ilustración del direccionamiento y la asignación, no una simulación del tiempo de GPU. Los espacios vacíos del último bloque siguen ocupando memoria; PagedAttention no elimina ni comprime las KV existentes. <a href="https://paweldubiel.com/es/glossary/flashattention">FlashAttention</a> se centra en la organización del cálculo y las transferencias durante la atención. Estos mecanismos pueden complementarse. Compartir memoria por bloques también resulta útil en la <a href="https://paweldubiel.com/es/glossary/cache-de-prefijos">caché de prefijos</a>.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Tiempo hasta el primer token</title>
  <link>https://paweldubiel.com/es/glossary/tiempo-hasta-el-primer-token</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/tiempo-hasta-el-primer-token</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Pulsas «Enviar» y miras el chat vacío. Para la comodidad del usuario importa cuándo aparece el principio de la respuesta, aunque escribirla entera lleve mucho más tiempo.</description>
  <content:encoded><![CDATA[<p>Pulsas «Enviar» y miras el chat vacío. Para la comodidad del usuario importa cuándo aparece el principio de la respuesta, aunque escribirla entera lleve mucho más tiempo. Necesitas medir esa primera espera.</p>
<p><strong>Time to First Token (TTFT)</strong> es el tiempo desde el inicio definido de la atención de una solicitud hasta el primer <a href="https://paweldubiel.com/es/glossary/token">token</a>, es decir, un fragmento de la respuesta. En la medición del cliente descrita, empezamos al enviar la solicitud y terminamos al recibir el primer contenido no vacío.</p>
<p>Si la pregunta se envió a los <code>0 ms</code> y el primer texto llegó a los <code>800 ms</code>, el TTFT es de <code>800 ms</code>. Esta cifra puede incluir la red, la cola, la preparación de la entrada y los cálculos. Una medición del tiempo del modelo tendría otros límites.</p>
<p>Un TTFT bajo no garantiza que el resto fluya: tras el primer fragmento puede haber una pausa larga. Eso lo describe <a href="https://paweldubiel.com/glossary/inter-token-latency" hreflang="pl">Inter-token Latency [Polski]</a>. Al comparar, siempre hay que indicar desde dónde y hasta dónde se ha medido el tiempo.</p>
<p>Fuente del mecanismo: <a href="https://docs.nvidia.com/nim/benchmarking/llm/latest/metrics.html#time-to-first-token" rel="noopener noreferrer">documentación de NVIDIA NIM Benchmarking, «Time to First Token»</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><img src="https://paweldubiel.com/assets/time-to-first-token-hero.webp" alt="El primer cuadrado dorado atraviesa el estrechamiento de un reloj de arena, mientras la mayor parte del contenido sigue arriba." loading="eager" decoding="async" width="1600" height="900"></p>
<p>TTFT incluye más que <a href="https://paweldubiel.com/es/glossary/prefill">Prefill</a>: el cliente puede esperar a la red, a la preparación de la entrada, a la cola, a los cálculos y al envío del resultado. Una medición que empieza dentro del servidor tiene otros límites. No deben compararse esas cifras sin comprobar de dónde proceden sus marcas de tiempo.</p>
<h2 id="el-primer-carácter-pronto-la-respuesta-completa-tarde">El primer carácter pronto, la respuesta completa tarde</h2>
<p>Traza de eventos propia: envío a los 0 ms, llegada al servidor a los 30 ms, preparación de 10 ms, cola de 200 ms, Prefill de 120 ms, preparación del primer resultado de 5 ms y entrega de 35 ms. El TTFT del cliente es <strong>400 ms</strong>; el tiempo desde la llegada de la solicitud hasta la preparación del resultado en el servidor es <strong>335 ms</strong>.</p>
<p>Después del primer token recibimos cuatro más, uno cada 20 ms. La respuesta completa llega a los 480 ms. Aumenta sus intervalos a 100 ms: el final pasa a los 800 ms, pero el primer token sigue llegando a los 400 ms. Después aumenta la cola y observa qué resultados cambian juntos.</p>
<div id="ttft-clock-lab"></div>
<p>Los tiempos son sintéticos, las etapas no se solapan y cada mensaje contiene un token. El streaming real puede agrupar tokens. TTFT no describe el ritmo de <a href="https://paweldubiel.com/es/glossary/decode">Decode</a> ni el tiempo hasta recibir la respuesta completa; la documentación separa esas métricas en «Inter-token Latency» y «End-to-End Request Latency». <a href="https://paweldubiel.com/glossary/inter-token-latency" hreflang="pl">Inter-token Latency [Polski]</a> describe los intervalos y las pausas después del primer token. <a href="https://paweldubiel.com/es/glossary/cache-de-prefijos">Prefix Caching</a> puede reducir el trabajo sobre el prompt, y <a href="https://paweldubiel.com/es/glossary/batching-continuo">Continuous Batching</a> influye en cuándo el scheduler admite la solicitud para su ejecución.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Decode</title>
  <link>https://paweldubiel.com/es/glossary/decode</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/decode</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ya ha aparecido el primer fragmento de la respuesta. El siguiente debe tener en cuenta lo que acaba de escribirse: después de «Hoy bebo té», el modelo tiene un contexto distinto que después de «Hoy…</description>
  <content:encoded><![CDATA[<p>Ya ha aparecido el primer fragmento de la respuesta. El siguiente debe tener en cuenta lo que acaba de escribirse: después de «Hoy bebo té», el modelo tiene un contexto distinto que después de «Hoy bebo agua». Hay que desarrollar sucesivamente ese texto que va cambiando.</p>
<p><strong>Decode</strong> es la etapa de generación de la continuación tras procesar la entrada inicial. En el bucle habitual, el modelo procesa el último <a href="https://paweldubiel.com/es/glossary/token">token</a> elegido —un fragmento de texto—, calcula las probabilidades del siguiente y una regla de selección añade uno de los candidatos.</p>
<p>El fragmento elegido se convierte en la entrada del siguiente paso. <a href="https://paweldubiel.com/es/glossary/cache-kv">KV Cache</a> conserva los resultados necesarios de cálculos anteriores, de modo que no hay que procesar de nuevo todo el historial.</p>
<p>Se crea una dependencia entre las elecciones sucesivas, aunque varias respuestas distintas pueden atenderse juntas. Aquí Decode significa desarrollar el texto mediante el modelo, no solo convertir los números de los tokens en caracteres. <a href="https://paweldubiel.com/es/glossary/prefill">Prefill</a> prepara el contexto inicial.</p>
<p>Fuente del mecanismo: <a href="https://arxiv.org/html/1911.02150v1#S2.SS4" rel="noopener noreferrer">Shazeer, <em>Fast Transformer Decoding</em>, §2.4</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><img src="https://paweldubiel.com/assets/decode-hero.webp" alt="Una fila de puntos de tejido ya hechos termina en un punto nuevo que se forma en la aguja." loading="eager" decoding="async" width="1600" height="900"></p>
<p>El primer token de la respuesta puede elegirse a partir del resultado de <a href="https://paweldubiel.com/es/glossary/prefill">Prefill</a>. Si la generación continúa, ese token se convierte en la entrada de la siguiente pasada por el modelo. Sus nuevas K y V se añaden a la <a href="https://paweldubiel.com/es/glossary/cache-kv">caché KV</a>, y su consulta utiliza la posición actual y las anteriores. Elegir el identificador de un token todavía no añade su representación a la caché. Esto se ve en el <a href="https://huggingface.co/docs/transformers/cache_explanation#cache-storage-implementation" rel="noopener noreferrer">bucle de generación de Hugging Face, «Cache storage implementation»</a>.</p>
<h2 id="token-elegido-pero-aún-sin-procesar">Token elegido, pero aún sin procesar</h2>
<p>El modelo miniatura propio tiene tres tokens: A, B y C. Sus vectores son, respectivamente, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(0,1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mo>−</mo><mn>1</mn><mo separator="true">,</mo><mo>−</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(-1,-1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">−</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">−</span><span class="mord">1</span><span class="mclose">)</span></span></span></span>. Tomamos <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Q</mi><mo>=</mo><mi>K</mi><mo>=</mo><mi>V</mi></mrow><annotation encoding="application/x-tex">Q=K=V</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8778em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">Q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.2222em;">V</span></span></span></span> iguales a esos vectores; la atención utiliza la escala <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mi mathvariant="normal">/</mi><msqrt><mn>2</mn></msqrt></mrow><annotation encoding="application/x-tex">1/\sqrt{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1572em;vertical-align:-0.25em;"></span><span class="mord">1/</span><span class="mord sqrt"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.9072em;"><span class="svg-align" style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="mord" style="padding-left:0.833em;"><span class="mord">2</span></span></span><span style="top:-2.8672em;"><span class="pstrut" style="height:3em;"></span><span class="hide-tail" style="min-width:0.853em;height:1.08em;"><svg xmlns="http://www.w3.org/2000/svg" width="400em" height="1.08em" viewBox="0 0 400000 1080" preserveAspectRatio="xMinYMin slice"><path d="M95,702
c-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,-10,-9.5,-14
c0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54
c44.2,-33.3,65.8,-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10
s173,378,173,378c0.7,0,35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429
c69,-144,104.5,-217.7,106.5,-221
l0 -0
c5.3,-9.3,12,-14,20,-14
H400000v40H845.2724
s-225.272,467,-225.272,467s-235,486,-235,486c-2.7,4.7,-9,7,-19,7
c-6,0,-10,-1,-12,-3s-194,-422,-194,-422s-65,47,-65,47z
M834 80h400000v40h-400000z"></path></svg></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1328em;"><span></span></span></span></span></span></span></span></span>. A partir del resultado <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>h</mi><mo>=</mo><mo stretchy="false">(</mo><msub><mi>h</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>h</mi><mn>1</mn></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">h=(h_0,h_1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> creamos los logits <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><msub><mi>h</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>h</mi><mn>0</mn></msub><mo separator="true">,</mo><mo>−</mo><msub><mi>h</mi><mn>0</mn></msub><mo>−</mo><msub><mi>h</mi><mn>1</mn></msub><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[h_1,h_0,-h_0-h_1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">−</span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">]</span></span></span></span>, y la <a href="https://paweldubiel.com/es/glossary/decodificacion-voraz">decodificación voraz</a> elige el mayor.</p>
<p>El prompt A B produce aproximadamente <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>h</mi><mo>=</mo><mo stretchy="false">(</mo><mn>0,330</mn><mo separator="true">;</mo><mn>0,670</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">h=(0{,}330;0{,}670)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">330</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">670</span><span class="mclose">)</span></span></span></span>, así que la primera respuesta es A. Por ahora, la caché contiene solo las dos posiciones del prompt. La siguiente pasada será la que procese el A elegido.</p>
<div id="decode-cache-lab"></div>
<p>Es un modelo de demostración completamente especificado, sin aprendizaje, posiciones, múltiples capas ni token de final. Su respuesta repetitiva no tiene significado lingüístico. La comparación con volver a calcular todo el prefijo comprueba la concordancia de los resultados, y el contador incluye solo las posiciones para las que se calcularon K/V.</p>
<p>La caché elimina los cálculos repetidos de K/V anteriores, pero attention sigue leyendo el contexto. Con batches pequeños, la transferencia de pesos o de la caché suele convertirse en el límite; depende del modelo, el hardware y la longitud de la secuencia. En la arquitectura <a href="https://paweldubiel.com/glossary/disaggregated-serving" hreflang="pl">Disaggregated Serving [Polski]</a>, Decode se ejecuta en recursos separados tras recibir la caché. En este sentido, Decode no es la conversión de identificadores de tokens de nuevo en texto mediante el tokenizador.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Decodificación especulativa</title>
  <link>https://paweldubiel.com/es/glossary/decodificacion-especulativa</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/decodificacion-especulativa</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El modelo grande genera texto correctamente, pero despacio. Un modelo pequeño puede proponer con rapidez varios fragmentos siguientes.</description>
  <content:encoded><![CDATA[<p>El modelo grande genera texto correctamente, pero despacio. Un modelo pequeño puede proponer con rapidez varios fragmentos siguientes. Quieres aprovechar su trabajo manteniendo el control del modelo grande sobre el resultado final.</p>
<p><strong>Speculative Decoding</strong> crea una propuesta de continuación más barata y luego la verifica con el modelo objetivo. En el algoritmo clásico aceptamos la secuencia inicial de <a href="https://paweldubiel.com/es/glossary/token">tokens</a> aprobados —fragmentos de texto— hasta el primer rechazo, y entonces calculamos una corrección.</p>
<p>El modelo grande puede evaluar una propuesta conocida para varias posiciones en paralelo. La variante correcta de muestreo usa probabilidades específicas de aceptación y corrección para conservar la distribución objetivo. La simple prueba «¿suena razonable?» no lo garantiza.</p>
<p>La aceleración depende del coste de la propuesta, el número de aceptaciones y el hardware. Si el modelo pequeño discrepa a menudo del grande, el trabajo adicional puede anular la mejora. La demostración siguiente muestra la conservación de las probabilidades, no un tiempo de ejecución garantizado.</p>
<p>Fuente del mecanismo: <a href="https://arxiv.org/html/2211.17192v2#S2" rel="noopener noreferrer">Leviathan et al., §2, algoritmo 1</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>Es una forma de acelerar <a href="https://paweldubiel.com/es/glossary/decode">Decode</a> conservando la distribución del modelo objetivo bajo las condiciones del algoritmo. No basta con comprobar si la propuesta «parece buena».</p>
<h2 id="por-qué-hace-falta-una-corrección">Por qué hace falta una corrección</h2>
<p>Llamemos <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> a la distribución objetivo y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi></mrow><annotation encoding="application/x-tex">q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span> a la del borrador, para el mismo prefijo y el mismo conjunto de tokens. Ambas incluyen las reglas de muestreo elegidas, por ejemplo la <a href="https://paweldubiel.com/es/glossary/temperatura">temperatura</a> y el <a href="https://paweldubiel.com/es/glossary/muestreo-top-p">muestreo top-p</a>. Aceptamos la propuesta <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>∼</mo><mi>q</mi></mrow><annotation encoding="application/x-tex">x\sim q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">∼</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span> con probabilidad:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>min</mi><mo>⁡</mo><mrow><mo fence="true">(</mo><mn>1</mn><mo separator="true">,</mo><mfrac><mrow><mi>p</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><mrow><mi>q</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mfrac><mo fence="true">)</mo></mrow></mrow><annotation encoding="application/x-tex">\min\left(1,\frac{p(x)}{q(x)}\right)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:2.4em;vertical-align:-0.95em;"></span><span class="mop">min</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner"><span class="mopen delimcenter" style="top:0em;"><span class="delimsizing size3">(</span></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.427em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.936em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose delimcenter" style="top:0em;"><span class="delimsizing size3">)</span></span></span></span></span></span></span>
<p>La propuesta muestreada tiene <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>></mo><mn>0</mn></mrow><annotation encoding="application/x-tex">q(x)>0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>. Tras rechazarla, muestreamos de una distribución proporcional a <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>max</mi><mo>⁡</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mi>p</mi><mo>−</mo><mi>q</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\max(0,p-q)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">max</span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mclose">)</span></span></span></span>. Este paso completa exactamente la masa de probabilidad que falta. Si <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mi>q</mi></mrow><annotation encoding="application/x-tex">p=q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span>, no se rechaza nada y no hace falta corrección. <a href="https://arxiv.org/html/2211.17192v2#A1.SS1" rel="noopener noreferrer">Leviathan et al., §2.3 y demostración A.1</a>.</p>
<p>Ejemplo propio: para los tokens A, B y C, sean <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,2</mn><mo separator="true">;</mo><mn>0,5</mn><mo separator="true">;</mo><mn>0,3</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">p=[0{,}2;0{,}5;0{,}3]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">2</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">3</span><span class="mclose">]</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,6</mn><mo separator="true">;</mo><mn>0,3</mn><mo separator="true">;</mo><mn>0,1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">q=[0{,}6;0{,}3;0{,}1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">6</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">3</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">]</span></span></span></span>. La masa incondicional de las propuestas aceptadas es <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0,2</mn><mo separator="true">;</mo><mn>0,3</mn><mo separator="true">;</mo><mn>0,1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0{,}2;0{,}3;0{,}1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">2</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">3</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">]</span></span></span></span>. Los 0,4 restantes deben repartirse a partes iguales entre B y C. Muestrear la corrección de la distribución <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> normal daría, en cambio, el resultado <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0,28</mn><mo separator="true">;</mo><mn>0,50</mn><mo separator="true">;</mo><mn>0,22</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0{,}28;0{,}50;0{,}22]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">28</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">50</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">22</span><span class="mclose">]</span></span></span></span>.</p>
<div id="speculative-mass-lab"></div>
<p>El experimento muestra el balance exacto de una posición, sin simular todo el bucle ni el tiempo de ejecución. Conservar la distribución no garantiza un texto idéntico con la misma semilla: los algoritmos consumen la aleatoriedad de formas distintas y los cálculos tienen precisión limitada. <a href="https://arxiv.org/html/2302.01318v1#S6.SS1" rel="noopener noreferrer">Chen et al., §4.2 y §6.1</a> lo explican.</p>
<p>La aceleración depende del porcentaje de aceptación, del coste del borrador y del hardware. Un borrador demasiado caro o muchos rechazos pueden anular el ahorro, aunque se conserve la distribución correcta.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>FlashAttention</title>
  <link>https://paweldubiel.com/es/glossary/flashattention</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/flashattention</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Attention compara muchas parejas de fragmentos de texto. Si guardamos todos los resultados intermedios en la gran memoria de la tarjeta de cálculo, transferir los datos puede resultar costoso.</description>
  <content:encoded><![CDATA[<p>Attention compara muchas parejas de fragmentos de texto. Si guardamos todos los resultados intermedios en la gran memoria de la tarjeta de cálculo, transferir los datos puede resultar costoso. Quieres realizar el mismo cálculo reduciendo el traslado y el almacenamiento de una tabla enorme.</p>
<p><strong>FlashAttention</strong> organiza el cálculo de attention por bloques en la pequeña memoria rápida del chip. No guarda toda la matriz de comparaciones y pesos en la memoria grande de la GPU, la tarjeta usada para cálculos paralelos.</p>
<p>Cada porción aporta parte del resultado, y el algoritmo actualiza correctamente la normalización y la suma. No basta con calcular medias separadas de las porciones y promediarlas: cada porción puede tener una contribución distinta.</p>
<p>Se conserva la operación matemática de attention exacto, con las diferencias habituales de la aritmética computacional. Para attention denso, el número de comparaciones sigue creciendo de forma cuadrática. La mejora procede de la organización de la memoria y la ejecución, no de eliminar dependencias entre parejas.</p>
<p>Fuente del mecanismo: <a href="https://arxiv.org/html/2205.14135v2#S3" rel="noopener noreferrer">Dao et al., §2–3.2, algoritmo 1</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><img src="https://paweldubiel.com/assets/flashattention-hero.webp" alt="Una pequeña superficie de trabajo procesa una sola placa de un gran conjunto, reduciendo el traslado de todo el contenido." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Para la atención densa, el número de operaciones sigue creciendo cuadráticamente con la longitud de la secuencia. La ganancia procede de la organización del cálculo y de la memoria. Durante el entrenamiento se recalculan algunas cantidades en la pasada hacia atrás en lugar de almacenarlas. «Exacta» significa que no se aproxima la propia operación; un orden diferente de operaciones en coma flotante puede producir pequeñas diferencias numéricas.</p>
<h2 id="no-basta-con-promediar-los-resultados-de-los-bloques">No basta con promediar los resultados de los bloques</h2>
<p><a href="https://paweldubiel.com/es/glossary/softmax">Softmax</a> normaliza los pesos respecto a todas las claves permitidas. Los bloques pueden tener sumas de pesos sin normalizar muy distintas. Por tanto, hay que asignar a cada uno la contribución correcta al resultado.</p>
<p>Esto puede hacerse gradualmente, manteniendo la puntuación máxima <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi></mrow><annotation encoding="application/x-tex">m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">m</span></span></span></span>, la suma <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>l</mi><mo>=</mo><msub><mo>∑</mo><mi>j</mi></msub><msup><mi>e</mi><mrow><msub><mi>s</mi><mi>j</mi></msub><mo>−</mo><mi>m</mi></mrow></msup></mrow><annotation encoding="application/x-tex">l=\sum_j e^{s_j-m}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.2071em;vertical-align:-0.4358em;"></span><span class="mop"><span class="mop op-symbol small-op" style="position:relative;top:0em;">∑</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.162em;"><span style="top:-2.4003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4358em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7713em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3281em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2819em;"><span></span></span></span></span></span></span><span class="mbin mtight">−</span><span class="mord mathnormal mtight">m</span></span></span></span></span></span></span></span></span></span></span></span> y el numerador <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo>=</mo><msub><mo>∑</mo><mi>j</mi></msub><msup><mi>e</mi><mrow><msub><mi>s</mi><mi>j</mi></msub><mo>−</mo><mi>m</mi></mrow></msup><msub><mi>v</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">u=\sum_j e^{s_j-m}v_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.2071em;vertical-align:-0.4358em;"></span><span class="mop"><span class="mop op-symbol small-op" style="position:relative;top:0em;">∑</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.162em;"><span style="top:-2.4003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4358em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7713em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3281em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2819em;"><span></span></span></span></span></span></span><span class="mbin mtight">−</span><span class="mord mathnormal mtight">m</span></span></span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2861em;"><span></span></span></span></span></span></span></span></span></span>. El resultado es <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mi mathvariant="normal">/</mi><mi>l</mi></mrow><annotation encoding="application/x-tex">u/l</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">u</span><span class="mord">/</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span></span></span></span>. Cuando un nuevo bloque aumenta el máximo a <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>m</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow><annotation encoding="application/x-tex">m'</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7519em;"></span><span class="mord"><span class="mord mathnormal">m</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7519em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span>, hay que reescalar los anteriores <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>l</mi></mrow><annotation encoding="application/x-tex">l</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi></mrow><annotation encoding="application/x-tex">u</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">u</span></span></span></span> por <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>e</mi><mrow><mi>m</mi><mo>−</mo><msup><mi>m</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow></msup></mrow><annotation encoding="application/x-tex">e^{m-m'}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.9425em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.9425em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">m</span><span class="mbin mtight">−</span><span class="mord mtight"><span class="mord mathnormal mtight">m</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8278em;"><span style="top:-2.931em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span> antes de añadir los nuevos términos. <a href="https://arxiv.org/html/1805.02867v2#S3" rel="noopener noreferrer">Milakov y Gimelshein, §3, algoritmo 3</a> explican el mecanismo de normalización estable.</p>
<p>El ejemplo propio utiliza las puntuaciones ya dadas <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><mo separator="true">,</mo><mi>ln</mi><mo>⁡</mo><mn>3</mn><mo separator="true">,</mo><mi>ln</mi><mo>⁡</mo><mn>3</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0,0,\ln 3,\ln 3]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mclose">]</span></span></span></span> y los valores <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0,0,1,1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span>. Los pesos antes de normalizar tienen proporciones <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>1</mn><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mn>3</mn><mo separator="true">,</mo><mn>3</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[1,1,3,3]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mclose">]</span></span></span></span>, así que el resultado es <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>6</mn><mi mathvariant="normal">/</mi><mn>8</mn><mo>=</mo><mn>0,75</mn></mrow><annotation encoding="application/x-tex">6/8=0{,}75</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">6/8</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">75</span></span></span></span>. Los resultados de los dos bloques son 0 y 1. Su media normal da el valor incorrecto de 0,5.</p>
<div id="flashattention-blocks-lab"></div>
<p>La demostración aísla la agregación para una consulta y valores escalares. El kernel completo calcula bloques de puntuaciones a partir de Q y K en la GPU; aquí, los números ya dados permiten comprobar el cálculo a mano. Cambiar el tamaño del bloque no es un benchmark.</p>
<p>La <a href="https://paweldubiel.com/es/glossary/atencion-de-consultas-agrupadas">atención de consultas agrupadas</a> reduce el número de cabezas K/V, y FlashAttention cambia cómo se transfieren y procesan los datos. Estas técnicas pueden combinarse. FlashAttention 2 es una evolución posterior de la implementación; el mecanismo descrito aquí procede del primer trabajo.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Prefill</title>
  <link>https://paweldubiel.com/es/glossary/prefill</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/prefill</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Envías una pregunta larga al chat y esperas la primera palabra. Antes de añadir la respuesta, el modelo tiene que procesar el contenido que ya ha recibido.</description>
  <content:encoded><![CDATA[<p>Envías una pregunta larga al chat y esperas la primera palabra. Antes de añadir la respuesta, el modelo tiene que procesar el contenido que ya ha recibido. Esta etapa inicial puede exigir mucho trabajo, sobre todo con un documento largo.</p>
<p><strong>Prefill</strong> es el procesamiento de la entrada conocida, llamada prompt, antes de seguir generando. El modelo crea descripciones numéricas de los <a href="https://paweldubiel.com/es/glossary/token">tokens</a> —fragmentos de texto— y puede conservar parte de los resultados en <a href="https://paweldubiel.com/es/glossary/cache-kv">KV Cache</a> para reutilizarlos.</p>
<p>Como toda la entrada ya existe, muchas de sus posiciones pueden calcularse en paralelo dentro de una capa. Las reglas de acceso al contexto siguen vigentes: el trabajo paralelo no permite a una posición anterior mirar un futuro prohibido.</p>
<p>El resultado de la posición final permite calcular las probabilidades del primer token nuevo. Elegirlo es un paso aparte. Prefill no abarca todo el tiempo desde el envío de la pregunta: también intervienen la red, la cola y otras etapas. <a href="https://paweldubiel.com/es/glossary/decode">Decode</a> describe el desarrollo posterior de la respuesta.</p>
<p>Fuente del mecanismo: <a href="https://developer.nvidia.com/blog/mastering-llm-techniques-inference-optimization/" rel="noopener noreferrer">NVIDIA, <em>Mastering LLM Techniques: Inference Optimization</em>, sección «Understanding LLM inference»</a>.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><img src="https://paweldubiel.com/assets/prefill-hero.webp" alt="Varias tiras de papel preparadas pasan a la vez bajo un peine ancho, y la última llega a un espacio vacío para un nuevo elemento." loading="eager" decoding="async" width="1600" height="900"></p>
<h2 id="el-prompt-conocido-puede-procesarse-en-paralelo">El prompt conocido puede procesarse en paralelo</h2>
<p>Todos los tokens de entrada ya están disponibles, así que dentro de una capa se pueden calcular muchas posiciones a la vez. Sigue aplicándose el <a href="https://paweldubiel.com/es/glossary/enmascaramiento-causal">enmascaramiento causal</a>: la segunda posición no utiliza la tercera. El cálculo paralelo no elimina esta dependencia ni el orden de paso por las capas. <a href="https://arxiv.org/html/1706.03762v7#S3" rel="noopener noreferrer">Vaswani et al., §3.1–3.2</a> describen su base.</p>
<p>Prefill también puede <a href="https://paweldubiel.com/glossary/chunked-prefill" hreflang="pl">procesar el prompt por partes [Polski]</a>, conservando la caché de las posiciones anteriores. La <a href="https://docs.vllm.ai/en/v0.21.0/configuration/optimization/#chunked-prefill" rel="noopener noreferrer">documentación de vLLM, «Chunked Prefill»</a> describe el uso de esta división para intercalar el trabajo sobre los prompts con la generación de respuestas de otras solicitudes.</p>
<h2 id="cuatro-posiciones-el-mismo-resultado">Cuatro posiciones, el mismo resultado</h2>
<p>El ejemplo propio aísla una cabeza de atención de dimensión 1: todas las consultas y claves valen 1, y los valores son <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>2</mn><mo separator="true">,</mo><mn>4</mn><mo separator="true">,</mo><mn>8</mn><mo separator="true">,</mo><mn>10</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[2,4,8,10]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">4</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">8</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">10</span><span class="mclose">]</span></span></span></span>. Los resultados de comparación permitidos son iguales, así que cada posición devuelve la media de los valores visibles: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>2</mn><mo separator="true">,</mo><mn>3</mn><mo separator="true">,</mo><mn>14</mn><mi mathvariant="normal">/</mi><mn>3</mn><mo separator="true">,</mo><mn>6</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[2,3,14/3,6]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">14/3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">6</span><span class="mclose">]</span></span></span></span>. Compara el procesamiento de los cuatro a la vez con fragmentos de dos. En la segunda variante, la tercera posición debe seguir viendo las dos primeras.</p>
<div id="prefill-chunks-lab"></div>
<p>Es el cálculo de una sola operación, sin los pesos de un modelo entrenado ni mediciones de GPU. En un modelo completo, la caché se mantiene por separado para cada capa. Cambiar la división puede introducir pequeñas diferencias numéricas de implementación; no cambia la máscara matemática.</p>
<p>Después del prompt empieza <a href="https://paweldubiel.com/es/glossary/decode">Decode</a>, donde las siguientes entradas dependen de los tokens que se acaban de elegir. El tiempo de Prefill por sí solo no abarca toda la espera del usuario: también importan la cola, la preparación de la entrada y la entrega del resultado. Véase también: el <a href="https://paweldubiel.com/es/glossary/tiempo-hasta-el-primer-token">tiempo hasta el primer token</a> incluye la espera del cliente por el primer token, y el <a href="https://paweldubiel.com/es/glossary/batching-continuo">batching continuo</a> permite cambiar la composición del grupo atendido entre iteraciones.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Atención de consultas agrupadas</title>
  <link>https://paweldubiel.com/es/glossary/atencion-de-consultas-agrupadas</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/atencion-de-consultas-agrupadas</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El modelo lee el texto anterior de varias formas en paralelo. Cada uno de esos cálculos es una cabeza de atención, o attention.</description>
  <content:encoded><![CDATA[<p>El modelo lee el texto anterior de varias formas en paralelo. Cada uno de esos cálculos es una cabeza de atención, o attention. Quieres reducir la memoria que ocupan esas cabezas, pero compartir por completo un único conjunto de datos podría limitar demasiado el modelo. Hay una variante intermedia: algunas cabezas usan un conjunto común y otras uno distinto.</p>
<p><strong>Grouped-Query Attention (GQA)</strong> divide las cabezas query en grupos que comparten key y value. Query es una descripción numérica que sirve para leer el contexto, key para establecer correspondencias y value para transmitir información. Cada cabeza sigue calculando sus propios pesos.</p>
<p>Ocho cabezas query divididas en dos grupos de cuatro significan dos conjuntos key/value, no ocho. Un único grupo da <a href="https://paweldubiel.com/es/glossary/atencion-multi-query">MQA</a>; un grupo por cabeza corresponde al <a href="https://paweldubiel.com/es/glossary/atencion-de-multiples-cabezas">MHA</a> habitual.</p>
<p>Con dimensiones compatibles, menos conjuntos reducen el coste de almacenar KV. Es un compromiso entre diseño y calidad, no un interruptor que garantice una velocidad concreta. El tiempo también depende del hardware y de los demás cálculos.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>Para <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi></mrow><annotation encoding="application/x-tex">H</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span></span></span></span> cabezas de consulta y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi></mrow><annotation encoding="application/x-tex">G</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span></span></span></span> grupos obtenemos <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi></mrow><annotation encoding="application/x-tex">G</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span></span></span></span> conjuntos de K/V. Cuando <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">G=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>, es <a href="https://paweldubiel.com/es/glossary/atencion-multi-query">atención multi-query</a>. Cuando <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo>=</mo><mi>H</mi></mrow><annotation encoding="application/x-tex">G=H</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span></span></span></span>, volvemos a la <a href="https://paweldubiel.com/es/glossary/atencion-de-multiples-cabezas">atención de múltiples cabezas</a>. <a href="https://arxiv.org/html/2305.13245v3#S2.SS2" rel="noopener noreferrer">Ainslie et al., <em>GQA</em>, §2.2</a> describen esta familia y la notación GQA-g.</p>
<h2 id="calcula-la-memoria-antes-de-adivinar-la-velocidad">Calcula la memoria antes de adivinar la velocidad</h2>
<p>Nuestro cálculo para <a href="https://paweldubiel.com/es/glossary/cache-kv">KV Cache</a> supone batch size 1, 32 capas, 1024 <a href="https://paweldubiel.com/es/glossary/token">tokens</a> almacenados, una dimensión de 128 para cada cabeza key/value y 2 bytes por número. Solo los elementos K/V ocupan:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mn>2</mn><mo>⋅</mo><mn>32</mn><mo>⋅</mo><mn>1024</mn><mo>⋅</mo><mi>G</mi><mo>⋅</mo><mn>128</mn><mo>⋅</mo><mn>2</mn><mtext> bytes</mtext></mrow><annotation encoding="application/x-tex">2\cdot32\cdot1024\cdot G\cdot128\cdot2\ \text{bytes}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">32</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1024</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">128</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord">2</span><span class="mspace"> </span><span class="mord text"><span class="mord">bytes</span></span></span></span></span></span>
<p>El primer dos representa K y V. Con ocho cabezas de consulta, el resultado es 128 MiB en MHA, 32 MiB con dos cabezas KV y 16 MiB en MQA. Un MiB son <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mn>20</mn></msup></mrow><annotation encoding="application/x-tex">2^{20}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">20</span></span></span></span></span></span></span></span></span></span></span></span> bytes. No contamos los pesos del modelo, los búferes, la alineación de memoria ni la replicación entre dispositivos.</p>
<div id="gqa-groups-lab"></div>
<p>Reducir el número de cabezas KV no acorta aquí el contexto ni elimina cabezas de consulta. Limita el número de representaciones K/V separadas. El cálculo de memoria no predice la calidad ni el tiempo de ejecución; estos también dependen del entrenamiento, del hardware y de la implementación.</p>
<p>Al convertir el checkpoint, los autores promediaban las proyecciones de K/V dentro de los grupos y después continuaban el <a href="https://paweldubiel.com/es/glossary/preentrenamiento">preentrenamiento</a> (§2.1–2.2). Los resultados de §3 corresponden a variantes concretas de T5 y a tareas determinadas. No establecen un número universal de grupos ni garantizan conservar la calidad con solo cambiar la configuración.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Atención multi-query</title>
  <link>https://paweldubiel.com/es/glossary/atencion-multi-query</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/atencion-multi-query</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El modelo relaciona el fragmento actual del texto con la conversación anterior mediante varios cálculos paralelos. Estos cálculos se llaman cabezas de atención, o attention.</description>
  <content:encoded><![CDATA[<p>El modelo relaciona el fragmento actual del texto con la conversación anterior mediante varios cálculos paralelos. Estos cálculos se llaman cabezas de atención, o attention. Si cada cabeza almacena sus propias descripciones de toda la conversación anterior, aumentan el coste de memoria y su lectura. ¿Se puede compartir parte de los datos manteniendo distintas formas de leerlos?</p>
<p><strong>Multi-Query Attention (MQA)</strong> mantiene múltiples query —descripciones de las necesidades de las posiciones actuales—, pero les da un conjunto común de key y value. Key sirve para establecer correspondencias y value contiene la información que se transmitirá. Todos son listas de números.</p>
<p>Dos cabezas pueden usar el mismo conjunto key/value y aun así repartir los pesos de forma distinta, porque tienen query diferentes. Compartir los datos no obliga a obtener un resultado idéntico.</p>
<p>El ahorro afecta, entre otras cosas, a <a href="https://paweldubiel.com/es/glossary/cache-kv">KV Cache</a>, las descripciones almacenadas del texto anterior. Sin embargo, el cambio puede afectar a la calidad y no significa una aceleración proporcional de todo el modelo. <a href="https://paweldubiel.com/es/glossary/atencion-de-consultas-agrupadas">Grouped-Query Attention</a> comparte los datos dentro de grupos más pequeños.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>En la <a href="https://paweldubiel.com/es/glossary/atencion-de-multiples-cabezas">atención de múltiples cabezas</a> habitual, cada cabeza tiene sus propias proyecciones de consulta, clave y valor. MQA elimina la dimensión de cabezas de K/V y de sus proyecciones, manteniéndola en las consultas. <a href="https://arxiv.org/html/1911.02150v1#S3" rel="noopener noreferrer">Noam Shazeer, <em>Fast Transformer Decoding: One Write-Head is All You Need</em>, §3</a> define así esta variante.</p>
<h2 id="la-misma-memoria-otra-pregunta">La misma memoria, otra pregunta</h2>
<p>Nuestro ejemplo tiene dos claves: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>1</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">k_1=(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0315em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>2</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">k_2=(0,1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0315em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span>. Dos cabezas query reciben respectivamente <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mn>1</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>2</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">q_1=(2,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mn>2</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>2</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">q_2=(0,2)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">2</span><span class="mclose">)</span></span></span></span>. <a href="https://paweldubiel.com/es/glossary/atencion-por-producto-escalar-escalado">Scaled Dot-Product Attention</a> divide los productos por <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msqrt><mn>2</mn></msqrt></mrow><annotation encoding="application/x-tex">\sqrt{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.04em;vertical-align:-0.1328em;"></span><span class="mord sqrt"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.9072em;"><span class="svg-align" style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="mord" style="padding-left:0.833em;"><span class="mord">2</span></span></span><span style="top:-2.8672em;"><span class="pstrut" style="height:3em;"></span><span class="hide-tail" style="min-width:0.853em;height:1.08em;"><svg xmlns="http://www.w3.org/2000/svg" width="400em" height="1.08em" viewBox="0 0 400000 1080" preserveAspectRatio="xMinYMin slice"><path d="M95,702
c-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,-10,-9.5,-14
c0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54
c44.2,-33.3,65.8,-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10
s173,378,173,378c0.7,0,35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429
c69,-144,104.5,-217.7,106.5,-221
l0 -0
c5.3,-9.3,12,-14,20,-14
H400000v40H845.2724
s-225.272,467,-225.272,467s-235,486,-235,486c-2.7,4.7,-9,7,-19,7
c-6,0,-10,-1,-12,-3s-194,-422,-194,-422s-65,47,-65,47z
M834 80h400000v40h-400000z"></path></svg></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1328em;"><span></span></span></span></span></span></span></span></span> y aplica <a href="https://paweldubiel.com/es/glossary/softmax">Softmax</a>. La primera cabeza da a las claves pesos de aproximadamente 0,804 y 0,196; la segunda invierte estas proporciones. Con unos <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mn>1</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">v_1=(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mn>2</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">v_2=(0,1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> comunes, esas son también las coordenadas de dos resultados distintos.</p>
<div id="mqa-shared-lab"></div>
<h2 id="de-dónde-procede-el-ahorro">De dónde procede el ahorro</h2>
<p>La <a href="https://paweldubiel.com/es/glossary/cache-kv">caché KV</a> almacena las K/V anteriores. Con ocho cabezas de consulta, MHA guarda ocho conjuntos de K/V, y MQA, uno. Para la misma longitud de secuencia, dimensión de cabeza y precisión, los propios tensores de la caché son entonces ocho veces menores. Es un cálculo del tamaño, no una aceleración de ocho veces de todo el modelo.</p>
<p>El análisis de Shazeer en §2.4.1 y §3.1 relaciona este cambio con la transferencia de memoria durante los pasos sucesivos de generación. Sin embargo, cambia la arquitectura y su capacidad de representación; no es una eliminación sin pérdida de copias idénticas de cualquier MHA entrenado. La <a href="https://paweldubiel.com/es/glossary/atencion-de-consultas-agrupadas">atención de consultas agrupadas</a> conserva varios conjuntos de K/V como variante intermedia.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Búsqueda en haz</title>
  <link>https://paweldubiel.com/es/glossary/busqueda-en-haz</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/busqueda-en-haz</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Al elegir el primer fragmento de una respuesta, puedes descartar demasiado pronto un camino que más adelante sería mejor.</description>
  <content:encoded><![CDATA[<p>Al elegir el primer fragmento de una respuesta, puedes descartar demasiado pronto un camino que más adelante sería mejor. Sin embargo, comprobar todas las secuencias posibles resulta demasiado costoso. Necesitas un conjunto limitado de alternativas.</p>
<p><strong>Beam Search</strong> conserva varias respuestas parciales con las mejores puntuaciones. En cada paso las amplía, compara las nuevas secuencias y vuelve a dejar solo un número determinado. El tamaño de este conjunto se llama beam width.</p>
<p>Con una anchura de dos, el sistema puede conservar los comienzos A y B en lugar de elegir A inmediatamente. En el siguiente paso compara sus continuaciones. La puntuación básica combina las probabilidades de los sucesivos <a href="https://paweldubiel.com/es/glossary/token">tokens</a> —fragmentos de texto—, aunque las implementaciones pueden corregir el efecto de la longitud.</p>
<p>Un conjunto mayor cuesta más memoria y cálculos, y aun así puede descartar el mejor camino. Una probabilidad alta de toda la secuencia tampoco garantiza la veracidad, diversidad o utilidad del texto.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>En el <a href="https://paweldubiel.com/es/glossary/modelado-autorregresivo-del-lenguaje">modelado autorregresivo del lenguaje</a>, la puntuación básica de una secuencia es la suma de los logaritmos de las probabilidades de sus tokens:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>S</mi><mo stretchy="false">(</mo><msub><mi>x</mi><mrow><mn>1</mn><mo>:</mo><mi>t</mi></mrow></msub><mo stretchy="false">)</mo><mo>=</mo><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>t</mi></munderover><mi>ln</mi><mo>⁡</mo><mi>p</mi><mo stretchy="false">(</mo><msub><mi>x</mi><mi>i</mi></msub><mo>∣</mo><msub><mi>x</mi><mrow><mo>&#x3C;</mo><mi>i</mi></mrow></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">S(x_{1:t})=\sum_{i=1}^{t}\ln p(x_i\mid x_{&#x3C;i})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0576em;">S</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span><span class="mrel mtight">:</span><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:3.0582em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.7806em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mrel mtight">=</span><span class="mord mtight">1</span></span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span><span style="top:-4.3em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">∣</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mrel mtight">&#x3C;</span><span class="mord mathnormal mtight">i</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1774em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span></span>
<p>Es el logaritmo del producto de las probabilidades. Una puntuación mayor es mejor; la suma evita multiplicar números muy pequeños. La <a href="https://huggingface.co/docs/transformers/generation_strategies#beam-search" rel="noopener noreferrer">documentación de Hugging Face, «Beam search»</a> describe cómo se mantienen varias secuencias. Una anchura de 1 reduce esta variante básica a la <a href="https://paweldubiel.com/es/glossary/decodificacion-voraz">decodificación voraz</a>.</p>
<h2 id="qué-prefijo-descartarás-demasiado-pronto">¿Qué prefijo descartarás demasiado pronto?</h2>
<p>El ejemplo propio empieza con las probabilidades A = 0,45, B = 0,35 y C = 0,20. Un haz de anchura 2 descarta C. La mejor continuación de A tiene después una probabilidad de 0,4, así que la puntuación de AA es 0,18. En cambio, la ruta omitida CA obtendría <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,20</mn><mo>⋅</mo><mn>0,99</mn><mo>=</mo><mn>0,198</mn></mrow><annotation encoding="application/x-tex">0{,}20\cdot0{,}99=0{,}198</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">20</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">99</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">198</span></span></span></span>. Una anchura de 3 conservará C y encontrará una puntuación mejor. Es un árbol pequeño y completo de dos tokens, sin final anticipado ni normalización de longitud.</p>
<div id="beam-pruning-lab"></div>
<p>La búsqueda en haz sigue siendo una aproximación: no vuelve a expandir un prefijo descartado. La anchura no indica el número de tokens muestreados de una sola distribución, como en el <a href="https://paweldubiel.com/es/glossary/muestreo-top-k">muestreo top-k</a>.</p>
<p>En secuencias de distintas longitudes importan el token de final, la condición de parada y la función de puntuación. Por ejemplo, <code>length_penalty</code> en <a href="https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.GenerationConfig" rel="noopener noreferrer">GenerationConfig</a> divide la puntuación logarítmica por la longitud elevada a una potencia dada. No debe confundirse este criterio con la probabilidad pura. Un haz más ancho tampoco garantiza un contenido mejor; <a href="https://arxiv.org/html/1904.09751v2#S3" rel="noopener noreferrer">Holtzman et al., §2.2–3</a> tratan este problema.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Decodificación voraz</title>
  <link>https://paweldubiel.com/es/glossary/decodificacion-voraz</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/decodificacion-voraz</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El modelo puede añadir varios fragmentos distintos. La elección más sencilla es tomar siempre el de mayor probabilidad.</description>
  <content:encoded><![CDATA[<p>El modelo puede añadir varios fragmentos distintos. La elección más sencilla es tomar siempre el de mayor probabilidad. Eso evita considerar alternativas, pero ¿el mejor primer paso conduce a la mejor secuencia completa?</p>
<p><strong>Greedy Decoding</strong> elige en cada paso el <a href="https://paweldubiel.com/es/glossary/token">token</a> con la mayor puntuación, es decir, un fragmento de texto, y continúa desde esa elección. No sortea ni vuelve a los caminos omitidos.</p>
<p>Si A tiene una probabilidad de <code>0,6</code> y B de <code>0,4</code>, elegirá A. Pero si el mejor paso siguiente tras A tiene una probabilidad de <code>0,51</code>, toda la ruta tiene <code>0,306</code>. La ruta por B con una continuación de <code>0,99</code> tiene <code>0,396</code>. Por tanto, el líder local puede perder al evaluar juntos dos pasos.</p>
<p>El método es sencillo, pero no garantiza la secuencia completa más probable ni la mejor respuesta para una persona. <a href="https://paweldubiel.com/es/glossary/busqueda-en-haz">Beam Search</a> conserva más caminos y asume un coste adicional.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>La <a href="https://huggingface.co/docs/transformers/generation_strategies#greedy-search" rel="noopener noreferrer">documentación de Hugging Face, «Greedy search»</a> presenta la regla. Matemáticamente elegimos <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>arg</mi><mo>⁡</mo><msub><mrow><mi>max</mi><mo>⁡</mo></mrow><mi>v</mi></msub><mi>p</mi><mo stretchy="false">(</mo><mi>v</mi><mo>∣</mo><msub><mi>x</mi><mrow><mo>&#x3C;</mo><mi>t</mi></mrow></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\arg\max_v p(v\mid x_{&#x3C;t})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">ar<span style="margin-right:0.0139em;">g</span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop"><span class="mop">max</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1514em;"><span style="top:-2.55em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0359em;">v</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">∣</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mrel mtight">&#x3C;</span><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1774em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span>: entre los tokens <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>v</mi></mrow><annotation encoding="application/x-tex">v</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">v</span></span></span></span> tomamos el máximo con la secuencia actual <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mrow><mo>&#x3C;</mo><mi>t</mi></mrow></msub></mrow><annotation encoding="application/x-tex">x_{&#x3C;t}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6079em;vertical-align:-0.1774em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mrel mtight">&#x3C;</span><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1774em;"><span></span></span></span></span></span></span></span></span></span>. Un empate requiere una regla de desempate fija. La ausencia de muestreo no promete un resultado idéntico si cambia el modelo, los cálculos o la configuración.</p>
<h2 id="el-ganador-local-puede-perder-en-la-secuencia-completa">El ganador local puede perder en la secuencia completa</h2>
<p>El ejemplo propio tiene exactamente dos pasos. Al principio, A tiene una probabilidad de 0,6, y B, de 0,4. Después de A, la mejor continuación tiene una probabilidad de 0,51; después de B, de 0,99. La decodificación voraz elegirá A y luego su mejor continuación: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,6</mn><mo>⋅</mo><mn>0,51</mn><mo>=</mo><mn>0,306</mn></mrow><annotation encoding="application/x-tex">0{,}6\cdot0{,}51=0{,}306</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">6</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">51</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">306</span></span></span></span>. Sin embargo, la ruta omitida a través de B tiene <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,4</mn><mo>⋅</mo><mn>0,99</mn><mo>=</mo><mn>0,396</mn></mrow><annotation encoding="application/x-tex">0{,}4\cdot0{,}99=0{,}396</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">99</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">396</span></span></span></span>. Todas las distribuciones son inventadas y suman 1; la secuencia termina después de dos tokens.</p>
<div id="greedy-choice-lab"></div>
<p>La <a href="https://paweldubiel.com/es/glossary/busqueda-en-haz">búsqueda en haz</a> conserva varias secuencias parciales para posponer esa elección. En cambio, el <a href="https://paweldubiel.com/es/glossary/muestreo-top-k">muestreo top-k</a> limita los candidatos para muestrear el siguiente token. Con un máximo único y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>, la elección del token coincide con la decodificación voraz.</p>
<p>El texto más probable no tiene por qué ser verdadero ni útil. <a href="https://arxiv.org/html/1904.09751v2#S3" rel="noopener noreferrer">Holtzman et al., §2.2–3</a> distinguen entre maximizar la probabilidad y la calidad de las continuaciones abiertas. Es un problema diferente del error de búsqueda mostrado arriba.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Embedding posicional rotatorio</title>
  <link>https://paweldubiel.com/es/glossary/embedding-posicional-rotatorio</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/embedding-posicional-rotatorio</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El modelo compara fragmentos de texto, pero también necesita saber a qué distancia se encuentran. «Ayer» junto al verbo puede desempeñar un papel distinto que la misma palabra en una cita lejana.</description>
  <content:encoded><![CDATA[<p>El modelo compara fragmentos de texto, pero también necesita saber a qué distancia se encuentran. «Ayer» junto al verbo puede desempeñar un papel distinto que la misma palabra en una cita lejana. ¿Cómo incorporar la posición a la comparación de descripciones numéricas?</p>
<p><strong>Rotary Position Embedding (RoPE)</strong> rota pares de números en query y key según la posición del <a href="https://paweldubiel.com/es/glossary/token">token</a>, es decir, un fragmento de texto. Query y key son vectores: listas de números que se comparan en attention.</p>
<p>Imagina dos flechas de longitudes determinadas. La posición fija su ángulo de rotación. Al compararlas importa la diferencia de ángulos y, por tanto, la diferencia de posiciones. En un modelo real se rotan muchos pares con distintas frecuencias.</p>
<p>Es una analogía de una operación sobre números, no un movimiento del texto en la memoria. RoPE no prohíbe el acceso al futuro ni garantiza un buen funcionamiento más allá de las longitudes conocidas durante el entrenamiento. Difiere de sumar una señal de posición en el <a href="https://paweldubiel.com/es/glossary/codificacion-posicional">Positional Encoding</a> original.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>A diferencia de la suma de un vector en la <a href="https://paweldubiel.com/es/glossary/codificacion-posicional">codificación posicional</a> original, aquí cambia la orientación de las consultas y las claves. Para una pareja bidimensional <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo>=</mo><mo stretchy="false">(</mo><mi>a</mi><mo separator="true">,</mo><mi>b</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">u=(a,b)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">a</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">b</span><span class="mclose">)</span></span></span></span>, la rotación de ángulo <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>ϕ</mi></mrow><annotation encoding="application/x-tex">\phi</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">ϕ</span></span></span></span> da:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>R</mi><mo stretchy="false">(</mo><mi>ϕ</mi><mo stretchy="false">)</mo><mi>u</mi><mo>=</mo><mo stretchy="false">(</mo><mi>a</mi><mi>cos</mi><mo>⁡</mo><mi>ϕ</mi><mo>−</mo><mi>b</mi><mi>sin</mi><mo>⁡</mo><mi>ϕ</mi><mo separator="true">,</mo><mtext> </mtext><mi>a</mi><mi>sin</mi><mo>⁡</mo><mi>ϕ</mi><mo>+</mo><mi>b</mi><mi>cos</mi><mo>⁡</mo><mi>ϕ</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">R(\phi)u=(a\cos\phi-b\sin\phi,\ a\sin\phi+b\cos\phi)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">(</span><span class="mord mathnormal">ϕ</span><span class="mclose">)</span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">cos</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">sin</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mpunct">,</span><span class="mspace"> </span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">sin</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">cos</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mclose">)</span></span></span></span></span>
<p>La rotación conserva la longitud del vector. <a href="https://arxiv.org/html/2104.09864v5#S3.SS2" rel="noopener noreferrer">Su et al., <em>RoFormer</em>, §3.1–3.2</a> derivan la construcción y combinan muchas parejas de este tipo con frecuencias distintas.</p>
<h2 id="desplaza-ambos-tokens-y-comprueba-el-resultado">Desplaza ambos tokens y comprueba el resultado</h2>
<p>Si las consultas y las claves sin rotar permanecen fijas, entonces:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo stretchy="false">(</mo><mi>R</mi><mo stretchy="false">(</mo><mi>m</mi><mi>θ</mi><mo stretchy="false">)</mo><mi>q</mi><msup><mo stretchy="false">)</mo><mi mathvariant="normal">⊤</mi></msup><mi>R</mi><mo stretchy="false">(</mo><mi>n</mi><mi>θ</mi><mo stretchy="false">)</mo><mi>k</mi><mo>=</mo><msup><mi>q</mi><mi mathvariant="normal">⊤</mi></msup><mi>R</mi><mo stretchy="false">(</mo><mo stretchy="false">(</mo><mi>n</mi><mo>−</mo><mi>m</mi><mo stretchy="false">)</mo><mi>θ</mi><mo stretchy="false">)</mo><mi>k</mi></mrow><annotation encoding="application/x-tex">(R(m\theta)q)^\top R(n\theta)k=q^\top R((n-m)\theta)k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1491em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">(</span><span class="mord mathnormal">m</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8991em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">⊤</span></span></span></span></span></span></span></span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.1491em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8991em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">⊤</span></span></span></span></span></span></span></span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">((</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">m</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi></mrow><annotation encoding="application/x-tex">m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">m</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> son las posiciones, y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi></mrow><annotation encoding="application/x-tex">\theta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span></span></span></span> el ángulo por unidad de distancia para esa pareja. El resultado depende de la diferencia entre posiciones. Desplazar ambas posiciones por igual rota las flechas, pero conserva su producto escalar.</p>
<p>El ejemplo propio utiliza <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo>=</mo><mi>k</mi><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">q=k=(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> y un <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi><mo>=</mo><msup><mn>30</mn><mo>∘</mo></msup></mrow><annotation encoding="application/x-tex">\theta=30^\circ</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6741em;"></span><span class="mord">3</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6741em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∘</span></span></span></span></span></span></span></span></span></span></span> convencional. A una distancia de 1, el producto es aproximadamente 0,866; a 6, es −1; y a 12, vuelve a ser 1. Es una pareja y una frecuencia deliberadamente sencilla, no la receta completa del modelo. El trabajo original utiliza <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>θ</mi><mi>i</mi></msub><mo>=</mo><msup><mn>10000</mn><mrow><mo>−</mo><mn>2</mn><mi>i</mi><mi mathvariant="normal">/</mi><mi>d</mi></mrow></msup></mrow><annotation encoding="application/x-tex">\theta_i=10000^{-2i/d}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.888em;"></span><span class="mord">1000</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.888em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span><span class="mord mtight">/</span><span class="mord mathnormal mtight">d</span></span></span></span></span></span></span></span></span></span></span></span> radianes para la pareja con índice <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo>=</mo><mn>0</mn><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><mi>d</mi><mi mathvariant="normal">/</mi><mn>2</mn><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">i=0,\ldots,d/2-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">d</span><span class="mord">/2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>.</p>
<div id="rope-rotation-lab"></div>
<p>El resultado mostrado es un componente del cálculo de la <a href="https://paweldubiel.com/es/glossary/atencion-por-producto-escalar-escalado">atención por producto escalar escalado</a>, antes del escalado y de <a href="https://paweldubiel.com/es/glossary/softmax">Softmax</a>. No es una probabilidad. En esta variante rotamos Q y K; V no necesita esa rotación. RoPE no sustituye al <a href="https://paweldubiel.com/es/glossary/enmascaramiento-causal">enmascaramiento causal</a>.</p>
<p>El retorno de una sola pareja a la misma orientación también muestra por qué no debe suponerse que todo resultado disminuye monótonamente con la distancia. La propiedad de las posiciones relativas no demuestra por sí sola que el modelo completo funcione correctamente con textos de longitud arbitraria.</p>
<p>Utilizo contenido generado por IA como parte de mi proceso de aprendizaje diario.</p>]]></content:encoded>
</item>
<item>
  <title>Caché KV</title>
  <link>https://paweldubiel.com/es/glossary/cache-kv</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/cache-kv</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>El modelo añade una respuesta fragmento a fragmento. Ya ha calculado mucha información sobre el texto anterior, de modo que calcularla desde cero en cada paso repetiría el trabajo.</description>
  <content:encoded><![CDATA[<p>El modelo añade una respuesta fragmento a fragmento. Ya ha calculado mucha información sobre el texto anterior, de modo que calcularla desde cero en cada paso repetiría el trabajo. Quieres recordar los resultados que siguen siendo válidos.</p>
<p><strong>KV Cache</strong> almacena key y value de las capas de attention. Son listas de números que sirven, respectivamente, para establecer correspondencias entre fragmentos y transmitir su información. No almacena una respuesta preparada ni un resumen de la conversación.</p>
<p>Después de procesar A, B y C, el nuevo fragmento D usa las descripciones guardadas de esas posiciones y añade las suyas. En un modelo con bloqueo del acceso al futuro, los nuevos fragmentos no cambian las descripciones anteriores, por lo que pueden reutilizarse si los ajustes coinciden.</p>
<p>Ahorramos repetir cálculos, pero pagamos memoria por los números almacenados. Con un contexto largo, ese coste crece. <a href="https://paweldubiel.com/es/glossary/prefill">Prefill</a> prepara la caché de la entrada conocida y <a href="https://paweldubiel.com/es/glossary/decode">Decode</a> la amplía durante la respuesta. Sigue siendo necesario leer y combinar la información necesaria.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>En un modelo con <a href="https://paweldubiel.com/es/glossary/enmascaramiento-causal">enmascaramiento causal</a>, los <a href="https://paweldubiel.com/es/glossary/token">tokens</a> posteriores no cambian las representaciones de las posiciones anteriores. Esto permite reutilizar la caché para el mismo prefijo y los mismos ajustes del modelo. <a href="https://arxiv.org/html/1706.03762v7#S3.SS1" rel="noopener noreferrer"><em>Attention Is All You Need</em>, §3.1 y §3.2.3</a>, describe la base del flujo de información, y la <a href="https://huggingface.co/docs/transformers/cache_explanation" rel="noopener noreferrer">documentación de Hugging Face: How caching works</a> describe la actualización de la caché en cada capa.</p>
<h2 id="qué-queda-del-paso-anterior">Qué queda del paso anterior</h2>
<p>Ilustración propia: el modelo ha procesado los tokens A, B y C. Al procesar D, utiliza las K y V guardadas de las tres posiciones anteriores y añade el par de D. Compara la consulta de la posición actual con las claves disponibles; el resultado utiliza los valores correspondientes. La caché no es una respuesta preparada ni un resumen textual de la conversación.</p>
<p>Almacenar los resultados tiene un coste. Un pequeño ejemplo propio para una capa: cuatro posiciones, dos cabezas KV, tres números en cada vector K y V, y cuatro bytes por número:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mn>2</mn><mo>⋅</mo><mn>4</mn><mo>⋅</mo><mn>2</mn><mo>⋅</mo><mn>3</mn><mo>⋅</mo><mn>4</mn><mo>=</mo><mn>192</mn><mtext> bytes</mtext></mrow><annotation encoding="application/x-tex">2\cdot4\cdot2\cdot3\cdot4=192\ \text{bytes}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">3</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord">192</span><span class="mspace"> </span><span class="mord text"><span class="mord">bytes</span></span></span></span></span></span>
<p>El primer factor 2 representa las claves y los valores separados. El resultado incluye solo los elementos de los tensores, sin la sobrecarga de asignación. Una caché dinámica completa crece con el número de posiciones almacenadas; las variantes con una ventana limitada pueden eliminar las posiciones más antiguas.</p>
<p>El <a href="https://paweldubiel.com/en/articles/kv-cache-scaling-problem-in-llm-inference" hreflang="en">artículo anterior sobre el escalado de la caché KV [English]</a> desarrolla el tema del coste de memoria. El <a href="https://paweldubiel.com/articles/kv-cache-miedzy-modelami-nvidia-zmniejsza-koszt-przelaczania" hreflang="pl">artículo sobre la transferencia de caché entre modelos [Polski]</a> trata un problema distinto: que las dimensiones de los tensores coincidan no garantiza que su significado coincida. Cambiar el modelo o el prefijo exige volver a determinar qué parte de la caché sigue siendo válida. Véase también: <a href="https://paweldubiel.com/es/glossary/pagedattention">PagedAttention</a> describe la organización de la memoria por bloques, y la <a href="https://paweldubiel.com/es/glossary/cache-de-prefijos">caché de prefijos</a>, la reutilización de las KV de un prefijo compartido.</p>
<div id="kv-cache-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Destilación de conocimiento</title>
  <link>https://paweldubiel.com/es/glossary/destilacion-de-conocimiento</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/destilacion-de-conocimiento</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modelo grande realiza bien la tarea, pero resulta demasiado costoso para el uso cotidiano. Un modelo pequeño podría intentar reproducir su comportamiento.</description>
  <content:encoded><![CDATA[<p>Un modelo grande realiza bien la tarea, pero resulta demasiado costoso para el uso cotidiano. Un modelo pequeño podría intentar reproducir su comportamiento. Sin embargo, necesita ejemplos o evaluaciones que muestren algo más que una lista de etiquetas correctas.</p>
<p><strong>Knowledge Distillation</strong> consiste en entrenar un modelo estudiante usando las salidas o predicciones de un modelo profesor. El estudiante cambia realmente sus parámetros; enviar una consulta al profesor no es entrenamiento.</p>
<p>Si el profesor asigna a A una probabilidad de <code>0,60</code>, a B de <code>0,35</code> y a C de <code>0,05</code>, la etiqueta «A» omite que B es una alternativa cercana. El estudiante puede aprender a reproducir toda esa distribución. Otra variante utiliza textos completos generados por el profesor.</p>
<p>El profesor no tiene por qué ser un único modelo mayor, pero tradicionalmente actúa como fuente del comportamiento que se imita. La destilación también puede transmitir errores. <a href="https://paweldubiel.com/es/glossary/divergencia-kl">KL Divergence</a> ayuda a medir la concordancia de las predicciones, y <a href="https://paweldubiel.com/es/glossary/autodestilacion-on-policy">On-policy self-distillation</a> es una construcción más específica de los datos y el profesor.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>En <a href="https://arxiv.org/pdf/1503.02531#page=2" rel="noopener noreferrer"><em>Distilling the Knowledge in a Neural Network</em>, §2</a>, Hinton, Vinyals y Dean describen el aprendizaje con distribuciones suaves de probabilidad. Una <a href="https://paweldubiel.com/es/glossary/temperatura">temperatura</a> mayor revela más información sobre las relaciones entre los candidatos. Al comparar las distribuciones se utiliza el mismo parámetro tanto en el profesor como en el estudiante. Los autores combinan este objetivo con el aprendizaje a partir de etiquetas correctas cuando están disponibles.</p>
<h2 id="más-información-que-una-sola-respuesta">Más información que una sola respuesta</h2>
<p>Nuestro ejemplo: el profesor asigna a los <a href="https://paweldubiel.com/es/glossary/token">tokens</a> hipotéticos A, B y C probabilidades de 0,60; 0,35; 0,05. La etiqueta «A» solo identifica al ganador. La distribución completa indica además que B era mucho más probable que C. El estudiante puede intentar reproducir esas proporciones mediante <a href="https://paweldubiel.com/es/glossary/entropia-cruzada">Cross-entropy</a> o una <a href="https://paweldubiel.com/es/glossary/divergencia-kl">KL Divergence</a> dirigida de forma adecuada. Es una señal de entrenamiento adicional, no una prueba de que las etiquetas del profesor sean correctas.</p>
<p>En los modelos que generan texto hay que distinguir entre comparar distribuciones del siguiente token y entrenar con secuencias completas generadas. <a href="https://aclanthology.org/D16-1139.pdf#page=3" rel="noopener noreferrer">Kim y Rush, <em>Sequence-Level Knowledge Distillation</em>, §2.2–3.2</a> describen ambos enfoques para la traducción automática. En la variante de secuencia, el estudiante se entrena con las salidas encontradas por la <a href="https://paweldubiel.com/es/glossary/busqueda-en-haz">búsqueda en haz</a> del profesor. El texto de esa respuesta no contiene las probabilidades completas de todos los tokens alternativos.</p>
<p>El resultado depende del profesor, de los datos y de las capacidades del estudiante. No supone copiar todas sus habilidades ni garantiza una mejora en todas las tareas. La nota separada sobre <a href="https://paweldubiel.com/es/glossary/autodestilacion-on-policy">autodestilación on-policy</a> describe una variante particular de TTPO; sus condiciones no son la definición general de la destilación de conocimiento.</p>]]></content:encoded>
</item>
<item>
  <title>Divergencia KL</title>
  <link>https://paweldubiel.com/es/glossary/divergencia-kl</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/divergencia-kl</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Dos modelos reparten de forma distinta las probabilidades entre las mismas respuestas. Uno asigna un 90% a A y un 10% a B; el otro les da un 50% a cada una.</description>
  <content:encoded><![CDATA[<p>Dos modelos reparten de forma distinta las probabilidades entre las mismas respuestas. Uno asigna un <code>90%</code> a A y un <code>10%</code> a B; el otro les da un <code>50%</code> a cada una. Quieres medir qué tan bien reproduce el segundo las predicciones del primero.</p>
<p><strong>KL Divergence</strong> compara dos distribuciones de probabilidad, es decir, conjuntos de probabilidades de los mismos sucesos. Hay que indicar la distribución de referencia y la que la aproxima. La contribución de cada suceso depende de su probabilidad en la distribución de referencia y de la razón entre ambas probabilidades.</p>
<p>Para los números indicados, la comparación de la primera con la segunda es aproximadamente <code>0,368</code>, y la inversa aproximadamente <code>0,511</code>, con logaritmo natural. La dirección importa: no es una distancia simétrica como el número de kilómetros entre ciudades.</p>
<p>En <a href="https://paweldubiel.com/es/glossary/destilacion-de-conocimiento">Knowledge Distillation</a> se pueden comparar las predicciones del profesor y del estudiante. Una KL pequeña significa concordancia, no que el profesor tenga razón. Asignar cero a un suceso con probabilidad positiva en la distribución de referencia produce matemáticamente una penalización infinita.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mi>D</mi><mrow><mi mathvariant="normal">K</mi><mi mathvariant="normal">L</mi></mrow></msub><mo stretchy="false">(</mo><mi>q</mi><mi mathvariant="normal">∥</mi><mi>p</mi><mo stretchy="false">)</mo><mo>=</mo><munder><mo>∑</mo><mi>i</mi></munder><msub><mi>q</mi><mi>i</mi></msub><mi>ln</mi><mo>⁡</mo><mfrac><msub><mi>q</mi><mi>i</mi></msub><msub><mi>p</mi><mi>i</mi></msub></mfrac></mrow><annotation encoding="application/x-tex">D_{\mathrm{KL}}(q\|p)=\sum_i q_i\ln\frac{q_i}{p_i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">D</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathrm mtight">KL</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mord">∥</span><span class="mord mathnormal">p</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.3852em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.1076em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.8804em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">q_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>p</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">p_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> son las probabilidades del mismo suceso <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>, por ejemplo, un <a href="https://paweldubiel.com/es/glossary/token">token</a> concreto. La <a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.entropy.html" rel="noopener noreferrer">documentación de SciPy: entropy</a> presenta la fórmula y la relación con <a href="https://paweldubiel.com/es/glossary/entropia-cruzada">Cross-entropy</a>. Se cumple <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>D</mi><mrow><mi mathvariant="normal">K</mi><mi mathvariant="normal">L</mi></mrow></msub><mo stretchy="false">(</mo><mi>q</mi><mi mathvariant="normal">∥</mi><mi>p</mi><mo stretchy="false">)</mo><mo>=</mo><mi>H</mi><mo stretchy="false">(</mo><mi>q</mi><mo separator="true">,</mo><mi>p</mi><mo stretchy="false">)</mo><mo>−</mo><mi>H</mi><mo stretchy="false">(</mo><mi>q</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">D_{\mathrm{KL}}(q\|p)=H(q,p)-H(q)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">D</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathrm mtight">KL</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mord">∥</span><span class="mord mathnormal">p</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mclose">)</span></span></span></span>: de Cross-entropy restamos la entropía de la distribución de referencia. Cuando <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi></mrow><annotation encoding="application/x-tex">q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span> es fija, esa diferencia no cambia el mínimo respecto a los parámetros del modelo que determina <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span>.</p>
<h2 id="la-dirección-de-la-comparación-importa">La dirección de la comparación importa</h2>
<p>Ejemplo propio: para <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,9</mn><mo separator="true">;</mo><mn>0,1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">q=[0{,}9;0{,}1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">9</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">]</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,5</mn><mo separator="true">;</mo><mn>0,5</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">p=[0{,}5;0{,}5]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mclose">]</span></span></span></span> obtenemos aproximadamente 0,368. Al intercambiar los papeles de las distribuciones, el resultado es aproximadamente 0,511. Utilizamos el logaritmo natural, así que la unidad son los nats. La divergencia KL no es una distancia simétrica: siempre hay que decir qué distribución está a cada lado.</p>
<p>Si <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mi>i</mi></msub><mo>></mo><mn>0</mn></mrow><annotation encoding="application/x-tex">q_i>0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7335em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span> pero <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>p</mi><mi>i</mi></msub><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">p_i=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>, el resultado es infinito. El término con <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mi>i</mi></msub><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">q_i=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span> se considera cero. <a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.rel_entr.html" rel="noopener noreferrer">SciPy: rel_entr</a> define estos casos límite.</p>
<p>En la <a href="https://paweldubiel.com/es/glossary/destilacion-de-conocimiento">destilación de conocimiento</a>, la distribución de referencia puede ser la predicción del profesor, y la aproximación, la del estudiante. Un valor pequeño indica que las distribuciones coinciden en los datos evaluados, no que las respuestas del profesor sean verdaderas.</p>
<p>En la implementación hay que prestar atención al orden de los argumentos. <a href="https://docs.pytorch.org/docs/2.11/generated/torch.nn.KLDivLoss.html#torch.nn.KLDivLoss" rel="noopener noreferrer">PyTorch: KLDivLoss</a> espera los logaritmos de las probabilidades del modelo como <code>input</code>, y la distribución de referencia como <code>target</code> con <code>log_target=False</code>. Para una matriz «ejemplos × clases», la reducción <code>batchmean</code> suma los términos por clases y promedia por ejemplos; <code>mean</code> promedia todos los elementos y produce otra escala.</p>
<div id="kl-divergence-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Muestreo top-k</title>
  <link>https://paweldubiel.com/es/glossary/muestreo-top-k</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/muestreo-top-k</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Al sortear el siguiente fragmento, el modelo admite muchas posibilidades muy poco probables. Quieres conservar algo de diversidad, pero eliminar la cola lejana de candidatos.</description>
  <content:encoded><![CDATA[<p>Al sortear el siguiente fragmento, el modelo admite muchas posibilidades muy poco probables. Quieres conservar algo de diversidad, pero eliminar la cola lejana de candidatos. Puedes admitir solo un número determinado de los mejor puntuados.</p>
<p><strong>Top-k Sampling</strong> sortea el siguiente <a href="https://paweldubiel.com/es/glossary/token">token</a>, es decir, un fragmento de texto, entre los <code>k</code> candidatos con las mejores puntuaciones. Excluye a los demás y recalcula las probabilidades de los conservados para que sumen uno.</p>
<p>Si A tiene una probabilidad de <code>0,5</code>, B de <code>0,3</code> y los demás juntos de <code>0,2</code>, para <code>k=2</code> quedan A y B. Tras dividir por <code>0,8</code>, sus probabilidades son <code>0,625</code> y <code>0,375</code>. B todavía puede ganar; el método no reparte por igual entre todos.</p>
<p>Un <code>k</code> fijo determina el número de candidatos, no su fiabilidad conjunta. Con una distribución muy plana, incluso los primeros pueden tener probabilidades pequeñas. <a href="https://paweldubiel.com/es/glossary/muestreo-top-p">Top-p Sampling</a> determina el conjunto según la suma de probabilidades, y <a href="https://paweldubiel.com/es/glossary/temperatura">Temperature</a> regula sus proporciones.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p>Una implementación práctica puede filtrar los logits antes de <a href="https://paweldubiel.com/es/glossary/softmax">Softmax</a>: asigna infinito negativo a las posiciones descartadas. Así, tras la normalización, su probabilidad es cero. La <a href="https://huggingface.co/docs/transformers/internal/generation_utils#transformers.TopKLogitsWarper" rel="noopener noreferrer">documentación de Transformers: TopKLogitsWarper</a> describe este mecanismo.</p>
<h2 id="dos-candidatos-no-significa-las-mismas-posibilidades">Dos candidatos no significa las mismas posibilidades</h2>
<p>Ejemplo propio para <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>=</mo><mn>2</mn></mrow><annotation encoding="application/x-tex">k=2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span></span></span></span>:</p>






























<table><thead><tr><th>Token</th><th align="right">Antes del filtrado</th><th align="right">Después del filtrado y la normalización</th></tr></thead><tbody><tr><td>A</td><td align="right">0,50</td><td align="right">0,625</td></tr><tr><td>B</td><td align="right">0,30</td><td align="right">0,375</td></tr><tr><td>C</td><td align="right">0,15</td><td align="right">0</td></tr><tr><td>D</td><td align="right">0,05</td><td align="right">0</td></tr></tbody></table>
<p>A y B tenían una probabilidad conjunta de 0,80. Dividimos por esa suma: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,50</mn><mi mathvariant="normal">/</mi><mn>0,80</mn><mo>=</mo><mn>0,625</mn></mrow><annotation encoding="application/x-tex">0{,}50/0{,}80=0{,}625</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">50/0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">80</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">625</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,30</mn><mi mathvariant="normal">/</mi><mn>0,80</mn><mo>=</mo><mn>0,375</mn></mrow><annotation encoding="application/x-tex">0{,}30/0{,}80=0{,}375</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">30/0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">80</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">375</span></span></span></span>. El muestreo todavía puede elegir B. Con <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> y un máximo único, siempre elegimos el token mejor puntuado.</p>
<p>Un <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span></span></span></span> fijo controla el número de candidatos, no su probabilidad conjunta antes del corte. Dos posiciones conservadas pueden concentrar casi toda la distribución o solo una pequeña parte de ella. El <a href="https://paweldubiel.com/es/glossary/muestreo-top-p">muestreo top-p</a> determina el límite según la suma de probabilidades. La <a href="https://paweldubiel.com/es/glossary/temperatura">temperatura</a> cambia las proporciones de las posibilidades; el escalado positivo por sí solo no altera el orden de los logits finitos.</p>
<p>Cuando hay empates, conviene comprobar la implementación. El <a href="https://github.com/huggingface/transformers/blob/v5.17.0/src/transformers/generation/logits_process.py" rel="noopener noreferrer">código de Transformers 5.17.0</a> elimina los resultados estrictamente inferiores al del candidato k-ésimo. Por ello puede conservar también tokens adicionales con el mismo valor en el límite. El ejemplo de la tabla no contiene empates.</p>
<div id="top-k-sampling-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Muestreo top-p</title>
  <link>https://paweldubiel.com/es/glossary/muestreo-top-p</link>
  <guid isPermaLink="true">https://paweldubiel.com/es/glossary/muestreo-top-p</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>A veces el modelo tiene un líder claro y otras veces muchas continuaciones con puntuaciones parecidas. Admitir siempre cinco candidatos no tiene en cuenta esa diferencia.</description>
  <content:encoded><![CDATA[<p>A veces el modelo tiene un líder claro y otras veces muchas continuaciones con puntuaciones parecidas. Admitir siempre cinco candidatos no tiene en cuenta esa diferencia. Quieres ajustar el tamaño del grupo según dónde se concentre la probabilidad.</p>
<p><strong>Top-p Sampling</strong>, también llamado Nucleus Sampling, elige el menor grupo inicial de candidatos ordenados por probabilidad descendente cuya suma alcanza el umbral <code>p</code>. Después sortea dentro de ese grupo tras recalcular las probabilidades para que sumen uno.</p>
<p>Para las probabilidades <code>0,7; 0,15; 0,1; 0,05</code> y un umbral de <code>0,75</code>, quedan los dos primeros: juntos tienen <code>0,85</code>. Para <code>0,4; 0,3; 0,2; 0,1</code>, hacen falta tres. Por tanto, cada paso de generación puede admitir un número distinto de <a href="https://paweldubiel.com/es/glossary/token">tokens</a> —fragmentos de texto—.</p>
<p>El umbral no significa una probabilidad mínima de cada candidato ni una calidad garantizada de la respuesta. <a href="https://paweldubiel.com/es/glossary/muestreo-top-k">Top-k Sampling</a> fija el número y top-p responde a la distribución; ninguno de esos filtros evalúa por sí solo la veracidad del texto.</p>
<h2 id="mecanismo-y-detalles">Mecanismo y detalles</h2>
<p><a href="https://arxiv.org/html/1904.09751v2#S3.SS1" rel="noopener noreferrer">Holtzman et al., <em>The Curious Case of Neural Text Degeneration</em>, §3.1</a> describen el método y la normalización. En cada paso del <a href="https://paweldubiel.com/es/glossary/modelado-autorregresivo-del-lenguaje">modelado autorregresivo del lenguaje</a>, el conjunto de candidatos se calcula de nuevo.</p>
<h2 id="el-mismo-umbral-distinto-número-de-tokens">El mismo umbral, distinto número de tokens</h2>
<p>Ejemplo propio para <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mn>0,75</mn></mrow><annotation encoding="application/x-tex">p=0{,}75</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">75</span></span></span></span>; las filas ya contienen las probabilidades ordenadas:</p>




















<table><thead><tr><th>Distribución para A, B, C, D</th><th>Tokens conservados</th><th align="right">Su suma antes de normalizar</th></tr></thead><tbody><tr><td>0,70; 0,15; 0,10; 0,05</td><td>A, B</td><td align="right">0,85</td></tr><tr><td>0,40; 0,30; 0,20; 0,10</td><td>A, B, C</td><td align="right">0,90</td></tr></tbody></table>
<p>En la segunda fila, A y B suman solo 0,70, así que hay que incluir C. Tras normalizar, sus probabilidades son, respectivamente, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mn>9</mn></mrow><annotation encoding="application/x-tex">4/9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/9</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn><mi mathvariant="normal">/</mi><mn>9</mn></mrow><annotation encoding="application/x-tex">3/9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">3/9</span></span></span></span> y <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi mathvariant="normal">/</mi><mn>9</mn></mrow><annotation encoding="application/x-tex">2/9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">2/9</span></span></span></span>. D queda excluido. El umbral no significa conservar tokens de los que <strong>cada uno por separado</strong> tenga una probabilidad de al menos 0,75.</p>
<p>El <a href="https://paweldubiel.com/es/glossary/muestreo-top-k">muestreo top-k</a> intentaría conservar el mismo número de candidatos en ambos casos. Top-p responde a la distribución de sus probabilidades. Si antes aplicamos la <a href="https://paweldubiel.com/es/glossary/temperatura">temperatura</a>, cambiará la suma de las probabilidades sucesivas y el límite de corte puede quedar en otro lugar.</p>
<p>El trabajo estudió, entre otras cosas, la continuación abierta de texto con GPT-2 (§4.1). Sus resultados no establecen un único umbral óptimo para todos los modelos y tareas. El parámetro <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> tampoco es la probabilidad de que la respuesta generada resulte correcta.</p>
<div id="top-p-sampling-lab"></div>]]></content:encoded>
</item>
</channel>
</rss>