How Are LLMs Trained? Neural Networks and Backpropagation Explained
An Anthropic researcher breaks down how neural networks learn: parameters, weights, loss, and backpropagation, using a simple real estate example.
What actually happens when an LLM “learns”?
A large language model learns by adjusting millions or billions of internal numbers, called parameters, so that its predictions get closer to correct answers. Training starts with those numbers set randomly, then repeatedly measures how wrong the model’s output is (the loss) and nudges each parameter slightly in the direction that reduces that error. That nudging process is called backpropagation, and a software library like PyTorch does the bookkeeping automatically. Run this cycle billions of times and you get a function capable of writing, reasoning, and answering questions.
TL;DR
- Neural networks are just functions with knobs: inputs get multiplied by numbers (parameters), summed up, and the result is a prediction, nothing more mystical than that at the core.
- Parameters are literally numbers in a file: a “2 trillion parameter model” means 2 trillion numbers, paired with a relatively small Python program that defines how they’re wired together.
- Loss measures how wrong the model is: training compares a prediction (like a predicted apartment price) against the real answer and calculates the gap.
- Backpropagation figures out which knobs to turn: it calculates, for every single parameter, how much changing that parameter would change the final loss.
- Autograd engines like PyTorch automate the tuning: instead of hand-adjusting millions of numbers, the software tracks every calculation and computes the needed adjustments automatically.
- Stacking layers builds more complex functions: a model’s output can feed into another set of knobs, and another, creating “a function inside a function inside a function.”
- This same basic mechanism underlies ChatGPT and Claude: the modern large language model landscape runs on these same core techniques, just at a vastly larger scale.
What is a neural network, really?
Strip away the jargon and a neural network is a function that maps inputs to an output. Anthropic researcher Jeremy Aburman illustrates this with a toy example: predicting New York apartment prices from inputs like location, square footage, and number of bathrooms.
You could hand-code rules for this (if square footage falls between 1,000 and 2,000 and bathrooms are between one and two, price it around a certain figure). That approach breaks down fast. It might work for seven examples, but not for thousands, millions, or for a real-world case with hundreds of relevant inputs, the way an experienced real estate broker weighs finishings, build year, and dozens of other subtle factors through pattern matching.
A neural network solves this differently: instead of a human writing the rules, the computer builds the function itself. Each input gets multiplied by a “knob,” a numerical parameter, initially set at random. Multiply the size by one random value, the bathrooms by another, the location by a third, add them together, and you get an output. Early on, with random knobs, that output is garbage. A Soho apartment that should sell for $2 million might get predicted at $942,000.
What do the “knobs” in a neural network actually represent?
Each knob is a weight, essentially a measure of how much a given input matters to the final prediction. A knob close to zero means that input barely affects the output. A large knob means that input strongly drives the result. In the apartment example, one knob might capture how much square footage matters, another how much bathroom count matters.
Real relationships are rarely that clean, though. The value of an extra bathroom might depend heavily on location, and a single layer of simple multiplication can’t capture that kind of interaction. That’s why networks stack layers: the output of one layer of knobs becomes the input to another layer of knobs, and so on. This “function inside a function inside a function” structure is what allows a neural network to represent far more complex relationships than a single formula could. Add enough layers and enough knobs, and the function can approximate patterns too complicated for a human to hand-code.
How does backpropagation work?
Once a network produces a prediction, you need a way to measure how wrong it is. That measurement is called loss, essentially the average gap between what the model predicted and what the correct answer actually is. If the model predicts $1 million for an apartment that sold for $2 million, that’s a large loss, and the goal of training is to keep shrinking that number.
The challenge is figuring out exactly how to adjust potentially billions of individual knobs to reduce that loss. Backpropagation is the technique that makes this tractable. It works by calculating the derivative of the loss with respect to each individual parameter, which is a precise way of asking: if I nudge this one knob slightly, how much does the final loss change?
Once you know that sensitivity for every parameter, you know which direction to adjust each knob, and roughly by how much, to push the prediction closer to correct. Do this across every parameter simultaneously, repeat across many examples, and the whole network gradually converges toward more accurate outputs.
Why do you need software like PyTorch for this?
Doing these calculations by hand is not realistic once a network has more than a handful of parameters. Tools like PyTorch, JAX, or TensorFlow are what’s known as autograd engines, and their core job is tracking every parameter and every mathematical operation that parameter is involved in throughout the network.
As the computation moves forward, through the layers, producing a final prediction, and then a loss value, the autograd engine records the entire chain of operations. It then works backward through that chain, calculating how a small change in each parameter would ripple forward to change the final loss. That backward pass is backpropagation in action, and it’s what lets a model with billions of parameters get systematically updated after every batch of training examples, without a human touching a single number directly.
How does this scale up to actual language models?
The apartment pricing example uses three inputs and a handful of knobs. A real large language model extends the identical principle to a vastly larger scale: instead of three inputs, it’s trained on enormous amounts of text, and instead of a few parameters, it has billions or trillions of them, organized across many layers.
A downloaded language model is, at its core, just a large file of numbers (the parameters) paired with a relatively small Python program that defines how those numbers are wired together and how inputs flow through them to produce outputs. Describing a model as having “2 trillion parameters” literally means it contains 2 trillion of these tunable numbers. Training adjusts all of them, using the loss-and-backpropagation cycle, so the overall function gets progressively better at predicting correct outputs, whether that output is an apartment price or the next word in a sentence. This foundational process, repeated at enormous scale and refined through additional stages like pre-training and post-training, is what underlies modern systems such as ChatGPT and Claude.
Frequently Asked Questions
What is a parameter in a neural network?
A parameter is a single adjustable number, also called a weight, that determines how much influence one piece of input has on the network’s output. A model described as having billions of parameters simply has that many individual numbers that get tuned during training.
What is loss in machine learning?
Loss is a numerical measure of how far a model’s prediction is from the correct answer. Training works by repeatedly calculating this gap and adjusting parameters to shrink it over time.
What is backpropagation in simple terms?
Backpropagation is the method used to figure out how much each parameter in a network contributed to an error, so it can be adjusted in the right direction. It calculates, for every parameter, how a small change to that parameter would affect the final loss.
Why is PyTorch used for training neural networks?
Nothing gets lost.
PyTorch is an autograd engine that automatically tracks every parameter and calculation in a network, then computes the adjustments needed for each parameter to reduce loss, removing the need to calculate these updates by hand.
Is this the same process used to train ChatGPT and Claude?
Yes, in essence. The core mechanics of weights, loss, and backpropagation described here are the same basic techniques underlying modern large language models, just applied with vastly more parameters, more data, and additional training stages.
