22 · Interactivos

Nivel 4 — Nivel IOAI · Ruta de Aprendizaje

¿Qué preguntarías si cada respuesta consumiera uno de tus intentos? Aquí no recibes de una vez toda la información: tus decisiones determinan qué observas después. La calidad de una pregunta depende de lo que ya sabes, de las preguntas permitidas y de cómo se puntúa terminar.

Los embeddings del módulo 12 y las probabilidades del 18 ayudan a representar incertidumbre. Pero elegir una acción exige considerar también el estado del juego y el costo de conseguir información.

1. Recibir la comparación de apertura
1. Recibir la comparación de apertura

Partida calculada con el juez didáctico y palabra oculta «secret». Sus vectores dan empate entre lamp y potato: el mensaje del turno 1 conserva lamp. Todavía no se ha adivinado ninguna palabra.

2. Proponer una palabra; el juez conserva la otra
2. Proponer una palabra; el juez conserva la otra

El jugador no puede reemplazar ambas palabras. rock es más cercana al secreto que lamp y pasa a ser la ganadora de la comparación siguiente. Compartir vector con secret no termina la partida: hay que acertar la palabra exacta.

3. Terminar al acertar la palabra exacta
3. Terminar al acertar la palabra exacta

La segunda propuesta acierta y devuelve win, con score 1,0 en esta partida. Los datos son sintéticos: el ejemplo muestra estado y turnos, no la dificultad ni los embeddings privados de Potato.

La información disponible depende del estado de la conversación. Conservar la ganadora restringe la siguiente comparación; un oráculo que dejara elegir libremente ambas palabras resolvería un problema diferente.

Qué cambia cuando hay un juez en vivo

En una predicción habitual, observas la entrada y devuelves una respuesta. En una tarea interactiva hay un diálogo: tu programa actúa, el juez responde y esa respuesta cambia la siguiente decisión.

Se parece a los problemas interactivos de la IOI. Estas tareas IOAI muestran distintas formas de ese diálogo:

TareaEl diálogoPresupuesto
The Analytical Language of John Wilkins (2026, at-home)preguntas sí/no sobre un animal oculto15 preguntas
Potato (2026, día 1)«¿cuál de estas dos palabras se parece más?»30 turnos
Concepts (2025, día 1)das pistas y otra IA adivinallamadas al LLM

El protocolo: mensajes que cambian el estado

Potato usa un objeto JSON por línea, por stdin/stdout. Otras tareas pueden exponer una API: verifica cada enunciado. La receta para ese transporte es Protocolo JSON con el juez. Este fragmento muestra solo el transporte; requiere sus imports y responder, además de una estrategia que interprete los mensajes de inicio, respuesta y terminación de la tarea:

def jugar(estrategia, entrada=sys.stdin, salida=sys.stdout):
    for linea in entrada:
        linea = linea.strip()
        if not linea:
            continue
        respuesta = estrategia(json.loads(linea))
        if respuesta is None:
            break
        responder(respuesta, salida)

stdout pertenece al protocolo

El juez interpreta cada línea como un mensaje JSON. Un print() de depuración en ese canal introduce un mensaje inválido; stderr permite observar el programa sin alterar la conversación.

flush hace que el mensaje salga del buffer. Sin él, jugador y juez pueden quedar esperando aunque la respuesta ya esté calculada. Son restricciones reales de comunicación, no pasos adicionales de aprendizaje.

Un juez local debe conservar el contrato

Descarga el juez y jugador inicial de Potato y extrae el ZIP. Incluye doce palabras con vectores inventados y funciona con Python 3.11 o posterior, sin instalar paquetes. Dentro de potato_local, ejecuta python3 ejecutar.py --oculto secret para ver una partida, o python3 ejecutar.py para evaluar el jugador sobre las doce palabras.

El archivo jugador.py es el punto de partida para cambiar las decisiones. Su estrategia inicial enumera palabras; con este vocabulario pequeño basta para ganar, pero no aprovecha las comparaciones ni representa la dificultad real.

juez_potato.py conserva estado, apertura, empate, victoria, límite y score. También puedes abrir Python en esa carpeta y ejecutar este ejemplo de su API en memoria. Sus print son una demostración local, fuera del canal de comunicación con un juez externo:

from juez_potato import JuezPotato
 
palabras = ["lamp", "potato", "rock", "secret"]
vectores = [[1, 0], [0, 1], [1, 1], [1, 1]]
juez = JuezPotato(palabras, vectores, oculto="secret")
print(juez.iniciar())  # turno 1: lamp vs potato; empate conserva lamp
print(juez.proponer({"new_word": "rock"}))  # rock compite contra lamp
assert not juez.terminada  # mismo vector no significa palabra exacta
print(juez.proponer({"new_word": "SECRET"}))  # victoria en turno 2
print(juez.puntaje)  # 1.0

La primera propuesta responde a la comparación de apertura y puede ganar en el turno 1. En cada paso propones una palabra nueva; no eliges una pareja arbitraria. same conserva la primera. Hay hasta 30 propuestas, y una palabra fuera del vocabulario incumple el protocolo. Una partida sin acierto puntúa cero.

El score local por partida está en 0–1. evaluar_estrategia promedia todas las partidas y multiplica por 100. Incluir derrotas importa: una política que gana 80% de las partidas en turno 5 tiene score esperado 80; una que gana siempre en turno 20 también tiene 80. El promedio de turnos ganados preferiría la primera sin mostrar que pierde una de cada cinco partidas.

Este juez en memoria usa tus embeddings, no los privados, y no implementa el límite global ni el transporte entre procesos. Contrasta la entrega con local_test.py oficial, que controla protocolo y tiempo con embeddings públicos. El score público es orientativo; no se declara equivalente al grader privado.

En datos.json, los vectores del jugador y del juez están separados. Cambia solo los del juez para observar cómo falla una estrategia que confía demasiado en su propia representación. El README del ZIP explica el contrato y los límites de esta simulación.

Ganancia de información: la aritmética del presupuesto

Supón ocho candidatos igualmente probables y respuestas sí/no correctas. Hay log₂(8)=3 bits de incertidumbre. Una pregunta que divide 4/4 deja cuatro posibilidades cualquiera sea la respuesta: elimina un bit. Dividir 7/1 puede resolver de inmediato el caso raro, pero normalmente deja siete.

División de los ocho candidatosIncertidumbre esperada despuésInformación ganada
4 / 42 bits1 bit
7 / 1(7/8)·log₂(7) ≈ 2.456 bits≈0.544 bits

En ese escenario, ceil(log₂(N)) es un límite inferior del número de preguntas necesario para identificar cualquiera de los N candidatos: para 1.400 da 11. No demuestra que 11 preguntas disponibles alcancen. Si dos animales responden igual a todas las preguntas permitidas, no pueden separarse con ellas.

The Analytical Language of John Wilkins da 15 preguntas para unos 1.400 animales. La ganancia de información es una guía útil bajo un modelo de respuestas, no una garantía. Si un candidato concentra casi toda la probabilidad, preguntar directamente por él puede tener sentido, especialmente si acertar termina el juego. La receta Búsqueda por ganancia de información ilustra el caso de filtrado con respuestas fiables:

q = mejor_pregunta(candidatos, disponibles, responde)
respuesta = preguntar_al_juez(q)
candidatos = filtrar(candidatos, q, respuesta, responde)

Cuando el juez no piensa como tú

En Potato, el juez usa una representación privada distinta de los embeddings públicos. Eso no implica que responda al azar: una comparación puede ser determinista y discrepar de tu modelo de similitud.

Con filtrado duro, descartas candidatos que tu modelo cree incompatibles. Una sola discrepancia puede eliminar la palabra oculta, aunque aún queden otros candidatos. Una alternativa es conservar pesos relativos y actualizar su plausibilidad con cada respuesta.

El fragmento siguiente supone embeddings normalizados, pesos iniciales positivos y una respuesta con ganadora estricta. confianza controla cuánto crees a la comparación de tu modelo; no es una probabilidad calibrada:

import math
 
def actualizar_pesos(pesos, candidatos, ganadora, perdedora, emb, confianza=2.0):
    """Aumenta el peso relativo de candidatos compatibles con la comparación."""
    for idx, c in enumerate(candidatos):
        margen = float(emb[c] @ emb[ganadora]) - float(emb[c] @ emb[perdedora])
        pesos[idx] *= 1.0 / (1.0 + math.exp(-confianza * margen))
    total = sum(pesos) or 1.0
    return [p / total for p in pesos]

El margen es cuánto más se parece el candidato a la ganadora que a la perdedora en tus embeddings. Un margen positivo multiplica por un factor mayor que 0.5; uno negativo, por un factor menor. Ambos pesos bajan antes de normalizar, pero los compatibles ganan peso relativo.

Con aritmética exacta y factores positivos no se elimina un candidato. Eso permite recuperarse de algunas discrepancias, sin garantizarlo: el peso correcto puede volverse diminuto. En secuencias largas, usar log-pesos evita subdesbordamiento. Un empate same conserva la primera palabra en el juego, pero no demuestra que sea más cercana; no debe tratarse como una victoria estricta en esta fórmula.

Queda además elegir qué palabra proponer. Maximizar información y maximizar score esperado no son lo mismo: preguntar también consume una oportunidad de acertar y está restringido por la palabra ganadora que conserva el juez.

Cuando el juez es otro modelo

Concepts (2025) es la variante en que el «juez» es una IA que adivina, y tú das las pistas. El bucle es el del módulo 20:

tu generador ─► pista ─► adivinador ─► ¿acertó? ─┐
      ▲                                           │
      └────────────── iterar ─────────────────────┘

Cada llamada tiene un costo. Un adivinador local puede servir como proxy si su ranking de pistas se parece al oficial, pero esa semejanza necesita evidencia. Una pista que explota una peculiaridad de tu proxy puede transferir mal al modelo que realmente adivina.

En el Individual 2025 (284 participantes), Concepts tuvo media 19.1/100. Publicó baseline 0.20 y Comité 0.54; tu proxy local necesita su propia comparación y esos números no explican su coste ni su fidelidad.

⚠️ Las tres trampas

1. Depurar en stdout. Introduce mensajes ajenos al protocolo y puede interrumpir la partida.

2. Confundir una partición balanceada con una buena jugada universal. La distribución de candidatos, el costo de preguntar y el premio por acertar pueden favorecer otra acción.

3. Confundir el juez con tu representación del juez. Un empate y una comparación incompatible con tus embeddings no son errores del protocolo. La política necesita interpretarlos sin inventar información que no recibió.

🏋️ Práctica

Primero, una pregunta que separa candidatos

Quedan cuatro candidatos igualmente probables. Una pregunta sí/no los separa 2–2 y otra 1–3. Calcula cuántos candidatos quedarían en promedio, ponderando el tamaño de cada grupo por la probabilidad de recibir esa respuesta.

Para profundizar

#EjercicioFuenteQué practica
1Implementa «20 preguntas» sobre 1.000 animales con atributos inventadosBúsqueda por ganancia de informaciónla aritmética del presupuesto
2Explora el juez local de Potato cambiando la palabra oculta y las propuestasJuez y jugador inicial (ZIP)cómo el estado restringe las decisiones
3⭐ The Analytical Language of John Wilkins: 15 preguntas, ~1.400 animalesabrir en Colabla tarea preparatoria, con solución medible
4⭐⭐ Potato: con el juez usando otra representaciónenunciado oficialfiltrar vs. puntuar, en carne propia
5Concepts: escribe el adivinador y optimiza las pistas contra élrepo oficialel juez como modelo

Cambiar solo los embeddings del juez permite comparar filtrado y pesos bajo una discrepancia controlada. Es una simulación de desajuste entre representaciones; no reproduce necesariamente el tipo de desajuste privado.

🎯 Mini-desafío (formato IOAI)

Tarea: Potato (IOAI 2026, día 1), completa. Métrica: 1 − 0.02 × máx(0, turno − 10) por partida; 0 si no se resuelve en 30 turnos. Promedio × 100. Datos: vocabulario de 1.602 palabras, embeddings públicos de 2.560 dimensiones, y un juez con representación privada. Límite: 10 minutos para las 120 partidas completas, incluyendo la carga de los modelos.

Fíjate en la métrica: los turnos 1 a 10 valen lo mismo (1.00). No hay premio adicional por adivinar en tres frente a diez. Optimiza el score esperado completo, incluidos aciertos de turnos 11–30 y fallos, no solo la probabilidad de llegar antes de diez ni el promedio de turnos ganados.

El tiempo es global: 10 minutos para 120 partidas equivalen a un promedio de 5 segundos por partida, incluyendo carga. No es un límite independiente de 5 segundos para cada juego; gastar más en uno deja menos para los demás.

En el Individual 2026 (440 participantes), el rendimiento normalizado observado tuvo media 8.2/100 y 66% de ceros. No uses esos agregados como score esperado de este juez público ni como descripción de las causas de fallo.

Para poner a prueba la intuición

¿Qué estrategia parece buena si solo promedias turnos ganados, pero mala al incluir fallos?

Construye un empate y comprueba qué palabra se conserva. ¿Por qué importa para la siguiente propuesta?

Cambia los embeddings del juez sin cambiar los del jugador: ¿qué rompe primero, el filtrado o los pesos suaves?


← 21 - Adversarial y robustez · Ruta de Aprendizaje · 23 - El día de competencia →