The Unreasonable Effectiveness of Recurrent Neural Networks

1. RNN Architecture Recap

A Recurrent Neural Network maintains a hidden state vector that gets updated at every time step. At step t, the network takes the current input x_t and the previous hidden state h_{t-1}, mixes them through a learned weight matrix, and squashes through tanh to produce the new hidden state h_t:

The final output y_t is passed through a softmax to get a probability distribution over the next character. Three weight matrices are learned end-to-end:

The output distribution for the next token is:

Training minimizes the cross-entropy loss summed over all time steps — the negative log-probability of the correct next character at each position:

Gradients flow backward through time via Backpropagation Through Time (BPTT). In practice, gradients are truncated after K steps to avoid memory blowup and vanishing/exploding gradients:

2. Character-Level Language Modeling

The key setup: feed the model one character at a time, and ask it to predict the next character. No tokenization, no subwords — just raw bytes of text. At test time, you sample from the predicted distribution at each step and feed the result back as input.

The training loop is simple: encode each character as a one-hot vector of size V (vocabulary size, typically ~100 for ASCII), run it through the RNN, compute softmax over next characters, backprop through K steps. Karpathy used a two-layer LSTM with 512 hidden units — tiny by today's standards.

3. What the Model Learns: Activation Analysis

The most striking part of the blog post: Karpathy visualized individual neuron activations as the RNN processed text, and found cells that had learned to track specific, interpretable properties of the sequence — with no supervision other than "predict the next character."

This analysis was groundbreaking: it showed that RNNs aren't just memorizing n-gram statistics. They're building internal representations of document structure. This foreshadowed what we now call "emergent capabilities" in large language models.

4. Generated Shakespeare

After training on the complete works of Shakespeare (~1MB of text), the model generates text that looks like this:

PANDARUS: Alas, I think he shall be come approached and the day When little sobs, shalt of best doth been here thou this the doth, And the grace with which the others they that be well. VIOLA: How the time is far with him that you stand, my lord, And we meet and that I should speak'd of you, mine own.

Generated by a character-level LSTM trained on Shakespeare. Note: character names in ALL CAPS, consistent stage-direction formatting, and rough iambic pentameter rhythm.

The model has learned, without any explicit supervision:

• Character names in ALL CAPS followed by a colon — the model correctly formats speaker labels like PANDARUS: and VIOLA:.
• Consistent indentation of dialogue — lines of speech are indented relative to the speaker label.
• Approximate iambic pentameter — lines tend to have 10 syllables with alternating stress, matching Shakespeare's verse form.
• Plausible Elizabethan vocabulary — words like "doth", "shalt", "mine own" appear in grammatically correct positions.

5. Generated Linux Kernel Code

Trained on the Linux kernel source code (~430MB of C code), the model generates text like this:

/*
 * Increment the size file of the new incorrect UI_FILTER group information
 * and target is the total.  So increment the request server tool
 * Temporary so that the start node depends to the file
 * all  units into the block device
 */
static int num_math(void) {
#ifdef CONFIG_BLOCK
        int block_read;
        mutex_lock(&dblock->mutex_io);
        if (num_error && !block_path) {
                device_trace(block, DEVICE_TYPE_DISK);
                return -EINVAL;
        }
#endif
        return 0;
}

Generated by a character-level LSTM trained on the Linux kernel. Note: syntactically valid C, correct #ifdef/#endif pairing, proper mutex patterns, realistic error-handling conventions.

The generated code exhibits remarkably realistic structure:

• Header guards (#ifdef CONFIG_BLOCK ... #endif) — the model opens and closes #ifdef blocks correctly, matching real kernel conventions.
• Function prototypes with realistic names — function names follow kernel naming conventions (snake_case, verb_noun patterns).
• Consistent indentation and brace style — the model learned Linux kernel's specific code style (tabs, Allman-adjacent bracing).
• Mutex, error code, and return value patterns — mutex_lock/unlock, -EINVAL returns, and NULL checks appear in the right contexts.

6. Temperature and Diversity

When sampling from the model, a temperature parameter T controls how peaked or spread-out the distribution is. At each step, instead of sampling from the raw softmax probabilities p(x), the model rescales the log-probabilities by T before exponentiating:

Temperature is still used in essentially the same way in modern LLMs (ChatGPT, Claude, Gemini). The math is unchanged — just divide logits by T before softmax. The practical insight from 2015 still holds: low T for factual/code tasks, higher T for creative writing.

7. Why This Was Surprising in 2015

To understand why this caused such a stir, consider the prevailing assumptions in 2015:

• Character models were considered toy models — the consensus was that useful sequence models needed word-level tokens at minimum. Character models couldn't possibly learn long-range structure.
• Linguistic structure required explicit encoding — most NLP systems used hand-crafted features: POS tags, parse trees, named entity labels. The idea that a model could discover quotation tracking from raw text was heretical.
• Scale skepticism — the pre-deep-learning intuition was that simple optimization (SGD on a fixed-width RNN) couldn't possibly learn hierarchical structure. You'd need specially designed architectures for each type of structure.
• The training signal seemed too weak — predicting the next character is a very weak, local supervision signal. It seemed implausible that this could encode document-level knowledge like "I am currently inside an if-statement."

The blog post's title was deliberate: Karpathy was echoing Wigner's "unreasonable effectiveness of mathematics" and Norvig's "unreasonable effectiveness of data" — the pattern that simple, general principles keep working at scales and domains where you'd expect them to fail.

8. Path to GPT

Karpathy's 2015 blog post established a template that GPT-1 (2018), GPT-2 (2019), and GPT-3 (2020) would follow almost exactly:

The core intellectual leap — that predicting the next token with a large enough model on enough data will spontaneously learn everything about the world embedded in that text — was already visible in Karpathy's 2015 Shakespeare experiment. GPT-3 is, in a direct sense, the same idea at 10,000× scale.

9. Additional Resources