Imagine a sensor sending one bit every millisecond. You want to answer a tiny question: did the bit change since the previous sample? A 0 → 1 means yes; a 1 → 1 means no. Looking only at the current bit cannot tell you which happened. You need memory.
In code, you would save the previous bit and XOR it with the new one. Keep that obvious solution in mind. We are using this toy problem to understand a more general trick: how to learn a function of a stream when you do not already know the rule.
Reservoir computing feeds the stream into a fixed dynamical system, then trains a simple readout of its changing state. The system supplies memory and useful transformations; learning decides how to combine them. The standard software version is an echo state network. [1]
01 / A familiar foothold
Memory can be a lingering effect
A moving average already does something like this. Each sample changes a number; later samples only partly overwrite it. You do not retain an event log, but earlier inputs still affect the present state.
Start at zero. Feed in 0, 1 and the final average is 0.5. Feed in 1, 1 and it is 0.75. Same current input; different state. An earlier event has left a trace.
Now imagine many state variables, with different responses, feeding into one another. Some react sharply; others preserve earlier activity. Each new sample perturbs the whole collection. This is a dynamical system: its next state depends on its current state and its input. “Recurrent network” is the neural-network name for this kind of feedback.
A reservoir uses the collection as a set of features describing recent history. “High dimensional” just means that instead of one moving average, you can inspect many numbers. Those numbers must preserve distinctions the task needs; a thousand identical averages would add little. The liquid-state-machine formulation makes this separation of histories explicit. [2]
02 / The important extra ingredient
Memory alone does not buy you XOR
Suppose the state generously exposes both the current bit a and previous bit b. Can a weighted sum, c + w₁a + w₂b, produce the answer?
| Current a | Previous b | Product ab | Changed? |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 0 | 0 | 1 |
| 1 | 1 | 1 | 0 |
The first row forces c = 0. The next two force both weights to be 1. But then the last row produces 2, where we need 0. Merely adding more linear mixtures of the same inputs cannot fix this: a weighted sum of weighted sums is still a weighted sum.
The product column changes everything. With the features [a, b, ab], the answer becomes:
For 1, 1, that is 1 + 1 − 2 = 0. For 1, 0, it is 1 + 0 − 0 = 1. A linear readout can solve a nonlinear problem if the features have already done the bending.
A typical reservoir does not explicitly manufacture ab. Its nonlinear responses create a collection of other features of the input history. We hope their combinations can approximate the function we want. That is a testable design choice, not a guarantee that arbitrary randomness will work.
03 / The actual machine
Freeze the rule. Let the state change.
Here is a simple echo state network. Let u be one incoming sample and x the vector of all reservoir values. At each step:
Trained interpretationŷt = c + w·xt
W mixes the previous state, a distributes the input, and b gives each unit an offset. tanh, applied to each component, is a smooth nonlinear squashing function with outputs between −1 and 1. The readout is just an intercept plus a weighted sum. This is the basic model without optional leakage or output feedback. [1]
For a tiny numerical example, one unit might compute tanh(0.8u + 0.5x − 0.2). With input u = 1, previous state x = 0.6 gives tanh(0.9) ≈ 0.716. Previous state −0.6 gives tanh(0.3) ≈ 0.291. Same weights. Same input. Different answer because of history.
“Untrained” describes the weights, not the activity. A classic reservoir chooses its internal weights randomly once, at a sensible scale, and keeps them. Training then looks like ordinary regression: [3]
- Run a labeled stream through the reservoir.
- Record one row of state values for each target answer.
- Fit the readout weights to those rows, usually with regularized least squares.
- Keep those weights and evaluate on a separate stream.
There is no backpropagation through the recurrent dynamics in this basic scheme. Size, connectivity, input strength, and memory timescale still need selection. You have made the fitting problem simpler; you have not eliminated model design. [3]
Live experiment / runs in this page
Take away one ingredient
A 24-unit reservoir learns the bit-change task. Switch models: each gets its own freshly fitted readout, using the same training stream. Only the internal update rule changes.
Both ingredients are present. The fixed reservoir supplies features from which the fitted readout recovers the bit-change rule on this test stream.
Inspect one step of that same computation
The state and weighted readout appear here when JavaScript runs.
Step forward and watch the state bars. With memory removed, every 1 produces the same state, regardless of what preceded it. With nonlinearity removed, history survives, but the readout remains a linear function of it.
What exactly is being computed?
A seeded, illustrative simulation, not a hardware benchmark. Each of 24 units has four random incoming connections; each row of W has absolute weights summing to 0.8. Input weights lie in [−1.5, 1.5], biases in [−0.8, 0.8]. These choices are fixed across modes.
Independent seeded binary streams provide 1,024 training and 512 test examples, after 64 warm-up steps each. Ridge regression minimizes the sum of squared errors plus 0.01‖w‖²; the intercept is unpenalized. Scores ≥ 0.5 count as “changed.” Scores are not probabilities. The trace shows the first 12 test inputs after warm-up.
“Remove memory” sets W = 0. “Remove nonlinearity” replaces tanh(z) with z; it keeps every connection. The plot uses a fixed −2.5 to +2.5 scale for all modes. This tiny known rule is deliberately easy: storing one bit and XORing it would solve it exactly with much less work.
The experiment does not prove reservoirs are universally good. It makes the division of labor visible: the reservoir creates the representation; the readout learns the task.
04 / A useful constraint
It must forget the right things
A reservoir should remember relevant recent input while eventually forgetting how it was initialized. Run two copies from different starting states, feed them the same long input, and their states should converge. This is the intuition behind the echo state property. It concerns dependence on input history, not convergence to a motionless state. [1]
Forgetting too quickly loses the previous bit. Letting irrelevant history or unstable dynamics dominate makes the readout's job harder. The useful timescale depends on the task. Our one-step question is forgiving; remembering a cue across thousands of unrelated samples is a different demand. A reservoir is a fading trace, not an addressable log. [3]
05 / Now the materials connection makes sense
The state does not have to live in RAM
So far, software has updated an array. But a physical system can also respond nonlinearly and retain effects of earlier inputs. Apply voltage pulses to a suitable device; measure its changing response; train a readout on those measurements. The material's dynamics perform the feature transformation. Physical reservoirs have been explored with electronic, optical, and other substrates. [4]
For a concrete example, Du and colleagues used dynamic memristors: devices whose resistance depends on their stimulation history. Closely spaced pulses accumulated a response; during a gap, it decayed. Their experiment used those transient states as reservoir features and implemented the readout in software. The memory was a physical relaxation process. [5]
This is why the idea attracts hardware researchers. You may be able to obtain useful computation from dynamics a device already has, without individually programming every internal connection.
06 / Put it on the map
Four connections to keep
- Streaming algorithms
- Both carry state forward. A reservoir's state is a distributed trace of history, rather than a hand-designed sufficient statistic.
- Linear regression
- The final learner can be ordinary regression. The nonlinear temporal computation has already happened in the features.
- Recurrent networks
- An echo state network is an RNN with its recurrent weights held fixed during readout fitting. “Reservoir computing” names the broader approach.
- Physical computing
- The same interface—input, evolving state, readout—can be realized by material dynamics. Useful memory and measurable features are the requirements.
In the literature, echo state networks usually mean the software-style recurrent networks we just built; liquid state machines originated with recurrent spiking circuits. Both helped establish the reservoir idea. [1] [2]
You do not have to teach every part of a machine its job. Sometimes you can find a machine whose natural responses preserve what you need, and learn how to read them.
For the next concrete step, read Lukoševičius's minimal echo state network implementation. You now know what each part is buying: the recurrence buys history, the nonlinear response supplies features, and the regression fits their interpretation.