How Does AI Learn?

Core Principles of Machine Learning and Optimization

At its core, how does AI learn is answered through mathematical optimization rather than biological cognition. Traditional computer software relies on explicit procedural instructions: human engineers write deterministic logic, declaring rules that dictate exactly how inputs transform into outputs. Artificial intelligence, and specifically machine learning, reverses this paradigm. Instead of handcrafting rules, engineers supply an algorithm with data and an objective function. The system iteratively analyzes examples, measures its own performance against the objective, and updates its internal parameters to minimize errors. What is Machine Learning? - IBM Machine learning, explained | MIT Sloan

In computational terms, learning refers to the automated refinement of a predictive mathematical function. Consider a target function $f(x) = y$, where $x$ represents input data (such as pixels, audio frequencies, or text tokens) and $y$ represents the desired output (such as an object label, transcription, or subsequent word). A model begins as an approximation function $\hat{y} = f(x; \theta)$, governed by a configuration of adjustable parameters known as weights and biases, collectively denoted as $\theta$. Learning is the systemic process of searching through parameter space to find an optimal configuration $\theta^*$ such that the model's predictions align as closely as possible with empirical reality across unseen data: What is Machine Learning? - IBM How Does Machine Learning Work? - Coursera

The learning process relies on three essential components:

1. Representation: The mathematical architecture chosen to approximate the relationship within the data, ranging from linear regression and decision trees to deep multilayer artificial neural networks.
2. Evaluation: An objective or loss function that computes a numeric penalty indicating how far the model's current output deviates from the ideal outcome.
3. Optimization: An algorithmic search mechanism that systematically modifies the parameters $\theta$ based on the evaluation metric to drive future errors downward.

Through these components, an artificial intelligence system does not acquire understanding in a human sense; rather, it identifies statistical regularities, structural correlations, and geometric manifolds within high-dimensional data. What is Machine Learning? - IBM

Primary Learning Paradigms

Machine learning systems operate under distinct frameworks defined by the presence, format, and timing of feedback during training. The four primary paradigms comprise supervised learning, unsupervised learning, self-supervised learning, and reinforcement learning.

Supervised Learning

Supervised learning requires datasets composed of matched pairs of inputs and target labels. The objective is to generalize from these examples so the model can correctly label novel inputs it has never encountered. Supervised tasks split broadly into classification (predicting a discrete class, such as distinguishing benign from malignant tissue) and regression (predicting a continuous scalar, such as forecasting electricity demand). The principal constraint of supervised learning is its dependence on large volumes of human-annotated data, which can introduce subjective bias, labeling errors, and substantial expense. What is Machine Learning? - IBM Machine learning, explained | MIT Sloan

Unsupervised Learning

Unsupervised learning operates on raw data devoid of human-assigned labels or target categories. Instead of calculating how close an output matches an expected label, the system measures statistical properties across the entire dataset. Common implementations include:

• Clustering: Algorithms such as $k$-means or hierarchical clustering group data points based on geometric proximity in feature space.
• Dimensionality Reduction: Techniques like Principal Component Analysis (PCA) and t-Distributed Stochastic Neighbor Embedding (t-SNE) compress high-dimensional feature spaces into lower-dimensional manifolds while preserving maximal variance or local neighborhood structure.
• Density Estimation: Models estimate the underlying probability density function that generated the observations, identifying rare outliers that deviate from common distributions.

Self-Supervised Learning

Self-supervised learning has become the foundational engine for modern foundation models and generative artificial intelligence. While structurally similar to unsupervised learning because it requires no human-annotated labels, it converts the problem into a supervised task by generating synthetic targets directly from the data itself.

In natural language processing, this often takes the form of causal language modeling or masked language modeling. In causal language modeling, the system receives a sequence of tokens and learns to predict the immediate next token:

In masked language modeling, portions of the input sequence are withheld or corrupted, and the network is trained to reconstruct the missing elements using surrounding bidirectional context. By processing billions or trillions of text tokens, images, or audio snippets in this manner, self-supervised models construct internal representations of syntax, semantic relationships, physical commonsense, and world knowledge.

Reinforcement Learning

Reinforcement learning (RL) differs fundamentally from pattern-matching approaches by framing intelligence as an agent operating sequentially inside an environment. The agent observes the current environmental state $s_t$, executes an action $a_t$ chosen according to its policy $\pi(a \mid s)$, receives a scalar reward $r_t$, and transitions into a new state $s_{t+1}$. How Does Machine Learning Work? - Coursera

Unlike supervised learning, where the correct answer is supplied at every step, reinforcement learning provides evaluative feedback rather than prescriptive instruction. The agent must balance exploration (attempting unfamiliar actions to discover superior outcomes) with exploitation (leveraging known actions that yield predictable rewards). Learning occurs as the agent updates its policy or value function using algorithms such as Q-learning, Policy Gradients, or Proximal Policy Optimization (PPO) to maximize expected cumulative discounted return: How Does Machine Learning Work? - Coursera

where $\gamma \in [0, 1)$ is a discount factor prioritizing immediate over distant gains.

The Mechanics of Training: How Neural Networks Update

To understand how deep artificial neural networks execute the learning process, one must examine the computational loop that runs across millions of training iterations: the forward pass, loss calculation, backpropagation, and parameter optimization. What is Backpropagation? | IBM A Data Scientist's Guide to Gradient Descent and ...

   [ Input Data: x ]
           │
           ▼
┌─────────────────────┐
│    Forward Pass     │  Compute layer-by-layer activations:
│   z = Wx + b; a=σ(z)│  Outputs model prediction ŷ
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│    Loss Function    │  Calculate error magnitude:
│      L(y, ŷ)        │  Measures divergence from target
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│   Backpropagation   │  Apply multivariable chain rule:
│     ∂L / ∂W, ∂L / ∂b│  Computes gradient of loss w.r.t. every weight
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  Gradient Descent   │  Update network parameters:
│   W := W - η ∇_W L  │  Shifts weights opposite to gradient slope
└─────────────────────┘

The Forward Pass and Architecture

An artificial neural network consists of layers of interconnected processing nodes, termed artificial neurons. Each individual connection holds an adjustable numerical value called a weight ($W$), and each neuron maintains an adjustable baseline offset called a bias ($b$).

During the forward pass, an input vector $x$ enters the network. Every neuron in the subsequent layer computes the dot product of its incoming weights and the input vector, adds its bias, and passes the resulting scalar through a non-linear activation function $\sigma$:

Non-linear activation functions—such as the Rectified Linear Unit (ReLU), GELU, or Sigmoid—are mathematically indispensable. Without non-linearity, stacking multiple layers would simply collapse into a single linear transformation, rendering deep networks incapable of approximating complex, high-dimensional surfaces. The forward pass terminates when the final layer produces a prediction $\hat{y}$. A Data Scientist's Guide to Gradient Descent and ...

Quantifying Error with Loss Functions

Once the model produces $\hat{y}$, that prediction is compared against the target label $y$ using a mathematically defined loss function (or cost function, when calculated over an entire batch). The loss function translates predictive errors into a single scalar value that the algorithm attempts to minimize. What is Backpropagation? | IBM A Data Scientist's Guide to Gradient Descent and ...

Common loss functions include:

• Mean Squared Error (MSE): Standard for continuous regression problems, heavily penalizing large outliers:

  $$\mathcal{L}_{\text{MSE}}(y, \hat{y}) = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2$$

• Cross-Entropy Loss: Standard for probabilistic classification tasks, measuring the divergence between the true probability distribution $y$ and the predicted distribution $\hat{y}$:

  $$\mathcal{L}_{\text{CE}}(y, \hat{y}) = - \sum_{k=1}^{K} y_k \log(\hat{y}_k)$$

Backpropagation and the Chain Rule

After computing the loss, the learning algorithm must deduce how much each individual weight in the network contributed to that error. In modern deep networks containing billions of parameters, manual derivation or brute-force search is mathematically impossible. The solution is backpropagation, an efficient implementation of the multivariable calculus chain rule. What is Backpropagation? | IBM

Backpropagation calculates the partial derivative of the loss function with respect to every individual weight ($\frac{\partial \mathcal{L}}{\partial w}$) by traversing the network backward from the final layer to the initial input layer. For a given weight $w_{ij}$ in layer $l$, the gradient represents the sensitivity of the overall loss to small changes in that specific parameter: What is Backpropagation? | IBM A Data Scientist's Guide to Gradient Descent and ...

By caching intermediate computations during the forward pass, backpropagation computes these gradients across the entire network in time proportional to the number of parameters, making deep network optimization computationally tractable. What is Backpropagation? | IBM

Gradient Descent and Parameter Updates

The vector containing all partial derivatives of the loss with respect to all parameters is the gradient ($\nabla_\theta \mathcal{L}$). The gradient points in the direction of steepest increase of the loss function. Consequently, to minimize the loss, the optimizer must update parameters in the exact opposite direction. A Data Scientist's Guide to Gradient Descent and ...

The foundational update rule of gradient descent adjusts parameters by subtracting a fraction of the gradient:

The hyperparameter $\eta$ (eta) represents the learning rate, which dictates step size:

• If $\eta$ is set too small, the training process progresses sluggishly and risks getting trapped in suboptimal local minima or flat saddle points.
• If $\eta$ is set too large, updates will overshoot the minimum, destabilizing the training process or causing the loss to diverge toward infinity.

In real-world applications, computing gradients across an entire dataset at once (Batch Gradient Descent) is computationally prohibitive. Instead, systems utilize Stochastic Gradient Descent (SGD) or Mini-Batch SGD, calculating gradients over small randomized subsets of data (typically 32 to several thousand samples). Advanced optimizers such as Adam (Adaptive Moment Estimation) dynamically calculate individual learning rates for each parameter based on running estimates of the first and second moments of the gradients, accelerating convergence through noisy or sparse terrain. A Data Scientist's Guide to Gradient Descent and ...

Data Representations and Feature Spaces

Raw human data—text characters, pixel brightness values, audio frequencies, or database records—cannot be processed directly by gradient descent algorithms. Learning requires translating raw data into continuous numerical vectors positioned within high-dimensional vector spaces. What is Machine Learning? - IBM

Feature Engineering versus Representation Learning

In classical machine learning (such as linear models, support vector machines, and boosted trees), humans performed explicit feature engineering. Data scientists transformed raw inputs into structured variables through domain-specific techniques: extracting edges from images using Gabor filters, calculating frequency distributions of words via TF-IDF (Term Frequency-Inverse Document Frequency), or calculating statistical aggregations across financial transactions. The model then mapped these human-engineered features to targets. What is Machine Learning? - IBM

Deep learning eliminated this bottleneck through representation learning. Modern networks take raw signals directly and construct hierarchical abstractions across internal layers:

• In computer vision, early convolutional or attention layers capture primitive lines, edges, and color gradients. Intermediate layers combine these primitives into textures, geometric corners, and parts (such as eyes or wheels). Deeper layers compose these parts into semantic representations of complete objects (such as faces, vehicles, or animals).
• In language models, tokens are mapped to continuous vectors known as embeddings. Through alternating self-attention blocks and feed-forward networks, tokens alter their geometric representations based on surrounding context, encoding syntax, semantics, and reference relationships directly into geometric proximity within the embedding space.

Generalization, Overfitting, and Regularization

The ultimate goal of artificial intelligence is not memorization of training instances, but generalization: the capability to accurately predict outcomes on completely novel data collected under similar conditions. Measuring and ensuring generalization requires managing the balance between underfitting and overfitting. What is Machine Learning? - IBM How Does Machine Learning Work? - Coursera

   Underfitting (High Bias)         Balanced Fit            Overfitting (High Variance)
        y                          y                          y
        │       *                  │       *                  │       *
        │     *   *                │     *   *                │  /\ *   *
        │   *       *              │   *       *              │ /  \*    \ *
        │ *           *            │ *           *            │*    \____/\*
        └─────────────── x         └─────────────── x         └─────────────── x
      Model too simple           Captures true trend        Memorizes noise & outliers

The Bias-Variance Tradeoff

Generalization error decomposes into three distinct components:

1. Bias: Error stemming from overly simplistic assumptions in the model. A linear model attempting to fit an intrinsically quadratic phenomenon exhibits high bias; it underfits, failing to capture underlying patterns in either training or validation data.
2. Variance: Error originating from hypersensitivity to minor fluctuations or noise in the training set. A high-capacity network that conforms too closely to training idiosyncrasies exhibits high variance; it overfits, scoring near-perfect accuracy on training examples while failing on holdout test data.
3. Irreducible Error: Inherent noise present in the data collection process, measurement instruments, or stochastic processes that no algorithm can eliminate.

Regularization Techniques

To prevent models from simply memorizing training sets, engineers employ various regularization techniques that penalize excessive complexity:

• $L_1$ and $L_2$ Regularization (Weight Decay): Appends a penalty proportional to the magnitude of the model's weights directly to the loss function. $L_1$ regularization ($\sum |w|$) drives non-essential weights to absolute zero, inducing sparsity. $L_2$ regularization ($\sum w^2$) discourages excessively large individual weights, smoothing the model's decision boundaries.
• Dropout: Randomly deactivates a fixed percentage of neurons during each training step. This prevents co-adaptation of features, forcing the network to develop redundant, robust representations across varied pathways.
• Early Stopping: Continuously evaluates model performance on a separate validation set during training. When validation loss ceases to improve and begins to ascend—signaling that the model is transitioning from learning general rules to memorizing training noise—optimization is halted.
• Data Augmentation: Artificially increases data diversity by applying label-preserving transformations to the training set (such as rotations, cropping, noise injection, or synonym replacement), exposing the network to wider input variability.

Modern Post-Training and Alignment Paradigms

In cutting-edge systems, particularly Large Language Models (LLMs) and multi-modal models, learning does not terminate with the completion of initial pre-training. Self-supervised pre-training creates a base model proficient at predicting likely tokens, but such models often generate unhelpful, hallucinated, or unaligned outputs. Learning is therefore extended through targeted post-training phases.

Transfer Learning and Fine-Tuning

Transfer learning takes a model pre-trained on massive generic datasets and adapts its parameters to a specialized downstream task using a much smaller, curated dataset. Rather than training a model from random initialization, fine-tuning leverages the foundational representations already established:

• Full Fine-Tuning: Updates all existing parameters using task-specific data with a low learning rate to prevent catastrophic forgetting (the erasure of previously acquired generalized capabilities).

• Parameter-Efficient Fine-Tuning (PEFT): Keeps the vast majority of base parameters frozen and injects small, trainable adapters. Techniques such as LoRA (Low-Rank Adaptation) freeze pre-trained weight matrices $W_0$ and decompose the update matrix into low-rank matrices:

  $$W = W_0 + \Delta W = W_0 + B \cdot A$$

  where $B \in \mathbb{R}^{d \times r}$ and $A \in \mathbb{R}^{r \times k}$ with rank $r \ll \min(d, k)$, reducing memory requirements and computational overhead by over 90% during domain adaptation.

Alignment via Preference Optimization

To make AI models follow human intent safely and productively, developers apply optimization algorithms driven by human judgments rather than raw textual prediction.

1. Reinforcement Learning from Human Feedback (RLHF):

   • A secondary neural network, known as a reward model, is trained on human preference rankings between alternative model outputs.
   • The primary language model acts as an RL policy, generating responses evaluated by this reward model.
   • Policy gradient algorithms (such as PPO) systematically adjust the primary model's weights to maximize the predicted human preference score while remaining constrained by a Kullback-Leibler (KL) divergence penalty to prevent the model from drifting too far from its original pre-trained distribution.

2. Direct Preference Optimization (DPO):

   • Derives an analytical solution to bypass the training of a separate reward model entirely.
   • DPO reparameterizes the loss function directly over pairs of preferred ($y_w$) and dispreferred ($y_l$) completions given prompt $x$:
   $$\mathcal{L}_{\text{DPO}}(\theta; \pi_{\text{ref}}) = - \mathbb{E}_{(x, y_w, y_l)} \left[ \log \sigma \left( \beta \log \frac{\pi_\theta(y_w \mid x)}{\pi_{\text{ref}}(y_w \mid x)} - \beta \log \frac{\pi_\theta(y_l \mid x)}{\pi_{\text{ref}}(y_l \mid x)} \right) \right]$$

   This enables the model to align its outputs with human preference using standard cross-entropy-style optimization.

In-Context Learning

In contemporary transformer models, an apparent form of learning occurs without any physical parameter adjustments. Known as in-context learning, the model is supplied with few-shot examples or system prompts directly inside its context window.

The weights of the neural network remain entirely frozen. Instead of physical parameter optimization via gradient descent, the multi-head self-attention mechanism acts as a dynamic routing engine. The model matches structural patterns, extracts situational constraints, and executes computational tasks entirely within its forward-pass activation states. In-context learning demonstrates that once a network learns sufficiently robust internal representations of reasoning and syntax during pre-training, it can simulate task adaptation at inference time purely through emergent algorithmic manipulation of its internal hidden states.

Learning in AI Means Adjusting Numbers Until Predictions Improve

An AI system does not learn the way a student memorises a textbook or the way a programmer writes rules. It learns by tuning parameters. A modern AI model is, mathematically, a very large function with millions or billions of adjustable numbers — usually called weights or parameters. Learning is the process of repeatedly showing the model data, measuring how wrong its output is, and nudging those numbers in the direction that makes the error smaller. Repeat that a few billion times and the model's outputs start to look like competent behaviour: recognising a tumour on a scan, translating Korean into Portuguese, or continuing a sentence plausibly.

That single idea — error-driven parameter adjustment — covers most of what people mean when they ask how AI learns. Everything else (labels, rewards, neural network architecture, reinforcement learning from human feedback) is a variation on where the error signal comes from and how it gets distributed back through the model.

It is worth separating two things that are often blurred. Machine learning is the broader family of methods in which a system improves at a task from data rather than from hand-written instructions. Deep learning is the subset that uses multi-layered neural networks, and it is what powers most of the systems people now call "AI." Classical AI in earlier decades often did not learn at all: expert systems encoded human rules directly. The shift to learned systems is precisely what made today's capabilities possible — and it is also why today's systems are statistical, imperfect, and dependent on their training data.

The Training Loop: Four Steps, Repeated Endlessly

Almost all neural-network learning follows the same cycle.

1. Forward pass. Input data enters the model. Each layer multiplies the input by its weights, adds a bias, and applies a non-linear function. The final layer produces a prediction — a class label, a number, a probability distribution over words.
2. Loss computation. A loss function (also called cost or objective) measures the gap between the prediction and the desired output. For classification, cross-entropy is standard; for continuous predictions, mean squared error is common.
3. Backward pass. The system computes how much each individual weight contributed to the loss. This is backpropagation: an efficient application of the chain rule from calculus that propagates error gradients from the output layer back through every earlier layer, giving a gradient for every parameter in the network. What is Backpropagation? | IBM Backpropagation
4. Parameter update. An optimiser — most often a variant of gradient descent — moves each weight a small step against its gradient:

Here $\theta$ is the set of parameters, $L$ is the loss, $\nabla_\theta L$ is the gradient, and $\eta$ is the learning rate, a small number controlling step size. Backpropagation is what makes gradient descent practical for deep, multi-layer networks; without it, computing gradients for a large network would be prohibitively expensive. Neural Networks: Training using backpropagation

The intuition often used is a hiker descending a foggy hill. You cannot see the valley floor, but you can feel which way the ground slopes beneath your feet, so you take a step downhill and re-measure. If your steps are too large you may overshoot the valley; too small and you never arrive. Real training also uses mini-batches (updating on a few dozen or few thousand examples at a time rather than the whole dataset) and adaptive optimisers that adjust the effective step size per parameter.

Two vocabulary distinctions matter here:

• Parameters are learned by the model (weights, biases).
• Hyperparameters are chosen by the humans running the training (learning rate, batch size, number of layers, how long to train). These are not learned by gradient descent; they are tuned by experimentation, search, or experience.

Where the Learning Signal Comes From

The mechanics above assume you can compute a loss. What differs across AI systems is what supplies the notion of "correct."

The core split is straightforward: supervised learning uses labelled input–output pairs, while unsupervised algorithms work on data without labels and must find patterns on their own. Supervised vs. Unsupervised Learning: What's the ... Reinforcement learning sits apart from both, because it needs neither labels nor a fixed training set — it learns from the consequences of its own actions, trading off exploring new behaviour against exploiting what already works. Rewards in RL are frequently delayed, so a major part of the difficulty is credit assignment: figuring out which of a long sequence of decisions actually caused the eventual outcome. Machine learning 101: The types of ML explained

Self-supervised learning deserves emphasis because it is the engine behind large modern models. It sidesteps the biggest bottleneck in supervised learning — the cost of human labelling — by manufacturing the labels from the raw data. Hide a word in a sentence and ask the model to recover it; the sentence is both the input and the answer key. This is why text and code on the open internet, video, and audio can be turned into training signal at enormous scale.

Case Study: How a Large Language Model Learns

Chatbots are the most visible AI systems, so it helps to trace their learning in stages, because "how does AI learn" has a different answer at each stage.

Stage 1 — Pretraining. The model is trained on very large amounts of text to predict the next token (a word or word fragment) given everything before it. This is self-supervised and autoregressive: text is tokenised, and the model repeatedly predicts the following token, with the loss measuring how much probability it assigned to the token that actually appeared. Improving Large Language Models with Concept-Aware Fine-Tuning Nothing about grammar, geography, or arithmetic is programmed in; those regularities are absorbed because they make next-token prediction more accurate. Pretraining is where most of the compute and most of the knowledge come from.

Stage 2 — Supervised fine-tuning. A raw pretrained model continues text rather than answering questions. Fine-tuning on curated examples of instructions and good responses reshapes its behaviour. Mechanically this is still the same next-token objective, applied to a smaller, purpose-built dataset.

Stage 3 — Learning from human preferences. Instruction-following is then sharpened using human feedback. In the widely cited InstructGPT work, human annotators ranked model outputs, those rankings trained a separate reward model, and the language model was optimised against that reward with reinforcement learning — a pipeline known as RLHF (reinforcement learning from human feedback). The reported result was that a much smaller RLHF-tuned model was preferred by human evaluators over a far larger unaligned model, illustrating that how a model is trained can matter as much as its size. Training language models to follow instructions with ... Aligning language models to follow instructions

Stage 4 — In-context "learning" (which is not weight learning). When you paste examples into a prompt and the model adapts, no parameters change. This in-context learning happens entirely within a single forward pass and disappears when the conversation ends; the model performs the task without any parameter updates. is not always better? Enhancing Many-Shot In-Context ... This is the single most common source of confusion about AI learning. A deployed chatbot is usually frozen: your conversation does not retrain it. Persistent "memory" features are typically implemented by storing text and re-inserting it into future prompts, not by modifying weights. Whether your interactions later feed a training dataset depends entirely on the provider, plan, and settings, and varies across products and regions.

Generalisation: The Real Goal, and Its Failure Modes

Reducing training error is easy. The difficult part is performing well on data the model has never seen — generalisation. A model that has effectively memorised its training set is overfit: it is so specialised to the training data that it cannot generalise to new inputs. Training, Validation, Test Split for Machine Learning Datasets

The standard defence is to split data into three parts:

• Training set — used to update the weights.
• Validation set — used to tune hyperparameters and decide when to stop training.
• Test set — held back and touched only for a final, honest performance estimate.

Performance that is markedly better on the training or validation data than on the test data is a classic indicator of overfitting. Training, validation, and test data sets Practitioners add further techniques: regularisation penalties on large weights, dropout (randomly disabling units during training), data augmentation, early stopping, and cross-validation when data is scarce. The mirror-image failure is underfitting — a model too simple, or trained too briefly, to capture the real structure.

What This Explains, and What It Limits

Understanding learning as parameter optimisation makes several otherwise puzzling behaviours predictable.

• Data quality bounds capability. A model can only encode regularities present in its training data. Biased, stale, or unrepresentative data yields biased, stale, or unrepresentative behaviour, and no amount of extra compute repairs a missing signal.
• Confident errors are structural, not accidental. A model optimised to produce plausible outputs has no separate mechanism guaranteeing truth. Fluency and factual accuracy are different objectives.
• Distribution shift degrades performance. A model trained on one hospital's scanners, one dialect, or one market's transactions may perform poorly elsewhere, because the statistics it optimised against have changed.
• Learning is not continuous by default. Most deployed systems learn in discrete training runs. Keeping them current requires deliberate retraining, fine-tuning, or retrieval of external information at query time.
• Interpretability is limited. Knowing that a weight was adjusted downward does not explain a decision in human terms. Explanation techniques exist, but they are approximations rather than complete accounts of the model's reasoning.

A last conceptual caution: the word "learning" is borrowed from human cognition and fits imperfectly. Gradient-based training requires far more examples than a person needs, has no explicit goals or understanding of its own, and optimises exactly the objective it is given — including any flaws in how that objective was specified. Much of the practical craft of machine learning consists of choosing a loss function, dataset, and evaluation scheme that genuinely reflect the outcome you want, because the system will faithfully learn what you measured rather than what you intended. For high-stakes deployments in medicine, hiring, credit, or safety-critical control, that gap between measured objective and real-world goal is a matter for domain experts and formal evaluation, not general intuition.