Introduction

A standard neural network looks at one input and produces one output. Show it the word bank, and it answers based on that word alone — context be damned. A recurrent neural network (RNN) does something cleverer: it routes its own output back to itself as an additional input. That loop threads a hidden state — a small vector of numbers — through every step of the sequence, so each new token is interpreted in the light of everything that came before.

The idea is old. In 1982 John Hopfield described feedback networks for associative memory; by the late 1980s researchers were training RNNs on sequences with backpropagation through time (BPTT), unrolling the loop step by step into a very deep network, then running gradient descent backwards. The architecture unlocked speech recognition, handwriting generation and language modelling — tasks where order matters and context stretches across many tokens.

The catch arrived quickly. Gradients flowing backwards through dozens or hundreds of time steps tend to shrink exponentially — the vanishing-gradient problem — or explode — the exploding-gradient problem. Either way, the network loses its grip on events far back in the sequence. That single flaw has shaped almost every advance in sequence modelling since.

Try It: Hidden State in Motion

The demo below runs a small Elman RNN with two hidden units through a hand-crafted sequence of five tokens. Each token is represented as a single number (its index). At each step the network computes a new hidden state using its recurrence formula and displays both the input and the evolving state vector.

<p class="hint">An Elman RNN with 2 hidden units processes a token sequence one step at a time. At each step the hidden state <b>h</b> is updated using the previous state and the new input. Watch the state evolve — and notice how early tokens fade as the sequence grows.</p>
<div class="controls">
  <label>Sequence length:
    <input type="range" id="seqLen" min="3" max="12" value="5">
    <span id="seqLenVal">5</span>
  </label>
  <button id="stepBtn" type="button">Step →</button>
  <button id="resetBtn" type="button" class="ghost">Reset</button>
</div>
<div id="timeline"></div>
<div class="legend">
  <span class="dot input"></span> Input token &nbsp;
  <span class="dot h0"></span> h[0] &nbsp;
  <span class="dot h1"></span> h[1]
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; font-size: 14px; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.controls { display: flex; align-items: center; gap: .8rem; flex-wrap: wrap; margin-bottom: .8rem; }
label { display: flex; align-items: center; gap: .4rem; font-size: .88rem; }
input[type=range] { width: 100px; accent-color: #1d3557; }
button { font: 600 13px system-ui; padding: .35rem .8rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 7px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
#timeline { display: flex; gap: 6px; flex-wrap: wrap; align-items: flex-end; min-height: 140px; }
.step-col { display: flex; flex-direction: column; align-items: center; gap: 4px; width: 52px; }
.step-col .label { font-size: .72rem; color: #666; }
.bar-wrap { display: flex; flex-direction: column; align-items: center; gap: 3px; width: 100%; }
.bar { width: 28px; border-radius: 4px; transition: height .35s ease; min-height: 4px; }
.bar.input  { background: #457b9d; }
.bar.h0     { background: #e63946; }
.bar.h1     { background: #2a9d8f; }
.bar-val { font-size: .7rem; color: #333; text-align: center; }
.legend { margin-top: .6rem; font-size: .8rem; display: flex; align-items: center; gap: 4px; }
.dot { width: 10px; height: 10px; border-radius: 50%; display: inline-block; }
.dot.input { background: #457b9d; }
.dot.h0    { background: #e63946; }
.dot.h1    { background: #2a9d8f; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Tiny Elman RNN: h_t = tanh(Wh * h_{t-1} + Wx * x_t + b)
// Fixed weights chosen so the hidden state carries visible but decaying memory.
// No imports, no external libs — pure vanilla JS.

// 2 hidden units, 1 input dimension
const Wh = [[0.6, -0.3], [0.4, 0.5]];  // 2x2 recurrent weights
const Wx = [[0.9], [0.7]];              // 2x1 input weights
const b  = [0.05, -0.05];              // bias

function matvec(M, v) {
  return M.map(row => row.reduce((s, w, j) => s + w * v[j], 0));
}
function tanh(x) { return Math.tanh(x); }

function rnnStep(h, x) {
  // h: [h0, h1], x: scalar input
  const recurrent = matvec(Wh, h);
  const input     = matvec(Wx, [x]);
  return [
    tanh(recurrent[0] + input[0] + b[0]),
    tanh(recurrent[1] + input[1] + b[1])
  ];
}

// Generate a simple token sequence (repeating 1,0,1,0,... pattern)
function makeSequence(len) {
  return Array.from({length: len}, (_, i) => i % 2 === 0 ? 1 : -1);
}

let seq = [];
let states = [];
let currentStep = 0;
const MAX_BAR = 100; // px

function init() {
  const len = parseInt(document.getElementById('seqLen').value);
  seq = makeSequence(len);
  states = [];
  currentStep = 0;
  // initial hidden state = zeros
  states.push([0, 0]);
  render();
}

function step() {
  if (currentStep >= seq.length) return;
  const h_prev = states[states.length - 1];
  const x = seq[currentStep];
  const h_next = rnnStep(h_prev, x);
  states.push(h_next);
  currentStep++;
  render();
}

function render() {
  const tl = document.getElementById('timeline');
  tl.innerHTML = '';

  // Show each consumed step as a column (step 0 = initial state, steps 1..currentStep = after processing)
  for (let t = 0; t <= currentStep; t++) {
    const col = document.createElement('div');
    col.className = 'step-col';

    const stepLabel = document.createElement('div');
    stepLabel.className = 'label';
    stepLabel.textContent = t === 0 ? 'init' : fmt('t=%t%', { t: t });
    col.appendChild(stepLabel);

    const barWrap = document.createElement('div');
    barWrap.className = 'bar-wrap';

    // Input bar (only for t > 0)
    if (t > 0) {
      const xVal = seq[t - 1];
      const inputBar = document.createElement('div');
      inputBar.className = 'bar input';
      const h = Math.round(Math.abs(xVal) * MAX_BAR * 0.5 + 8);
      inputBar.style.height = h + 'px';
      barWrap.appendChild(inputBar);

      const inputVal = document.createElement('div');
      inputVal.className = 'bar-val';
      inputVal.textContent = xVal > 0 ? '+1' : '-1';
      barWrap.appendChild(inputVal);
    } else {
      // placeholder
      const ph = document.createElement('div');
      ph.style.height = '26px';
      barWrap.appendChild(ph);
    }

    // h0 bar
    const h0 = states[t][0];
    const bar0 = document.createElement('div');
    bar0.className = 'bar h0';
    bar0.style.height = Math.round(Math.abs(h0) * MAX_BAR + 6) + 'px';
    barWrap.appendChild(bar0);
    const val0 = document.createElement('div');
    val0.className = 'bar-val';
    val0.textContent = h0.toFixed(2);
    barWrap.appendChild(val0);

    // h1 bar
    const h1 = states[t][1];
    const bar1 = document.createElement('div');
    bar1.className = 'bar h1';
    bar1.style.height = Math.round(Math.abs(h1) * MAX_BAR + 6) + 'px';
    barWrap.appendChild(bar1);
    const val1 = document.createElement('div');
    val1.className = 'bar-val';
    val1.textContent = h1.toFixed(2);
    barWrap.appendChild(val1);

    col.appendChild(barWrap);
    tl.appendChild(col);
  }

  document.getElementById('stepBtn').disabled = currentStep >= seq.length;
  if (currentStep >= seq.length) {
    document.getElementById('stepBtn').textContent = 'Done';
  } else {
    const remaining = seq.length - currentStep;
    document.getElementById('stepBtn').textContent =
      fmt('Step → (t=%currentStep%%v%, x=%v2%)', { currentStep: currentStep, v: 1, v2: seq[currentStep] > 0 ? '+1' : '-1' });
  }
}

document.getElementById('seqLen').addEventListener('input', function() {
  document.getElementById('seqLenVal').textContent = this.value;
  init();
});
document.getElementById('stepBtn').addEventListener('click', step);
document.getElementById('resetBtn').addEventListener('click', init);

init();

// Verification log (node-testable)
// Run all 5 steps of the default sequence and log final hidden state
(function verify() {
  const testSeq = makeSequence(5);
  let h = [0, 0];
  const log = [];
  for (let i = 0; i < testSeq.length; i++) {
    h = rnnStep(h, testSeq[i]);
    log.push('t=' + (i+1) + ' x=' + testSeq[i] + ' h=[' + h.map(v => v.toFixed(4)).join(', ') + ']');
  }
  log.forEach(l => console.log(l));
  // Sanity: h values must stay in (-1, 1) since tanh is applied
  const ok = h.every(v => v > -1 && v < 1);
  console.log(fmt('tanh bounds check: %v%', { v: ok ? 'PASS' : 'FAIL' }));
})();
Result
Console

Watch the hidden state columns: earlier tokens leave a trace that shapes later computations. Then notice what happens as you increase the sequence length — the influence of the very first token fades. That gradual erasure is the vanishing-gradient problem made visible.

The Real Complexity

Training an RNN means computing gradients through the unrolled recurrence — effectively through a very deep network with shared weights. That causes two symmetric disasters:

  • Vanishing gradients: if the weight matrix has spectral radius less than 1, each timestep multiplies the gradient by a number smaller than 1. After 100 steps the signal is ×(0.9)¹⁰⁰ ≈ 0.000027 of its original size — indistinguishable from noise. The network simply cannot attribute an outcome to a cause that happened early in the sequence.
  • Exploding gradients: if the spectral radius exceeds 1, gradients blow up exponentially. The fix — gradient clipping — caps the norm of the gradient vector before each update. It is a workaround, not a solution.

The solution to vanishing gradients was gating. In 1997 Sepp Hochreiter and Jürgen Schmidhuber introduced the Long Short-Term Memory (LSTM), which adds three learned gates — input, forget and output — that directly control what enters, what stays, and what leaves the hidden state. A cell state runs forward mostly unchanged, like a conveyor belt, and gradients can flow back through it without collapsing. In 2014 Kyunghyun Cho et al. proposed the simpler Gated Recurrent Unit (GRU), merging the forget and input gates into one reset gate and one update gate.

Even with gating, plain recurrent models struggle beyond a few hundred steps. Modern sequence modelling has largely moved to Transformers (attention over all positions in parallel) and state-space models (structured recurrences that avoid gradient issues by design). But the original RNN remains the clearest illustration of why sequence modelling is hard — and why the solution required rethinking how networks carry memory.

For more on the learning complexity that sits behind all neural training see P vs NP and non-convex optimization.

Where It Matters

Despite being largely superseded by Transformers for language, RNNs and their gated variants remain important across many domains:

  • Speech recognition: LSTMs were the backbone of Google's voice search and Apple's Siri for years, processing audio frames one by one while accumulating phoneme context.
  • Machine translation: the encoder-decoder LSTM architecture (Sutskever et al., 2014) was the first neural system to approach human translation quality on short sentences, and spawned the attention mechanism that later became Transformers.
  • Time-series forecasting: financial returns, sensor readings and energy consumption all arrive as sequences where the history genuinely matters. LSTMs and GRUs remain competitive here, especially on irregular or short series where Transformers over-fit.
  • Music and handwriting generation: RNNs trained character-by-character or note-by-note can generate plausible continuations of human style, as shown in Graves's 2013 handwriting synthesis work.
  • Bioinformatics: protein secondary structure prediction and DNA sequence analysis naturally map to sequence-to-sequence tasks where recurrent models excel.

The conceptual legacy is even broader. The idea that a model should carry an explicit memory state forward through time, updated at each step by new evidence, reappears in reinforcement learning agents, world models and even the modern selective-state-space models (Mamba, 2023) that are challenging Transformer dominance on long sequences.

Conclusion

The recurrent neural network made a bold promise: feed the output back into the input and the network will remember its own past. For short sequences that promise holds — the hidden state carries genuine context. For long sequences the vanishing-gradient problem quietly empties that memory, step by exponential step.

The fixes — LSTM gates, GRU resets, attention, Transformers, state-space models — are each a different answer to the same question: how do you keep a useful signal alive across hundreds or thousands of steps? RNNs were the first serious attempt, and understanding why they fail is still the best entry point into why sequence modelling is hard.

The next time an autocomplete system finishes your sentence, or a voice assistant catches your meaning across a long pause, there is a good chance that somewhere in the stack a hidden state is quietly accumulating the past — and a gating mechanism is deciding, step by step, what to remember and what to let go.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/recurrent-networks/Content licensed under CC BY-NC 4.0.