aiwiki.page
English

Machine Learning

Machine learning is the study of algorithms that improve their performance on a task by learning patterns from data, rather than following explicitly programmed rules.

129 keywords830 linked from2 not yet writtenWritten by AI
Artificial Intel…Training dataStatisticsLinear AlgebraCalculusMathematical opt…Linear regressio…Large Language M…Machine Le…

Machine learning (ML) is a field of artificial intelligence concerned with algorithms that improve their performance on a task through experience, typically by fitting a model to training data rather than following rules written by hand. Its methods draw heavily on statistics, linear algebra, calculus and optimization, and its models range from simple linear regression to large language models with billions of parameters. The field is now central to language technology, image analysis, scientific discovery such as protein structure prediction, and a wide range of commercial systems.

This entry first sets out what machine learning is and how it relates to statistics and AI, then traces its history from early neural models and symbolic AI to the deep learning and transformer era. It next covers the mathematical foundations, the main learning paradigms (supervised, unsupervised, self-supervised and reinforcement learning), and the principal model families, including classical algorithms, neural networks, transformers and generative models. Training methods, evaluation and generalization, data practices, computing infrastructure, and applications follow, and the entry closes with societal questions and open technical problems.

Definition and Scope

Machine learning is the study of algorithms that improve their performance on a task through exposure to data, rather than through instructions a programmer writes for every case. In a rule-based system, an engineer encodes the decision logic directly: a spam filter might reject any message containing a fixed list of phrases. A learning system instead receives labeled examples and adjusts an internal model so that it classifies new messages correctly, so its behavior depends largely on the data and the learning procedure. The approach is most useful when the rules are too numerous, subtle or variable to specify by hand, as in speech recognition or image classification.

Three learning settings

The main settings are distinguished by the form of feedback and the goal of learning. In supervised learning, each training example pairs an input with a target output, and the goal is to predict outputs for unseen inputs. Classification (assigning discrete labels) and regression (predicting continuous values) are the canonical problems. In unsupervised learning, the data have no labels, and the task is to find structure, such as grouping examples into clusters, estimating the distribution that generated them, or compressing them into fewer dimensions. In reinforcement learning, an agent acts in an environment, receives a reward signal that may be delayed, and learns a policy that maximizes cumulative reward. Here the feedback is evaluative rather than a list of correct answers, and the problem is one of sequential decision-making.

These categories are not rigid. Semi-supervised methods combine a few labels with many unlabeled examples, and self-supervised methods derive training targets from the data itself, for instance by predicting a masked word in a sentence.

Relationship to statistics, data mining and symbolic AI

Machine learning shares much of its mathematics with statistics, including probability, estimation and regression, and many of its methods were developed by statisticians. The fields differ mainly in emphasis. Classical statistics typically begins with a model whose parameters are interpretable and asks what can be inferred about them, including uncertainty and hypothesis tests. Machine learning typically prioritizes predictive accuracy on new data, flexible model classes with very many parameters, and algorithms that scale to large datasets.

Data mining is better understood as a practice: searching large databases for useful patterns, often in commercial settings. It relies heavily on machine learning algorithms, but its concerns also include data preparation, database engineering and business application. Machine learning is the body of methods for building predictors or policies that generalize from examples.

Symbolic AI represents knowledge explicitly as logical statements, rules and search procedures. Expert systems of the 1970s and 1980s were a prominent example. Such systems are transparent and can be reasoned about formally, but they struggle to acquire knowledge at scale and to handle noisy perceptual data. Machine learning usually stores knowledge implicitly in numerical parameters estimated from data. The two traditions have been combined in neuro-symbolic approaches, so the boundary between them is best treated as a matter of degree.

Terminology: models, parameters, hyperparameters and inference

A model is the family of functions a learning system can represent, together with the procedure that maps inputs to outputs. For a predictor written as y^=fθ(x)\hat{y} = f_\theta(x), the vector θ\theta collects the parameters, such as the coefficients of a linear regression or the weights and biases of a neural network. Their values are determined from data.

Hyperparameters are settings that the fitting procedure does not learn directly. Examples include the learning-rate, the depth of a decision tree, the number k of neighbors in k-nearest neighbors, or the strength of a regularization penalty. Because they are set outside the fitting procedure, their values are usually chosen by comparing performance on held-out data, typically a validation set.

Training is the process of adjusting parameters to reduce a loss computed on training data, for example by minimizing 1n∑i=1nL(fθ(xi),yi)\frac{1}{n}\sum_{i=1}^{n} L(f_\theta(x_i), y_i). Inference, in machine learning usage, means applying a trained and fixed model to new inputs to produce predictions. The word has a second meaning in statistics, where it denotes drawing conclusions about a population or its parameters from data, including Bayesian posterior computation, so the intended sense should be checked from context.

Historical Development

The roots of machine learning lie in attempts to describe the nervous system mathematically. In 1943, Warren McCulloch and Walter Pitts offered what is often regarded as the first mathematical model of a neural network, and their idealized neuron, the McCulloch–Pitts unit, became a standard reference point in the field. Their threshold units, wired into feedforward networks, can represent any Boolean function, a result that later served as an early statement of the representational power of layered networks.

The term "machine learning" is commonly attributed to Arthur Samuel, who introduced it in a 1959 paper on a checkers-playing program he developed at IBM. The program combined rote memorization of positions with learning by generalization, and it reached a reasonable level of play after about eight to ten hours of running on an IBM 701. Samuel's framing of the goal, that computers should be able to improve without being explicitly programmed, is the earliest widely cited definition of the field. Between 1957 and 1958, Frank Rosenblatt introduced the perceptron, a single-layer device whose connection weights were adjusted from labeled examples so that it could sort inputs into categories.

The perceptron's limits were then formalized. In 1969, Marvin Minsky and Seymour Papert published Perceptrons, a mathematical analysis showing that single-layer perceptrons can only realize linearly separable decision rules; the XOR function is the standard example. The proofs concerned single layers, but the book was widely read as showing that neural networks were fundamentally limited, even though multilayer networks could handle such cases. Minsky had already observed that multilayer models would be needed, but no practical training algorithm for them was known. Funding and interest in connectionist approaches fell sharply, and the period is often called the first AI winter. Sources differ on its extent: one places its onset in the mid-1970s, alongside critical reports and philosophical critiques of AI, the first, associated with the mid-1970s, followed the critical reception of ambitious symbolic and perceptron-based programmes, while another dates it from 1969 to 1982 and emphasizes that DARPA redirected its resources toward symbolic AI.

Interest returned in the 1980s. In 1986, David Rumelhart, Geoffrey Hinton and Ronald Williams showed that backpropagation could train multilayer networks effectively, which removed the practical obstacle that Minsky and Papert had highlighted for single-layer models. The same decade saw growth in decision-tree induction methods such as ID3 and in statistical approaches to learning from data. The enthusiasm did not last: the second, associated with the late 1980s and early 1990s, followed a second round of disappointed expectations for AI. During the 1990s, support vector machines and other kernel-based margin methods became the dominant tools in many benchmark settings, while neural networks remained a minority research direction.

Several milestones marked the field's public progress. Deep Blue's 1997 victory over world chess champion Garry Kasparov showed the strength of search-based game-playing systems, though it relied largely on hand-crafted evaluation rather than learning. In 2012, AlexNet, a deep convolutional network trained on graphics processors by Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton, reduced the top-5 error rate on the ImageNet classification benchmark to about 15 percent, far below the runner-up's roughly 26 percent, and it is widely treated as the start of the modern deep learning era. In 2024, the Nobel Prize in Physics was awarded to John Hopfield and Geoffrey Hinton for foundational discoveries that enable learning with artificial neural networks, and the Nobel Prize in Chemistry was shared by Demis Hassabis and John Jumper, for protein structure prediction with AlphaFold, and David Baker, for computational protein design.

Mathematical Foundations

Formally, a supervised learning problem is specified by an input space X\mathcal{X}, an output space Y\mathcal{Y}, an unknown joint probability distribution DD over X×Y\mathcal{X}\times\mathcal{Y}, a hypothesis space H\mathcal{H} of candidate functions h:X→Yh:\mathcal{X}\to\mathcal{Y}, and a loss function ℓ(y^,y)\ell(\hat y, y) that scores the gap between a prediction y^\hat y and the true label yy. The learner receives a training sample S={(xi,yi)}i=1nS=\{(x_i,y_i)\}_{i=1}^{n} and returns one member of H\mathcal{H}. This is the precise sense in which learning differs from a rule-based system: the designer fixes H\mathcal{H} and ℓ\ell, and the data determine which function is selected. The ideal target is the expected loss, or true risk,

R(h)=E(x,y)∼D[ℓ(h(x),y)],R(h) = \mathbb{E}_{(x,y)\sim D}\big[\ell(h(x),y)\big],

which cannot be computed because DD is unknown. The practical substitute is the empirical risk,

R^S(h)=1n∑i=1nℓ(h(xi),yi),\hat R_S(h) = \frac{1}{n}\sum_{i=1}^{n}\ell(h(x_i),y_i),

and empirical risk minimization (ERM) selects h^=arg⁡min⁡h∈HR^S(h)\hat h = \arg\min_{h\in\mathcal{H}}\hat R_S(h).

The probabilistic framing treats each training pair as a sample drawn independently from DD. For any fixed hh, the law of large numbers ensures that R^S(h)\hat R_S(h) approaches R(h)R(h) as nn grows. The difficulty is that ERM chooses hh after seeing the data, so the selected function may be favoured by sample-specific noise. The gap between true and empirical risk therefore has to be controlled uniformly across the whole hypothesis space. For a finite H\mathcal{H} and losses bounded in [0,1][0,1], Hoeffding's inequality combined with a union bound gives, with probability at least 1−δ1-\delta,

sup⁡h∈H∣R(h)−R^S(h)∣≤ln⁡(2∣H∣/δ)2n.\sup_{h\in\mathcal{H}} \big|R(h)-\hat R_S(h)\big| \le \sqrt{\frac{\ln(2|\mathcal{H}|/\delta)}{2n}}.

The gap thus shrinks at the rate 1/n1/\sqrt{n} and grows only logarithmically with the size of the hypothesis space. The bound is stated over probability distributions, which is why the sample is treated as random rather than fixed.

Learning theory asks when such guarantees are possible at all. Probably approximately correct (PAC) learning, introduced by Leslie Valiant in 1984, requires that for every distribution and every target concept, an algorithm output, with probability at least 1−δ1-\delta, a hypothesis whose error is at most ε\varepsilon, using a number of samples that is polynomial in 1/ε1/\varepsilon and 1/δ1/\delta. For a finite class in the realizable setting, any consistent learner needs roughly n≥1ε(ln⁡∣H∣+ln⁡(1/δ))n \ge \frac{1}{\varepsilon}\big(\ln|\mathcal{H}| + \ln(1/\delta)\big) samples. For infinite classes, the Vapnik–Chervonenkis (VC) dimension measures capacity as the size of the largest point set that H\mathcal{H} can label in every possible way. Linear classifiers in Rd\mathbb{R}^d, for example, have VC dimension d+1d+1, and sample-complexity bounds scale with this quantity. These results explain how data requirements grow with model complexity, but they are often loose for heavily overparameterized neural networks, where the gap between bound and observed behaviour remains an open problem.

The no free lunch theorem, shown by David Wolpert and William Macready in the 1990s, sets a limit on general-purpose learning. If performance is averaged uniformly over all possible target functions on a finite domain, every learning algorithm has the same expected error on the inputs not seen during training. No learner is therefore best across all problems. Any advantage a method displays must come from assumptions about the problem class, which are formalized as inductive bias. Choosing H\mathcal{H}, a loss, or a regularizer is the mathematical form that such bias takes. The theorem does not imply that all algorithms perform equally on practical tasks, since real-world problems are a small, structured subset of all possible functions; it implies that a method's success is always tied to the structure it presumes.

Learning Paradigms

Learning paradigms are usually distinguished by the kind of signal a learner receives during training. In supervised learning, each training example pairs an input with a target label, and the learner fits a function that maps inputs to labels so that it predicts correctly for inputs it has not seen. When the labels are discrete, as in spam filtering or handwritten digit recognition, the task is classification. When they are continuous, as in forecasting demand or estimating a house price, the task is regression. The criterion that matters is generalization: a model that reproduces its training pairs but fails on new inputs has not learned the task. Because every example needs a label, the cost of annotation is often the main constraint on a supervised project.

Unsupervised learning works with inputs alone and aims to uncover structure in them. Three families are most prominent. Clustering partitions data into groups of similar items; k-means, for example, alternately assigns each point to the nearest of kk centroids and recomputes those centroids. Density estimation seeks to model the distribution p(x)p(x) from which the data were drawn, which supports tasks such as flagging unusual observations and generating new samples. Dimensionality reduction maps high-dimensional data into fewer coordinates while retaining as much variation as possible; principal component analysis does this with a linear projection onto the directions of greatest variance. Because no correct answer is supplied, evaluation is indirect and relies on internal criteria or on how useful the result is for a later task.

Semi-supervised learning lies between the two. A small set of labeled examples is accompanied by a much larger pool of unlabeled ones, and the method exploits the unlabeled data under assumptions such as smoothness, meaning that nearby points tend to share labels, or the cluster assumption, meaning that decision boundaries should fall in low-density regions. Common techniques include self-training, in which the model labels the unlabeled examples it is most confident about and retrains on them, and label propagation, which spreads labels across a graph linking similar points. The approach is valuable when labeling is expensive and raw data are plentiful, although incorrect pseudo-labels can reinforce the model's own errors.

Self-supervised learning derives its training signal from the data itself. Part of each input is hidden, and the model is trained to predict the hidden part. A masked language model such as BERT predicts tokens removed from a sentence, while an autoregressive model such as GPT predicts each token from those preceding it. Masked image modeling predicts missing patches, and contrastive methods train two augmented views of the same image to map to nearby vectors while pushing apart the views of different images. These pretext tasks are rarely the end goal. The pretrained model is then adapted through fine-tuning or by training a small output layer on frozen features, which is why self-supervision underpins most large language models and foundation models.

Representation learning is the idea that ties these paradigms together. Classical pipelines depended on hand-designed features, such as edge detectors in vision or cepstral coefficients in speech, whose design required domain expertise and often transferred poorly between tasks. Representation learning instead treats the features themselves as parameters to be learned from data. In a deep convolutional network trained on photographs, early layers tend to respond to edges and textures, middle layers to parts and motifs, and later layers to object categories. Word embeddings such as those produced by word2vec place words in a vector space in which geometric relations reflect patterns of usage. Viewed this way, supervised, unsupervised and self-supervised methods differ mainly in where their training signal comes from, while the learned intermediate representation is the shared product that can be reused across tasks. Reinforcement learning, which learns from rewards gathered through sequential interaction, is treated in its own section.

Classical Algorithms

Before deep neural networks became dominant, a family of "classical" algorithms formed the core of applied machine learning. Many remain in wide use for tabular data, where they train quickly, are comparatively interpretable, and are often competitive with much larger models.

Linear and logistic regression

Linear models compute a weighted sum of input features, f(x)=w⊤x+bf(\mathbf{x}) = \mathbf{w}^\top \mathbf{x} + b. The weight vector w\mathbf{w} sets how strongly each feature pushes the prediction, and the bias bb shifts it. In linear regression, this output is the prediction itself, and the parameters are usually fitted by least squares, which can be solved in closed form through the normal equations.

Logistic regression adapts the same linear score to classification. It passes the score through the logistic (sigmoid) function, σ(z)=1/(1+e−z)\sigma(z) = 1/(1+e^{-z}), to obtain a probability, P(y=1∣x)=σ(w⊤x+b)P(y=1 \mid \mathbf{x}) = \sigma(\mathbf{w}^\top \mathbf{x} + b). Training maximizes the likelihood, which is equivalent to minimizing the cross-entropy loss, typically with gradient-descent. The decision boundary is the set of points where w⊤x+b=0\mathbf{w}^\top \mathbf{x} + b = 0, a hyperplane. The sign of each weight gives the direction of a feature's effect, and its magnitude indicates strength when features are standardized. Because the boundary is linear, these models cannot represent problems such as XOR without transformed features. L1 or L2 regularization is commonly added.

Decision trees and tree ensembles

A decision tree recursively partitions the feature space. At each node it selects the feature and threshold that best separate the labels, measured by impurity criteria such as the Gini index or entropy (information gain), and it stops when a rule such as a depth limit is met. Classic variants include ID3, C4.5 and CART. A single deep tree is easy to read but has high variance and tends to overfit, so pruning or depth limits are standard.

Ensemble methods address this instability. Bagging (bootstrap aggregating) trains each tree on a bootstrap resample of the training data and combines their predictions by averaging or voting, which reduces variance. Random forests extend bagging by also restricting each split to a random subset of features, which decorrelates the trees. Boosting proceeds differently: learners are trained sequentially, each focusing on the errors of those before it. Gradient-boosted trees fit each new small tree to the negative gradient of the loss with respect to the current predictions, scaled by a learning rate. This framing generalizes boosting to arbitrary differentiable losses. Both families are part of the broader ensemble-learning approach and remain among the strongest methods for structured tabular data.

Margin-based and instance-based methods

A support vector machine seeks the separating hyperplane with the largest margin between classes. For linearly separable data, the hard-margin problem minimizes 12∥w∥2\tfrac12\lVert \mathbf{w}\rVert^2 subject to yi(w⊤xi+b)≥1y_i(\mathbf{w}^\top \mathbf{x}_i + b) \ge 1. Real data usually requires a soft margin, which penalizes violations with the hinge loss max⁡(0, 1−yif(xi))\max(0,\, 1 - y_i f(\mathbf{x}_i)), weighted by a regularization parameter. This is a convex optimization problem, so the solution is global. Kernels extend SVMs to nonlinear boundaries. The algorithm needs only inner products K(x,x′)=ϕ(x)⊤ϕ(x′)K(\mathbf{x},\mathbf{x}') = \phi(\mathbf{x})^\top \phi(\mathbf{x}'), so the implicit feature map ϕ\phi never has to be computed explicitly. Common choices include polynomial and radial basis function kernels.

k-nearest neighbors is an instance-based method. It stores the training set and classifies a new point by majority vote (or by averaging, for regression) among its kk closest training examples under a chosen distance metric. It has no real training phase, so the cost moves to prediction, which requires searching the stored data. Its accuracy degrades in high dimensions because distances become less discriminative, a manifestation of the curse-of-dimensionality. Feature scaling strongly affects its results.

Probabilistic classifiers and clustering

Naive Bayes applies bayes-theorem under the assumption that features are conditionally independent given the class:

P(y∣x1,…,xn)∝P(y)∏i=1nP(xi∣y).P(y \mid x_1,\dots,x_n) \propto P(y)\prod_{i=1}^{n} P(x_i \mid y).

Despite this strong assumption, the method is fast, needs relatively little data, and performs well in text classification such as spam filtering, where word counts are modeled per class. Its probability estimates are often poorly calibrated even when its rankings are useful.

k-means is an unsupervised method that partitions data into kk clusters by minimizing the within-cluster sum of squared distances to centroids:

min⁡C1,…,Ck ∑j=1k∑x∈Cj∥x−μj∥2.\min_{C_1,\dots,C_k}\ \sum_{j=1}^{k}\sum_{\mathbf{x}\in C_j}\lVert \mathbf{x}-\boldsymbol{\mu}_j\rVert^2 .

The standard iterative procedure alternates between assigning each point to its nearest centroid and recomputing each centroid as its cluster mean. It converges only to a local optimum, so results depend on initialization, and the number of clusters kk must be chosen in advance.

Optimization and Training

Gradient descent and mini-batch training

Training a parametric model means adjusting its parameters so that a loss computed on the training data becomes small. The basic procedure is gradient-descent: at each step the parameters move a short distance against the gradient of the loss, with the step length set by the learning-rate η\eta, so that θt+1=θt−η∇L(θt)\theta_{t+1} = \theta_t - \eta \nabla L(\theta_t). Full-batch gradient descent computes this gradient over the entire dataset, which becomes impractical when the dataset is large. Stochastic gradient descent (SGD) replaces the full gradient with an estimate from a random subset. Strictly, the original formulation used one example per update, but in modern usage, the term "SGD" is used loosely to mean "minibatch gradient descent," a variant of GD in which small batches of training data are used at a time. Typical batch sizes in deep learning run from the tens to the low thousands; one tutorial cites a common range of 32, 64, ... 1024. Averaging over a batch lowers the noise of each update, and the computation maps well onto parallel hardware, which is why minibatch gradient descent is the default in deep learning.

Backpropagation and automatic differentiation

In a layered network, the loss depends on each weight through a long chain of nested functions. backpropagation computes the gradient of the loss with respect to every parameter in one forward pass followed by one backward pass, applying the chain-rule layer by layer from the output toward the input. Its cost is only a small constant multiple of evaluating the network itself, which is what makes gradient-based training of very large models feasible. Modern frameworks implement this through automatic-differentiation, which records the operations performed in the forward computation and derives the corresponding derivatives mechanically, so practitioners rarely write gradient code by hand.

Adaptive optimizers and hyperparameters

Plain SGD applies one global step size to all parameters, which is awkward when different parameters have gradients of very different magnitudes. Adam, proposed by Diederik Kingma and Jimmy Ba in 2014, addresses this by keeping running averages of each parameter's gradient (the first moment mtm_t) and of its square (the second moment vtv_t). The averages are corrected for their initial bias toward zero, giving the update

θt+1=θt−ηv^t+ϵ m^t,m^t=mt1−β1t,v^t=vt1−β2t.\theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat v_t} + \epsilon}\,\hat m_t, \qquad \hat m_t = \frac{m_t}{1-\beta_1^t}, \quad \hat v_t = \frac{v_t}{1-\beta_2^t}.

The authors suggested defaults of 0.9 for the first-moment decay, 0.999 for the second, and 1e-8 for the numerical constant. Adam combines a momentum-like term with per-parameter scaling, and it often trains quickly with little tuning.

The learning rate and the other settings that govern optimization, such as the batch size, the moment decay rates, and any learning-rate schedule, are hyperparameters: they are chosen before training rather than fitted to the data, and they are usually selected by comparing results on a validation set. The learning rate is the most sensitive of these. Too high causes oscillation; too low causes stagnation. Practitioners therefore often use warm-up phases or decay schedules. The choice of optimizer also interacts with generalization. Plain SGD is sometimes reported to reach flatter minima that generalize better, although it often requires more careful tuning of the learning rate and learning rate schedule.

Non-convex landscapes and convergence

Linear models trained with convex losses have a single global minimum, and gradient methods reach it under standard conditions. Neural network losses are non-convex: they contain many local minima, flat plateaus, and saddle points, where the gradient vanishes but the point is not a minimum. Work by Dauphin and colleagues in 2014 emphasized that in high-dimensional problems saddle points are a more serious obstacle than poor local minima. Gradient descent can stall near saddle points, and mini-batch noise helps the model escape shallow local minima and saddle points that trap full-batch methods. In general, gradient-based training guarantees only progress toward a stationary point, not a global optimum, and with stochastic updates the loss fluctuates around the true minimum rather than descending smoothly into it.

Reaching a low training loss is also not the same as achieving good performance elsewhere. The optimizer minimizes an empirical objective computed on finite data, and the minimum it finds can fit idiosyncrasies of that sample, which is the core issue of generalization and overfitting. The optimization settings influence which solution is found: out-of-sample performance is often worse when trained with large-batch methods as compared to small-batch methods. As a result, the practical quality of a trained model depends on the interaction between the optimizer, its hyperparameters, and the data, not on the training objective alone.

Neural Networks and Deep Learning

A neural network is a parameterized function built from layers of units, each of which forms a weighted sum of its inputs and passes the result through a nonlinear function. In a multilayer perceptron, every unit in one layer feeds every unit in the next, and all layers are trained together. The nonlinearity is essential. Without it, a stack of layers collapses into a single linear map and cannot express the interactions that a linear model misses. Early networks mostly used the logistic sigmoid or the hyperbolic tangent, whose derivatives are small across much of their range, so error signals weakened as they travelled backward through many layers. The rectified linear unit (ReLU) replaced these in many designs, and it helps to mitigate the vanishing gradient problem. Weights are adjusted by backpropagation combined with gradient descent, which is covered in the optimization section.

Convolutional neural networks build two assumptions about images into their structure. Local receptive fields restrict each unit to a small patch of the input, so that edges and textures can be detected wherever they occur. Weight sharing applies the same small filter at every position, which greatly reduces the number of free parameters and makes detected features roughly tolerant to translation. Stacking convolution and pooling layers yields features that move from edges to parts to whole objects. An early and well-known example is LeNet-5, originally designed for handwritten-digit recognition, is a shallow architecture composed of convolution, subsampling, and fully connected layers.

Recurrent neural networks process sequences by passing a hidden state from one step to the next, so the same weights can handle inputs of any length. Training them with backpropagation through time exposes a basic difficulty: gradients carried across many steps either shrink exponentially toward zero, the vanishing gradient problem, or grow without bound, the exploding gradient problem. Sepp Hochreiter had analyzed the vanishing gradient problem in his 1991 diploma thesis. In 1997 Hochreiter and Jürgen Schmidhuber introduced the long short-term memory (LSTM) unit, which is designed to address the inability of conventional recurrent networks to retain information over extended time intervals. The LSTM cell keeps a memory path updated largely by addition, and learned input, forget and output gates regulate what is written, kept and read. Hochreiter and Schmidhuber called this path the constant error carousel. LSTMs still process tokens one after another, which limits parallel training and leaves very long-range dependencies difficult to capture. These limits helped motivate the attention-based architectures discussed later.

Deep stacks also depend on techniques that stabilize training. Dropout randomly zeroes a fraction of activations during training, and AlexNet also introduced dropout regularization, which is a powerful technique to reduce overfitting. Batch normalization standardizes each layer's activations using statistics from the current mini-batch, followed by learned scale and shift parameters. It reduces sensitivity to weight initialization and tolerates larger learning rates. Both methods interact with hyperparameter choices, so their settings are usually tuned on validation data.

The turning point for deep learning is usually placed at AlexNet in 2012. The annual ImageNet Large Scale Visual Recognition Challenge in 2012 became the turning point for the application of deep CNNs in large-scale image classification. The network, designed by Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton, has eight layers, five convolutional and three fully connected. Its top-5 error on the ImageNet benchmark was 15.3 percent, against 26.2 percent for the runner-up. Its success rested on data and hardware as well as architecture. Without the huge ImageNet dataset, there would have been no AlexNet. Training a deep CNN was also computationally very demanding and feasible only with the modern graphical processors present today, which is why GPUs became central to the field. The result shifted effort from feature engineering to automated DL architectures, and it set up the rapid growth of deep learning that followed.

Transformers and Large Language Models

The transformer architecture was introduced in 2017 by a team at Google. Its authors proposed a network built only from attention operations, with recurrence and convolution removed entirely. Earlier sequence models such as recurrent networks and LSTMs processed tokens one after another, so each step depended on the hidden state produced by the previous one. In a transformer, every position can weigh every other position directly through self-attention, and the positions are computed together. The original paper reported that its translation models were more parallelizable and requiring significantly less time to train. Because the model has no built-in sense of order, it adds positional information to the token embeddings. Multi-head attention runs several attention operations side by side, so different heads can capture different kinds of relations between tokens.

Pretraining and Fine-Tuning

Transformers made a two-stage recipe practical: pretrain on large unlabeled text, then adapt the result to a specific task. The first GPT model from OpenAI in 2018 stacked decoder blocks and was trained to predict the next word, after which it was adapted to downstream tasks. The original GPT paper was the first model to very successfully pre-train a large transformer network unsupervised and then fine-tune it to achieve state-of-the-art on NLP benchmarks. Google's BERT followed later in 2018. It used the encoder half of the architecture and read context in both directions at once, rather than left to right. Instead of predicting the next word, BERT was trained by masking some input tokens and recovering them, and it was pretrained on the BooksCorpus (800 million words) and English Wikipedia (2,500 million words). A pre-trained BERT representation can be fine-tuned with just one additional output layer for many tasks. Before a model sees text, the text is split into subword units by a tokenization procedure, which lets a fixed vocabulary represent rare and novel words. This pretraining approach is a form of self-supervised learning and transfer learning, and the resulting pretrained models are often called foundation models.

Scaling Laws and Emergent Behavior

In 2020, Kaplan and colleagues at OpenAI reported that the loss scales as a power-law with model size, dataset size, and the amount of compute used for training, with some trends spanning more than seven orders of magnitude. They also found that other architectural details such as network width or depth have minimal effects within a wide range. These scaling laws made it possible to predict the loss of a larger model from smaller runs. Their compute-optimal recommendation favored very large models trained on relatively modest data. A later study by Hoffmann and colleagues in 2022, known as the Chinchilla law, refined these findings, arguing that parameters and training tokens should grow in roughly equal proportion as compute increases. Scale also brought abilities that were not evident in smaller systems. The most discussed is in-context-learning, in which a model performs a new task from examples given in its prompt, without any change to its weights. GPT-3 (2020) was the influential demonstration of this behavior. Researchers continue to debate whether such abilities appear abruptly or emerge gradually as measured by different metrics.

Alignment and External Knowledge

A model trained only to predict text does not necessarily follow instructions or behave helpfully. Reinforcement learning from human feedback (RLHF) addresses this in stages: human demonstrations are used for supervised fine-tuning, human rankings of model outputs train a separate reward model, and the language model is then optimized against that reward with a reinforcement learning algorithm. OpenAI's InstructGPT (2022) popularized this approach. Its results depend heavily on the quality and consistency of the human preference data, and the reward model can be exploited by the policy it trains.

Retrieval-augmented generation (RAG) takes a different route to reliability. A retriever searches an external document collection for passages relevant to a query, and the generator conditions on those passages when producing its answer. This allows responses to draw on information that was absent from the training data and can be updated by changing the index rather than retraining the model. RAG does not eliminate hallucination; answers can still misstate or ignore the retrieved sources, and retrieval quality limits what the generator can use.

Generative Models

Generative models learn a probability distribution over the data itself, rather than only a mapping from inputs to labels. A discriminative classifier estimates p(y∣x)p(y \mid x), the probability of a label given an input, while a generative model estimates p(x)p(x), or p(x,y)p(x, y) when labels are present. Once this distribution is learned, the model can draw new samples that resemble the training data, which makes the approach central to image, audio, video and text synthesis. Three families dominate the field: variational autoencoders, generative adversarial networks and diffusion models. Each handles the difficulty of modeling a high-dimensional distribution in a different way.

Variational autoencoders (VAEs) introduce a latent variable zz, a compact code from which observations are assumed to be generated. An encoder network produces the parameters of an approximate posterior qϕ(z∣x)q_\phi(z \mid x), and a decoder network defines pθ(x∣z)p_\theta(x \mid z). Because the true posterior is intractable, training maximizes the evidence lower bound (ELBO):

L(θ,ϕ;x)=Eqϕ(z∣x)[log⁡pθ(x∣z)]−DKL(qϕ(z∣x) ∥ p(z))\mathcal{L}(\theta, \phi; x) = \mathbb{E}_{q_\phi(z \mid x)}\left[\log p_\theta(x \mid z)\right] - D_{\mathrm{KL}}\left(q_\phi(z \mid x)\,\|\,p(z)\right)

The first term rewards accurate reconstruction, and the Kullback–Leibler term keeps the approximate posterior close to a simple prior, usually a standard Gaussian. Sampling is made differentiable through the reparameterization trick, which writes zz as a deterministic function of the encoder outputs and independent noise. The resulting latent space is continuous, so interpolating between two latent codes produces smooth transitions between outputs. A common criticism is that VAEs trained with pixel-wise likelihoods tend to produce blurry images, because averaging over plausible reconstructions is penalized less than committing to sharp but wrong details.

Generative adversarial networks (GANs) avoid an explicit likelihood altogether. A generator GG maps random noise to samples, and a discriminator DD tries to distinguish real data from generated samples. Training is a two-player minimax game:

min⁡Gmax⁡D  Ex∼pdata[log⁡D(x)]+Ez∼p(z)[log⁡(1−D(G(z)))]\min_G \max_D \; \mathbb{E}_{x \sim p_{\text{data}}}[\log D(x)] + \mathbb{E}_{z \sim p(z)}[\log(1 - D(G(z)))]

In principle the game reaches an equilibrium where the generator's distribution matches the data. In practice, optimization is unstable. Typical failures include mode collapse, in which the generator produces only a few kinds of output, and vanishing gradients when the discriminator becomes too strong. Subsequent work, such as deep convolutional architectures, Wasserstein-distance objectives and progressive style-based generators, was largely aimed at stabilizing training and improving sample quality, and GANs produced highly realistic face images before diffusion methods became dominant in many image tasks.

Diffusion models generate data by reversing a gradual noising process. In the forward process, Gaussian noise is added to a data sample over many small steps until the result is close to pure noise. A neural network is then trained to undo one step at a time, usually by predicting the noise that was added at each step. Sampling starts from random noise and repeatedly applies the learned denoising steps. The training objective is simpler and more stable than the adversarial game, and sample quality is high, though generation requires many network evaluations, which made early models slow. Latent diffusion methods reduce this cost by running the process in the compressed latent space of an autoencoder, and text conditioning allows prompts to steer the output. The same principle has been extended to video generation, where temporal consistency across frames adds further difficulty.

Evaluating generative systems is harder than evaluating classifiers, because there is no single correct output for a given input. Common quantitative measures, such as the Inception Score and the Fréchet Inception Distance, compare statistics of generated and real samples in the feature space of a pretrained image network, but they capture only part of what matters. Fidelity and diversity can trade off against each other, and a model may score well by reproducing training examples, which raises separate questions about memorization and privacy. Likelihood-based scores are available for VAEs and some diffusion models but do not always track perceived quality. For text, the most prominent generative systems produce fluent output that can be factually wrong, and hallucination is difficult to measure automatically because it requires checking claims against sources. Many evaluations therefore rely on human judgment, which is costly, inconsistent across raters and sensitive to how the task is framed.

Reinforcement Learning

Reinforcement learning (RL) differs from supervised-learning in that the learner is not given the correct output for each input. An agent acts in an environment, observes the resulting state, receives a numerical reward, and must find a behavior that maximizes the reward it accumulates over time. The standard formal model is the markov-decision-process (MDP). At each discrete time step the agent observes a state sts_t, selects an action ata_t according to a policy π\pi, and the environment returns a reward rt+1r_{t+1} and a new state st+1s_{t+1}. In the Markov setting, the next state depends only on the current state and action. The usual objective is the expected discounted return

Gt=∑k=0∞γkrt+k+1,0≤γ<1G_t = \sum_{k=0}^{\infty} \gamma^{k} r_{t+k+1}, \qquad 0 \le \gamma < 1

where the discount factor γ\gamma weights near-term rewards more heavily and keeps the sum finite in continuing tasks. Because an action affects both immediate reward and future states, the learner must attribute later reward to earlier decisions. This credit-assignment problem is what distinguishes RL from one-step prediction.

Value-based methods estimate how good states or state–action pairs are, and then act greedily with respect to those estimates. q-learning learns an action-value function Q(s,a)Q(s,a) from sampled transitions using the update

Q(st,at)←Q(st,at)+α[rt+1+γmax⁡aQ(st+1,a)−Q(st,at)]Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha \left[ r_{t+1} + \gamma \max_{a} Q(s_{t+1},a) - Q(s_t,a_t) \right]

where α\alpha is the learning-rate. In the tabular setting, with a suitably decaying learning rate and sufficient exploration, these values converge toward optimal values. For large state spaces, the table is replaced by a neural network. Policy-based methods instead parameterize the policy directly and adjust its parameters to increase expected return. They handle continuous action spaces and stochastic policies more naturally, and are often combined with value estimates in actor–critic architectures.

Every RL method faces the exploration–exploitation trade-off. An agent that always chooses the action currently believed to be best may never discover better options, while an agent that explores indefinitely forgoes reward. A common compromise is the ε-greedy rule, which picks a random action with probability ε and otherwise the highest-valued action, often with ε reduced during training. Other approaches add exploration bonuses for rarely tried actions or use upper confidence bounds. The same tension appears in simpler bandit problems, where an agent has only one state to act in.

Landmark systems show how RL can be combined with other techniques. AlphaGo used deep neural networks trained partly by reinforcement learning, together with monte-carlo-tree-search, in which simulated rollouts guide the search for moves. In March 2016 it defeated Lee Sedol 4–1 in Seoul. Its successor, AlphaZero, learned chess, shogi and Go largely through self-play, without human game records. This contrasts with Deep Blue, which relied on hand-designed evaluation and brute-force search rather than learning from experience.

RL also connects to the alignment of language models. In reinforcement-learning-from-human-feedback, a reward model is first trained on human judgments of which model outputs are preferable, and the language model is then optimized against that learned reward, often with a penalty that keeps it close to the original pretrained model. The approach shows how RL turns a hard-to-write objective into a learned signal, but it also exposes the difficulty of specifying reward functions. Rewards indicate what outcome is desired but not how to achieve it, and a reward that is poorly designed or only an imperfect proxy for the intended goal can be exploited by the agent. Delayed or sparse rewards make learning slow, and RL in general requires very many interactions, which is why much training takes place in simulated environments.

Generalization, Evaluation and Model Selection

Training, validation and test data

The central aim of supervised learning is generalization: a model should perform well on new inputs drawn from the same distribution as its training data. Because the true risk cannot be computed directly, practitioners divide labeled data into three parts. The training set fits the parameters, usually by minimizing a loss function with gradient-descent. The validation set compares candidate models, chooses hyperparameters such as the learning-rate or tree depth, and informs when to stop training. The test set is held back and used to estimate final performance.

Held-out data are needed because error on the training set is an optimistic estimate: the fitting procedure has already seen those examples. If the same data are used both to tune and to evaluate, the reported score is inflated. Repeatedly consulting the test set for selection produces the same effect over time, so a test set is best treated as a one-time check. Leakage between splits, such as normalization statistics computed over the full dataset or near-duplicate examples appearing on both sides, causes similar inflation (see data-leakage). Time-ordered data need splits that respect chronology, since random splitting lets the model see the future.

Overfitting, underfitting and the bias–variance trade-off

A model underfits when it is too simple to capture the structure of the data, so error is high on both training and held-out examples. It overfits when it fits noise specific to the training sample, so training error keeps falling while validation error rises. Overfitting is more likely when a model has many parameters relative to the number of examples, when labels are noisy, or when training continues long enough to memorize the data. The gap between training and held-out performance is the practical signal of both problems.

For squared-error regression, expected prediction error decomposes into squared bias, variance and irreducible noise. Bias measures how far the average prediction over possible training sets lies from the true function; variance measures how much predictions change with the particular sample drawn. Low-capacity models, such as a linear fit to a strongly nonlinear problem, tend toward high bias and low variance. Highly flexible models, such as very deep trees or a 1-nearest-neighbor classifier with zero training error, tend toward low bias and high variance. Model selection amounts to finding the capacity at which these terms together are smallest. The exact decomposition applies to squared loss, and its interpretation is less straightforward for other losses.

Regularization, early stopping and cross-validation

Regularization limits a model's effective capacity. The most common form adds a penalty to the training objective. An L2 penalty, λ∥w∥22\lambda \lVert w \rVert_2^2, shrinks weights toward zero (weight decay), while an L1 penalty, λ∥w∥1\lambda \lVert w \rVert_1, tends to set some weights exactly to zero. The strength λ\lambda is a hyperparameter selected on validation data. Other methods act differently: dropout randomly removes units during training, and data-augmentation enlarges the training set with transformed examples.

Early stopping monitors validation loss during training, halts once it has not improved for a set number of epochs (the patience), and returns the parameters from the best checkpoint. It is inexpensive and common in neural networks, though it ties the stopping decision to the validation set.

Cross-validation supports model selection when a single validation split would be too small or too noisy. In k-fold cross-validation, the data are partitioned into k folds; each fold serves once as the validation set while the model trains on the remaining k−1 folds, and the k scores are averaged. Leave-one-out is the case where k equals the number of examples. If the same folds are used both to tune hyperparameters and to report the final score, the estimate is again optimistic, and nested cross-validation separates these roles. Stratified folds preserve class proportions, and time-series data call for forward-chaining splits.

Performance metrics

No single number suits every application. For a binary classifier, predictions are tallied as true or false positives and negatives. Accuracy, TP+TNTP+TN+FP+FN\frac{TP+TN}{TP+TN+FP+FN}, is intuitive but misleading under class imbalance: if 1% of cases are fraudulent, a detector that never flags fraud still scores 99%. Precision, TPTP+FP\frac{TP}{TP+FP}, measures how many flagged cases are correct, and recall, TPTP+FN\frac{TP}{TP+FN}, measures how many true cases are found. Raising the decision threshold generally increases precision and reduces recall, and the F1 score summarizes the two as their harmonic mean.

ROC curves plot true positive rate against false positive rate across all thresholds, and the area under the curve summarizes ranking quality independent of any single threshold. Under heavy imbalance, precision–recall curves are often more informative, because the false positive rate can look small even when false alarms far outnumber true cases. Calibration asks whether predicted probabilities match observed frequencies: among cases scored near 0.8, about 80% should be positive. Calibration is assessed with reliability diagrams and scores such as the Brier score, and it matters where probabilities drive decisions, as in medical risk estimation. Regression tasks use measures such as mean-squared-error or mean absolute error. A metric that ignores the real cost of different errors, such as optimizing accuracy when false negatives are far more costly, can yield a model that looks strong on paper and fails in deployment.

Data: Collection, Labeling and Quality

A learned model can be no more reliable than the examples it is trained on. Training sets are assembled from web crawls, sensor logs, transaction records, scanned documents, clinical archives and crowdsourced annotations, and each source carries its own selection biases. For supervised-learning, every example also needs a label, the answer the model is asked to reproduce. In many domains that label must come from people with specialized knowledge, which makes annotation one of the most expensive stages of a project. Before deep learning, a large share of the effort went into feature engineering, in which practitioners hand-designed the measurements a model could see, such as edge counts, word frequencies or sensor statistics. Neural networks reduced this manual work by learning intermediate representations from raw inputs, but they generally demand much larger volumes of curated data in return, so the cost shifted rather than vanished.

Raw data is rarely ready for direct use. Numerical variables measured on very different scales are commonly rescaled through feature-scaling, so that one large-valued column does not dominate distance calculations or gradient updates. Missing entries must be deleted, imputed with a summary statistic such as the median, or flagged with an indicator variable recording that a value was absent. Categorical fields are encoded as numbers, text is split into tokens, and images are resized and normalized. A subtle hazard lies in the fact that these steps estimate quantities such as means, vocabularies and imputation values from the data. If they are computed before the dataset is divided, information from the evaluation portion seeps into training. The standard remedy is to fit each step only on the training portion of every split, which is why cross-validation is normally implemented as a chained pipeline.

When labeled examples are scarce, data augmentation expands the training set by applying transformations that should not change the label, such as cropping or flipping images, adding background noise to audio, or paraphrasing sentences. Synthetic data goes further by generating new examples from a simulator, a generative model or handcrafted rules. Its advantage is coverage of rare events and of settings where real records cannot be shared for privacy reasons. Its risk is that the generator's own artifacts become part of the training signal, so a model may learn to recognize synthetic patterns instead of the real phenomenon. Augmentation is normally applied to training data only; applying it to evaluation data would make measured performance less representative of real inputs.

Labels are not ground truth. Annotators disagree, instructions are ambiguous, and crowd workers may be careless or inconsistent. Errors that are random tend to slow learning, whereas systematic errors, such as a class consistently confused with a neighboring one, bias the model in a predictable direction. This kind of label noise is not confined to hastily built corpora. In a 2021 study, Northcutt, Athalye and Mueller used confident learning to flag suspicious labels in the test sets of ten widely used computer vision, language and audio benchmarks; human reviewers confirmed errors at an estimated average rate of at least 3.3%, including roughly 6% of the ImageNet validation set. Because rankings of models depend on test labels, such errors can change which system appears best, so small reported gains may lie within the range that label error alone could produce. Real-world datasets, which are usually less curated than benchmarks, are plausibly affected to a greater degree.

Several other failure modes distort reported performance. Data leakage occurs when information that would be unavailable at prediction time enters training or evaluation. Common routes include duplicate records appearing in both training and test splits, future values in time-ordered data, and several individuals' records spread across folds, which allows a model to recognize people rather than learn the task. Leakage inflates measured accuracy while the deployed model performs worse; a neuroimaging study reporting 91% accuracy for predicting suicidality in young people was retracted after its feature selection was found to be leakage-prone. distribution-shift is a separate problem: a model validated on held-out data drawn from the same source as its training set may fail when a hospital changes scanners, a sensor is recalibrated, or customer behavior changes after a product launch. Strong results on a single validation split therefore say little about performance under new conditions unless the split reflects the intended deployment setting.

Computing Infrastructure and Deployment

Most machine learning workloads reduce to large volumes of dense linear algebra, chiefly matrix multiplication, and the hardware used for them has been shaped by that fact. GPUs were originally built for rendering graphics, but their large number of parallel cores proved well suited to the batched arithmetic of gradient computation, and they became the default engine for training neural networks. NVIDIA's data-center GPUs add dedicated tensor cores that accelerate the small matrix blocks at the core of convolutional and transformer layers. Tensor processing units follow a different design. Google's application-specific chips use a systolic array, in which data moves through a grid of multipliers without a memory access for every operation, and Cloud TPU Pods can contain more than 1,000 chips. The choice between the two is a matter of workload: TPUs suit large, regular batch jobs and are tied to Google Cloud, while GPUs support a wider range of frameworks, dynamic architectures and custom kernels.

Training a large model usually exceeds the memory or throughput of a single accelerator, so the computation is spread across many devices. In distributed training, data parallelism assigns different mini-batches to different devices and synchronizes their gradients, while model parallelism partitions the network's layers or tensors across devices. Both depend on fast interconnects, and the effort of coordinating thousands of accelerators is a large part of the engineering cost of frontier models. Energy is a related constraint. Reported figures vary widely: one estimate puts the training of GPT-3 at about 1,287 MWh of electricity, while estimates for later models are less reliable, because firms rarely publish their energy use. Measured academic runs show the same scaling pattern, with a 6.1-billion-parameter model trained on 256 NVIDIA A100 GPUs consuming on the order of 100 MWh to complete. Data-center cooling and water use add to the total, and the efficiency of a facility is commonly reported through its power usage effectiveness.

Once trained, a model's operational footprint can exceed its training footprint. Estimates attribute the large majority of AI computing to inference, meaning the repeated serving of predictions to users, and one study notes that a popular model deployed millions of times can emit more carbon through use than through training. Deployment therefore raises engineering questions about batch size, hardware choice and model size. Real-time applications such as speech, fraud screening or autonomous driving impose latency constraints, which often lead teams to use smaller or distilled models, quantized weights or accelerators designed specifically for inference, including edge accelerators that run on devices with a few watts of power.

Deployment does not end the work. Models can degrade in production because the data they receive changes over time. Monitoring typically covers two levels: operational metrics, such as latency, memory, CPU and GPU use, uptime and cost, and model-level metrics, such as input data quality, data drift, concept drift, prediction drift and calibration against observed outcomes. When monitoring detects degradation, teams retrain or update the model, which requires version tracking of models, data and code. This is also where reproducibility becomes practical: reported results can only be reproduced if the training data, preprocessing steps, hyperparameters and software environment are recorded for each release. The discipline that organizes these steps is commonly called mlops.

Open-source tooling and cloud platforms have made this infrastructure widely available. Frameworks such as TensorFlow, PyTorch and JAX provide automatic differentiation and device backends, and deployment projects such as Kubeflow, MLflow and Seldon Core package models for serving. Monitoring tools, including Prometheus, Grafana and Evidently AI, track model behavior in production. Cloud platforms let organizations rent GPUs and TPUs by the hour rather than purchasing them, which lowers the entry cost of large-scale experiments, although it concentrates much of the computing capacity for model development in a small number of providers and data centers.

Applications

Applications of machine learning cluster into a few domains, and each one stresses different parts of the pipeline: the kind of input data, the cost of errors, and how much a human stays in the loop. The examples below are illustrative rather than exhaustive.

Language and speech form the most visible area. Natural language processing covers tasks such as machine translation, text classification and question answering, and most current systems learn these behaviors from very large text corpora rather than from hand-written grammars. speech-recognition maps audio to text, typically with neural acoustic models trained on paired recordings and transcripts.

Vision and robotics extend learned models into the physical world. computer-vision applies convolutional and related architectures (see convolutional-neural-network) to object detection, segmentation and face recognition. In robotics and autonomous systems, learned perception is combined with control policies, which are often trained in simulation first and then transferred to hardware, and reinforcement-learning is one method used to learn those policies.

In science and medicine, the most prominent case is protein structure prediction. AlphaFold2, a machine-learning based model developed by DeepMind, won the championship in the 14th Critical Assessment of Structure prediction (CASP14) in December 2020. Its predictions showed accuracy competitive with experimental structures in a majority of cases, and greatly outperformed other methods. Internally, the system uses evolutionary history through a multiple sequence alignment, and a dedicated module models coevolutionary patterns between residues before a structure module produces the final three-dimensional coordinates. Its impact has since extended to a public resource: predicted structures for more than 200 million proteins, covering nearly the whole known protein universe, were released in partnership with EMBL-EBI. The 2024 Nobel Prize in Chemistry recognized this line of work. In diagnostic medicine, diagnostic support relies heavily on image analysis. Deep networks have been applied to organ segmentation, cancer detection, disease categorization, and computer-assisted diagnosis, and the main task categories include enhancement, registration, segmentation, classification, localization, and detection. The evidence base is more cautious than these claims might suggest. A systematic review and meta-analysis that searched Medline and EMBASE up to January 2020 identified 11,921 studies, of which 503 were included in the systematic review. Its authors framed the diagnostic accuracy of deep learning as an open question to be measured, not a settled result, and clinical deployment generally treats these systems as decision support under human oversight.

Business and finance make up a large commercial share of deployed systems. Fraud detection is a clear illustration of why the choice of evaluation metric matters. In a dataset where fraud is rare, a naive classifier can look excellent: consider a dataset of 100,000 bank accounts where only 100 are fraudulent; a model that classifies all accounts as legitimate would achieve an accuracy of 99.9% without detecting any fraud. For this reason practitioners typically report precision, recall and precision-recall curves rather than accuracy alone. Common methods include tree ensembles such as gradient-boosted trees, and anomaly-detection approaches that build a baseline of normal behavior and flag deviations. Forecasting and recommendation systems follow similar patterns, with models retrained on fresh data as conditions change. Deployed results are usually reported in narrow terms; for instance, one fraud framework that combined historical and forward-looking behavior reported that after it was applied online, the daily average recall rate increased by 4% to 5%.

Across these domains, the practical question is rarely whether a model can fit historical data. It is whether the chosen metric, the data distribution at deployment, and the consequences of mistakes all match the setting in which the system is used.

Probabilistic and Bayesian Perspectives

Probabilistic approaches treat learning as inference about unknown quantities given observed data. Rather than asking only which single function fits the data best, they ask how probable different parameter settings are and how confident a prediction can be.

Maximum likelihood estimation

For a parametric model p(x∣θ)p(x \mid \theta) and independent observations x1,…,xnx_1, \dots, x_n, maximum likelihood estimation (MLE) selects the parameters that make the observed data most probable:

θ^MLE=arg⁡max⁡θ∑i=1nlog⁡p(xi∣θ)\hat{\theta}_{\text{MLE}} = \arg\max_{\theta} \sum_{i=1}^{n} \log p(x_i \mid \theta)

The logarithm turns a product of likelihoods into a sum without changing the maximizer, so maximizing log-likelihood is equivalent to minimizing a negative log-likelihood loss. Many familiar losses are special cases: squared error corresponds to Gaussian noise with fixed variance, and cross-entropy corresponds to a categorical output distribution. MLE is a fitting criterion, not a guarantee of generalization; with few samples or very flexible models, the maximizer can overfit. Adding a penalty term to the likelihood gives maximum a posteriori estimation, where an L2 penalty corresponds to a Gaussian prior on the weights and an L1 penalty to a Laplace prior.

Bayesian inference

Bayesian inference treats parameters as random variables with a prior distribution p(θ)p(\theta). Bayes' theorem combines the prior with the likelihood to yield a posterior:

p(θ∣D)=p(D∣θ) p(θ)p(D),p(D)=∫p(D∣θ) p(θ) dθp(\theta \mid \mathcal{D}) = \frac{p(\mathcal{D} \mid \theta)\,p(\theta)}{p(\mathcal{D})}, \qquad p(\mathcal{D}) = \int p(\mathcal{D} \mid \theta)\,p(\theta)\,d\theta

The denominator, the evidence or marginal likelihood, normalizes the posterior and supports comparison between model classes. Predictions average over the posterior instead of committing to one parameter value:

p(y∣x,D)=∫p(y∣x,θ) p(θ∣D) dθp(y \mid x, \mathcal{D}) = \int p(y \mid x, \theta)\, p(\theta \mid \mathcal{D})\, d\theta

The spread of this posterior predictive distribution quantifies uncertainty. A model trained on little data yields broad predictions, and the spread narrows as data accumulate. Gaussian processes and Bayesian neural networks are standard examples. The integrals are usually intractable for realistic models, which motivates the approximate methods below.

Graphical models and approximate inference

A probabilistic-graphical-model encodes a joint distribution over many variables as a graph whose edges represent conditional dependence. Directed models such as Bayesian networks factorize the joint into each variable's probability given its parents, while undirected models such as Markov random fields use factors over cliques. Hidden Markov models, a chain-structured example, were long central to speech recognition. Exact inference becomes expensive as the graph's treewidth grows, so approximations are needed.

Markov chain Monte Carlo builds a Markov chain whose stationary distribution is the target posterior, and averages over its samples approximate posterior expectations. Metropolis–Hastings and Gibbs sampling are common variants; chains require burn-in and convergence checks. Variational inference instead chooses a tractable family q(θ)q(\theta) and minimizes KL(q ∥ p)\mathrm{KL}(q \,\|\, p), a Kullback–Leibler divergence, which is equivalent to maximizing an evidence lower bound. It is typically faster than sampling but tends to underestimate posterior variance.

Expectation-maximization performs maximum likelihood when some variables are latent, as with component assignments in a gaussian-mixture-model. The E-step computes posterior probabilities of the latent variables under current parameters, and the M-step maximizes the expected complete-data log-likelihood over the parameters. Each iteration does not decrease the observed-data likelihood, but convergence is only to a local optimum. K-means can be viewed as a hard-assignment limit of this scheme.

Predictive association and causal inference

A model that predicts well has learned an association, P(y∣x)P(y \mid x). Setting XX by intervention rather than observing it produces a different distribution, P(y∣do(x))P(y \mid \mathrm{do}(x)). When a third variable ZZ affects both XX and YY, confounding causes the two to diverge. If patients who receive a treatment are typically sicker, a model fit to observational records may show the treatment as harmful even when it helps. Adjusting for measured confounders and randomized experiments are standard routes to interventional effects, and causal-inference frameworks specify when such effects can be identified from data. A predictor trained only on observational correlations has no guarantee of holding up when the data-generating process is changed by intervention.

Societal Impact, Governance and Ethics

Fairness and bias

A model learns whatever regularities its training data contain, including historical inequities, uneven sampling and inconsistent labeling. A system with low average error can therefore fail much more often for groups that are rare in the data or were labeled less carefully. Auditors measure these gaps by reporting error rates separately for each group, comparing false positive and false negative rates, and checking whether a predicted probability means the same thing across groups. Work published in 2016 and 2017 showed that several of these criteria cannot all be satisfied at once when base rates differ between groups, so choosing a fairness metric is a normative decision that statistics alone cannot settle. Interventions can be applied before training (reweighting examples or collecting more representative data), during training (adding constraints to the objective), or after training (adjusting decision thresholds for each group), and each one usually trades one property against another.

Privacy and memorization

Large neural models can retain fragments of their training corpora rather than only general patterns. Early work on GPT-2 showed that exact training sequences could be recovered through ordinary queries to the model. When prompted with text that resembles personal details, the model may complete it with email addresses, phone numbers and locations. Extraction success tends to rise with scale, since the success of such extractions increases with model size and complexity. A related attack, membership inference, asks a different question: whether a particular record was part of the training set at all. Such attacks matter most when the training data are medical or otherwise sensitive. Research on data-privacy therefore aims to build models that capture general linguistic or statistical structure while avoiding the storage of sensitive individual records, and to measure leakage with metrics that can be compared across systems.

Copyright and intellectual property

Training pipelines copy and transform large volumes of protected works, and courts in the United States have begun to separate permissible from impermissible uses. In a 2025 decision in Bartz v. Anthropic, the court reasoned that training on legally obtained books could be transformative, while keeping pirated copies fell outside that protection. The dispute was later resolved by a settlement of about $1.5 billion, with an estimated payout of approximately US$3,000 per work. A separate ruling involved Ross Intelligence's platform, which is not a generative AI model, but rather an AI-driven case search tool; that ruling was upheld by a US appeals court. The U.S. Copyright Office's May 2025 report took the view that training generative systems to produce expressive content that competes with the original works goes beyond the scope of fair use. Major cases remain open: the New York Times alleges OpenAI used millions of its articles to train ChatGPT, and in July 2026 publishers and authors filed a class action against Google over training of its Gemini models. Commentators note that the courts in Anthropic and Meta took vastly different approaches to evaluating the various kinds of market harm, so the doctrine remains unsettled. Questions about intellectual-property and copyright are thus being decided case by case rather than by a single rule.

Regulation and standards

The European Union's AI Act entered into force on August 1, 2024, and phased its obligations in over several years: prohibited practices and AI literacy duties became enforceable on February 2, 2025; GPAI provider obligations followed on August 2, 2025. The timetable for high-risk systems has since been revised. The deferral pushes compliance for standalone high-risk AI systems (Annex III) from August 2, 2026, to December 2, 2027, and for AI embedded in products already covered by EU product-safety law (Annex I) to August 2, 2028. According to the sources reviewed, the amending regulation was published in the Official Journal on July 24, 2026, and the transparency duties were not postponed; the Article 50 transparency obligations requiring disclosure of AI interactions remain in force on their original August 2, 2026, schedule. Officials attributed the postponement to the regulatory infrastructure needed to make those obligations operable has not materialized on schedule. Beyond statutory law, industry standards for safety, documentation and transparency are still being developed, and their content and adoption vary across jurisdictions and sectors.

Open Problems and Limitations

Machine learning has advanced quickly, but several basic questions remain open. Some concern why methods work at all. Others concern how systems behave once they leave the laboratory and the benchmark.

The most prominent theoretical gap involves heavily overparameterized models, which can have more parameters than training examples and can fit their training data exactly. Classical reasoning based on the bias-variance-tradeoff predicts that test error rises once a model becomes too complex for its data. In practice, however, error can fall again as capacity keeps growing past the point of perfect fit, a pattern usually called double descent. Worst-case bounds based on Rademacher complexity or VC dimension do not explain this, because such models can also fit random labels. Current explanations therefore point to a combination of architecture, optimizer and implicit regularization, as in stochastic-gradient-descent training, rather than to model size alone. Theory has not yet produced bounds that are both tight and applicable to the networks in use, and the question of which properties of a learned solution make it generalize remains unresolved. See generalization for the wider framework.

Robustness is a second area of difficulty. Small, carefully chosen perturbations of an input, often imperceptible to people, can change a model's output, as described in adversarial-example research. Performance also degrades when the data encountered at deployment differ from the training distribution, a problem known as distribution-shift. Models may then fail on out-of-distribution inputs while still returning confident predictions, which makes such failures hard to detect in advance. Methods such as data-augmentation and domain adaptation reduce some of these failures, but no general remedy has been found, and a model's behavior on inputs unlike its training data is often unpredictable.

Sample efficiency is a third limitation. Contemporary systems usually require very large datasets and substantial computation. The empirical neural-scaling-law relationships suggest that further gains tend to demand ever more data and compute, while people learn many concepts from far fewer examples. Research directions such as self-supervised-learning, transfer-learning and representation-learning aim to reuse learned structure across tasks, but it is still unclear whether the gap can be closed through better inductive biases, better learning algorithms, or simply through scale. The energy and financial costs of this approach also constrain who can carry out such research.

Interpretability is a fourth open problem. Large models contain billions of parameters, and their internal representations are distributed, so a single unit rarely corresponds to a single human-understandable concept. Attribution methods, probing classifiers and other explainable-artificial-intelligence techniques provide partial views, but they can be unfaithful to what the model actually computes. Whether the internal representations of large models can be reliably interpreted, and whether explanations can be checked against the model's real mechanisms, remains an active and contested question.

Reproducibility and the relation between benchmarks and reality form a fifth set of concerns. Reported gains often depend on random seeds, hyperparameter choices, undocumented preprocessing and implementation details. A 2018 study of deep reinforcement learning showed that non-determinism in standard environments could make some published comparisons statistically uninterpretable. Reuse of the same test set across many studies can also inflate reported scores, because the test set is effectively tuned over time; a re-creation of the ImageNet and CIFAR-10 test sets showed a systematic accuracy drop for published models. Benchmarks can also saturate, with leading systems reaching near-identical scores, so they stop separating good methods from merely tuned ones. Their results are further affected by data-leakage and by test sets that do not reflect deployment conditions. A model that scores highly on a curated dataset may still underperform when it meets different hardware, populations or workflows, which is why reproducibility and external validation have become central concerns in the field.

These limitations are interrelated: a model that generalizes poorly under distribution-shift is harder to explain, verify and reproduce, and benchmark results that overstate real-world performance make the other problems harder to detect.

References

  1. Perceptrons: An Introduction to Computational Geometryresearchgate.net
  2. Walter Pittsen.wikipedia.org
  3. Scientists in silico?arxiv.org
  4. Checkers at the origins of AI and Machine Learningdigitaltribune.com
  5. 70th Anniversary of Publication: Warren McCulloch & Walter Pitts - A Logical Calculus of the Ideas Immanent in Nervous Activitylink.springer.com
  6. RcTorch: a PyTorch Reservoir Computing Package with Automated Hyper-Parameter Optimizationarxiv.org
  7. Chapter 9: Minsky and Papert’s Analysis — Classical Foundations of Artificial Neural Networksbnaskrecki.faculty.wmi.amu.edu.pl
  8. History of the AI Winters: AI History Guideaitimeline.world
  9. What is stochastic gradient descent?ibm.com
  10. Deep Learning: A Tutorialarxiv.org
  11. Gradient Descent, Stochastic Optimization, and Other Talesarxiv.org
  12. Stochastic Gradient Descent in Deep Learning Explainedguvi.in
  13. Stochastic Gradient Descent (SGD) and Variantsapxml.com
  14. [PDF] Adam: A Method for Stochastic Optimizationsemanticscholar.org
  15. Energy Considerations for Large Pretrained Neural Networksarxiv.org
  16. ImageNet Classification with Deep Convolutional Neural Networksresearchgate.net
  17. Long short-term memory - Learn AIai.miraheze.org
  18. How LSTMs Solve the Vanishing Gradient Problemletsdatascience.com
  19. 1D Convolutional Neural Networks and Applications: A Surveyarxiv.org
  20. AlexNet and ImageNet: The Birth of Deep Learningpinecone.io
  21. The Story of AlexNet: A Historical Milestone in Deep Learningmedium.com
  22. A Critical Review of Recurrent Neural Networks for Sequence Learningarxiv.org
  23. huggingface.cohuggingface.co
  24. Paper summary — BERT: Bidirectional Transformers for Language Understandingmedium.com
  25. FinBERT-QA: Financial Question Answering with pre-trained BERT Language Modelsarxiv.org
  26. BERT: Pre-training of Deep Bidirectional Transformers foreecs.csuohio.edu
  27. (Open Access) Scaling Laws for Neural Language Models (2020)scispace.com
  28. Position: Enough of Scaling LLMs! Lets Focus on Downscalingarxiv.org
  29. Reinforcement Learning - Markov Decision Processesopencourse.inf.ed.ac.uk
  30. Stochastic Approximation with Markov Noise: Analysis and applications in reinforcement learningarxiv.org
  31. A Survey of Learning in Multiagent Environments: Dealing with Non-Stationarityarxiv.org
  32. Introducing Q-Learning · Hugging Facehuggingface.co
  33. Machine learning-based decentralized TDMA for VLC IoT networksarxiv.org
  34. ALPHAGO AND MONTE CARLO TREE SEARCHinforms-sim.org
  35. (PDF) Mastering the game of Go with deep neural networks and tree searchresearchgate.net
  36. Pervasive Label Errors in Test SetsDestabilize Machine Learning Benchmarksarxiv.org
  37. Machine learning benchmarks revealed to contain ‘pervasive’ labeling errorsaibusiness.com
  38. On Leakage in Machine Learning Pipelinesarxiv.org
  39. Don't Push the Button! Exploring Data Leakage Risks in Machine Learning and Transfer Learningarxiv.org
  40. Data Leakage in Machine Learning Models - Shelf.ioshelf.io
  41. How to prevent Data Leakage while evaluating the performance of a Machine Learning modeltowardsdatascience.com
  42. Hardware Acceleration of Explainable Machine Learning using Tensor Processing Unitsarxiv.org
  43. TPU vs GPU: Choosing the Right Hardware for Your AI Projectsdigitalocean.com
  44. TPU vs GPU Compared for AI Training and Inferencetelnyx.com
  45. What is a Tensor Processing Unit (TPU)?ultralytics.com
  46. Machine Learning in High Energy Physics Community White Paperarxiv.org
  47. Hardware Accelerators for Artificial Intelligencearxiv.org
  48. Deep Learning and Machine Learning with GPGPU and CUDA: Unlocking the Power of Parallel Computingarxiv.org
  49. Measuring the Carbon Intensity of AI in Cloud Instancesarxiv.org
  50. AI Energy Consumption Statisticsaimultiple.com
  51. The Hidden Cost of AI Energy Consumption - Knowledge at Whartonknowledge.wharton.upenn.edu
  52. How much energy does AI actually consume?knowledge.energyinst.org
  53. A Guide to Monitoring Machine Learning Models in Productiondeveloper.nvidia.com
  54. Machine Learning Model Monitoring: What to Do In Productionheavybit.com
  55. Monitoring and explainability of models in productionarxiv.org
  56. Model Monitoring: Best Practices for Tracking ML Performance - WitnessAIwitness.ai
  57. AlphaFold2 and its applications in the fields of biology and medicinenature.com
  58. Highly accurate protein structure prediction with AlphaFoldnature.com
  59. Predicting a Protein's Stability under a Million Mutationsarxiv.org
  60. A Review Paper about Deep Learning for Medical Image Analysisncbi.nlm.nih.gov
  61. Diagnostic accuracy of deep learning in medical imaging: a systematic review and meta-analysisnature.com
  62. Financial fraud detection using machine learningalloy.com
  63. Fraud Detection framework integrating recommendation mechanisms for future representation augmentationlink.springer.com
  64. Machine Learning in Finance: Use Cases, Benefits & Trendsintellectsoft.net
  65. A Survey on Model Extraction Attacks and Defenses for Large Language Modelsarxiv.org
  66. Privacy in Large Language Models: Attacks, Defenses and Future Directionsarxiv.org
  67. AI in litigation series: An update on AI copyright cases in 2026nortonrosefulbright.com
  68. Court Finds That Using Copyrighted Material as AI Training Data Is Not Fair Usefuturism.com
  69. AI Training on Copyrighted Data: Is It Fair Use? (2026 Ruling Guide)aicopyrightlegal.com
  70. A New Look at Fair Use: Anthropic, Meta, and Copyright in AI Trainingreedsmith.com
  71. EU AI Act’s High-Risk Deadline: Deferred, Not Cancelledlabs.cloudsecurityalliance.org
  72. EU AI Act High-Risk Deadline Pushed to December 2027labs.cloudsecurityalliance.org
  73. EU AI Act Omnibus Agreement — Postponed High-Risk Deadlines and Other Key Changes - Gibson Dunngibsondunn.com
  74. AI Training Data Lawsuits 2026: What the Google and Anthropic Cases Mean for Your Companywittliffcutter.com
  75. Privacy Issues in Large Language Models: A Surveyarxiv.org
  76. What Does it Mean for a Language Model to Preserve Privacy?arxiv.org
  77. Implicit Regularization and Generalization in Overparameterized Neural Networksarxiv.org
  78. Generalization for multiclass classification with overparameterized linear modelsarxiv.org
  79. Neural Feature Geometry Evolves as Discrete Ricci Flowarxiv.org
  80. AI Has a Paper Problem: The Publish-or-Perish Crisis in Machine Learningmedium.com
  81. Machine Learning's Reproducibility Crisis: NeurIPS Checklist And Code-Release Reformsatticusli.com
  82. Improving the Reproducibility of Deep Learning Software: An Initial Investigation through a Case Study Analysisarxiv.org
  83. RecourseBench: A Modular Framework for Reproducible Algorithmic Recourse Evaluationarxiv.org