"AI", "machine learning", "deep learning" and "LLM" show up in the news as if they were synonyms.
They aren't. Each one fits inside the other, like nesting dolls:
Every LLM is deep learning, all deep learning is machine learning, and all machine learning is AI. The reverse isn't true.
In this article, we'll open each doll: what it is, when it appeared and what changed with it. Along the way, it becomes clear why AI turned into a race for chips and data centers.
AI: the umbrella
The term "artificial intelligence" was born in 1955, in the proposal for a summer workshop at Dartmouth, in the United States, held the following year. The idea was ambitious: get machines to solve problems that, until then, only people could solve.
AI is therefore the goal, not a technique. It covers any system that does something that looks intelligent: playing chess, translating a text, recognizing a face, planning a route.
For decades, the main approach was writing the rules by hand. Experts described their knowledge as "if this, then that", and the program followed the rules.
The most famous example of this era is IBM's Deep Blue, which beat world chess champion Garry Kasparov in 1997. It didn't learn to play the way today's systems do: it combined specialized hardware, which analyzed over 100 million positions per second, with an evaluation function of thousands of chess criteria, calibrated on master games and fine-tuned by a grandmaster.
This works well when the rules fit in a manual. The problem is that most of the world doesn't.
Machine learning: learning from examples
Try writing the rules to decide whether someone will repay a loan. Income, age, history, job, debts... The combinations explode, and the rules that work today change tomorrow.
Machine learning flips the logic: instead of writing the rules, you show examples and let the algorithm find the pattern. The term was popularized in 1959 by Arthur Samuel, who made a checkers program improve by playing against itself.
In the loan case, the examples are the customer history: who repaid and who didn't. The algorithm finds the function that best separates one group from the other and applies it to new customers.
There are three main ways to learn:
- Supervised: the examples come with the right answer ("repaid" or "didn't repay"). This is the most common case: sales forecasting, fraud detection, email classification.
- Unsupervised: there's no answer, and the algorithm looks for structure in the data, such as groups of similar customers.
- Reinforcement: the system learns by trial and error, receiving rewards. Samuel's checkers program was a forerunner of this idea, which today shows up in robots and game-playing systems.
Classic algorithms (regression, decision trees, random forests, gradient boosting) are very much alive. On tabular data, the kind that lives in spreadsheets and databases, they still tend to beat more sophisticated models, at least on medium-sized datasets, as a 2022 study showed.
Deep learning: many layers and a lot of compute
Deep learning is a kind of machine learning that uses neural networks with many layers.
Think of an assembly line: each layer takes the previous one's output, applies a simple transformation and passes it on. In an image, the first layers detect edges; the next ones, shapes; the last ones, objects. The "deep" is the number of stacked layers.
Training works with an algorithm called backpropagation, popularized in 1986: the network compares the answer it gave with the right one and nudges each layer a little in the direction that reduces the error. Repeated millions of times, this is how the network learns.
The big advantage: the network figures out on its own which features matter. In classic machine learning, someone has to decide which columns go into the model. With deep learning, you hand over the raw image, audio or text.
If the idea dates from the 1980s, why did it only take off much later? Because deep networks need two things that didn't exist in large enough amounts: data and compute.
The turning point came in 2012. A network called AlexNet won the ImageNet image recognition competition by a huge margin: for 15% of the images, the right answer wasn't among the network's top 5 guesses, against 26% for the runner-up. It was trained on two NVIDIA graphics cards, made for gaming.
Graphics cards do thousands of simple calculations in parallel, exactly the kind of math neural networks need. From then on, the GPU became AI's standard machine.
LLMs: one model, many tasks
LLMs (Large Language Models) are deep learning models trained on huge amounts of text. They're behind ChatGPT, Claude and Gemini.
The missing piece appeared in 2017, in a Google paper called "Attention Is All You Need". It introduced the Transformer, an architecture that looks at all the words in a text at once and learns which ones relate to which. That made training much easier to parallelize, that is, to spread across many GPUs.
Training an LLM sounds simple: predict the next word of a text. Done at a large enough scale, on much of the internet, books and code, this task forces the model to learn grammar, facts, reasoning and style.
The big change is in how it's used. Until then, each problem needed its own model: one to classify emails, another to translate, another to summarize. An LLM does all of that with the same model, and you just ask in natural language.
In November 2022, ChatGPT brought this to the general public.
In practice, what should you use?
The newest doll doesn't replace the others. Each layer is still the best tool for a kind of problem:
| Problem | Example | Most common approach |
|---|---|---|
| Clear, stable rules | Calculating tax, validating a form | Traditional programming |
| Tabular data | Sales forecasting, credit risk, churn | Classic machine learning |
| Images, audio, signals | Visual inspection, transcription, medical imaging | Deep learning |
| Text and conversation | Summarizing documents, customer support, extracting data from contracts | LLM |
An LLM can analyze a sales spreadsheet, but a gradient boosting model does it faster, cheaper and with results you can audit. Using an LLM for everything is like driving a truck to the corner bakery.
Why it turned into a race
Notice the pattern: each doll needed more data and more compute than the one before.
Deep Blue's rules fit in a specialized computer. AlexNet needed two GPUs. A current LLM is trained on thousands of GPUs at once, for months.
And for LLMs, scale isn't just a cost: it's the recipe. Research published from 2020 onward showed that these models improve predictably as they grow in data, parameters and compute. Whoever has more compute trains better models.
That's why today's conversation about AI runs so much through chips, data centers, energy and multi-billion-dollar investments. That's the subject of the AI Industry pillar here at Salada de Dados.