What is machine learning? What is AI? A historical perspective.

"Artificial intelligence" and "machine learning" are often used interchangeably, but they are not the same thing. Getting the distinction right makes it much easier to understand what today's systems actually do — and why the field looks the way it does. This article gives working definitions, then walks through the history that produced them: from a question posed in 1950 to the large language models of today.

The definitions, in one place

Artificial intelligence (AI) is the broad field concerned with building systems that perform tasks we associate with intelligence: reasoning, planning, perceiving, understanding language, making decisions. It says nothing about how those tasks are accomplished. A hand-written chess program from the 1970s is AI; so is a modern neural network.

Machine learning (ML) is a subfield of AI. Instead of programming behavior explicitly, you give an algorithm data and let it infer the rules itself. The classic framing comes from Tom Mitchell (1997): a program learns if its performance at a task, measured by some metric, improves with experience. In practice, "experience" means data.

Deep learning is, in turn, a subfield of machine learning: it uses neural networks with many layers ("deep" networks) that learn hierarchical representations of the data. Nearly everything that has made headlines since 2012 — image recognition, speech recognition, machine translation, large language models — is deep learning.

So the relationship is a set of nested circles:

AI  ⊃  machine learning  ⊃  deep learning  ⊃  large language models

Everything in the inner circles belongs to the outer ones, but not the other way around. A decision tree is machine learning but not deep learning. A rule-based expert system is AI but not machine learning at all.

1950–1956: the founding questions

The field's origin is usually traced to Alan Turing's 1950 paper Computing Machinery and Intelligence, which opens with the question "Can machines think?" and, recognizing that "think" is hopelessly vague, replaces it with an operational test: can a machine hold a conversation indistinguishable from a human's? That test — the imitation game, now called the Turing test — reframed intelligence as observable behavior rather than inner experience, a move the field never really walked back.

The name "artificial intelligence" came six years later. In the summer of 1956, John McCarthy organized a workshop at Dartmouth College with Marvin Minsky, Claude Shannon, and others, proposing to study "how to make machines use language, form abstractions and concepts, solve kinds of problems now reserved for humans, and improve themselves." The Dartmouth workshop is conventionally treated as the founding event of AI as a research field.

1957–1969: perceptrons and symbolic AI

Two research programs emerged almost immediately, and their rivalry shaped the next half century. The first was connectionism: building learning systems loosely modeled on neurons. Frank Rosenblatt's perceptron (1958) was a single artificial neuron that could learn to classify simple patterns by adjusting its weights from examples — recognizably the ancestor of every neural network trained today.

The second was symbolic AI: intelligence as the manipulation of symbols according to logical rules, with knowledge programmed in by hand. Early successes like Newell and Simon's Logic Theorist made this look like the fast lane, and for decades it was the dominant paradigm.

In 1969, Minsky and Papert's book Perceptrons gave a rigorous account of what single-layer perceptrons could not do (the XOR problem being the famous example). Multi-layer networks could in principle overcome those limits, but nobody had a practical way to train them yet. Funding and attention drained away from neural networks for over a decade.

1970s–1980s: winters and expert systems

AI has repeatedly over-promised, and the field's history includes two "AI winters" — periods when funding collapsed after inflated expectations met hard reality. The first hit in the mid-1970s, after reports (notably the UK's Lighthill Report in 1973) concluded that AI had failed to deliver on its grand claims.

The 1980s brought a commercial boom in expert systems: symbolic AI programs that encoded a human specialist's knowledge as thousands of hand-written if–then rules. Systems like MYCIN (medical diagnosis) and XCON (computer configuration at DEC) showed real value, but the approach scaled poorly — the rules were brittle, expensive to maintain, and could not cope with situations their authors hadn't anticipated. When the market for specialized AI hardware collapsed in the late 1980s, the second AI winter followed.

Amid the symbolic boom, connectionism quietly revived. In 1986, Rumelhart, Hinton, and Williams popularized backpropagation — an efficient algorithm for training multi-layer neural networks by propagating errors backwards through the layers. This solved exactly the problem Perceptrons had exposed. The ingredients of modern deep learning existed by the late 1980s; what was missing was data and compute.

1990s–2000s: machine learning becomes statistics

Through the 1990s the field reinvented itself around a humbler, more rigorous goal: instead of building general intelligence, learn specific functions from data, with mathematical guarantees where possible. This is the era when machine learning matured as a discipline distinct from symbolic AI — support vector machines, decision trees and ensembles, Bayesian methods, and the formalization of the train/test methodology that still underpins all applied ML today.

The symbolic tradition had one last headline moment: in 1997, IBM's Deep Blue defeated world chess champion Garry Kasparov. Deep Blue learned nothing from data — it won through specialized hardware, brute-force search, and hand-tuned evaluation functions. It was a triumph of engineering, and also a demonstration of that approach's ceiling: the techniques did not transfer to anything but chess.

Meanwhile the web began generating datasets of unprecedented size, and graphics cards (GPUs), built to render video games, turned out to be nearly ideal for the matrix multiplications at the heart of neural networks. The stage was set.

2012–2017: the deep learning era

The turning point has a date: in 2012, a deep convolutional neural network called AlexNet (Krizhevsky, Sutskever, and Hinton) won the ImageNet image classification challenge by a margin so large it ended the debate. Trained on GPUs over 1.2 million labeled images, it cut the error rate of the best traditional computer vision methods by roughly ten percentage points. Within two years, essentially every competitive entry was a deep network.

The recipe — deep networks, big data, GPU compute — then swept one field after another: speech recognition, machine translation, game playing. In 2016, DeepMind's AlphaGo defeated Go champion Lee Sedol, a feat many researchers had placed a decade further out, by combining deep networks with reinforcement learning and tree search.

In 2017, a Google team published Attention Is All You Need, introducing the transformer architecture. Transformers process sequences using an attention mechanism instead of recurrence, which makes them dramatically more parallelizable — and therefore scalable. Virtually every large language model since is a transformer variant.

2018–present: large language models

Researchers noticed that transformer language models improve smoothly and predictably as you scale up parameters, data, and compute — the "scaling laws." GPT-2 (2019) and GPT-3 (2020) demonstrated that a model trained only to predict the next word acquires, as a side effect, the ability to translate, summarize, answer questions, and write code. The public release of ChatGPT in November 2022 turned this from a research curiosity into a general-purpose technology, and models from OpenAI, Anthropic, Google, Meta, and a fast-growing open-weights ecosystem have iterated rapidly since.

It is worth noting the historical irony: the connectionist program that was declared a dead end in 1969 now powers systems that pass the conversational bar Turing proposed in 1950 in many practical settings — while researchers continue to debate what that does and doesn't tell us about "thinking."

The three kinds of machine learning

Modern ML is conventionally divided into three paradigms, by the kind of feedback available:

• Supervised learning — learn from labeled examples: inputs paired with correct outputs. Classification (is this transaction fraud?) and regression (what will this house sell for?) are the two canonical task types. Most commercial ML is supervised.
• Unsupervised learning — find structure in unlabeled data: clustering customers into segments, reducing dimensionality, detecting anomalies. The closely related self-supervised learning — generating labels from the data itself, like predicting the next word of a sentence — is how large language models are pretrained.
• Reinforcement learning — learn by acting: an agent takes actions in an environment and receives rewards, gradually discovering a strategy that maximizes them. It powered AlphaGo, and a variant (reinforcement learning from human feedback, RLHF) is a key step in aligning language models with what users actually want.

What this looks like in code

Machine learning sounds abstract until you see how compact the workflow is. Here is a complete supervised learning example in Python with scikit-learn: train a random forest to classify tumors as malignant or benign, and evaluate it on data the model has never seen.

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Load a labeled dataset: 569 tumors, 30 measurements each
X, y = load_breast_cancer(return_X_y=True)

# Hold out 25% of the data for testing
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

# "Learning" happens here: the model infers rules from examples
model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)

# Evaluate on data the model has never seen
predictions = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, predictions):.3f}")

Nobody wrote a rule about tumor radius or cell texture. The model derived its own decision logic from 426 training examples — that inversion, rules from data instead of rules from programmers, is the entire conceptual leap of machine learning. The train/test split matters just as much: a model is only as good as its performance on data it hasn't memorized.

Why the history matters

Three lessons from seventy years of AI research are directly useful when deciding what to build today:

• Method follows data and compute. Neural networks didn't win because the idea was new — it was six decades old. They won when data and hardware caught up. Evaluate techniques against your actual data volume, not the headline results.
• Hand-written rules don't scale; learned rules need data. Expert systems died of maintenance costs. But if you don't have (or can't get) representative data, a simple rule-based baseline is still often the right first system.
• Hype cycles are part of the pattern. The field has over-promised before, and the winters that followed were caused by the gap between claims and delivery. The technology is real; so is the value of scoping projects to what's demonstrably achievable.

All posts