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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
- Distributed Machine Learning Patterns
- Designing Deep Learning Systems: A guide for software engineers
- How Large Language Models Work
- Software Engineering for Data ScientistsIn early access (MEAP)
- Understanding AIIn early access (MEAP)
- Interview Speak
- Python Workout, Second Edition
- Deep Learning with JAX
- Practices of the Python Pro
- AI Agents in Action
- Data Storytelling with Altair and AI
- Demand Forecasting Best Practices
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- machine learningMachine learning is a field of computational methods in which systems learn patterns or relationships from data to make predictions, decisions, or other outputs.
- parameterA parameter is a value or named input that specifies or influences the behavior, computation, or output of a function, model, or system.
- embeddingAn embedding is a numerical vector representation of an item in a feature space, encoding selected properties or relationships for computational tasks such as comparison or retrieval.
Related concepts
- checkpointingproduces · Checkpointing is the recording of an intermediate state or progress point in a process to support recovery, resumption, inspection, or control.
- hyperparameteruses · A hyperparameter is a setting chosen outside ordinary parameter learning that controls a model, algorithm, or learning procedure.
- inferencecontrasts with · Inference is the process of applying a trained model to input data to produce predictions or other outputs.
- reward model trainingincludes · Reward model training fits a model to estimate the desirability of outputs or actions from preference judgments or other labeled examples.
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.































