Uttu — model map

Why a random, untrained network?

This is the part that trips everyone up. The big pools of neurons are wired at random and never trained. Only the thin readout is fitted.

The reason it works is an idea borrowed from Fourier. He couldn't solve how heat spreads through a jagged temperature profile — but he could solve it for a smooth sine wave. So he asked: what if the jagged shape is just a pile of sine waves added together? Then solve the easy problem for each and add up the answers. Sines form a basis — universal building blocks that, mixed in the right proportions, make any curve you want.

A reservoir is the same trick with the building blocks chosen at random. Feed a signal into a tangle of randomly-connected neurons and every neuron reacts differently — you get a library of squiggly responses. None of them is meaningful alone. But if the library is big enough, some weighted mixture of them adds up to the thing you're trying to predict. The readout's only job is to find those weights, and that's plain least squares — the same maths as fitting a line through points.

So nothing clever happens inside the bucket. The bucket supplies raw variety; the readout does the choosing.

Six random reservoir responses (dim), and the one weighted mixture of them that reproduces a target (white = target, green = what the readout builds from the six).

Two knobs keep this stable. Spectral radius (0.8 here) sets how strongly neurons drive each other: below 1, every input leaves an echo that fades — the echo state property. Push it above 1 and the network never settles, a tiny difference explodes, and you can't compute with an explosion. Leak rate sets how fast each neuron forgets, which is why rung1 runs three of them at once (weeks, days, hours) — it widens the library to cover several timescales.

How ONE readout predicts 30 assets

A readout is exactly what it looks like: an equation that fits a pile of messy waves onto a target wave. The only thing worth staring at is its shape — and the two pool families do it in opposite directions.

The monolithic pool feeds every asset's features in at once, so its 300 neurons describe the market — one state vector per bar, not one per coin. The only way 30 different answers come out of one shared state is 30 different sets of weights. So its fitted weights are a 300×30 matrix: column j is a 300-long recipe for asset j. It really is 30 regressions — they just share one solve, because the expensive half (a 300×300 matrix built from the states) is identical for all of them and only the right-hand side changes.

The per-coin pools (rung1, dirconv) are the reverse. The reservoir runs once per asset, so the states already differ, and the fit stacks all 30 assets' rows into one tall regression. The result is a single weight vector with no asset axis at all — one equation, applied 30 times to 30 different inputs. It has no idea which coin it is looking at. That is deliberate: it's what makes the map general and gives it 30× the training rows.

Either way the training is one matrix solve — no gradients, no epochs. The only tuning knob is α, which shrinks the weights toward zero; the monolithic pool runs α=1000, a heavy penalty, because 300 correlated neurons will happily find a beautiful in-sample fit made entirely of noise. Everything slow in a training run is the reservoir producing the states, not the readout consuming them.

Where this model differs from the textbook picture

The classic demo drives a reservoir with a boring metronome and asks it to generate something rich — a birdsong out of a sine wave. All the complexity comes from the reservoir's own dynamics.

Here it's the other way round. The input is the rich thing: 30 assets × several channels of live market data. The reservoir isn't inventing structure, it's holding memory — giving the readout hundreds of differently-delayed, differently-smoothed views of recent history to choose from.

Same machinery, different job, and one important consequence. "A big enough random basis can reconstruct any signal" is a statement about fitting. It says nothing about predicting a bar you haven't seen. That gap is the whole problem — it's why the readout is ridge regression rather than plain least squares (the α penalty deliberately refuses to fit the training data perfectly), and why every number this system reports comes from walk-forward out-of-sample testing.

How scores become a ranking

Each readout predicts a relative move: how much this asset beats or lags the pack, not where its price goes. Because one shared readout is applied to every asset, the numbers are directly comparable.

At each bar the pool emits one number per asset. The pools disagree, so the numbers are converted to rank order first and then averaged — a pool that is wildly confident can't shout down the others; only the order it puts assets in counts.

The final ordering is all that leaves Uttu. What to hold, how much, and when to trade it is the Loom's job.