De 0,2 a 35 manzanas en 13 segundos de CPU

Todas las corridas se evaluaron en las mismas 30 semillas de prueba (5000 a 5029) con exploración apagada (ε = 0):

La Corrida 1 (c1_base) es el intento directo: le damos a una red de 48 neuronas ocultas las 6 coordenadas normalizadas del juego (cabeza_x, cabeza_y, manzana_x, manzana_y, dx, dy) y la entrenamos con Q-Learning dando +10 al comer, −10 al chocar y 0 en cualquier otro paso.

El resultado después de 240 partidas es 0,23 manzanas por partida (igual que jugar al azar). Al inspeccionar cómo terminan las 30 partidas de evaluación aparece la causa: 25 de las 30 partidas terminan por límite de pasos sin comer y solo 4 por choque contra la pared. La red descubrió que girar siempre hacia el mismo lado no recibe el castigo de −10.

Antes de correr la Corrida 2 dejamos escritas tres predicciones verificables:

La mejora es dramática: de 0,23 a 19,53 manzanas. Pero al revisar las estadísticas de la Corrida 2 aparecen dos cuellos de botella:

1. Tiempo de cómputo e inestabilidad: actualizar los pesos con backpropagation en cada turno individual hace que la curva oscile brusco cuando una partida larga pisa los pesos recién aprendidos.
2. Cómo muere ahora la serpiente: en 28 de las 30 partidas (93 %) la serpiente muere chocando contra su propio cuerpo.

¿Cuánto tiempo de CPU se va en simular el tablero de Snake y cuánto en calcular gradientes de PyTorch? Medimos ambos tiempos por separado: dar un paso en snake.py tarda ~12 microsegundos, mientras que un paso de backward() + step() tarda ~350 microsegundos. Además, entrenar con estados consecutivos viola el supuesto de muestras independientes.

El resultado de P5 es clave: ni el mejor optimizador del mundo puede evitar que la serpiente se encierre si sus sensores no ven el callejón.

Repetimos cuadro a cuadro las muertes de c3_replay_rapido cuando la serpiente supera las 20 casillas de largo. En casi todas pasa lo mismo: el cuerpo forma un anillo o bolsillo contra una pared; la casilla de entrada al bolsillo está vacía (así que el sensor de peligro a 1 casilla vale 0), y como la manzana está en esa dirección, la red entra al bolsillo. Tres turnos después se le acaban las casillas libres.

Una forma de ver todo el tablero sería pasar la grilla de 10×10 por una red convolucional (CNN), pero eso multiplicaría por 20 el número de parámetros y por 50 el tiempo de entrenamiento. En cambio, formulamos H4:

Con las 14 entradas de H4 ya validadas, nos hicimos la última pregunta: ¿qué método entrena mejor una red para Snake, el aprendizaje por refuerzo con gradientes (Double DQN) o evolucionar una población de redes sin derivadas (Neuroevolución / Algoritmo Genético)?

Para que la búsqueda evolutiva fuera rápida, redujimos la red a 14 → 12 → 3 (219 parámetros en vez de los 1 155 de DQN). En el camino tuvimos que resolver tres hipótesis internas dentro de la propia neuroevolución:

Comparación final: ¿DQN (C4) o Neuroevolución (C5)?

• En puntaje máximo y eficiencia por segundo: gana Double DQN (C4). Aprovecha cada paso individual de la partida para ajustar los pesos con gradiente exacto, alcanzando 35,57 manzanas de media (máximo 50) en 13,8 segundos (y ya promedia 26+ manzanas a los 6 segundos).
• En simplicidad y tamaño de red: destaca Neuroevolución (C5). Con solo 219 parámetros en NumPy puro (5 veces menos pesos que DQN) y sin ecuación de Bellman ni PyTorch, alcanza 29,20 manzanas de media (mediana 30,5) en 30 generaciones.

Si quieres entrenar desde cero una red que juegue un Snake excelente en apenas 6 a 14 segundos de CPU, esta es la combinación óptima encontrada tras resolver las 5 tesis: