experiments

The demo

demo.html lets you watch the hand-written networks drive. It is a single HTML file with no build step and no server code: the network weights are embedded in the page, and every move is computed by a forward pass in your browser.

Live: https://gaberger.github.io/experiments/mini-jev/demo.html Locally: open demo.html in any browser.

What you see

 ┌───┬───┬───┐
 │   │   │ ▓ │  ← 5 rows ahead (top)
 │   │ ▓ │   │
 │ ▓ │   │   │
 │   │   │ ▓ │
 │   │ ▓ │ ▓ │  ← next row the car enters
 ├───┼───┼───┤
 │   │ ● │   │  ← the car
 └───┴───┴───┘

• Road (left): three lanes. Orange cells are obstacles. The top row is 5 steps ahead, and the bottom row of the grid is the next row the car drives into. The car sits below the grid: green while driving, red after a crash.
• Network output (right): the probabilities the network gives to Left, Stay and Right for the current road. The highlighted bar is the top choice, and that is the move the car makes.
• Steps survived / Best: steps on the current road, and the best run since you last picked a driver or pressed New road.

Controls

Control	What it does
Deep net	The 11-layer network that computes which lanes can still reach a clear path.
Shallow net	The 2-layer network that scores how clear each neighbouring lane looks.
Random	Picks a move uniformly at random. Its bars always show 33% each.
Play / Pause	Steps the road every 0.38 s. After a crash it starts a new road on its own.
New road	Starts a fresh road and resets the best score.

What to look for

• Deep net almost never crashes. In the Python benchmark it finishes 99.6% of 300-step roads, the same as a planner that searches every move sequence. Its probabilities are often split, for example 50/50 between two lanes. That is the network saying both moves are safe, not that it is unsure which one is.
• Shallow net does fine until the only gap is two lanes away. It only looks at the lane it would move into, so it can steer into a dead end. Watch for crashes where the car had to cross from one edge lane to the other.
• Random usually lasts about 6 steps.

How it works

Each step the page builds the same 18-number input the Python script uses:

• 3 numbers: which lane the car is in (one of them is 1).
• 15 numbers: the 5 rows ahead, 3 lanes each, 1 for an obstacle and 0 for clear.

It runs that through the network layer by layer (W·x + b, ReLU on hidden layers), applies a softmax to the 3 outputs, and moves in the direction with the highest probability. Hitting an obstacle ends the run.

Network	Layers	Layer widths
Deep	11	18 → 21 → 15 → 18 → 12 → 15 → 9 → 12 → 6 → 9 → 3
Shallow	2	18 → 9 → 3

The deep network’s layers alternate between two jobs, working from the far row back toward the car: keep the inputs it still needs, and compute, for each lane of a row, “this cell is clear AND a clear cell is reachable in the row after it”. See the main README for the ReLU tricks that do the AND and OR.

The road follows the same rules as mini_jev.py: each cell is an obstacle with probability 0.45, and a hidden safe lane that drifts by at most one lane per row is always kept clear, so a drivable path always exists. The page uses its own random number generator, so its roads differ from the 500 benchmark roads in the Python script.

Editing the demo

The weights live in the WJ constant near the top of the <script> block: for each network, a list of [W, b] pairs, one per layer, where W has one row per output unit. Change a number and reload the page to see what it does to the driving.