liveBook · Manning

Training

Also called train

Training is the process of fitting a machine-learning model to data by adjusting its parameters or learned representations to improve its performance on a task.

How 32 Manning books explain it

Deep Learning with PyTorch, Second Edition

The optimization phase in which a model learns from examples.

How it is used
Uses training to specialize models for tasks from temperature prediction and image classification to segmentation and diffusion.
How deep it goes
Works through gradient-based updates, minibatch loops, validation, and practical convergence adjustments.
Examples
Uses thermometer readings, bird-versus-airplane images, noise prediction, and CT nodule segmentation as training examples.
What you can do after
Apply it via PyTorch to build training loops, update model parameters, and monitor validation performance.

Read how Deep Learning with PyTorch, Second Edition explains training →

Math and Architectures of Deep Learning

The step of estimating model parameters so the model’s outputs on training inputs match the corresponding targets as closely as possible.

How it is used
Estimates model weights and biases so a selected architecture maps training inputs toward known targets.
How deep it goes
Develops iterative loss minimization through gradient descent, backpropagation, test holdouts, and PyTorch loops while noting convergence limits.
Examples
Uses noisy linear regression, a height-and-weight three-class classifier, and variational autoencoder reconstruction and KL-divergence losses.
What you can do after
Apply it via PyTorch by writing batchwise forward, loss, backward, gradient-reset, and optimizer-update steps.

Read how Math and Architectures of Deep Learning explains training →

Lead Developer Career Guide

The process of acquiring knowledge, understanding, or ability through study, experience, or instruction.

How it is used
Develops specific technical competencies through instruction, hands-on practice, and feedback.
How deep it goes
Explains learner goals, format selection, practice, and feedback, but does not provide a detailed curriculum-design procedure.
Examples
Uses video-versus-documentation comparison, a rewritten timekeeping application, and regular 30-minute practice as concrete tactics.
What you can do after
Practice/perform skill development by choosing an objective, trying a format, applying the skill, and checking what needs more study.

Read how Lead Developer Career Guide explains training →

Deep Learning with Python, Third Edition

The phase during which a model’s parameters are optimized from data before deployment for prediction.

How it is used
Uses training to learn model weights from data and prepare models for prediction.
How deep it goes
Explains batch-level optimization and backpropagation, then develops built-in and custom training-loop workflows.
Examples
Uses MNIST digit classification to demonstrate epochs, batches, and learning-rate tuning.
What you can do after
Build a training loop from scratch or apply training through Keras compile() and fit().

Read how Deep Learning with Python, Third Edition explains training →

Machines that Think

Learning is the acquisition or improvement of knowledge, representations, or capabilities through experience or data.

How it is used
Explains how training turns data into model capabilities and frames comparisons with human learning.
How deep it goes
Outlines parameter updates, batches, epochs, and distributed training without providing an implementation.
Examples
Contrasts a child learning from a falling glass with language-model training on large datasets.
What you can do after
Evaluate model behavior by distinguishing generalization from memorization and plausible outputs from verified facts.

Read how Machines that Think explains training →

Inside Deep Learning: Math, Algorithms, Models

The process of fitting a model's parameters on data to improve performance on a task.

How it is used
Uses loss minimization as the reusable basis for fitting regression models, classifiers, and neural networks.
How deep it goes
Works from loss-minimization notation through a batch-by-batch PyTorch loop, then adapts that loop for GANs and Faster R-CNN.
Examples
Uses linear and logistic regression as starting models, plus alternating GAN updates and a custom Faster R-CNN loop.
What you can do after
Build it from scratch in PyTorch as a reusable training loop, adapting updates or loss handling when a model requires it.

Read how Inside Deep Learning: Math, Algorithms, Models explains training →

Classic Computer Science Problems in Swift: Essential techniques for practicing programmers

Training is the process of fitting a machine-learning model by providing examples and adjusting its parameters to reduce output error.

How it is used
Fits neural-network weights from labeled examples so the network can classify inputs it has not trained on.
How deep it goes
Works through repeated training and validation in Swift, with backpropagation and weight updates explained without formal derivations.
Examples
Trains on iris measurements and wine samples, then checks predictions against reserved examples.
What you can do after
Build it from scratch with a Swift Network and validate iris or wine classifications on held-out samples.

Read how Classic Computer Science Problems in Swift: Essential techniques for practicing programmers explains training →

Build AI Drug Discovery Pipelines

Model training is the process of fitting a model to learn a mapping from input features to target labels or values.

How it is used
Places training after featurization and before evaluation in a drug-discovery prediction workflow.
How deep it goes
Defines fitting and works through classifier training and neural-network updates, while deferring SGDClassifier internals.
Examples
Uses molecular fingerprints and hERG blocker labels for a linear classifier, plus training and validation loss for a neural network.
What you can do after
Apply training via Scikit-Learn’s SGDClassifier and PyTorch, then monitor fit and validation loss.

Read how Build AI Drug Discovery Pipelines explains training →

Machine Learning Platform Engineering

Model training is the process of fitting a machine learning model to data by optimizing its parameters according to a training objective.

How it is used
Places model fitting in an automated pipeline between prepared data and evaluation.
How deep it goes
Works through component responsibilities, a YOLO training call, configuration choices, and artifacts, but not the recommender algorithm’s details.
Examples
Uses an ID card detector trained with YOLO and a movie recommender trained from split Parquet data.
What you can do after
Apply it via Ultralytics YOLO and pipeline components to run reproducible training and inspect validation artifacts.

Read how Machine Learning Platform Engineering explains training →

CUDA for LLMs

Model training is the process of adjusting a model's parameters using data and an optimization procedure.

How it is used
Uses training as a parallel-workload contrast for sequential transformer inference and CUDA kernel design.
How deep it goes
Explains sequence-level attention parallelism and shows forward loss calculation, without demonstrating an optimization procedure.
Examples
Uses a 64-token transformer configuration and a PyTorch forward pass that computes loss from targets.
What you can do after
Supports evaluating how training and inference differ in sequence parallelism and kernel requirements.

Read how CUDA for LLMs explains training →

Grokking AI Applications

Model training is the iterative optimization process that learns parameter values from examples to improve predictions.

How it is used
Frames training as the stage before GPT-3 sentence-completion inference.
How deep it goes
Explains how deep networks learn hierarchical representations, but gives no optimization procedure or parameter-update details.
What you can do after
Understand training as the stage in which deep networks learn hierarchical representations.

Read how Grokking AI Applications explains training →

Outlier Detection in Python

The process of fitting a model to data so that it learns parameters or patterns.

How it is used
Establishes a reference for normality against which current or later records are evaluated.
How deep it goes
Defines fitting, contrasts model representations, and discusses data representativeness, refitting, and sample-size trade-offs.
Examples
Uses ongoing sensor readings and financial audits to illustrate comparisons with current or prior-period baselines.
What you can do after
Apply it by fitting a model to typical data, then comparing incoming records against the learned reference.

Read how Outlier Detection in Python explains training →

Local Image Generation

Training is the process of adjusting a model's learned parameters from examples so that it performs a desired task.

How it is used
Uses training to customize image generation with a subject- or style-focused LoRA.
How deep it goes
Explains examples, learn-mode inputs, repeated weight updates, and a practical LoRA workflow without deeper optimization internals.
Examples
Uses captioned images, noisy reconstruction, a Keats LoRA, baseline samples, and checkpoint comparison.
What you can do after
Apply it via AI-Toolkit to train a Flux LoRA from labeled images and evaluate sample checkpoints.

Read how Local Image Generation explains training →

Think Like a Software Engineering Manager

Training is the structured acquisition or improvement of knowledge and skills through instruction, practice, or guided learning.

How it is used
Uses targeted learning to build team skills, address performance gaps, and prepare people for delegated work.
How deep it goes
Explains identifying skill gaps, selecting resources, and reassessing assignments when gaps exceed what support can bridge.
Examples
Uses leadership seminars, pair-programming, and learning resources as examples of training support.
What you can do after
Practice/perform targeted support by matching skill gaps with resources or mentorship and reconsidering tasks when gaps are too large.

Read how Think Like a Software Engineering Manager explains training →

LLMs in Production

Training is the process of optimizing a machine-learning model's parameters from data so it learns a desired behavior or capability.

How it is used
Uses training as a route to model control and as a practical part of implementing Llama 3.
How deep it goes
Connects training to data quality and resource limits, without detailing optimization mechanics.
Examples
Uses a Llama 3 implementation and a game studio seeking to fix model behavior.
What you can do after
Build and productionize a modest model while recognizing the limits imposed by data and GPU resources.

Read how LLMs in Production explains training →

Learn AI-Assisted Python Programming, Second Edition

Model training is the process of fitting an artificial-intelligence model to patterns in data so it can produce outputs for new inputs.

How it is used
Frames AI training as the one-time learning stage behind repeated code generation and prediction.
How deep it goes
Defines training through corpus size and reuse, then stops short of explaining model internals.
Examples
Uses Copilot's code corpus, outdated Python print syntax, and a square-area program as concrete examples.
What you can do after
Diagnose generated-code mistakes by checking suggestions against the active Python version and testing them.

Read how Learn AI-Assisted Python Programming, Second Edition explains training →

Build a Reasoning Model (From Scratch)

A method that improves model behavior by further updating the model through training.

How it is used
Improves reasoning behavior by changing model weights after baseline evaluation.
How deep it goes
Outlines the workflow and names reinforcement learning and distillation, but defers their implementation details.
Examples
Uses a conventional pretrained LLM, evaluation tools, and reinforcement-learning or distillation workflows as concrete anchors.
What you can do after
Evaluate whether additional training improves reasoning behavior and understand its place in the model-building workflow.

Read how Build a Reasoning Model (From Scratch) explains training →

Learn Generative AI with PyTorch

The iterative process of feeding data through a model, computing loss, and updating parameters.

How it is used
Trains image and text generators to produce outputs resembling examples in their training data.
How deep it goes
Details alternating GAN updates and output checks, while describing LSTM and GPT training at a higher level.
Examples
Uses a clothing-image GAN, an LSTM text generator, and three Hemingway novels for GPT training.
What you can do after
Build it from scratch by iterating over batches, alternating discriminator and generator updates, and inspecting generated images.

Read how Learn Generative AI with PyTorch explains training →

Deep Learning with R, Third Edition

Training is the process of adjusting a machine-learning model's parameters using data and an optimization procedure.

How it is used
Uses examples and measured output error as feedback to adjust a model toward useful predictions.
How deep it goes
Defines feedback-driven learning and links neural-network weight updates to loss minimization and gradient descent, without deriving the optimization.
Examples
Uses speech recognition, image tagging, image denoising, and next-word prediction as training examples.
What you can do after
Understand how examples, loss, and weight updates work together to train a neural network.

Read how Deep Learning with R, Third Edition explains training →

The AI Pocket Book

The process of fitting a model using data and computation.

How it is used
Explains how machine-learning models acquire useful parameter values after engineers design their architecture.
How deep it goes
Explains architecture, parameters, data-guided adjustment, and resource demands without detailing the optimization algorithm’s internals.
Examples
Uses token-to-vector dictionaries, a PyTorch embedding-and-projection model, and measured electricity comparisons for generated outputs.
What you can do after
Evaluate how a model’s architecture and data-guided parameter fitting produce task performance and resource costs.

Read how The AI Pocket Book explains training →

Statistics Every Programmer Needs

fit is an estimator method that learns model parameters or structure from supplied training data.

How it is used
Uses fitting to train classifiers and time-series models on supplied data.
How deep it goes
Explains tree construction and ARIMA parameter estimation, but does not detail the fitting algorithms’ internals.
Examples
Demonstrates fitting a decision tree, an ARIMA model, and a logistic regression to training data.
What you can do after
Apply via scikit-learn or statsmodels to fit configured models to training data.

Read how Statistics Every Programmer Needs explains training →

Grokking AI Algorithms, Second Edition

Training is the process of adjusting a model's parameters using examples so that its predictions better match desired outcomes.

How it is used
Uses examples to adjust ANN weights and to teach LLMs relationships among text tokens.
How deep it goes
Explains ANN cost, initialization, weight updates, and stopping, while outlining the LLM workflow without its update mechanics.
Examples
Traces an ANN prediction of 0.7 against a target of 1.0 and outlines text-to-token-ID processing for an LLM.
What you can do after
Apply gradient descent to adjust ANN weights from prediction error and describe the main stages of an LLM training workflow.

Read how Grokking AI Algorithms, Second Edition explains training →

AI-Powered Search

Training is the process of optimizing a model's parameters from data so that it learns representations or predictive behavior.

How it is used
Uses training to fit search ranking models for relevance and to create foundation-model weights from large datasets.
How deep it goes
Details feature selection, data splitting, model upload, and offline evaluation; describes masked-token pretraining but not its optimization internals.
Examples
Uses description-field search features and judged sessions, plus masked-token prediction and domain-specific text or code.
What you can do after
Evaluate ranking models on held-out queries and assess live-user performance through an A/B test.

Read how AI-Powered Search explains training →

Fundamentals of Cybersecurity

Training is guided instruction and practice that develops the practical, role-specific skills needed to perform security-related tasks.

How it is used
Develops practical, role-specific skills for performing security-related tasks.
How deep it goes
Explains role tailoring and several practice formats, but does not provide a complete training plan.
Examples
Uses phishing recognition, secure system configuration, backup restoration, and incident-response exercises as practical examples.
What you can do after
Practice role-specific security tasks through hands-on activities, simulations, and realistic scenarios.

Read how Fundamentals of Cybersecurity explains training →

Machine Learning System Design

Model training is the process of fitting a machine learning model to data by adjusting its learned parameters.

How it is used
Uses training as the core step in a pipeline that turns prepared data into a trained model.
How deep it goes
Outlines pipeline stages and identifies training as complex, while leaving data fetching details and inference pipelines aside.
Examples
Uses feature selection as training-specific preprocessing and neural-network gradient descent to illustrate repeated inference steps.
What you can do after
Build a trained model from preprocessed data as one step in a larger pipeline.

Read how Machine Learning System Design explains training →

Graph Neural Networks in Action

Model training is the optimization process that fits a machine-learning model to data by adjusting its parameters.

How it is used
Uses training to fit GNNs to preprocessed graph data before evaluating their predictions.
How deep it goes
Details optimizer setup, epoch-level updates, validation, loss tracking, and testing without deriving the optimization algorithm.
Examples
Compares GCN and GraphSAGE on the same data and evaluates predictions of product categories.
What you can do after
Apply the PyTorch training loop to update GNN weights, monitor validation losses, and test generalization.

Read how Graph Neural Networks in Action explains training →

Advanced Algorithms and Data Structures

Training is the process of fitting a model's parameters from data so that the model approximates the desired relation.

How it is used
Fits a model’s parameters by reducing prediction error on training data with gradient descent.
How deep it goes
Defines parameter fitting through squared-error loss and gradient descent, while deferring training-set selection details.
Examples
Uses a line fitted to data points, minimizing squared vertical errors by adjusting its slope and intercept.
What you can do after
Apply gradient descent to adjust a line’s slope and intercept toward lower squared prediction error.

Read how Advanced Algorithms and Data Structures explains training →

The Complete Obsolete Guide to Generative AI

Model training is the process of fitting a model by exposing it to data so it learns patterns for making predictions or generating outputs.

How it is used
Fits generative models to data so they can predict text or create new text, images, audio, and video.
How deep it goes
Explains data gathering, pattern learning, numerical representation, feedback, and iteration, while stopping short of detailed mathematics.
Examples
Uses internet text, personal writing processed with llama_index, and audio, image, and video collections as training examples.
What you can do after
Understand how to train models with existing data and domain constraints, then verify generated results for accuracy.

Read how The Complete Obsolete Guide to Generative AI explains training →

Coding with AI

Training is the process of adjusting a machine-learning model by analyzing data so it learns statistical patterns.

How it is used
Explains how models learn language and code patterns, framing data quality as a cause of unreliable generated code.
How deep it goes
Defines training through pattern learning, then traces flawed data to hallucinations and Python coding biases.
Examples
Uses mixed-quality coding examples and Python tendencies such as list preference, edge-case failures, and outdated pre-3.6 patterns.
What you can do after
Evaluate generated code by checking correctness, edge cases, Python practices, and fit with project architecture.

Read how Coding with AI explains training →

Build an Advanced RAG Application (From Scratch)

Model training is the process of optimizing a model's parameters from data so that it learns a target task or distribution.

How it is used
Optimizes LLM parameters from language data to support language understanding and generation for NLP applications.
How deep it goes
Defines next-word prediction, weights, biases, iterative adjustment, and compute costs without specifying an optimization algorithm.
Examples
Uses human-language data, next-word prediction, chatbots, summarization, content generation, and sentiment analysis.
What you can do after
Evaluate/understand how data exposure and parameter updates improve language-pattern predictions and inform compute planning.

Read how Build an Advanced RAG Application (From Scratch) explains training →

Build a Large Language Model (From Scratch)

The process of optimizing model parameters using data so the model learns the desired behavior.

How it is used
Converts an untrained GPT model into a coherent text generator by optimizing parameters with data.
How deep it goes
Connects training to parameter optimization and generation quality but does not detail objectives, data flow, or implementation steps.
Examples
Uses GPT models ranging from 124 million to 1,542 million parameters to illustrate shared implementation across scales.
What you can do after
Evaluate whether training is necessary for coherent text generation from a GPT-like model.

Read how Build a Large Language Model (From Scratch) explains training →

Timeless Algorithms, The Foundational Ideas

Training is the process of fitting a model by adjusting its parameters using data.

How it is used
Connects information measurement to learning by using cross-entropy as a guide for model training.
How deep it goes
Makes a conceptual connection but does not detail parameter updates, optimization, or a training procedure.
Examples
Uses cross-entropy's shift from information measurement to training guidance as its example.

Read how Timeless Algorithms, The Foundational Ideas explains training →

Also covered in

What to know first

Related concepts

Questions about training

What is training?

Training is the process of fitting a machine-learning model to data by adjusting its parameters or learned representations to improve its performance on a task.

Which Manning books explain training?

Deep Learning with PyTorch, Second Edition, Math and Architectures of Deep Learning, Lead Developer Career Guide, Deep Learning with Python, Third Edition, Machines that Think, Inside Deep Learning: Math, Algorithms, Models, Classic Computer Science Problems in Swift: Essential techniques for practicing programmers, Build AI Drug Discovery Pipelines and 24 more.

What should I know before learning training?

Manning books that teach training usually introduce language model, machine learning, parameter and embedding first.

What is the difference between training and inference?

Training is the process of fitting a machine-learning model to data by adjusting its parameters or learned representations to improve its performance on a task. Inference is the process of applying a trained model to input data to produce predictions or other outputs.

What kinds of training are there?

Kinds of training include recovery training and reward model training.

What is training also called?

Training is also called train.

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.