¶ Minimal Neural Network Structures for Spatial Problem Solving
Members: Pulkit ChaudharyUG, Sayor SinghaUG, Amiya HarishHS, Srinithin GaneshHS Faculty advisor: Professor Bernhard Firner
¶ Project overview
A jumping spider studies a maze from above, then solves it once dropped inside, on a brain far smaller than the networks normally pointed at navigation problems. We wanted to know how small a network can be and still do the same thing, and which resource actually binds: capacity, training data, or memory.
The answer we ended on is the one sentence worth taking away from this page. A small network that remembers beats a large network that sees everything, which is how the real animal does it.
- We generate random thin-wall mazes. Each maze is a perfect maze, a spanning tree, so there is exactly one route between any two cells and every wrong turn leads to a dead branch.
- We label cells with the optimal next move, computed by breadth-first search.
- The network outputs one of five actions: up, down, left, right, or stay.
- We plot success against solution length rather than a single score, so we can see where a model breaks instead of just how often it wins.
Every maze in every number on this page is brand new, generated at test time. Nothing is memorised.
¶ How to read the numbers
There are two views of a maze in this project and they are not the same task, so every number below names its view.
From above the network receives the whole grid: four wall channels, its own position, and the goal. First-person it receives only the cells immediately around it, which is the version a real spider faces and the harder problem by a wide margin. A number from one view says nothing about the other.
"Success" means the spider reached the goal within a step cap, running closed loop on its own predictions. Mazes in the early CNN experiments are not seeded, so re-running moves those numbers by roughly a point. The tuning study in the last section is fully seeded and reproduces exactly. Rows from different tables are not directly comparable, and nothing below about one point should be read as a real difference.
Sample sizes vary across the sections below and are stated wherever they matter. The first-person comparison in particular was evaluated more than once at different sizes, and we report every run we have rather than the best one.
¶ The maze
Blue is the spider, red is the goal, and green is the one route between them. From above, the maze reaches the network as six layers: one for each of the four wall directions, one marking where the spider is, and one marking where the goal is. First-person, it gets only the walls of the cell it is standing in, which is the whole reason the same maze is so much harder from inside.
¶ Architecture
The baseline is a plain CNN: two conv layers (6 to 16 to 32 channels, 3x3 kernels), a flatten, one 128-unit hidden layer, five outputs. It picks a move, the view is redrawn from the new position, and it runs again. The deeper models in the results below extend this to three, four, and five conv layers.
That design has one specific failure mode, and it is the thing that shaped the whole project. The network is a pure function of the current frame, so it has no memory of where it has been. One wrong move puts it in a state that appears on no optimal path in training, and it does not come back.
¶ The first network worked, and then it did not
On 3x3 mazes the first full pipeline solved 997 of 1000. We then made the network bigger four separate ways, adding layers, batch normalization and four times the compute, and it barely moved.
Sorting the same model's results by how long the maze's answer is shows why.
Perfect on short mazes, falling to zero past roughly 20 steps. The network had learned what common mazes look like rather than how to solve one. The same shape appears across separate training runs, so it is not a single unlucky model.
¶ The spider never recovers from a mistake
Over 2,000 fresh 7x7 mazes, viewed from above, the baseline solved 639, or 31.9%. Of those 639, the number solved after making at least one wrong move was zero. Every failure took one of two shapes: bouncing between the same two cells until the step cap, or pushing into a wall that was visible in its own input.
The cause is structural rather than statistical. On a perfect maze one wrong turn is always terminal, and because the policy depends only on the current frame, two adjacent cells whose predictions point at each other form a fixed point with no way out. The prediction that follows is that no amount of data or capacity can fix it, and that is what we see: across all 32 configurations in our parameter sweep, overall success moves from 0.020 to 0.826 while the recovery rate stays at exactly 0.000 in every single row.
¶ Where the scaling runs out
More data helps and then flattens. On 5x5, 5,000 mazes give 84%, 10,000 give 94%, and 15,000 give 98%.
More parameters do almost nothing by comparison. Doubling the training data at a fixed network size added 17.3 points, while going from 0.90M to 2.0M parameters changed nothing we can measure.
And the compute cost is the real problem. Against a plain breadth-first search, our CNN was hundreds of millions of operations to do something normally done in ten. Each step up that axis is a factor of ten.
We were building an extremely inefficient maze solver. This is where the project changed direction.
¶ Training throughput
Moving training onto the GPU gave roughly 3.5x at batch size 32, rising to about 6x at large batches, measured on an M4 Pro.
¶ The bug
The model worked on 3x3 and stalled around 40% on 5x5. That particular pattern, strong on the tiny case and stuck on the slightly larger one, usually means a bug rather than a hard problem, and it did here.
Three of the five parts of the network were receiving zero learning signal. The convolutional front end, the part that reads the maze, had never trained at all and had been frozen at its random initialisation all summer. One line was passing a stale copy of the state instead of the live one.
Same code, same data, same model size. The only difference is that the network's eyes were finally allowed to learn: 5.7% to 98.3% on 5x5 from above. The lesson we would pass on is to confirm every part of a model is actually training before tuning anything.
¶ A different kind of network
Instead of one pass from maze to move, the model splits into a slow planner and a fast worker that loop and exchange state before committing to a move, and it carries memory forward from one move to the next.
The full model, as built: a global pass builds a high-level plan once, then for every physical step a local view is combined with that plan and the current memory, refined by a reasoning core, and checked by a confidence test that decides whether to think again or commit to a move.
¶ The headline result: memory replaces sight
Three configurations of the same task. Seeing the whole maze from above: 98%. Dropped inside with only local sight and no memory: 6%, a total collapse. Dropped inside with memory: 66%.
Memory does the job that sight was doing, and memory is far cheaper. That is the project's result in one figure.
We measured this comparison more than once, and the runs are worth reporting together rather than picking the most favourable one. Both are 5x5.
| Evaluation | Mazes | From above | First-person, no memory | First-person, with memory |
|---|---|---|---|---|
| The run in the figure above | not recorded | 98% | 6% | 66% |
| Final evaluation table | 30 | 96.7% (CNN) | 43.3% (CNN) | 76.7% |
| Tuning sweep | 200 | not measured | 11% (CNN) | not measured |
The direction is the same every time and it is a large effect, but the exact values move between runs, and the first-person baseline moves most: 6%, 11% and 43.3% across three evaluations. Thirty mazes is a small sample, and the 200-maze sweep is the most reliable estimate of the memoryless baseline we have. Treat the headline figure as the shape of the result rather than three precise numbers. A single evaluation of all three configurations at 200 or more mazes, with error bars, is the outstanding measurement, and it is the first thing we would run next.
For completeness, the final evaluation also recorded a variant with learned rather than hand-written memory, which reached 20% first-person, so the hand-written no-backtrack rule is doing much of the work in the 66% figure. Making that memory learned is on the future work list below.
The failure without memory is not a near miss. It wanders and stays lost.
The same maze, the same starting cell, run twice. Without memory it takes 162 steps and never gets out. With memory it is done in 19.
Repeated across three separate training runs, with error bars, the ordering holds rather than depending on one lucky model.
¶ It decides how long to think
The confidence check in the architecture above means the model spends a variable amount of computation per move. It turns out to spend it in a sensible place: 5.76 thinking steps on its very first move, and 1.29 on every move afterwards. It works hard once to orient itself, then coasts on the memory it has built.
It also spends about 18% less thinking on long mazes, which is the right instinct, since long mazes are mostly corridors with one available move.
Training the same network five times, changing one setting each time, every configuration with memory beat the old memoryless model, and the half-size network tied for best.
¶ Watching it run
Left panel is the maze from above, for our benefit. Right panel is everything the spider actually receives.
Two runs where it matched the optimal path exactly, from inside, with no map. The 9x9 has a shortest path of 29 steps and it took 29.
¶ Smaller and better
The final model is roughly 36% smaller than the CNN it replaced, 0.77M parameters against 1.21M, and better at the first-person task that matters.
The advantage widens as mazes get bigger, so it is not an artefact of small grids.
¶ Follow-up: why depth helped, and why not for the reason we assumed
After the presentation we ran a controlled tuning study on the overhead-view 7x7 task, changing one variable at a time from a configuration that reproduces the original baseline exactly, training each run from scratch on the same seeds and scoring all of them on the same 500 held-out mazes. Thirty-two configurations, fully reproducible from the repository.
Depth is the strongest architectural lever in that study, moving the reference from 0.406 to 0.826 at five layers. The natural explanation is reach: a 3x3 kernel moves information one cell per layer, so a two-layer network has a receptive field of 5, and on a 7x7 maze the cell the spider occupies cannot see the far corner at all.
That hypothesis makes a sharp prediction, that any change buying the same reach should buy the same accuracy, and it fails.
| Configuration | Receptive field | Parameters | Success |
|---|---|---|---|
| depth 4, 3x3 kernels | 9 | 901,461 | 0.686 |
| depth 2, 5x5 kernels | 9 | 216,725 | 0.410 |
| depth 2, 7x7 kernels | 13 | 231,317 | 0.340 |
Two networks with identical reach differ by 27.6 points, and buying reach through kernel size alone does nothing: 7x7 kernels, which let every cell see the entire grid, make it worse.
Parameter count does not explain it either. At a matched budget of roughly 0.9 million parameters, a deeper network scores 0.686 against 0.558 for a wider one, and 811,413 parameters spent on a larger dense layer score 0.402, no better than the 206,997-parameter reference.
What depth has that width and kernel size do not is sequential steps: each layer applies another nonlinearity to the output of the last. If the task rewards successive rounds of computation, the expensive way to buy them is to stack layers, and the cheap way is to apply one block repeatedly and carry state, which is what the planner and worker design does.
¶ Future work
The direction we would take next is a world model: instead of reacting to what it can see, the network predicts what it would see before it moves, and navigates against that prediction.
- Re-run the three-way first-person comparison once at 200 or more mazes with error bars, so the headline has a single sample size behind it.
- Let the memory break its own loops, rather than relying on a hand-written no-backtrack rule. The learned-memory variant reached 20% against the hand-written rule's 66%, so this is the largest open gap.
- Push past 7x7 and 9x9 to larger grids.
- Finish the adaptive-thinking work, including spending an extra step whenever the confidence check is close rather than defaulting to stop.
- Move toward a world model, where the network predicts what it would see before it moves.
¶ Progress log
¶ Week one
- Framed the question: can a network match a spider's ability to adapt inside a maze it has not seen before?
- Separated the two views that matter, the maze from above and the maze from the spider's own position.
- Planned to start with a maze generator and a network that solves it, then scale up.
- Week 1 slides
¶ Week two
- Finished the maze generator: random thin walls, random exit, any grid size.
- Outlined the CNN and got spider movement working.
- Encoded the training data into the six-channel format used by every later experiment. This took most of the week and fixed the input representation for the rest of the project.
- Week 2 slides
¶ Week three
- First full pipeline: generate, train, test, plot. On 3x3 mazes it solved 997 of 1000.
- Ran 5x5 and 7x7.
- Found the failure mode that shaped the rest of the project: sorted by solution length, success falls to zero past about 20 steps, so the network was reproducing what common mazes look like rather than solving the one in front of it.
- Week 3 slides
¶ Week four
- Added layers and batch normalization so we could raise the learning rate.
- Set up a node to run training, and read up on receptive fields.
- Ran the 5x5 and 7x7 sweeps at 15,000 mazes.
- Week 4 slides
¶ Week five
- Measured the compute cost against breadth-first search and found we were hundreds of millions of operations away from a task normally done in ten.
- Pinned the bottlenecks to data volume and network depth, and concluded the architecture was the problem rather than its size.
- Started reading on hierarchical reasoning models.
- Week 5 slides
¶ Week six
- Worked out how a planner and worker design would change the network and what we wanted from it.
- Planned the port and reviewed the reference implementation.
- Started onboarding the two high school team members.
- Week 6 slides
¶ Week seven
- Implemented the new model: a global planning pass, a per-step local pass, memory carried between moves, and a confidence check that decides whether to think again before committing.
- Debugged a GPU error that showed up during the port.
- First results against the baseline.
- Week 7 slides
¶ Week eight
- Found and fixed the bug that had frozen the convolutional front end at its random initialisation for most of the summer, taking 5x5 from 5.7% to 98.3%.
- Measured the headline comparison: 98% from above, 6% first-person without memory, 66% first-person with memory.
- Measured the adaptive thinking behaviour: 5.76 steps on the first move and 1.29 afterwards.
- Recorded the live demonstrations, including perfect first-person runs at 7x7 and 9x9.
- Week 8 slides
¶ Week nine
- Built a batched reimplementation of the maze rules with a verification script that checks it against the original pipeline cell for cell, so tuning numbers could be trusted.
- Ran the 32-configuration tuning study on the overhead-view task, one variable at a time against a shared held-out set.
- Confirmed that recovery from a wrong turn stays at exactly zero in every configuration, which is what the memory result addresses.
- Week 9 slides
¶ Week ten
- Tested the receptive-field explanation for why depth helps by moving reach and depth independently, and found it does not hold: at a matched reach of 9, a 4-layer network scores 0.686 against 0.410 for a 2-layer network with 5x5 kernels.
- Showed the effect is not parameter count either, since depth beats width at a matched budget.
- Wrote up the study and brought the repository to a state where every reported number is reproducible from a committed script, table or log.
- Week 10 slides