4. Comparación de las resoluciones antes y después del entrenamiento

El mismo puzzle, dos métodos

Resolví dos veces un puzzle fácil (35 casillas vacías) con el LoRA del 8B de la entrada 3 (15 ciclos).

• Primera vez: para los números del 1 al 9 en orden, el VLM escribe las casillas donde el número no puede ir, y se rellena la casilla que queda como único sitio.
• Segunda vez: el mismo método, pero cada vez que se rellena una casilla, el código rellena de inmediato las cajas, filas y columnas a las que solo les queda una casilla vacía.

Primera vez: se detuvo con 2 casillas vacías

En 16 juicios hizo 38 jugadas, y 33 fueron correctas. Se quedó con 2 casillas vacías sin encontrar dónde más jugar. De los 16 juicios, 9 acertaron sin fallos las casillas donde no se podía poner el número.

Las 5 jugadas erróneas salieron todas de marcar por error como imposible una casilla posible. Al tacharse un sitio de más, una casilla equivocada quedaba como único sitio. La demo no puso las jugadas erróneas en el tablero; solo las registró.

Segunda vez: completado en 10 juicios

La segunda vez rellenó las 35 casillas en 10 juicios. Los juicios del VLM rellenaron 15 casillas, el código rellenó a continuación 20, y no hubo ninguna casilla incorrecta. De los 10 juicios, 8 fueron completos sin fallos, pero las casillas que faltaron no cambiaron ninguna respuesta.

Al rellenar dos casillas con el número 2, aparecieron cajas, filas y columnas con una sola casilla vacía, y el código rellenó cinco casillas seguidas. Con el número 7 y con el número 3 de la segunda vuelta también se encadenaron cinco casillas cada vez. Al haber menos juicios que hacer, el modelo tuvo menos ocasiones de equivocarse.

Las respuestas anteriores generan las siguientes

El modelo de la entrada 1 rellenaba fila por fila desde arriba a la izquierda y no usaba las respuestas ya rellenadas como fundamento para la siguiente casilla. La segunda resolución va rellenando casillas dispersas por todo el tablero, y cada casilla recién rellenada se convierte en el fundamento de la siguiente. Es el mismo orden en que resuelven las personas.

El código real de este paso

Este es el código que se ejecuta después de cada juicio del VLM en la segunda resolución. Si a una caja, fila o columna solo le queda una casilla vacía, la rellena con el número que falta.

def _missing_one(values: list[int]) -> int | None:
    present = {v for v in values if v != 0}
    miss = [d for d in range(1, 10) if d not in present]
    return miss[0] if len(miss) == 1 else None


def last_empty_unit_moves(
    board: list[list[int]],
) -> list[tuple[int, int, int, str]]:
    """박스·행·열에 빈칸이 정확히 1개면 빠진 숫자로 채움."""
    found: dict[tuple[int, int], tuple[int, str]] = {}

    def add(r: int, c: int, digit: int, reason: str) -> None:
        key = (r, c)
        if key not in found:
            found[key] = (digit, reason)
        elif found[key][0] == digit:
            prev = found[key][1]
            if reason not in prev:
                found[key] = (digit, f"{prev}+{reason}")

    for br in range(3):
        for bc in range(3):
            cells = [
                (r, c)
                for r in range(br * 3, br * 3 + 3)
                for c in range(bc * 3, bc * 3 + 3)
            ]
            empties = [(r, c) for r, c in cells if board[r][c] == 0]
            if len(empties) != 1:
                continue
            digit = _missing_one([board[r][c] for r, c in cells])
            if digit is not None:
                add(empties[0][0], empties[0][1], digit, "code_last_box")

    for r in range(9):
        empties = [(r, c) for c in range(9) if board[r][c] == 0]
        if len(empties) != 1:
            continue
        digit = _missing_one([board[r][c] for c in range(9)])
        if digit is not None:
            add(empties[0][0], empties[0][1], digit, "code_last_row")

    for c in range(9):
        empties = [(r, c) for r in range(9) if board[r][c] == 0]
        if len(empties) != 1:
            continue
        digit = _missing_one([board[r][c] for r in range(9)])
        if digit is not None:
            add(empties[0][0], empties[0][1], digit, "code_last_col")

    return [
        (r, c, digit, reason)
        for (r, c), (digit, reason) in sorted(found.items())
    ]

La siguiente entrada es "5. Una IA que ayuda a las personas".