What Deep Learning Actually Is

This is the opening article of the Deep Learning Foundations series, so let’s start with the question the whole series answers: when a machine appears to learn something, what is actually going on?

Picture the most ordinary thing. You type half a question into a search box and it completes the rest. You open your photos app, search “beach,” and it finds pictures you never labeled. You ask a chatbot to explain a tax form and it writes back in clear sentences. None of these were programmed by a human writing out rules for beaches or tax forms. They were trained, by being shown enormous numbers of examples until they found the patterns on their own. That single shift, from writing rules to learning them, is the whole story, and it is simpler than the mystique suggests.

The good news: deep learning is built from a handful of clean ideas. Once you see them, the rest of this series is just picking up one idea at a time and making it concrete.

It feels like magic when a machine finishes your sentence or finds an unlabeled photo. Underneath, it is a mechanism: examples in, patterns out, one layer at a time.

Three words people use interchangeably, and shouldn’t#

The first thing to fix is vocabulary, because “AI,” “machine learning,” and “deep learning” get thrown around as if they were synonyms. They are not. They are three circles nested inside each other.

flowchart TB
    subgraph AI["Artificial Intelligence"]
        subgraph ML["Machine Learning"]
            DL["Deep Learning"]
        end
    end

Deep learning is a kind of machine learning, which is a kind of artificial intelligence. Each inner circle is a more specific idea than the one around it.

AI is the broadest circle: the effort to get computers to do intellectual tasks that normally need a human. It was born as a research field in 1956, at a summer workshop organized by John McCarthy at Dartmouth College, and for its first few decades it barely mentioned “learning” at all. Early chess programs and the “expert systems” of the 1980s ran on rules that humans typed in by hand, an approach now called symbolic AI. That worked beautifully for tidy, logical problems like chess. It fell apart on fuzzy ones. Nobody could write down the explicit rules that separate a photo of a cat from a photo of a dog, or turn a spoken sentence into text, because those rules do not exist in any form a person can articulate. Something else was needed.

ML is the middle circle, and it is the something else. Instead of a human writing the rules, the machine looks at many examples and figures out the rules itself. It became the dominant approach starting in the 1990s, driven by faster hardware and bigger datasets. Deep learning, the innermost circle, is one particular and very powerful style of machine learning. We will get to what makes it “deep” shortly. First, the flip that makes machine learning work at all.

If you want to read an introduction to what really is machine learning, go to this article: Introduction to machine learning

The flip: from writing rules to learning them#

Classical programming and machine learning are mirror images of each other, and the difference is worth seeing clearly.

In classical programming, you the programmer supply the rules and the data, and the computer produces the answers. You write “if the email contains these words and comes from an unknown sender, mark it spam,” feed in an email, and out comes a verdict. You had to know the rules in advance.

In machine learning, you flip two of those boxes. You supply the data and the answers, and the machine produces the rules. You show it thousands of emails already labeled spam or not spam, and it works out the pattern that separates them. Then you can apply that learned pattern to a brand new email it has never seen.

flowchart LR
    subgraph CP["Classical programming"]
        direction TB
        R1["Rules"] --> E1
        D1["Data"] --> E1["Program"]
        E1 --> A1["Answers"]
    end
    subgraph ML2["Machine learning"]
        direction TB
        D2["Data"] --> E2["Training"]
        A2["Answers"] --> E2
        E2 --> R2["Rules (a trained model)"]
    end

Classical programming: you write the rules, the computer applies them. Machine learning: you provide examples and their answers, and the computer writes the rules for you.

A machine learning system is trained rather than explicitly programmed. To train one, you need exactly three things:

First, input data points. If the task is recognizing speech, these are audio clips. If it is tagging photos, they are images.

Second, examples of the expected output. For speech, the human-written transcripts. For photos, the correct tags like “dog” or “beach.”

Third, a way to measure whether the system is doing well. This is a number that captures how far the current output is from the expected one. That number is the crucial part, because it becomes a feedback signal. The system uses it to adjust itself, and that adjustment, repeated over and over, is what we call learning.

The real job: finding good representations#

So what does a machine learning system actually learn? The honest answer is that it learns to represent the data differently. This is the single most important idea in the whole field, so let’s slow down on it.

A representation is just a different way of looking at the same data. A color can be described by how much red, green, and blue it contains, or by its hue, saturation, and brightness. Same color, two representations. Some tasks are trivial in one and painful in the other. “Select every reddish pixel” is easy if your image is stored as red-green-blue values. “Make the whole image less vivid” is easy in the hue-saturation-brightness form. Picking the right representation can turn a hard problem into an easy one.

Here is the classic picture. Imagine a scatter of points, some white and some black, mixed together so that no simple rule tells them apart in their raw form. Now rotate and shift the coordinate system, choosing new axes. In the new view, all the black points might sit on the right and all the white points on the left. Suddenly the rule is trivial: “black if the new horizontal coordinate is positive.” Nothing about the points changed. Only the way we looked at them did, and that new representation made the problem fall open.

Same points, two representations. In the raw view no simple rule separates the colors. After a coordinate change, one straight cut does the whole job. Learning good representations is the entire game.

For that toy example, a human can pick the right coordinate change by hand. But could you hand-write the transformations that tell a handwritten 6 from an 8 across every messy human scrawl? People have tried, with rules like “count the closed loops,” and the results are brittle and miserable to maintain. Every new style of handwriting breaks them. So we automate the search instead. We let the machine try many possible transformations of the data, keep the ones that make the answers easier to read off, and use the feedback signal to steer the search. That is machine learning in one sentence: an automatic search for useful representations of data, guided by a feedback signal, within a predefined space of possibilities.

The “deep” in deep learning#

Now we can say precisely what makes deep learning deep. It is not that the machine understands things more deeply. The “deep” refers to a structure: successive layers of representations, stacked one on top of another.

Older machine learning methods usually learned one or two layers of representation, which is why they are sometimes called shallow learning. Deep learning learns many, often tens or hundreds. Each layer takes the representation the previous layer produced and transforms it into something a little more useful for the final task. The number of layers is called the depth of the model.

flowchart LR
    IN["Input<br/>(raw pixels)"] --> L1["Layer 1<br/>edges"]
    L1 --> L2["Layer 2<br/>textures"]
    L2 --> L3["Layer 3<br/>parts"]
    L3 --> OUT["Output<br/>the digit '4'"]

A deep network is a multistage filter. Early layers pick out simple features, later layers combine them into meaningful ones, and the final layer reads off the answer. The representation gets purer at every step.

Think of a network several layers deep looking at an image of a handwritten digit. The first layer might respond to simple edges. The next combines edges into small shapes. The next assembles shapes into recognizable parts, and the final layer reads out which digit it is. Information flows through the stack like water through a series of filters, coming out increasingly purified with respect to the question you care about. Crucially, nobody designed those intermediate features. They were all learned automatically from examples. That is the technical heart of deep learning: a multistage way to learn data representations, where every stage is learned.

How the learning actually happens#

We have said the machine “adjusts itself” using a feedback signal. Here is the mechanism, in plain terms and three moving parts.

Each layer’s behavior is controlled by a set of numbers called its weights, also known as its parameters. The weights are the knobs. What a layer does to its input is entirely determined by its weights, so “learning” means finding the right values for all the weights in the network at once, such that example inputs get mapped to their correct outputs. A large network can have tens of millions of these knobs, and turning one affects all the others, which is why finding good values sounds impossible at first.

To turn a knob in the right direction, you first need to know how wrong you currently are. That is the job of the loss function, sometimes called the objective or cost function. It takes the network’s prediction and the true target, and computes a single number, the loss score, that measures how far off the prediction is. High loss means bad prediction, low loss means good.

The final piece is the optimizer. It takes the loss score and uses it to nudge every weight a tiny amount in the direction that will make the loss a little lower next time. The specific algorithm it uses is called backpropagation, and it is the central algorithm in all of deep learning. We are going to give it a full, careful treatment in Part 3, so for now just hold the shape of it: the loss tells you how wrong you are, and the optimizer walks the weights slightly downhill.

flowchart LR
    X["Input X"] --> M["Network<br/>(weights)"]
    M --> P["Prediction Y'"]
    P --> L["Loss function"]
    T["True target Y"] --> L
    L --> S["Loss score"]
    S --> O["Optimizer"]
    O -->|"nudge the weights"| M

The training loop. The network makes a prediction, the loss function scores how wrong it is against the true target, and the optimizer uses that score to adjust the weights. Repeat this over many examples and the loss falls.

Put those together and the whole thing runs like this. At the start, the weights are random, so the network’s output is nonsense and the loss is high. You show it an example, measure the loss, and let the optimizer nudge every weight a hair in the improving direction. You do this again with the next example, and the next, typically making many passes over thousands of examples. Each nudge is tiny, but they accumulate, and the loss steadily drops. A network whose loss has been driven low is one whose outputs are now close to the targets. That is a trained model. It is a genuinely simple mechanism, and yet, scaled up far enough, its results can look like magic. Holding both of those facts at once, simple mechanism and startling results, is the mark of actually understanding deep learning.

What makes deep learning different#

Machine learning existed for decades before deep learning took over. So why did deep learning become such a big deal that companies now pour hundreds of billions of dollars into it? Three properties.

The first is simplicity, which sounds backward but is real. Before deep learning, the hardest and most skilled part of a machine learning project was feature engineering: humans manually crafting good representations of the raw data so that a shallow model could cope. Deep learning automates that away. Because it learns all the layers of representation itself, you can often replace a fragile multistage pipeline of hand-built features with a single model trained end to end. The most painful step became free.

The second is scalability. Deep learning runs extremely well on graphics processing units (GPUs), the same parallel hardware built for video games, and on newer chips designed specifically for it. It also trains on data in small batches, which means you can throw datasets of essentially any size at it. Give it more data and more computing power and it tends to keep getting better, which is exactly the property you want in an era where both are growing fast.

The third is reusability. Unlike many older methods, a trained deep learning model can be extended with new data without starting over, and a model trained on one huge task can be repurposed for many others with little or no retraining. This is the idea behind foundation models: enormous models trained once on vast amounts of data, then reused everywhere. It is why a single large language model can help with email, code, and cooking without being rebuilt for each.

flowchart TB
    S1["Simplicity<br/>automates feature engineering"]
    S2["Scalability<br/>GPUs + batches + more data"]
    S3["Reusability<br/>foundation models"]
    S1 --- S2 --- S3

The three properties that turned deep learning from one technique among many into the engine of modern AI.

That reusability is also what powers the generative AI wave you actually notice: the chatbots and image generators. Those run on very large foundation models trained by a clever trick called self-supervised learning, where the model learns by predicting missing pieces of its own input, such as the next word in a sentence or a clean version of a blurred image. Because the “correct answer” comes from the data itself, no human has to label anything, which unlocks training on almost unlimited text and images. That is the short version of how the current generation of AI got so capable so fast. We will not go deeper on generative models here; the point for now is that they are not a different kind of magic, just the same representation-learning mechanism scaled to an extraordinary degree.

An honest word about the hype#

Here is where a trustworthy guide has to slow you down. Deep learning is genuinely transformative, and it is also wrapped in a great deal of nonsense, and telling the two apart is a skill worth having from day one.

The real achievements are not small. In roughly the last decade, deep learning has delivered fluent chatbots, strong programming assistants, photorealistic image generation, human-level image classification and speech transcription, dramatically better machine translation, autonomous vehicles now carrying passengers in several cities, and superhuman play in Go, chess, and poker. That is a remarkable list for ten years.

But the breathless predictions have a poor track record. In early 2023, plenty of commentators claimed mass unemployment within a year and productivity gains of ten to a hundred times. Neither happened. The impact is large and growing quickly, yet it is nowhere near those promises. A useful way to hold this: today’s AI is best described not as artificial intelligence but as cognitive automation, the encoding of human skills and knowledge into systems that can apply them. It excels at tasks with clear requirements and plenty of examples. It is not a mind.

The difference that matters is adaptability. Think of automation as a cartoon character and real intelligence as a living being. A cartoon, however detailed, can only act out the scenes it was drawn for. A living being can face something genuinely new, adapt to it, and learn from it. Today’s systems, no matter how fluent, are much closer to the cartoon. That is not an insult, it is a clarification, and it explains both why they are so useful and why they stumble the moment they leave familiar ground.

Today’s AI is cognitive automation: brilliant inside the scenes it was trained on, stuck the moment the script changes. Real intelligence is the ability to handle the scene nobody drew.

Wrapping up#

Strip away the marketing and deep learning is one clean idea. Machine learning replaced hand-written rules with rules learned from examples. The learning is really a search for good representations of the data, and “deep” means learning many successive layers of them, each one refining the last. The search runs on a simple loop: make a prediction, measure how wrong it is with a loss function, and let an optimizer nudge millions of weights slightly downhill, over and over, until the model is right. That mechanism, plus enough data and computing power, is what makes everything from photo search to chatbots work. It is not a brain, and it is not magic. It is a mathematical framework for learning representations, and now you have the map of it.

The short version: deep learning is machine learning that discovers its own layered representations of data by minimizing a loss, and that single mechanism, scaled up, is the engine behind modern AI.

What’s next#

In Part 2, we stop talking and start building. We will construct the smallest unit of a neural network, a single artificial neuron, from scratch in NumPy, and train it to classify points with nothing but a weighted sum and a nudge-on-error rule. Everything abstract in this article, the weights, the loss, the training loop, becomes a few lines of code you can run and watch learn. See you at the neuron.