I Trained a Small Network to Compress Data, and It Ended Up Drawing a Pentagon.

Meta description: NumPy reproduces Anthropic Toy Models of Superposition with hand-derived gradients and no borrowed numbers, per a Towards Data Science post.

Tags: NumPy, Anthropic, Toy Models of Superposition, Tiny Networks, Machine Learning Basics

Featured image: An abstract, friendly illustration of small connected nodes with compressed lines forming a pentagon, no real people, no logos, and no text.

This is for readers who want a clear, minimal way to look at an Anthropic Toy Models of Superposition NumPy reproduction without taking a full framework at face value. A Towards Data Science post describes a from-scratch rebuild of Anthropic's "Toy Models of Superposition" using NumPy, a Python library for numerical arrays. The post appeared first on Towards Data Science, but the excerpt does not name the author or give a publication date. It says the work used hand-derived gradients and no borrowed numbers.

Why the reproduction is useful

The name "Toy Models of Superposition" points to simplified neural network setups used to explore superposition. Superposition is the idea that a network may store more features than it has neurons by letting several features share activation patterns. For a non-expert, that can sound abstract. A small NumPy implementation gives readers something concrete: a tiny version of the idea they can inspect, run, or modify.

The value is not only in the result. It is in the path. When a model is rebuilt from scratch, the reader sees the shape of the computation: inputs, weights, activations, loss, and the update step. That makes the concept easier to audit than a large prebuilt pipeline. It also helps readers notice which parts are essential to the idea and which parts are just framework plumbing.

What hand-derived gradients mean

Hand-derived gradients are the update signals for a model's parameters, worked out by the person writing the code instead of relying only on an automatic differentiation engine. NumPy can calculate arrays and matrix operations, but it does not automatically build a gradient tape for a custom model in the way a high-level framework might. To train the network, the author had to write the backward pass by hand.

This matters because gradients are where many interpretability experiments live. If a reader can follow the derivative step, they can see why a feature moves one way or another during training. The excerpt says the reproduction also avoided borrowed numbers, though it does not define that phrase further. In plain terms, that suggests the author did not copy numerical values from another implementation. For a reader, that makes the code more like a worked example than a patched-together demo.

The pentagon result

The post's title is "I Trained a Tiny Network to Compress Data. It Drew a Pentagon." That title tells readers the output was visual. A tiny network trained to compress data drew a pentagon. The excerpt does not say what data was used, what loss function was applied, or whether the pentagon was the goal or an emergent side effect.

Still, a simple drawing is a useful checkpoint. It gives readers a way to ask whether the tiny model is doing something recognizable, not just minimizing a number. If a compressed representation can create a clean shape, it hints at how networks may turn many input signals into a smaller set of useful directions. That connection is exactly the kind of intuition toy models are meant to provide.

What readers can do with this

Readers can treat the NumPy reproduction as a learning target. Start by checking whether they understand each part: the model architecture, the loss, the gradient, and the update rule. Then compare the behavior to the idea of superposition. If several features are stored in the same small network, the code can show how activations overlap.

The post also shows a boundary. A small reproduction is not the same as a large research program. It may be enough to build intuition, but it may not capture every detail of Anthropic's original setup. The excerpt does not provide the code, data, training length, or final loss values, so readers should avoid assuming it proves a specific result.

For people learning machine learning, the takeaway is practical: a from-scratch build can turn a scary interpretability topic into a readable experiment. For people evaluating AI research claims, the same approach can be a test of transparency. If a claim can be reduced to a few arrays and a hand-written gradient, it becomes easier to question, modify, and understand.