Deep Learning & Neural Networks

Every model you’ve met in this course — the chatbot, the agent, the image reader — is, underneath, a neural network: millions or billions of tiny numbers, tuned by trial and error until they turn inputs into useful outputs. This page opens the hood. You won’t leave a deep-learning engineer, but you will understand what a network is, how it learns, why “deep” changed everything, and how the pieces connect to the LLMs and agents you already know.

What a neural network actually is

☺ Like you’re 10: Picture a huge crowd doing “telephone,” but instead of whispering words they pass along numbers. Each person listens to a few people, does a little math in their head, and shouts a number to the next row. By the last row, the crowd has turned “a photo of a cat” into the answer “cat.”

Strip away the mystique and a neural network is a big function: numbers go in, numbers come out. What’s special is how it computes that function — through layers of simple units, loosely inspired by brain cells, called neurons. It’s inspiration, not biology; a neuron here is just a bit of arithmetic.

Each neuron does three tiny things:

• Weighted sum. It takes the numbers coming in, multiplies each by a weight (how much it cares about that input), and adds them up. A weight near zero means “ignore this input”; a big weight means “this one matters a lot.”
• Bias. It adds a small constant — a bias — that shifts the result up or down, like a thumb on the scale.
• Activation. It passes that total through an activation function — a simple non-linear bend (the common one, ReLU, just means “keep positives, zero out negatives”). This bend is what lets a stack of neurons learn curvy, complicated patterns instead of only straight-line ones.

Wire many neurons into a layer, stack layers so each one feeds the next, and you have a network. The first layer sees the raw input (pixels, words-as-numbers); the last layer emits the answer (“cat,” or the probability of the next word); the layers in between build up meaning step by step. The weights and biases together are the model’s parameters — the knobs. “A 70-billion-parameter model” means 70 billion of these numbers, all tuned during training. Everything the model “knows” lives in those numbers.

How networks learn: loss, gradients, backprop

☺ Like you’re 10: You’re blindfolded on a hill and want to reach the bottom. You can’t see, but you can feel which way the ground slopes under your feet, so you take a small step downhill. Feel, step, feel, step. That’s exactly how a network finds better numbers — the “hill” is how wrong it is, and “downhill” is “less wrong.”

A fresh network starts with random weights, so its first guesses are garbage. Learning is the process of nudging those weights until the guesses get good. It runs in a loop:

1. Forward pass. Feed in an example (say, an image) and let the numbers flow through to produce a guess (“40% cat, 60% dog”).
2. Measure the loss. A loss function scores how wrong that guess was versus the true answer. Low loss = close; high loss = way off. Loss is the single number the whole system is trying to shrink.
3. Backpropagation. Work backward through the layers to compute, for every weight, which direction and how much to change it to reduce the loss. This bundle of directions is the gradient — the “which way is downhill” signal for millions of knobs at once.
4. Gradient descent. Nudge every weight a tiny step in its downhill direction. How big a step is the learning rate — too big and you overshoot the valley; too small and you crawl.

Repeat over the whole dataset, again and again, and the loss slowly drops as the weights settle into a valley where the guesses are mostly right. That’s the entire engine: guess → measure error → roll the weights downhill → repeat. “Backpropagation” sounds intimidating, but it’s just the bookkeeping that figures out the slope; “gradient descent” is the act of stepping downhill along it.

for each pass over the data (an "epoch"):
    for each batch of examples:
        guess = network(inputs)          # forward pass
        error = loss(guess, answers)     # how wrong?
        grads = backprop(error)          # slope for every weight
        weights -= learning_rate * grads # step downhill

Why “deep” unlocked so much

☺ Like you’re 10: One person can spot a single edge in a drawing. But a line of people — the first spots edges, the next joins edges into shapes, the next joins shapes into faces — can recognize your grandma. Depth means many layers, each building on the last, so the network sees bigger and bigger ideas.

The “deep” in deep learning just means many layers stacked deep — sometimes dozens, sometimes hundreds. Old neural nets from the 1990s were shallow (a layer or two) and could only learn simple patterns. The breakthrough insight: with enough depth, a network learns a hierarchy of features on its own. Early layers pick up primitive things; later layers combine them into abstract ones.

Nobody hand-labels “this layer finds edges.” The network discovers these levels because that hierarchy is what minimizes the loss. This is why deep learning replaced decades of hand-crafted feature engineering (the world of classical machine learning, where humans designed the features by hand): given enough data and compute, a deep net learns better features than people can invent. Depth plus scale is the reason a single architecture can now caption images, write code, and hold a conversation — the same recipe just scaled up.

Key architectures at a glance

☺ Like you’re 10: A network’s “shape” is like the layout of a workshop — you arrange the tools differently depending on whether you’re building with pictures, with sound, or with sentences. Same idea of learning, different floor plan for the job.

“Neural network” is a family, not one thing. The wiring pattern — the architecture — is chosen to fit the kind of data. A few you’ll hear named constantly:

The one to fixate on is the Transformer. Its “attention” mechanism lets every word look at every other word in parallel — which both captures long-range meaning better than RNNs and trains far more efficiently on GPUs. That combination is what made truly large models practical, and it’s why essentially every frontier LLM — Anthropic’s Claude, OpenAI’s GPT, Google’s Gemini, Meta’s Llama — is a Transformer at heart. We deliberately skip the math here; the intuition for tokens, attention, and next-word prediction lives in How AI models work, which picks up exactly where this page leaves off.

What training actually needs

☺ Like you’re 10: To get really good at a sport you need lots of practice (data), a good field to practice on (computers), and many practice sessions (epochs). Skip any one and you stay wobbly.

Training a serious network is a hungry process. Three ingredients dominate:

• Data. Networks learn from examples, so more (and cleaner, more varied) data usually means a better model. Frontier LLMs train on trillions of words. Getting that data flowing — collected, cleaned, labeled, versioned — is a whole discipline of its own, covered in data engineering.
• Compute (GPUs/TPUs). The forward-and-backward loop is billions of multiply-adds. GPUs (and Google’s TPUs) do those in massive parallel, which is why they, not CPUs, power deep learning. Big models train across thousands of chips for weeks — the reason frontier training is so expensive.
• Epochs & iteration. One epoch is one full pass over the data; training takes many passes (or many steps over a giant stream), plus endless tuning of the learning rate, batch size, and architecture. This is why 🦥 Sol the Sloth preaches patience: results come from a long grind, not a single run.

You rarely start from scratch, though. Most practical deep learning is transfer learning or fine-tuning: take a big model someone already trained at great expense, then adapt it to your task with a little of your own data. That’s the same fine-tuning you met in Retrieval & RAG — and the reason a small team can build on a giant model without owning a data center. Turning any of this into a repeatable, monitored pipeline is the job of MLOps.

Overfitting & regularization

☺ Like you’re 10: Memorizing the answers to last year’s test isn’t the same as understanding the subject — you’ll ace the old test and bomb the new one. A network can “cheat” the same way, so we hide some questions and only trust it if it does well on the ones it never saw.

The whole point of training is to do well on new data, not the examples it studied. Overfitting is the classic failure: the network memorizes quirks of the training set — even the noise — and nails practice questions while flopping on anything fresh. You spot it by the gap: high accuracy on training data, low accuracy on held-out data it never trained on. (Splitting data into train / validation / test is how you catch this; it’s 🐢 Timmy the Turtle’s core ritual and a staple of training models.)

The fixes are called regularization — techniques that stop the network from memorizing and push it to generalize:

The frameworks — and why deep learning powered the LLM era

☺ Like you’re 10: You could build a car from raw metal, but most people use a toolkit with the engine and wheels ready to bolt on. Deep-learning frameworks are that toolkit — they handle the fiddly math so builders can focus on the design.

Nobody hand-codes backpropagation for a billion weights. Frameworks do the heavy lifting — they run on the GPU, and above all they compute gradients for you automatically (autodiff), so you describe the network and they figure out the downhill directions. The main ones you’ll hear:

These frameworks are the loom the whole modern era was woven on. The straight line runs: neural networks → made deep → the Transformer architecture → scaled up on GPUs with trillions of words → the large language models at the center of this course. Every capability you’ve studied — prompting, reasoning, agentic AI, multimodal understanding — is emergent behavior of one very large, very deep Transformer trained by exactly the guess-measure-roll-downhill loop on this page. You don’t need to build a network to use LLMs well, but knowing what’s under the hood tells you why they hallucinate, why context and data quality matter so much, and where the field is heading.