Last reviewed
Apr 27, 2026
Sources
15 citations
Review status
Source-backed
Revision
v8 · 5,581 words
Add missing citations, update stale details, or suggest a clearer explanation.
A feedforward neural network (FFN), also called a multilayer perceptron (MLP) when it has multiple layers, is a type of artificial neural network in which information flows in one direction only, from the input layer through any hidden layers to the output layer. There are no cycles, loops, or feedback connections in the graph of the network. This unidirectional flow distinguishes FFNs from recurrent neural networks (RNNs), which contain feedback loops that allow information from later processing stages to influence earlier ones.
Feedforward networks are among the oldest and most widely studied neural network architectures. They serve as the foundation for many modern deep learning systems, including the feedforward sublayers inside every transformer block. Despite the rise of more specialized architectures such as convolutional neural networks (CNNs) and transformers, plain feedforward networks remain a workhorse for tabular data, function approximation, classification, and regression tasks.
Imagine a toy factory with three rooms in a row. In the first room, workers receive raw materials (like plastic, paint, and screws). They pass those materials through a window into the second room, where a different team puts them together and paints them. Then the half-finished toy goes through another window into the third room, where the final team adds stickers, checks for problems, and boxes it up. Materials only move forward through the rooms; nobody sends anything backward.
A feedforward neural network works the same way. Data enters the first layer, gets transformed by the middle layers (the "hidden" layers), and comes out the other end as an answer. Each layer does its own small job, and the information only moves in one direction. During training, a supervisor checks the final answer, figures out what each room got wrong, and tells every room how to adjust. Over time, the factory learns to build exactly the right answer.
The development of feedforward neural networks spans over eight decades, moving through periods of rapid progress and stagnation.
Warren McCulloch and Walter Pitts published "A Logical Calculus of the Ideas Immanent in Nervous Activity" in 1943. Their paper proposed a mathematical model of a biological neuron as a simple binary threshold unit. Each McCulloch-Pitts neuron receives binary inputs, computes a weighted sum, and fires (outputs 1) if the sum exceeds a threshold. McCulloch and Pitts showed that networks of these units can compute any Boolean function, establishing the theoretical link between neural networks and computation.
Frank Rosenblatt introduced the perceptron at the Cornell Aeronautical Laboratory in 1958. Unlike the fixed-weight McCulloch-Pitts neuron, the perceptron had adjustable weights that could be learned from data through a supervised learning rule. The perceptron was a single-layer network capable of binary classification for linearly separable patterns. Rosenblatt's work generated significant excitement about the potential of neural networks.
In 1969, Marvin Minsky and Seymour Papert published Perceptrons, a book that rigorously analyzed the limitations of single-layer perceptrons. They proved that a single-layer perceptron cannot learn the XOR function because XOR is not linearly separable. Although multilayer networks could in principle solve XOR, no effective training algorithm for multilayer networks was widely known at the time. The book contributed to a sharp decline in funding and interest in neural network research, a period often called the first "AI winter."
Seppo Linnainmaa published the general method of automatic differentiation (reverse mode), which is the mathematical foundation of backpropagation, in his 1970 master's thesis. Paul Werbos described applying gradient descent to neural networks in his 1974 PhD thesis and further developed the idea in a 1982 publication. However, these contributions did not receive widespread attention at the time.
David Rumelhart, Geoffrey Hinton, and Ronald Williams published "Learning Representations by Back-propagating Errors" in Nature in 1986. Their paper clearly demonstrated that backpropagation could train multilayer feedforward networks to learn internal representations and solve problems like XOR that had defeated single-layer perceptrons. This work reignited interest in neural networks and made multilayer perceptrons a practical tool for the first time.
George Cybenko proved in 1989 that a feedforward network with a single hidden layer of sigmoid neurons can approximate any continuous function on a compact subset of R^n to arbitrary accuracy, given enough hidden units. In the same year, Kurt Hornik, Maxwell Stinchcombe, and Halbert White proved a broader version of this result, showing that standard multilayer feedforward networks are universal approximators. Hornik followed up in 1991 by showing that it is the multilayer feedforward architecture itself, not the specific activation function, that provides the universal approximation capability. Moshe Leshno, Vladimir Ya. Lin, Allan Pinkus, and Shimon Schocken established in 1993 that a feedforward network can approximate any continuous function if and only if its activation function is not a polynomial. This necessary-and-sufficient condition unified previous results.
Geoffrey Hinton and collaborators showed in 2006 that deep networks could be effectively trained using layer-wise pretraining with restricted Boltzmann machines. The introduction of the rectified linear unit (ReLU) activation function, batch normalization, residual connections, dropout, and dramatically faster GPU hardware removed many of the obstacles that had previously limited deep feedforward networks. Today, feedforward layers are a component of nearly every neural network architecture, from standalone MLPs to the position-wise FFN sublayers within transformers.
| Year | Milestone | Key contributors |
|---|---|---|
| 1943 | McCulloch-Pitts binary neuron model | Warren McCulloch, Walter Pitts |
| 1958 | Perceptron with learnable weights | Frank Rosenblatt |
| 1965 | Group Method of Data Handling (early deep learning) | Alexei Ivakhnenko, Valentin Lapa |
| 1967 | First multilayer network trained by SGD | Shun'ichi Amari |
| 1969 | Perceptrons book; XOR limitation proved | Marvin Minsky, Seymour Papert |
| 1970 | Reverse-mode automatic differentiation | Seppo Linnainmaa |
| 1974 | Backpropagation applied to neural networks (thesis) | Paul Werbos |
| 1986 | Backpropagation popularized for MLPs | David Rumelhart, Geoffrey Hinton, Ronald Williams |
| 1989 | Universal approximation theorem for sigmoid networks | George Cybenko |
| 1989 | Universal approximation for general activations | Kurt Hornik, Maxwell Stinchcombe, Halbert White |
| 1991 | Architecture, not activation choice, is key to universality | Kurt Hornik |
| 1993 | Non-polynomial activation is necessary and sufficient | Moshe Leshno, Allan Pinkus, et al. |
| 2006 | Deep pretraining with restricted Boltzmann machines | Geoffrey Hinton, Ruslan Salakhutdinov |
| 2010s | ReLU, batch normalization, dropout, residual connections | Various researchers |
A feedforward neural network is organized as a sequence of layers. Each layer is a collection of neurons (also called units or nodes). Connections run from every neuron in one layer to every neuron in the next layer (in a fully connected, or "dense," network), but never within the same layer or backward to a previous layer.
The input layer receives the raw feature values of an input example. The number of neurons in this layer equals the dimensionality of the input data. No computation occurs in the input layer; it simply distributes values to the first hidden layer.
Hidden layers perform the actual computation. Each neuron in a hidden layer computes a weighted sum of its inputs, adds a bias term, and passes the result through a nonlinear activation function. In mathematical notation, the output of neuron j in layer l is:
a_j^(l) = f( sum_i( w_{ji}^(l) * a_i^(l-1) ) + b_j^(l) )
where:
a_i^(l-1) is the output of neuron i in the previous layerw_{ji}^(l) is the weight connecting neuron i in layer l-1 to neuron j in layer lb_j^(l) is the bias of neuron j in layer lf is the activation functionIn vector form for an entire layer:
a^(l) = f( W^(l) * a^(l-1) + b^(l) )
A network may have one hidden layer (a "shallow" network) or many hidden layers (a "deep" network). Adding more hidden layers increases the network's depth, which generally allows it to learn more abstract, hierarchical representations of the data.
The output layer produces the network's final prediction. Its structure depends on the task:
| Task | Output neurons | Activation function | Example |
|---|---|---|---|
| Binary classification | 1 | Sigmoid | Spam detection |
| Multi-class classification | One per class | Softmax | Image classification |
| Regression | One per output dimension | Linear (identity) | Price prediction |
| Multi-label classification | One per label | Sigmoid (per neuron) | Tag prediction |
An individual neuron is the basic computational unit of the network. It performs two operations in sequence: (1) compute the weighted sum of its inputs plus a bias, and (2) apply a nonlinear activation function to that sum. The weights and biases are the learnable parameters of the network, adjusted during training to minimize a loss function.
Activation functions introduce nonlinearity into the network. Without them, a multilayer network would collapse to a single linear transformation, regardless of depth. The choice of activation function affects training dynamics, convergence speed, and final performance.
| Activation function | Formula | Range | Advantages | Disadvantages | Typical use |
|---|---|---|---|---|---|
| Sigmoid | sigma(z) = 1 / (1 + e^(-z)) | (0, 1) | Output interpretable as probability | Vanishing gradients; output not zero-centered | Binary classification output |
| Tanh | tanh(z) = (e^z - e^(-z)) / (e^z + e^(-z)) | (-1, 1) | Zero-centered; stronger gradients near zero | Vanishing gradients for large inputs | Hidden layers (older networks) |
| ReLU | max(0, z) | [0, inf) | Simple; efficient; mitigates vanishing gradients | Dying ReLU problem (neurons output zero permanently) | Hidden layers (most common default) |
| Leaky ReLU | max(alpha * z, z), alpha ~ 0.01 | (-inf, inf) | Avoids dying ReLU | Introduces extra hyperparameter | Hidden layers |
| Parametric ReLU (PReLU) | max(alpha * z, z), alpha learned | (-inf, inf) | Learns optimal negative slope | Slightly more parameters | Hidden layers |
| ELU | z if z > 0; alpha * (e^z - 1) if z <= 0 | (-alpha, inf) | Smooth; pushes mean activations toward zero | Slower to compute than ReLU | Hidden layers |
| GELU | z * Phi(z), where Phi is the standard Gaussian CDF | approx (-0.17, inf) | Smooth, probabilistic gating; good gradient flow | More expensive than ReLU | BERT, GPT |
| SiLU / Swish | z * sigma(z) | approx (-0.28, inf) | Non-monotonic; smooth; self-gated | Slightly more expensive than ReLU | EfficientNet, vision models |
| SwiGLU | Swish(xW) * (xV) | varies | State-of-the-art for LLMs; gated linear unit variant | Requires two weight matrices per layer | LLaMA, PaLM |
| Softmax | e^(z_i) / sum(e^(z_j)) | (0, 1), sums to 1 | Produces valid probability distribution | Only used at output layer | Multi-class classification output |
ReLU and its variants remain the most common choice for hidden layers in general-purpose feedforward networks. GELU is standard in transformer encoder models like BERT, while SiLU/Swish and SwiGLU are preferred in large decoder-only transformers such as LLaMA and PaLM.
A feedforward neural network with L layers defines a function f: R^(d_0) -> R^(d_L) that maps an input vector x in R^(d_0) to an output y in R^(d_L), where d_0 is the input dimension and d_L is the output dimension.
For each layer l from 1 to L:
z^(l) = W^(l) * a^(l-1) + b^(l) (linear transformation)
a^(l) = f_l(z^(l)) (activation function)
where:
The full network computes:
y = f_L( W^(L) * f_(L-1)( ... f_2( W^(2) * f_1( W^(1) * x + b^(1) ) + b^(2) ) ... ) + b^(L) )
The total number of learnable parameters in a fully connected feedforward network is:
sum over l from 1 to L of (d_l * d_(l-1) + d_l)
where d_l * d_(l-1) counts the weights and d_l counts the biases in layer l.
The universal approximation theorem is one of the foundational theoretical results in neural network research. It provides a mathematical guarantee that feedforward networks have sufficient representational power to model a broad class of functions.
In its most general form (Leshno et al., 1993), the theorem states: a standard feedforward network with a single hidden layer using any locally bounded, piecewise continuous activation function can approximate any continuous function on a compact subset of R^n to any desired accuracy, if and only if the activation function is not a polynomial.
| Year | Authors | Result |
|---|---|---|
| 1989 | George Cybenko | A single hidden layer with sigmoid activation can approximate any continuous function on a compact set |
| 1989 | Kurt Hornik, Maxwell Stinchcombe, Halbert White | Multilayer feedforward networks with as few as one hidden layer are universal approximators (broader class of activations) |
| 1991 | Kurt Hornik | The multilayer feedforward architecture itself, not the choice of activation function, gives networks the universal approximation property |
| 1993 | Moshe Leshno, V.Y. Lin, Allan Pinkus, S. Schocken | Non-polynomial activation is the necessary and sufficient condition for universal approximation |
| 2017 | Zhou Lu et al. | Networks of bounded width (n + 4 neurons per layer, with ReLU) can approximate any Lebesgue-integrable function if depth is unlimited |
| 2020 | Patrick Kidger, Terry Lyons | Extended depth results to activations like tanh and GELU |
| 2021 | Park et al. | Minimum width for universal approximation is max(d_x + 1, d_y), where d_x and d_y are input and output dimensions |
The theorem is an existence result. It guarantees that a network with the right architecture and weights can approximate a target function, but it does not:
In practice, deeper networks (more layers with fewer neurons per layer) tend to approximate complex functions more efficiently than very wide, shallow networks. This observation, supported by theoretical work on the expressive power of depth, is one reason modern deep learning favors deep architectures.
Training a feedforward neural network means adjusting its weights and biases to minimize a loss function that measures how far the network's predictions are from the true values.
During the forward pass, input data propagates through the network layer by layer. Each layer computes its weighted sum, applies the activation function, and passes the result to the next layer. The final output is compared to the target value using a loss function.
The choice of loss function depends on the task:
| Task | Loss function | Formula |
|---|---|---|
| Regression | Mean squared error (MSE) | (1/n) * sum((y_i - y_hat_i)^2) |
| Binary classification | Binary cross-entropy | -(1/n) * sum(y_i * log(y_hat_i) + (1 - y_i) * log(1 - y_hat_i)) |
| Multi-class classification | Categorical cross-entropy | -(1/n) * sum(sum(y_{ic} * log(y_hat_{ic}))) |
| Regression (robust) | Mean absolute error (MAE) | (1/n) * sum(abs(y_i - y_hat_i)) |
| Ranking | Hinge loss | max(0, 1 - y_i * y_hat_i) |
Backpropagation is the algorithm used to compute the gradient of the loss function with respect to every weight and bias in the network. It works by applying the chain rule of calculus, propagating error signals backward from the output layer through each hidden layer to the input layer.
For a weight w_{ji}^(l) connecting neuron i in layer l-1 to neuron j in layer l:
partial L / partial w_{ji}^(l) = delta_j^(l) * a_i^(l-1)
where delta_j^(l) is the error signal (local gradient) at neuron j in layer l, computed recursively from the output layer backward.
The computational cost of backpropagation scales linearly with the number of parameters in the network, making it efficient even for large models.
Backpropagation has a complex history. Although most commonly associated with the 1986 paper by Rumelhart, Hinton, and Williams, earlier versions were developed by Henry Kelley (1960), Arthur Bryson (1961), Stuart Dreyfus (1962), and Seppo Linnainmaa (1970). Paul Werbos first applied it to neural networks in 1982. The 1986 paper provided the clearest exposition and experimental validation that drove widespread adoption.
Once gradients are computed, an optimization algorithm updates the weights. Several algorithms have been developed, each with different trade-offs between convergence speed, stability, and generalization.
| Optimizer | Key idea | Introduced by |
|---|---|---|
| SGD | Update weights using gradient of a mini-batch | Robbins and Monro, 1951 |
| SGD with momentum | Accumulate past gradients to accelerate convergence in consistent directions | Polyak, 1964 |
| Nesterov momentum | Look-ahead gradient for better convergence | Nesterov, 1983 |
| AdaGrad | Adapt learning rate per parameter based on historical gradient magnitudes | Duchi et al., 2011 |
| RMSProp | Exponential moving average of squared gradients | Hinton (unpublished lecture), 2012 |
| Adam | Combines momentum (first moment) with adaptive learning rates (second moment) | Kingma and Ba, 2015 |
| AdamW | Decouples weight decay from the adaptive learning rate update | Loshchilov and Hutter, 2019 |
Adam is the most widely used optimizer in practice because it converges quickly and requires little hyperparameter tuning. SGD with momentum sometimes achieves better generalization in the final model, especially in computer vision tasks, but requires more careful learning rate scheduling.
Proper weight initialization is important to prevent vanishing or exploding gradients at the start of training.
| Method | Designed for | Variance of weights |
|---|---|---|
| Xavier / Glorot (Glorot and Bengio, 2010) | Sigmoid and tanh activations | 2 / (fan_in + fan_out) |
| He / Kaiming (He et al., 2015) | ReLU activations | 2 / fan_in |
| LeCun (LeCun et al., 1998) | SELU activations | 1 / fan_in |
Xavier initialization keeps the variance of activations roughly constant across layers when using sigmoid or tanh activations. He initialization doubles the variance to compensate for the fact that ReLU zeros out roughly half of its inputs.
The universal approximation theorem shows that a single hidden layer is theoretically sufficient to approximate any continuous function. In practice, however, deeper networks (with more layers and fewer neurons per layer) offer several advantages over wider, shallow networks:
Deep networks also face challenges:
Overfitting occurs when a network learns to fit the training data too closely, including its noise, and performs poorly on unseen data. Several regularization techniques have been developed to address this.
L1 regularization adds the sum of absolute values of weights to the loss function, encouraging sparsity. L2 regularization (weight decay) adds the sum of squared weights, discouraging large weight values. Both techniques penalize model complexity.
Introduced by Srivastava, Hinton, Krizhevsky, Sutskever, and Salakhutdinov in 2014, dropout randomly sets a fraction of neuron outputs to zero during each training step. This prevents neurons from co-adapting and forces the network to learn redundant representations. At test time, all neurons are active but their outputs are scaled to account for the dropout rate. Dropout can be interpreted as training an exponential number of "thinned" sub-networks and averaging their predictions.
Proposed by Ioffe and Szegedy in 2015, batch normalization normalizes the input to each layer by subtracting the mini-batch mean and dividing by the mini-batch standard deviation. It adds learnable scale and shift parameters. Batch normalization stabilizes training, allows higher learning rates, and provides a mild regularization effect. A related technique, layer normalization (Ba, Kiros, and Hinton, 2016), normalizes across features rather than across the batch and is preferred in transformers and RNNs.
Early stopping monitors the loss on a held-out validation set during training and halts training when the validation loss stops improving. It is a simple and effective form of regularization that limits the capacity of the network by restricting the number of training steps.
Data augmentation artificially increases the size of the training set by applying transformations (rotation, flipping, cropping, color jittering for images; synonym replacement, back-translation for text). This exposes the network to more variation and reduces overfitting.
Label smoothing replaces hard target labels (0 or 1) with soft targets (e.g., 0.1 and 0.9). This prevents the network from becoming overconfident and improves generalization, especially in classification tasks.
The transformer architecture, introduced by Vaswani et al. in 2017 in "Attention Is All You Need," contains a position-wise feedforward network (FFN) as one of two main sublayers in each transformer block (the other being the self-attention sublayer).
The standard transformer FFN applies two linear transformations with a nonlinear activation in between:
FFN(x) = W_2 * activation(W_1 * x + b_1) + b_2
In the original transformer, the activation function was ReLU. Modern transformers use GELU (in BERT, GPT-2) or SwiGLU (in LLaMA, PaLM).
The hidden dimension of the FFN (d_ff) is typically four times the model dimension (d_model). For example, in the original transformer with d_model = 512, d_ff = 2048. This 4x expansion allows the FFN to project token representations into a higher-dimensional space where nonlinear transformations can capture richer patterns, before projecting back down to d_model.
The FFN parameters typically account for about two-thirds of the total parameters in a transformer block. In a model with d_model = 4096 and d_ff = 16384, each FFN sublayer has 2 * 4096 * 16384 = 134 million parameters (ignoring biases).
| Model | FFN activation | Year |
|---|---|---|
| Original Transformer | ReLU | 2017 |
| BERT | GELU | 2018 |
| GPT-2, GPT-3 | GELU | 2019, 2020 |
| PaLM | SwiGLU | 2022 |
| LLaMA, LLaMA 2 | SwiGLU | 2023 |
SwiGLU, proposed by Noam Shazeer in 2020, incorporates a gating mechanism that controls information flow through the FFN. It uses three weight matrices instead of two, which adds approximately 15% more computation but consistently improves model quality as measured by perplexity.
While the self-attention sublayer allows tokens to exchange information across positions in a sequence, the FFN sublayer processes each token independently and identically. Research has shown that FFN sublayers act as key-value memories that store factual knowledge learned during training. The combination of attention (inter-token communication) and FFN (per-token transformation) gives transformers their representational power.
In some modern architectures, the dense FFN sublayer is replaced by a mixture of experts (MoE) layer. In an MoE layer, multiple FFN "experts" exist in parallel, and a gating network routes each token to a small subset of experts. This allows the model to have many more total parameters while keeping the computation per token roughly constant.
Several specialized architectures build on the basic feedforward design.
RBF networks use radial basis functions (typically Gaussian) as activation functions instead of sigmoid or ReLU. They have a single hidden layer where each neuron computes the distance between the input and a stored center vector, then applies a radial function. RBF networks train faster than MLPs for low-dimensional problems but scale poorly to high-dimensional data.
An autoencoder is a feedforward network trained to reconstruct its input. It consists of an encoder that compresses the input into a lower-dimensional representation and a decoder that reconstructs the original input from that representation. Autoencoders are used for dimensionality reduction, denoising, and feature learning.
Residual networks (ResNets), introduced by Kaiming He et al. in 2015, add skip connections that allow the input to a layer to bypass one or more layers and be added directly to the output. Formally, a residual block computes y = F(x) + x, where F is the transformation learned by the skipped layers. Residual connections address the vanishing gradient problem and enable training of networks with over 100 layers. He et al. won the ImageNet classification challenge in 2015 with a 152-layer ResNet achieving a 3.57% top-5 error rate.
Introduced by Srivastava, Greff, and Schmidhuber in 2015, highway networks use gating mechanisms to regulate information flow through skip connections. Unlike ResNets, which simply add the skip connection, highway networks learn a gating function that controls how much information flows through the transformation versus the skip path.
| Feature | FFN / MLP | RNN | CNN | Transformer |
|---|---|---|---|---|
| Information flow | Unidirectional, no cycles | Contains feedback loops | Unidirectional with local receptive fields | Unidirectional with global attention |
| Parameter sharing | None (fully connected) | Weights shared across time steps | Weights shared across spatial positions | Weights shared across sequence positions |
| Parallelization | Fully parallel | Sequential (inherently) | Highly parallel | Highly parallel |
| Inductive bias | None (general purpose) | Sequential / temporal structure | Spatial locality and translation invariance | Pairwise interactions between all positions |
| Input type | Fixed-size vectors | Variable-length sequences | Grid-structured data (images) | Variable-length sequences |
| Typical applications | Tabular data, function approximation, classification | Time series, language modeling (legacy) | Image recognition, object detection | NLP, computer vision, multimodal |
| Scalability | Quadratic in layer width | Limited by sequential processing | Scales well with spatial dimensions | Scales well; quadratic in sequence length |
Feedforward neural networks are used across many domains:
A simple feedforward neural network for binary classification can be defined in PyTorch as follows:
import torch
import torch.nn as nn
class FeedforwardNet(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super().__init__()
self.layer1 = nn.Linear(input_dim, hidden_dim)
self.relu = nn.ReLU()
self.layer2 = nn.Linear(hidden_dim, output_dim)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = self.layer1(x)
x = self.relu(x)
x = self.layer2(x)
x = self.sigmoid(x)
return x
# Example: 10 input features, 64 hidden neurons, 1 output
model = FeedforwardNet(input_dim=10, hidden_dim=64, output_dim=1)
This network has one hidden layer with 64 neurons using ReLU activation and a sigmoid output for binary classification. In practice, adding more hidden layers, using dropout, and selecting an appropriate optimizer like Adam would improve performance.