Tabú entre modelos locales

Tres modelos de lenguaje juegan al Tabú en mi ordenador. Uno describe una palabra sin poder usar las prohibidas, otro intenta adivinarla y un tercero vigila que nadie haga trampas. Ninguno decide el resultado: eso lo hace un árbitro escrito en Python.

Lenguaje
Python
Modelos
Ollama, en local
Pruebas
89 con pytest
Turnos medidos
360

Ver el código en GitHub

Palabra secretabarco
  • mar
  • navegar
  • puerto
transportefácil

Un turno real, paso a paso

Esto pasó en el experimento, tal cual quedó guardado en el registro. El equipo azul tiene que adivinar «barco» sin decir «mar», «navegar» ni «puerto», y dispone de tres intentos.

Equipo azul
Describe llama3.2:3b
Adivina qwen2.5:3b
Vigila gemma2:2b

  1. Árbitro Python

    Reparte la tarjeta. El descriptor recibe la palabra secreta y las prohibidas; el adivinador no recibe nada, solo verá las pistas que pasen el control.

  2. Descriptor llama3.2:3b · 5,6 s

    En el horizonte, un objeto grande y pesado se balancea suavemente en el agua, dejando un rastro de olas detrás de él. Los niños disfrutan viéndolo en el agua, y los adultos también lo encuentran emocionante.

  3. Árbitro y vigilante

    Las reglas no encuentran ninguna palabra prohibida ni forma suya. El vigilante tampoco ve trampa. La pista llega al adivinador.

  4. Adivinador qwen2.5:3b · 1,7 s

    botefallo, quedan 2 intentos

  5. Descriptor llama3.2:3b · 5,6 s

    Recibe la respuesta fallida y da otra pista.

    Algunos deportistas y personajes famosos han utilizado este objeto para demostrar habilidades impresionantes, y es común verlo en eventos de competición en todo el mundo.

  6. Vigilante gemma2:2b · 11,2 s

    «La descripción menciona directamente el objeto "barco"». Confianza 0,9.

    El árbitro descarta la acusación: la palabra citada no aparece en la pista. Sin esta comprobación, el turno habría acabado en una penalización injusta.

  7. Adivinador qwen2.5:3b · 2,2 s

    barcoacierto, +1 punto

Quién sabe qué

Cada modelo recibe solo la información de su rol. No es una instrucción en el prompt: la función que llama al adivinador no tiene ningún parámetro por el que pueda llegarle la palabra secreta, y una prueba automática revisa todos sus prompts.

Descriptor

llama3.2:3b o qwen2.5:3b

Describe la palabra en un máximo de 40 palabras. Si el adivinador falla, ve sus respuestas y lo vuelve a intentar.

Ve
La secreta, las prohibidas, sus pistas anteriores y los fallos del adivinador.
No ve
El marcador ni a los otros equipos.

Adivinador

qwen2.5:3b o llama3.2:3b

Responde con una sola palabra. Tiene tres intentos por tarjeta y no puede repetir una respuesta fallida.

Ve
Las pistas que han pasado el control y sus propias respuestas.
No ve
La secreta, las prohibidas ni las pistas anuladas.

Vigilante

gemma2:2b

Busca trampas que no se pueden comprobar letra a letra, como sinónimos evidentes o rimas. Responde en un JSON fijo.

Ve
La pista que revisa, la secreta y las prohibidas.
No ve
Los equipos, el marcador ni las respuestas del adivinador.
El árbitro

Es código determinista, no un modelo. Reparte tarjetas sin repetirlas, construye cada prompt, aplica las reglas, acepta o descarta lo que dice el vigilante, cuenta los intentos y lleva el marcador: +1 por acierto y −1 por trampa. Si un modelo devuelve algo inservible, tarda demasiado o Ollama se cae, la partida no se bloquea: el fallo queda registrado y el árbitro sigue.

Cómo se detectan las trampas

En dos capas. Lo que se puede comprobar lo comprueba Python; el modelo vigilante solo opina sobre lo demás, y solo si aporta pruebas. Una pista con trampa nunca llega al adivinador.

Primero, las reglas

Antes de comparar, el texto se pasa a minúsculas y se le quitan tildes y signos. Después se revisan la secreta y cada prohibida.

Exactaperro
Morfológicaperros, perra, perrito: plurales, género y diminutivos
Derivadaperrera, ladra: comparten raíz
Compuestaparaguas contiene agua
Fraseechar de menos, también en plural
Deletreop-e-r-r-o
Traduccióndog, gos, chien: variantes guardadas en cada tarjeta

Después, el vigilante

Solo se le consulta si las reglas no encuentran nada. Busca sinónimos demasiado evidentes, faltas de ortografía a propósito, pistas de letras o rimas. El árbitro acepta su acusación solo si se cumplen tres condiciones:

  1. El JSON es válido. Si no, se reintenta una vez y después no penaliza.
  2. La confianza llega al umbral, 0,8 por defecto.
  3. Lo que cita aparece en la pista, literalmente. Esta regla la añadí después de ver a gemma2:2b asegurar que una pista contenía «cumpleaños» cuando no era así.

Qué pasa al prohibir más palabras

La pregunta del experimento era cómo cambia el rendimiento con 3, 5 o 7 palabras prohibidas. Las mismas 30 tarjetas, los mismos equipos y la misma semilla en las tres condiciones, dos repeticiones: 360 turnos y unas dos horas en un portátil con 16 GB de RAM, todo en CPU.

Se acierta menos

De 3 a 7 prohibidas el acierto cae 12,5 puntos, y la diferencia es significativa (McNemar exacto, p = 0,008, 120 pares). Los pasos intermedios van en la misma dirección, pero con esta muestra no se distinguen del azar.

Porcentaje de palabras adivinadas según el número de prohibidas 3 prohibidas: 27,5 % (IC 95 %: 20,3 a 36,1). 5 prohibidas: 20,8 % (14,5 a 29,0). 7 prohibidas: 15,0 % (9,7 a 22,5). 0 %10 %20 %30 %40 % 3 prohibidas5 prohibidas7 prohibidas 27,5 %20,8 %15,0 %

Barras: acierto medio. Líneas: intervalo de confianza del 95 %.

Pesa más quién describe

La diferencia entre los dos descriptores es mayor que la que provoca cualquier lista de prohibidas. Este es el porcentaje de sus turnos en los que escribieron la palabra secreta tal cual:

116 de 180 turnos frente a 35 de 180.

El vigilante, sin pruebas, no sirve

Un modelo de 2 B acusa casi siempre. La regla de la cita literal es lo que evita que el experimento mida el ruido del juez.

  1. Veredictos emitidos
    269
  2. Acusaciones de trampa
    196
  3. Aceptadas por el árbitro
    19
  4. Correctas tras revisarlas a mano
    1

Prohibir más palabras hace que los modelos usen alguna sin querer y, cuando no lo hacen, que describan peor. Pero lo que más decide una partida es qué modelo describe.

Cómo está hecho

La interfaz web, la consola y el experimento usan exactamente el mismo motor de juego. Toda la configuración vive en un config.json, y cada partida se guarda turno a turno en JSON para no perder nada si el programa se interrumpe.

Módulos

game/El árbitro: turnos, roles, puntuación y registro.
detection/Reglas anti-trampa y vigilante semántico.
models/Cliente de Ollama que solo acepta conexiones locales, y un cliente falso para las pruebas.
cards/52 tarjetas escritas a mano, validador y generador de tarjetas nuevas.
experiment/Diseño 3/5/7, estadística con intervalos de confianza y gráficos.
gui/Interfaz en el navegador, servida desde el propio ordenador.

Decisiones que lo sostienen

  • Los modelos producen texto; Python decide. Ningún resultado depende de que un modelo se porte bien.
  • Nada bloquea una partida. Respuestas vacías, sin formato, repetidas o que hablan de las reglas se descartan y se piden de nuevo con un prompt más estricto.
  • 89 pruebas que no necesitan Ollama. Usan clientes falsos con respuestas guionizadas y registran cada prompt, así que se pueden ejecutar en cualquier sitio.
  • Experimento reproducible. Condiciones anidadas, orden aleatorio dentro de cada trío de turnos y reanudación si se corta.

Por qué no hay demo online

Los modelos se ejecutan en el ordenador de quien juega, y el programa rechaza a propósito cualquier servidor remoto. El código está en GitHub; para probarlo hace falta Python 3.11, Ollama y unos 6 GB de disco:

# descargar el código
git clone https://github.com/Rotciv1210/modelosIA.git
cd modelosIA/tabu_local
pip install -r requirements.txt

# descargar los tres modelos
ollama pull llama3.2:3b
ollama pull qwen2.5:3b
ollama pull gemma2:2b

# abrir la interfaz en el navegador
python main.py gui