NeuroDino

A small neural network that plays Chrome's T-Rex game. Watch it play live, with its network drawn next to it: NeuroDino Space. The code that trained it: github.com/ahm3texe/NeuroDino. The paper describes all three models and how they were tested: paper/neurodino-en.pdf (Turkish original: paper/neurodino.pdf).

This is v3. The earlier models are in v2/ and v1/.

Model

A multilayer perceptron written with NumPy, no ML framework:

• 12 inputs → 56 hidden neurons (tanh) → 3 outputs (softmax): jump, duck, run
• 899 parameters: weights 12×56 + 56×3, biases 56 + 3
• hidden neurons 48–55 feed only duck; their weights to jump and run are 0
• every frame the obstacles move, the game computes the inputs and the dino takes the likeliest action

Inputs

Missing obstacles give 0. Distances are in game pixels, the speed in pixels per frame at 60 fps, and "the next obstacle" is the nearest one ahead of the dino.

The reference implementation is neurodino/sensors.py.

Usage

import numpy as np
from huggingface_hub import hf_hub_download
from safetensors.numpy import load_file

w = load_file(hf_hub_download("ahm3texe/neurodino", "model.safetensors"))

def act(inputs):
    """The 12 inputs above in, 'jump', 'duck' or 'run' out."""
    hidden = np.tanh(w["weights_ih"] @ inputs + w["bias_h"])
    logits = w["weights_ho"] @ hidden + w["bias_o"]
    return ["jump", "duck", "run"][int(np.argmax(logits))]  # = argmax of the softmax

Compute the inputs after the obstacles have moved for the frame, as the website and watch_model.py do. Duck in the air is a fast drop. To watch it play, run watch_model.py from the GitHub repository.

Training

• v1: a genetic algorithm with 50 networks per generation (the best two carry over unchanged, the rest are bred by tournament selection, uniform crossover and Gaussian mutation), 83 generations from random weights. Each generation played a single game. Its runner let the networks decide before the obstacles moved each frame, so v1 acts on what it saw a frame earlier.
• v2: the same algorithm for 40 more generations starting from v1, in the website's loop, with every network playing the same 10 games each generation, and picked on validation games. 12-48-3; it never ducks.
• v3: v2 crashed about once in a hundred hours at top speed, nearly always still in the air when the next obstacle needed a jump; a fast drop would have saved it. v3 adds 8 hidden neurons that drive only duck. Frames in the air were labelled by playing on from them twice, with a duck and without, and the new neurons and duck's output row learned from those labels by gradient descent, with duck's bias then lowered by 1. Everything else is v2's, so every jump is exactly as v2 makes it.

The logs are training_log.csv (v1), training_log_v2.csv and validation_v2.csv; v3's pipeline is in the repository's training/.

Results

On the website's engine, four-hour games:

Neither v2 nor v3 had played the test games (seeds 1–200) or the new ones before. Every game is in the repository's evaluation/.

Limitations

• It was taught to duck only to drop fast in the air, not under a bird: Obj Act marks only the highest bird, which needs no action, so a bird it would have to duck under looks the same as a low one it can jump.
• Its timing is tuned to about a frame; played in another game loop, the results change completely (see v1 in the repository's evaluation).
• It sees at most two obstacles and tells distances apart only up to 50 frames ahead; Gap never rises above 0 with Chrome's normal obstacle gaps.

Files

License

MIT. The game it learned on is Chromium's T-Rex runner (BSD-3-Clause), ported to Python; not affiliated with Google.