Training
Model training is the process of fitting a machine-learning model to data by adjusting its parameters or structure to perform a task.
Deep Learning with PyTorch, Second Edition
The optimization phase in which a model learns from examples.
- How it is used
- Fits model parameters to examples for prediction, classification, noise prediction, and segmentation.
- How deep it goes
- Works through parameter updates, epochs, minibatches, loss, gradients, optimizers, and validation in executable loops.
- Examples
- Uses a linear temperature fit, a bird-versus-airplane classifier, noise prediction, and CT-image segmentation.
- What you can do after
- Build it from scratch: write a PyTorch training loop and adapt its data, model, and loss to different tasks.
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
- Turns examples and feedback into model weights used for prediction, rather than requiring hand-written task rules.
- How deep it goes
- Works through batches, forward passes, losses, gradient updates, epochs, and custom loops, with practical guidance for stalled fitting.
- Examples
- Uses an MNIST learning-rate comparison, a hand-written epoch loop, and Keras `fit()` customization.
- What you can do after
- Build it from scratch as a training loop, or apply it via Keras `compile()` and `fit()` and diagnose a stalled run.
Read how Deep Learning with Python, Third Edition 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
- Fits neural-network parameters on labeled examples to reduce task loss and improve predictions.
- How deep it goes
- Defines notation and the loss-minimization objective, then connects minimization to gradient descent and automatic differentiation.
- Examples
- Uses CNN experiments with CIFAR10 and MNIST, varying epochs, layers, pooling, filters, and image transforms.
- What you can do after
- Apply it via PyTorch by computing loss, obtaining gradients, updating parameters, and comparing experimental model choices.
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.
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 →
Grokking AI Applications
Model training is the iterative optimization process that learns parameter values from examples to improve predictions.
- How it is used
- Explains how neural networks acquire parameters and later use them to generate predictions.
- How deep it goes
- Explains layers, neurons, parameters, and hierarchical representations, but does not detail optimization algorithms.
- Examples
- Uses GPT-3’s training-to-inference stages, Italy-to-Rome prediction, and pretrained-model fine-tuning.
- What you can do after
- Evaluate the difference between training, inference, and fine-tuning in a language-model workflow.
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.
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.
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 →
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 →
Related concepts
- training datasetuses · A training dataset is a collection of examples or data used by a learning procedure to fit or adapt a model.
- objective functionuses · An objective function is a mathematical function or criterion that assigns values to candidate solutions or parameter settings and is optimized toward a specified goal.
- parameterproduces · A parameter is a value or variable that specifies or controls a characteristic, computation, or behavior of a function, model, operation, or request.
- epochhas part · In machine learning, an epoch is one complete pass through the training data during model training or optimization.
- language modelproduces · A language model is a computational model that represents patterns in linguistic tokens to estimate their probabilities and predict or generate sequences of them.
- hyperparameterconfigured by · A hyperparameter is a configuration value chosen outside ordinary parameter learning that governs a model, algorithm, or learning procedure.
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.