DEV Community

Cover image for Por qué un LLM local pequeño se repite cuando le pides 100 filas de JSON

Por qué un LLM local pequeño se repite cuando le pides 100 filas de JSON

Pedirle datos sintéticos de entrenamiento a un modelo de lenguaje suele resumirse en un solo prompt: "Genera N filas como un array JSON", un esquema y unas cuantas filas de ejemplo. Con un modelo de 3B ejecutándose en un portátil, eso funciona con 20 filas y empieza a romperse con 40, y siempre de la misma manera: el modelo se pone a copiar sus propias filas anteriores y ya no para. Las cifras de este artículo salen de ejecutar ese tipo de prompt muchas veces con Qwen2.5-3B-Instruct (4 bits, con mlx-lm) en un Apple M1 de 8 GB, midiendo cuándo empieza el bucle, por qué al modelo le cuesta tanto salir de él y qué soluciones funcionan de verdad.

El prompt y la configuración

El prompt es el mismo que construye el generador de datasets de la aplicación de escritorio de osFoundry (buildPrompt en su PromptEditor.tsx), para un dataset de clasificación de texto con mensajes de una tienda online, tres etiquetas permitidas y tres filas de ejemplo:

SYSTEM = "You are a data generation assistant. Output only valid JSON arrays."

def build_prompt(n):
    return f"""Generate {n} data samples as a JSON array.

Domain: Online shop customer messages
Language: English

Each object must have these fields:
  "text" (text) — Input text
  "label" (enum) — Classification label [allowed values: refund, shipping, spam]

Here are example rows to follow:
{json.dumps(FEW_SHOT, indent=2)}

Generate {n} more rows following the same style and patterns.

Output ONLY a valid JSON array, no other text."""
Enter fullscreen mode Exit fullscreen mode

La generación se hizo con mlx_lm.stream_generate con temperatura 0,8, top-p 0,95 y max_tokens=8192, cada ejecución con su propia semilla fija. Una fila cuesta unos 27 tokens, así que 8192 tokens dan para unas 300 filas: con 95 filas, quedarse sin tokens no es el problema.

Cómo son 95 filas en una sola petición

La primera respuesta de 95 filas, grabada mientras se hacía un vídeo sobre esta función, es un buen ejemplar. Tiene 302 filas completas (la 303 queda cortada) y solo 24 distintas. A partir de la fila 27 el modelo no escribe nada nuevo: va rotando entre tres frases hasta agotar los tokens, y el ] de cierre nunca llega.

"my order is late, please refund my money"
"please refund my money as the product is defective"
"i need to cancel my order due to a change of mind"
"my order is late, please refund my money"
...
Enter fullscreen mode Exit fullscreen mode

La versión en japonés del mismo prompt fue peor: 272 filas completas, 6 distintas, y de la 7 a la 272 todas son la misma frase. Un cliente que busque un [...] completo y le pase JSON.parse obtiene cero filas de cualquiera de las dos respuestas.

Una tabla generada en la que el mismo mensaje se repite de la fila 16 a la 21

Dónde se rompe: barrido por tamaño de lote

Para ver dónde empieza, el prompt en inglés se ejecutó tres veces con 10, 20, 40, 60 y 95 filas. Para ahorrar tiempo, una ejecución se daba por bucle y se detenía cuando las últimas 12 filas contenían 4 textos distintos o menos.

Filas pedidas Ejecuciones que cerraron el array Filas distintas en cada ejecución Detenidas por bucle
10 3 de 3 10, 10, 10 de 10 0
20 3 de 3 17, 18, 20 de 20 0
40 2 de 3 40 de 44, 28 de 41 1 (en la fila 37)
60 2 de 3 15 de 61, 41 de 51 1 (en la fila 22)
95 1 de 3 15 de 81 1 (en la fila 39)

La tercera ejecución de 95 filas no activó la regla de las 12 filas porque su ciclo tenía más de cuatro frases; siguió hasta el límite de tokens (342 segundos) con 304 filas y 16 distintas.

Hay dos cosas en esta tabla que se pasan por alto con facilidad. Que el array se cierre no significa que la respuesta sea buena: la ejecución de 60 filas que cerró con 61 tenía solo 15 textos distintos, y la de 95 que cerró tenía 81 filas y 15 textos. Y el modelo no cuenta. Al pedirle 40, devolvió 44 y 41; al pedirle 95, paró en 81. El número del prompt es una pista, no un contrato.

En japonés fue menos estable en todos los tamaños. Con 20 filas, dos de tres ejecuciones se detuvieron por bucle (13 filas con 5 distintas, 15 filas con 6); con 95 filas, las tres se detuvieron antes de la fila 24.

Por qué no puede salir: las probabilidades

Muestrear con temperatura 0,8 debería, en teoría, acabar desviándose de una frase repetida tarde o temprano. No pasa, y el motivo aparece al volver a pasar por el modelo la respuesta grabada de 95 filas (teacher forcing) y leer la probabilidad que el modelo asignó a cada token que realmente escribió. Promediando sobre los tokens dentro de cada valor "text":

Filas de la respuesta de 95 Filas Probabilidad media por token
Primera aparición de una frase 24 0,555
Repeticiones de una frase anterior 279 0,996
Filas 41 a 303 263 1,000 (redondeado)

Como referencia, una respuesta sana de 20 filas sin repeticiones da una media de 0,493. Escribir una frase nueva es una secuencia de elecciones bastante inciertas. En cuanto una frase ya está dos veces en el contexto, el modelo predice cada token de la tercera copia casi con total seguridad, y una temperatura de 0,8 apenas cambia nada cuando el token más probable acapara el 99,9 % de la masa. Cada copia hace más probable la siguiente, y por eso el bucle se cierra cada vez más en lugar de deshacerse. Un presupuesto de 8192 tokens tampoco ayuda: solo decide cuánto dura el bucle. (La entrada del glosario sobre temperatura explica qué puede y qué no puede hacer la temperatura aquí.)

Detectar el bucle durante el streaming

Como una respuesta en bucle no sirve de todos modos, la solución más barata es dejar de generar en cuanto empieza. Sacar los objetos completos de una respuesta parcial es fácil con json.JSONDecoder.raw_decode, que además rescata filas de una respuesta que quedó cortada:

def objects(text):
    """Complete {...} objects inside the first [, even if the array never closes."""
    dec, i, rows = json.JSONDecoder(), text.find("["), []
    if i < 0:
        return rows
    i += 1
    while True:
        while i < len(text) and text[i] in " \t\r\n,":
            i += 1
        if i >= len(text) or text[i] != "{":
            return rows
        try:
            obj, i = dec.raw_decode(text, i)
        except ValueError:
            return rows  # the last object is still being written
        rows.append(obj)
Enter fullscreen mode Exit fullscreen mode

Una regla de parada más simple que la del barrido resultó ser más fiable: parar cuando las últimas 10 filas no aportaron nada nuevo.

def stalled(rows, k=10):
    seen, since_new = set(), 0
    for r in rows:
        t = str(r.get("text", "")).strip().lower()
        since_new = since_new + 1 if t in seen else 0
        seen.add(t)
    return since_new >= k

text = ""
for chunk in stream_generate(model, tok, prompt, max_tokens=8192, sampler=sampler):
    text += chunk.text
    if "}" in chunk.text and stalled(objects(text)):
        break
Enter fullscreen mode Exit fullscreen mode

Reproducida offline sobre las respuestas grabadas completas, esta regla salta en la fila 36 en la respuesta inglesa de 302 filas, en la fila 29 en la de 304 y en la fila 16 en la japonesa de 272, en vez de dejar que cada una llegue a 8192 tokens. De las 47 respuestas recogidas para este artículo, saltó en todas aquellas en las que menos de un tercio de las filas eran distintas (siete respuestas, incluidos dos lotes japoneses de 20 filas), una vez en una respuesta con 30 filas distintas de 51, y nunca en las otras 39.

Penalización por repetición: importa más la ventana que la intensidad

mlx-lm tiene una penalización por repetición (make_logits_processors(repetition_penalty=..., repetition_context_size=...)), y la ventana por defecto es de 20 tokens. Una fila ocupa unos 27 tokens, así que con la ventana por defecto la penalización nunca ve la copia anterior de una frase. Dos ejecuciones de cada caso con el prompt de 95 filas y penalización 1,1:

Ventana Filas devueltas Filas distintas Array cerrado
20 tokens (por defecto) 49, 51 33, 30 2 de 2
200 tokens 47, 53 47, 53 2 de 2

Con una ventana de 200 tokens, todas las filas fueron distintas. Aun así, el modelo paró más o menos a la mitad de las 95 filas pedidas, así que la penalización no sirve para sacar lotes grandes en una sola llamada.

Además tiene un coste que se nota en el JSON. La penalización se aplica a todos los tokens de la ventana, incluidos ", : y las claves text y label, que por diseño se repiten en cada fila. En uno de cinco lotes japoneses de 20 filas con la ventana de 200 tokens, el modelo cerró dos cadenas con ...' en lugar de ..." y la respuesta dejó de ser JSON válido. objects() aun así recuperó las 12 filas anteriores a la primera rota.

Lo que funcionó: lotes de 20 y limpieza después

Cinco lotes de 20 por configuración, cada lote una llamada independiente con el mismo prompt:

Configuración Filas Filas distintas Etiquetas
Inglés, sin penalización 100 95 65 refund, 14 shipping, 21 spam
Inglés, penalización 1,1, ventana 200 101 100 37 refund, 32 shipping, 32 spam
Japonés, sin penalización 99 64 67 shipping, 17 refund, 15 spam
Japonés, penalización 1,1, ventana 200 93 93 50 shipping, 14 refund, 29 spam

Cada configuración tardó unos dos minutos en los cinco lotes en el M1 (de 113 a 126 segundos). Los lotes por sí solos resuelven el problema de que la respuesta nunca termine; los duplicados entre lotes y dentro de cada lote siguen ahí, sobre todo en japonés, y el reparto de etiquetas puede quedar desequilibrado hacia cualquier lado. Con una sola ejecución por configuración, que las etiquetas en inglés salgan más equilibradas con la penalización puede ser casualidad; los recuentos de duplicados, en cambio, son coherentes en todas las ejecuciones anteriores.

Sean cuales sean los ajustes de generación, tres comprobaciones después de los lotes cuestan poco y detectan problemas reales:

def clean(rows, allowed):
    out, seen = [], set()
    for r in rows:
        r = {k.strip(): v for k, v in r.items()}           # "text " happens
        t = str(r.get("text", "")).strip()
        if not t or r.get("label") not in allowed:          # labels outside the list
            continue
        key = " ".join(t.lower().split())
        if key in seen:                                     # exact duplicates
            continue
        seen.add(key)
        out.append({"text": t, "label": r["label"]})
    return out

print(collections.Counter(r["label"] for r in clean(rows, ALLOWED)))
Enter fullscreen mode Exit fullscreen mode

Ninguna de las ejecuciones anteriores devolvió una etiqueta fuera de la lista, pero los lotes japoneses grabados antes sí: 15 de 99 filas llegaron con la etiqueta 配送料変更 ("cambio en los gastos de envío"), que nunca fue un valor permitido. Una de las respuestas grabadas también usaba la clave "text " con un espacio al final. Las dos cosas son de las que solo aparecen cuando las filas se revisan con código y no a ojo.

Cómo hacerlo en la aplicación

El generador de datasets de la aplicación de escritorio de osFoundry (Models, Datasets, Generate) usa el prompt de arriba, y su botón Generate More (append) envía un lote por clic, así que dejar Samples en 20 y hacer clic hasta que la tabla sea lo bastante grande da el comportamiento por lotes medido aquí. Los datasets guardados se pueden usar después en los trabajos de entrenamiento descritos en la página de entrenamiento de modelos personalizados.

Top comments (0)