Neural Cellular Automata on Programmer.ie: Modern AI programming

Cellular Automata From First Principles 48: What Did the Neural CA Actually Learn?

Mon, 10 Aug 2026 20:41:00 +0100

Cellular Automata From First Principles 48: What Did the Neural CA Actually Learn?

Visualization gives us hypotheses.

Intervention gives us evidence.

If we suspect a hidden channel carries useful information, the next question is simple:

what happens if we remove it?

This chapter turns NCA interpretability into controlled experimentation.

Establish the behavioral baseline

Before touching the model, record its normal performance.

baseline = evaluate_suite(model, test_mazes)

Keep metrics such as:

valid-path rate
optimal-path rate
mean excess path length
unreachable-maze accuracy
stabilization time

Every intervention will be compared with this baseline.

Cellular Automata From First Principles 47: Inspect Hidden-State Propagation

Mon, 10 Aug 2026 20:40:00 +0100

Cellular Automata From First Principles 47: Inspect Hidden-State Propagation

A neural cellular automaton can solve a maze while most of its computation remains invisible.

The visible output might be one distance channel.

The internal state may contain twelve more channels evolving underneath it.

This chapter asks:

what is moving through those hidden channels while the answer is being computed?

Capture the entire state trajectory

Instead of saving only the final output:

Cellular Automata From First Principles 43: Test Generalization Beyond Training

Mon, 10 Aug 2026 20:39:00 +0100

Cellular Automata From First Principles 43: Test Generalization Beyond Training

A model can look robust while still depending on the exact conditions used during training.

So after growth, persistence and regeneration, we need a harder question:

what happens when the world changes?

Build a generalization matrix

Vary dimensions independently:

canvas size
seed position
update rate
rollout length
damage geometry
damage severity
noise level
boundary conditions

Then evaluate combinations that were not used during training.

Cellular Automata From First Principles 46: Generalize to Harder and Larger Mazes

Mon, 10 Aug 2026 20:39:00 +0100

Cellular Automata From First Principles 46: Generalize to Harder and Larger Mazes

Training accuracy answers the easiest question:

Can the model solve problems drawn from the training distribution?

The more interesting question is:

Did the local rule learn a reusable computation?

This chapter turns that into an explicit evaluation protocol.

Hold out dimensions of difficulty

Instead of one validation set, create several test families.

For example:

A: 32×32, familiar wall density
B: 48×48, familiar wall density
C: 64×64, familiar wall density
D: 32×32, denser obstacles
E: 32×32, longer required paths
F: different procedural maze generator
G: narrow bottlenecks and many dead ends

The point is not to maximize one aggregate score.

Cellular Automata From First Principles 42: Regenerate After Damage

Mon, 10 Aug 2026 20:38:00 +0100

Cellular Automata From First Principles 42: Regenerate After Damage

Persistence asks whether the organism can remain near its target.

Regeneration asks a different question:

after part of the state is destroyed, can local rules reconstruct the missing structure?

This is a much stronger test.

Damage the state, not just the image

If we erase only visible RGBA channels but leave hidden channels untouched, the model may retain a perfect invisible blueprint.

Cellular Automata From First Principles 45: Learn to Solve Mazes

Mon, 10 Aug 2026 20:38:00 +0100

Cellular Automata From First Principles 45: Learn to Solve Mazes

A pathfinding NCA becomes interesting only when the training problem itself is disciplined.

If every maze has the same size, wall density and corridor style, the model may learn the dataset more than the algorithm.

So this chapter builds the training system around procedural variation.

Generate mazes as data

Start with binary occupancy:

0 = open
1 = wall

One simple generator begins with random walls and rejects disconnected examples.

Cellular Automata From First Principles 41: Train for Persistence

Mon, 10 Aug 2026 20:37:00 +0100

Cellular Automata From First Principles 41: Train for Persistence

Growing a target once is not enough.

A useful self-organizing system should continue to satisfy its objective after it arrives.

That means the target should behave more like an attractor than a timestamped frame.

The failure mode

Suppose training always evaluates at step 64.

The model can learn:

seed
 ↓
grow
 ↓
target at step 64
 ↓
overshoot
 ↓
disintegrate

The loss never sees the failure after step 64.

Cellular Automata From First Principles 44: Neural Cellular Automata for Pathfinding

Mon, 10 Aug 2026 20:37:00 +0100

Cellular Automata From First Principles 44: Neural Cellular Automata for Pathfinding

Until now our neural cellular automata have learned to make and maintain shapes.

Now we will ask them to compute something.

Given:

walls
start
finish

can a shared local update rule discover a path?

This is an unusually good task for an NCA because classical pathfinding already has a local interpretation.

Breadth-first search expands a frontier:

start
  ↓
nearby reachable cells
  ↓
next layer of reachable cells
  ↓
...
  ↓
goal

That looks remarkably like information propagating through a cellular system.

Cellular Automata From First Principles 40: Randomize the Update Schedule

Mon, 10 Aug 2026 20:36:00 +0100

Cellular Automata From First Principles 40: Randomize the Update Schedule

Most cellular automata in this book have used synchronous updates:

all cells observe state_t
all cells update
state_t+1 appears

Neural cellular automata become more robust when we stop assuming perfect global synchronization.

Stochastic firing

Instead of applying every predicted update, sample a binary mask:

def stochastic_update(x, dx, fire_rate=0.5):
    mask = (
        torch.rand(
            x.shape[0], 1, x.shape[2], x.shape[3],
            device=x.device,
        ) <= fire_rate
    )
    return x + dx * mask

Half the cells update on average.

Cellular Automata From First Principles 39: Grow a Target From One Seed

Mon, 10 Aug 2026 20:35:00 +0100

Cellular Automata From First Principles 39: Grow a Target From One Seed

Now we can pose the central morphogenesis problem:

Start from one cell and learn local rules that construct a target pattern.

Prepare a target

Assume an RGBA image has been loaded into a tensor:

# shape: [1, 4, H, W], values in [0, 1]
target = load_target("target.png").to(DEVICE)

The NCA state contains more channels than the image, so only the visible channels are compared:

Cellular Automata From First Principles 38: Hidden Cell Channels and Local Memory

Mon, 10 Aug 2026 20:34:00 +0100

Cellular Automata From First Principles 38: Hidden Cell Channels and Local Memory

A visible pixel is not enough state for a cell that must also coordinate growth.

So give every cell a vector.

[R, G, B, alpha, h1, h2, ... h12]

The first channels can be rendered. The rest are private internal state.

CHANNELS = 16
VISIBLE = 4

state = torch.zeros(1, CHANNELS, 64, 64, device=DEVICE)

The hidden channels have no labels. We do not tell the model that channel 8 means “distance from the centre” or channel 11 means “grow east”. If useful internal signals exist, training must discover them.

Cellular Automata From First Principles 37: Learn the Local Update Rule

Mon, 10 Aug 2026 20:32:00 +0100

Cellular Automata From First Principles 37: Learn the Local Update Rule

A neural cellular automaton does not need a large neural network.

It needs a small local network applied everywhere.

That distinction matters.

The intelligence of the system comes less from the size of one cell’s computation and more from the repeated interaction of many cells over time.

Perception first

Each cell needs information about itself and nearby cells.

For a single visible channel we can compute several local features: