liveBook · Manning

Forward pass

Also called forward propagation, forward method

A forward pass is a computation that propagates inputs through a model or dependency structure in the forward direction to calculate outputs or intermediate values.

How 14 Manning books explain it

Build AI Drug Discovery Pipelines

A forward pass is the computation that transforms model inputs into predictions by propagating them through the model.

How it is used
Uses forward passes to generate predictions during neural-network training and validation.
How deep it goes
Traces computations through a logistic regression graph and places forward passes within a batch training loop.
Examples
Illustrates a weighted input vector with a sigmoid prediction and a target, then uses batches in a PyTorch training loop.
What you can do after
Apply it via PyTorch using model(inputs) in training and evaluation loops.

Read how Build AI Drug Discovery Pipelines explains forward pass →

Statistics Every Programmer Needs

A forward pass is a project-scheduling calculation that determines each activity's earliest start and earliest finish times by progressing through its dependencies.

How it is used
Schedules activities as early as dependencies permit to establish the project timeline and support critical path analysis.
How deep it goes
Defines ES and EF, explains predecessor handling, demonstrates a network, and implements the calculation in Python.
Examples
Uses an automated reporting tool network, activities A and B, a 29-week timeline, and a tabular CPM output.
What you can do after
Build it from scratch with Python, pandas, and NumPy to calculate earliest schedule times for dependent activities.

Read how Statistics Every Programmer Needs explains forward pass →

Optimization Algorithms: AI techniques for design, planning, and control problems

Forward propagation is the computation that passes inputs through successive neural-network layers to produce an output.

How it is used
Produces neural-network outputs during supervised training before loss calculation and parameter adjustment.
How deep it goes
Explains layer-by-layer computation through activations, logits, probabilities, and loss, but does not detail gradient derivation.
Examples
Uses a NumPy implementation for three-class penguin classification with four input features and ten hidden units.
What you can do after
Apply it via NumPy to compute logits, class probabilities, and loss from neural-network parameters.

Read how Optimization Algorithms: AI techniques for design, planning, and control problems explains forward pass →

Build a DeepSeek Model (From Scratch)

A forward pass is the computation that propagates input data through a neural network to produce model outputs.

How it is used
Uses forward passes for autoregressive prediction and as the computation distributed across GPUs during training.
How deep it goes
Explains a generation loop and linear-layer precision flow, then traces forward-pass scheduling across pipeline stages.
Examples
Demonstrates GPT-2 token generation and traces eight micro-batches through a four-GPU GPipe schedule.
What you can do after
Evaluate how repeated model calls, precision choices, and pipeline dependencies affect forward-pass computation.

Read how Build a DeepSeek Model (From Scratch) explains forward pass →

Deep Learning with R, Third Edition

A forward pass is the propagation of input values through a computational graph in the direction of its outputs.

How it is used
Uses input batches to produce predictions before loss calculation and parameter updates during neural-network training.
How deep it goes
Defines graph-wide value propagation and illustrates it with scalar arithmetic, stopping before detailed implementation of large-network execution.
Examples
Uses scalar multiplication and addition, a two-layer model, and a mini-batch training loop to demonstrate prediction.
What you can do after
Understand how neural networks turn input batches into predictions and how those predictions supply loss values for optimization.

Read how Deep Learning with R, Third Edition explains forward pass →

Natural Language Processing in Action, Second Edition

Forward propagation is the computation of a neural network's output by passing inputs through its units in the forward direction.

How it is used
Computes predictions before loss evaluation, backpropagation, and optimizer updates.
How deep it goes
Explains single-neuron and layered propagation, then demonstrates a PyTorch implementation without developing forward-pass mathematics further.
Examples
Uses a basic perceptron, a layered network, and PyTorch name-gender predictions from TF-IDF features.
What you can do after
Apply it via PyTorch by defining forward(), generating predictions, and feeding them into a loss function.

Read how Natural Language Processing in Action, Second Edition explains forward pass →

Grokking AI Algorithms, Second Edition

A forward pass is the computation that propagates input through a model to produce predictions.

How it is used
Produces predictions from inputs during neural-network inference and supplies predictions for loss calculation during training.
How deep it goes
Traces weighted sums, hidden and output activations, matrix operations, and a compact equation, while deferring weight adjustment to backpropagation.
Examples
Uses a scaled car-collision dataset, pretrained connection weights, sigmoid calculations, Python code, and Transformer token batches.
What you can do after
Apply it to trace or implement prediction flow through a multilayer neural network before calculating loss or updating weights.

Read how Grokking AI Algorithms, Second Edition explains forward pass →

Timeless Algorithms, The Foundational Ideas

The computation that propagates input data through a model to produce its output.

How it is used
Produces a model prediction as the first step in the repeated cycle of prediction, error measurement, and parameter adjustment.
How deep it goes
Derives node calculations and traces layer transformations through task-specific outputs, stopping before parameter learning.
Examples
Uses regression and classification outputs, including a pedestrian-detection probability that crosses a braking threshold.
What you can do after
Understand how fixed network parameters transform an input into a prediction and distinguish prediction from learning.

Read how Timeless Algorithms, The Foundational Ideas explains forward pass →

Math and Architectures of Deep Learning

The layer-by-layer computation, or forward pass, that produces neural-network activations and outputs from an input.

How it is used
Uses layer-by-layer inference to generate neural-network predictions and feed supervised-training loss.
How deep it goes
Derives affine and activation computations, explains sequential evaluation, and demonstrates a PyTorch loop without expanding the full nested function.
Examples
Uses layered MLP equations, a PyTorch forward function, and a two-layer height-and-weight classifier.
What you can do after
Apply it via PyTorch to compute model scores, predictions, and training losses.

Read how Math and Architectures of Deep Learning explains forward pass →

Machines that Think

A forward pass is the computation that propagates inputs through successive neural-network layers to produce an output.

How it is used
Positions forward passes within both neural-network training and inference.
How deep it goes
Explains weighted combinations and activation functions across successive layers without numerical calculations or implementation details.
Examples
Illustrates successive transformations with email classification into personal, work, or spam.
What you can do after
Understand how a network transforms inputs into outputs and distinguish the forward pass's role in training from its role in inference.

Read how Machines that Think explains forward pass →

Deep Learning with JAX

The computation that applies a neural network to input data to produce output activations or predictions.

How it is used
Uses a pure function to apply a JAX neural network to input data and produce predictions.
How deep it goes
Explains layer operations, activation functions, parameter passing, and logits, while deferring training mechanics to gradient transformations.
Examples
Demonstrates a 784-input, two-layer network that returns ten logits for a flattened image.
What you can do after
Build it from scratch by writing a parameterized JAX prediction function and inspecting its output shape.

Read how Deep Learning with JAX explains forward pass →

Applied Reinforcement Learning

A forward pass computes a neural network's output by propagating an input through its layers in order.

How it is used
Computes a network prediction from raw, high-dimensional input as the first stage of the learning loop.
How deep it goes
Describes layer-by-layer weighted sums, biases, and nonlinear activations at a high level.
Examples
Uses images, sensor vectors, medical records, and high-dimensional state descriptions as possible inputs.
What you can do after
Understand how neural networks transform inputs layer by layer into predictions.

Read how Applied Reinforcement Learning explains forward pass →

CUDA for LLMs

A forward pass computes a neural network's outputs from its inputs and parameters.

How it is used
Computes network outputs from inputs and parameters as the forward stage of training.
How deep it goes
Traces matrix equations, cached NumPy layers, and explicit C loops, while leaving CUDA parallelization for later.
Examples
Uses a two-layer NumPy network with ReLU and a C implementation using nested matrix-multiplication loops.
What you can do after
Build a manual forward pass in NumPy or C using matrix multiplication, bias addition, and activation operations.

Read how CUDA for LLMs explains forward pass →

Deep Learning with PyTorch, Second Edition

The stage of model execution that propagates inputs through the network to produce outputs and loss values.

How it is used
Uses the forward pass to turn inputs into predictions and losses during model training.
How deep it goes
Explains its place in training and multi-GPU execution, but does not detail layer-level computations.
Examples
Demonstrates noisy-data parameter estimation and independent processing of batch shards across two GPUs.
What you can do after
Apply it via PyTorch as the first step of a training loop before loss calculation and backpropagation.

Read how Deep Learning with PyTorch, Second Edition explains forward pass →

Also covered in

What to know first

Related concepts

Questions about forward pass

What is forward pass?

A forward pass is a computation that propagates inputs through a model or dependency structure in the forward direction to calculate outputs or intermediate values.

Which Manning books explain forward pass?

Build AI Drug Discovery Pipelines, Statistics Every Programmer Needs, Optimization Algorithms: AI techniques for design, planning, and control problems, Build a DeepSeek Model (From Scratch), Deep Learning with R, Third Edition, Natural Language Processing in Action, Second Edition, Grokking AI Algorithms, Second Edition, Timeless Algorithms, The Foundational Ideas and 6 more.

What should I know before learning forward pass?

Manning books that teach forward pass usually introduce gradient, language model, parameter and objective function first.

What is forward pass also called?

Forward pass is also called forward propagation or forward method.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.