Machine learning in one sentence

Machine learning (ML) is the discipline of building systems that improve performance on a task by learning patterns from data—or from interaction—rather than by programming every rule by hand. The word learning refers to how the model updates its internal parameters (weights, policies, cluster centroids) when exposed to examples or outcomes.

Before choosing an algorithm, ask one question: What feedback does the system get during training? The answer usually points you to supervised, unsupervised, or reinforcement learning.

The three paradigms at a glance

These are not rigid silos. Production stacks mix them: unsupervised embeddings feed supervised classifiers; RL fine-tunes language models from human preference data; semi-supervised methods use a small labeled set plus a large unlabeled pool.

Supervised learning

In supervised learning, the training set includes labels—the correct outputs you want the model to predict on new inputs. The model learns a mapping from inputs to outputs by minimizing error between its predictions and those labels.

Two main problem types

• Classification — predict a discrete category: fraud vs not fraud, cat vs dog, sentiment positive/negative/neutral.
• Regression — predict a continuous value: house price, demand forecast, latency estimate.

Related variants include ranking (order items by relevance) and structured prediction (sequences, graphs, or multiple labels per example).

How training works

1. Split data into train, validation, and test sets (or use cross-validation).
2. Choose a model family (linear model, tree ensemble, neural network).
3. Define a loss function (cross-entropy for classification, mean squared error for regression).
4. Optimize parameters to reduce loss on training data; tune hyperparameters on validation data.
5. Report final metrics on the held-out test set—never tune on the test set.

The hardest part is often not the algorithm but data quality: mislabeled rows, leakage (future information in features), and distribution shift between training and production.

Common algorithms

• Logistic regression / linear regression — fast baselines, interpretable coefficients.
• Decision trees and random forests — strong on tabular data; handle mixed feature types well.
• Gradient boosting (XGBoost, LightGBM, CatBoost) — frequent winners on structured competitions.
• Support vector machines — still useful on smaller, well-separated datasets.
• Neural networks — default for images, text, audio, and large multimodal inputs.

Evaluation metrics

• Classification: accuracy (only when classes are balanced), precision, recall, F1, ROC-AUC, PR-AUC.
• Regression: MAE, RMSE, R².
• Business: cost of false positives vs false negatives—metrics should reflect what stakeholders actually care about.

Real-world examples

• Credit risk scoring, medical diagnosis support, churn prediction.
• Image classification (defect detection on a factory line).
• Spam filtering and content moderation (often hybrid with rules and LLMs).

When supervised learning is the right choice

Use it when you have (or can afford to create) reliable labels and a well-defined prediction target. If labels are expensive, consider active learning (label the most informative examples) or semi-supervised methods before jumping to a bigger model.

Unsupervised learning

In unsupervised learning, training data has no labels. The algorithm searches for regularities—clusters, low-dimensional structure, or unusual points—that help you understand or preprocess data.

Major tasks

• Clustering — group similar items (customer segments, document themes). Algorithms: k-means, hierarchical clustering, DBSCAN, Gaussian mixtures.
• Dimensionality reduction — compress features while preserving variance or neighborhood structure. PCA, t-SNE, UMAP for visualization; autoencoders for learned compression.
• Anomaly detection — flag outliers in logs, transactions, or sensor streams (isolation forest, one-class SVM, reconstruction error).
• Association rules — “customers who bought X often buy Y” (market basket analysis).
• Density estimation — model the probability distribution of data (useful for generative modeling foundations).

Embeddings: unsupervised work that powers supervised systems

Learning dense embeddings (vectors that capture similarity) is often unsupervised or self-supervised: word2vec, sentence transformers, image encoders. Those vectors then feed supervised classifiers or retrieval in RAG pipelines. If you use vector search for a chatbot, you are standing on unsupervised representation learning even when the user-facing task is supervised or generative.

Evaluation is trickier

Without ground-truth labels, you judge unsupervised methods by:

• Internal metrics — silhouette score, inertia (k-means), reconstruction loss.
• Downstream utility — do clusters improve a later supervised model or a business campaign?
• Human review — do topic clusters make sense to domain experts?

A “good” cluster is one that is useful, not necessarily one that maximizes a abstract math score.

Real-world examples

• Customer segmentation for marketing (clustering + business validation).
• Log anomaly detection before an incident becomes an outage.
• Document clustering for knowledge-base organization.
• Pre-training representations later fine-tuned with labels.

Reinforcement learning

Reinforcement learning (RL) trains an agent to take actions in an environment so as to maximize cumulative reward over time. Unlike supervised learning, there is usually no single correct label per step—the agent discovers what works through trial and error.

Core concepts

State

What the agent observes about the world (board position, robot sensors, API metrics).

Action

What the agent can do (move, scale replicas, change bid price).

Reward

Scalar feedback after each step or episode—designed by humans; bad reward design produces bad behavior.

Policy

Strategy mapping states to actions (deterministic or stochastic).

Value function

Estimate of expected future reward from a state or state–action pair.

Exploration vs exploitation

Try new actions to learn more, or repeat actions known to pay off—classic tradeoff.

Major approaches

• Tabular methods — Q-learning when state/action spaces are small.
• Deep RL — neural networks approximate Q-values or policies (DQN, PPO, SAC).
• Model-based RL — learn a model of the environment, plan ahead (sample-efficient but hard to get right).
• Multi-agent RL — many agents co-evolve (games, traffic, auctions).

Famous successes—and why production is hard

RL made headlines with AlphaGo, game-playing agents, and robotics research. In industry, RL appears in recommendation systems (long-term engagement), ad bidding, inventory control, and some autoscaling experiments. Challenges include:

• Sample inefficiency — millions of interactions may be needed.
• Safety — exploring in production can be expensive or dangerous.
• Non-stationarity — the world changes; yesterday’s optimal policy fails today.
• Reward hacking — agents optimize the metric, not the intent (clickbait, loopholes).

Most teams start with supervised baselines and add RL only when sequential decisions and clear reward signals justify the complexity—often inside simulators with human oversight.

RL and modern language models

Alignment techniques such as RLHF (reinforcement learning from human feedback) use human preference rankings as reward signals to steer large language models toward helpful, harmless behavior. The “environment” is conversational; the “actions” are tokens or completions. This is reinforcement learning at foundation-model scale—paired with supervised fine-tuning and evaluation harnesses. See AI Foundation Models in Depth for the full training stack.

Semi-supervised and self-supervised learning (the bridge)

Pure labels are expensive; raw data is cheap. Two hybrids matter in 2026:

• Semi-supervised learning — a small labeled set plus a large unlabeled set; consistency regularization or pseudo-labeling propagates signal.
• Self-supervised learning — create labels from the data itself (predict masked words, next frame in video, rotated image class). GPT-style pre-training is self-supervised on text; BERT masked language modeling is another example.

When people say “we trained a foundation model,” they usually mean massive self-supervised pre-training followed by supervised fine-tuning and sometimes RL from preferences. The three classical paradigms still apply—they just appear in sequence.

How to choose a paradigm

Shared engineering concerns

Regardless of paradigm, production ML shares the same skeleton:

• Data versioning and lineage — know what trained what.
• Train/serve skew — features computed differently offline vs online break models silently.
• Monitoring — accuracy drift, embedding drift, reward distribution shift.
• Responsible use — bias, privacy, explainability where regulations require it.

Platform engineers care because GPUs, batch jobs, feature stores, and inference endpoints look similar whether the model is a random forest or a policy network.

A minimal mental model

Supervised:     "Here are 10,000 emails labeled spam/not spam — learn the pattern."
Unsupervised:   "Here are 1M user sessions — find structure we didn't name yet."
Reinforcement:  "Play this game a million times — I'll tell you when you score."

Foundation models add: “Read the internet and predict the next token” (self-supervised), then “Answer like this example” (supervised fine-tuning), then “Prefer answers humans rank higher” (reinforcement from feedback).

Further reading

• Christopher Bishop — Pattern Recognition and Machine Learning
• Richard Sutton & Andrew Barto — Reinforcement Learning: An Introduction (free online)
• James, Witten, Hastie, Tibshirani — An Introduction to Statistical Learning
• Scikit-learn, PyTorch, and Hugging Face tutorials for hands-on practice

Related posts on this site

For vocabulary and career context, see How to Become an AI Developer. For how modern models fit into history, see From Symbols to Foundation Models. For transformers, training, and deployment, see AI Foundation Models in Depth and Large Language Models in Depth. Course notes: AWS Machine Learning Foundations.

Blog index · AI developer guide · AI historical paradigms · Foundation models · ML Foundations

Back to blog list