liveBook · Manning

Parameter

A parameter is a value or named input that specifies or influences the behavior, computation, or output of a function, model, or system.

How 41 Manning books explain it

Grokking Machine Learning

A numerical model parameter that multiplies a corresponding feature and determines its contribution to the prediction.

How it is used
Uses weights and bias to turn features into regression predictions and classification scores.
How deep it goes
Defines parameters through worked predictions and sketches repeated weight updates, while deferring update-size and stopping-rule explanations beyond the initial procedure.
Examples
Works through room-count housing prices, word-count sentiment scores, and inspected IMDB review coefficients.
What you can do after
Build it from scratch: adjust a simple regression model’s weight and bias to improve housing-price predictions.

Read how Grokking Machine Learning explains parameter →

Deep Learning with PyTorch, Second Edition

A learnable numeric value in a model.

How it is used
Uses parameters as adjustable model values fitted to data, from thermometer calibration to neural networks and pretrained image recognition.
How deep it goes
Works through loss, gradients and iterative updates, then demonstrates parameter tracking, inspection and persistence in PyTorch modules.
Examples
Fits a linear thermometer calibration model and inspects parameters in linear and convolutional layers.
What you can do after
Apply it via PyTorch to supply model parameters to an optimizer, inspect them and save or reload trained values.

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

Natural Language Processing in Action, Second Edition

A weight is a learned numerical parameter that controls the contribution of an input or connection in a neural network.

How it is used
Uses weights to explain how neural networks combine inputs, learn from error, and scale to language models.
How deep it goes
Works from weighted sums through optimization and recurrent weight sharing, using error surfaces to explain local minima.
Examples
Uses a word-count perceptron and a PyTorch name-classification model to demonstrate weighted predictions and training.
What you can do after
Apply weights via PyTorch to train a classification model with a loss function and stochastic gradient descent.

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

Math and Architectures of Deep Learning

The tunable values of a model estimated from data.

How it is used
Defines the values training estimates to turn a chosen model architecture or distribution family into a usable predictor.
How deep it goes
Explains weights, biases, matrices, distribution parameters, iterative fitting, maximum likelihood, and Bayesian posteriors; defers gradient-adjustment details in the initial algorithm.
Examples
Uses a cat threat-score weighted sum, neural-layer weight matrices, convolution kernels, GMM point clouds, and a small-sample Gaussian height model.
What you can do after
Evaluate/understand how trained weights, biases, and distribution values determine model outputs and why fitting procedures estimate them from data.

Read how Math and Architectures of Deep Learning explains parameter →

Grokking AI Algorithms, Second Edition

A neural network weight is a learned numerical parameter that determines the strength of a connection or contribution between network units.

How it is used
Uses weights to control signal contributions and encode patterns learned by neural networks.
How deep it goes
Works through weighted sums, matrix projection, initialization, and training updates, with an intuitive account of vanishing and exploding gradients.
Examples
Illustrates weights with apartment-rental prediction and a four-input, eight-output projection calculation.
What you can do after
Evaluate how changing weights affects predictions and how initialization can influence learning.

Read how Grokking AI Algorithms, Second Edition explains parameter →

Timeless Algorithms, The Foundational Ideas

A parameter is a quantity that determines aspects of a model’s behavior.

How it is used
Uses parameters to explain how models produce predictions, learn representations, and trade off margin violations.
How deep it goes
Explains coefficients and neural-network updates mathematically, and compares illustrative soft-margin objectives under different penalties.
Examples
Illustrates logistic probabilities for specified coefficients and compares three candidate boundaries under different slack penalties.
What you can do after
Evaluate and understand how parameter values affect predictions, training, model capacity, and boundary selection.

Read how Timeless Algorithms, The Foundational Ideas explains parameter →

Outlier Detection in Python

A configurable value that controls the behavior or fitting of a model or algorithm.

How it is used
Controls outlier-detector behavior and provides a setting to compare when selecting and evaluating detectors.
How deep it goes
Explains tuning through neighbor-count experiments, decision boundaries, and score averaging; cautions that 2D plots rarely determine settings for higher-dimensional data.
Examples
Compares KNN neighbor counts on clustered synthetic data and plots how k changes scored regions.
What you can do after
Operate/configure outlier detectors by testing plausible settings, interpreting score changes, and averaging across parameter values when appropriate.

Read how Outlier Detection in Python explains parameter →

The Design of Web APIs, Second Edition

A query parameter is a named value in the query component of a URI that conveys nonhierarchical request data and can contribute to resource identification.

How it is used
Places search filters and other resource modifiers in URI queries while keeping hierarchical identifiers in paths.
How deep it goes
Defines query syntax, works through placement and filter choices, and specifies array serialization; defers long-URL workarounds.
Examples
Uses product searches, transaction filters, and a keyword-array OpenAPI listing to demonstrate query values and their serialization.
What you can do after
Apply it via OpenAPI to describe query inputs and choose consumer-friendly filters and array serialization.

Read how The Design of Web APIs, Second Edition explains parameter →

Causal AI

A weight parameter is a learned numerical coefficient that controls the contribution of an input in a machine-learning function or model.

How it is used
Specifies distribution instances and causal Markov kernels so their values can be estimated before causal inference.
How deep it goes
Works through probability constraints, fitting objectives, Bayesian estimation, and kernel modularity; does not derive general optimization algorithms.
Examples
Uses a three-outcome die, residence probabilities conditional on education, and an online-game causal model.
What you can do after
Apply it via pgmpy to specify or fit distribution parameters, then use estimated kernels in a causal inference workflow.

Read how Causal AI explains parameter →

Learn Go with Pocket-Sized Projects

A query parameter is an optional key-value component of a URL that supplies filtering or other request options to an API.

How it is used
Uses optional query parameters to filter API requests and supply choices such as game language or a displayed week.
How deep it goes
Explains query syntax and Go retrieval through a handler, leaving language-specific game creation as a TODO.
Examples
Shows `lang=en` for game creation and proposes a `week` parameter for habit-tracker navigation.
What you can do after
Apply it via Go's `net/http` request URL to retrieve optional query values and plan defaults and request tests.

Read how Learn Go with Pocket-Sized Projects explains parameter →

Deep Learning with R, Third Edition

A weight is a learned numerical parameter that determines part of a neural-network transformation, including an embedding lookup.

How it is used
Explains how learned values determine layer transformations and store information acquired from training data.
How deep it goes
Traces random initialization, forward passes, loss calculation, and weight updates, while introducing kernel and bias tensors.
Examples
Uses a bag-of-words movie-review model and a layer with a kernel, bias, and ReLU.
What you can do after
Evaluate how parameter values affect predictions and distinguish trainable weights from other model weights.

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

Learn Generative AI with PyTorch

The learned numerical parameters of a neural network model after or during training.

How it is used
Uses parameters to connect model training with pretrained-weight reuse for text generation.
How deep it goes
Explains gradient-based updates and walks through copying pretrained tensors, including shape checks and transposition.
Examples
Illustrates parameters with dense image classification, shared convolutional filters, and GPT-2XL feed-forward weight matrices.
What you can do after
Apply pretrained weights via PyTorch and Hugging Face transformers, checking tensor shapes and transposing selected matrices before copying.

Read how Learn Generative AI with PyTorch explains parameter →

.NET in Action, Second Edition

A query parameter is a key-value input appended to a URL that supplies options or filters for a web request.

How it is used
Supplies optional rendering choices and paging, filtering, or sorting inputs to ASP.NET Core endpoints.
How deep it goes
Explains name-based binding, nullable optionality, conversion failures, and handler defaults through implementations; does not detail the binding internals.
Examples
Uses an ASCII-art font selector and a font-list endpoint with skip, take, name, direction, and order inputs.
What you can do after
Build it from scratch in a minimal API: accept optional query inputs and apply them to rendering or collection results.

Read how .NET in Action, Second Edition explains parameter →

Deep Learning with JAX

The model parameters stored in a training state and updated by an optimizer during training.

How it is used
Separates learned model state from pure prediction, loss, gradient, and update functions throughout a JAX training workflow.
How deep it goes
Defines parameters as weights and biases, shows initialization and updates, and stops short of optimizer-library internals.
Examples
Uses MNIST-sized dense layers, randomly initialized weights and biases, prediction logits, and mini-batch gradient updates.
What you can do after
Build it from scratch by initializing, passing, differentiating, updating, saving, and restoring parameter pytrees.

Read how Deep Learning with JAX explains parameter →

Prompt Engineering in Practice

A model parameter is a setting that controls a model's behavior when generating an output.

How it is used
Separates changing runtime inputs from stable prompt instructions so one template can handle recurring engineering tasks.
How deep it goes
Defines placeholder substitution, compares two syntaxes, and works through a filled release-note prompt; does not describe model-internal parameters.
Examples
Uses release notes with version and change fields, plus refactor planning that injects assessment answers into a second prompt.
What you can do after
Build it from scratch: define a reusable prompt template, fill its named inputs, and test it across varied cases.

Read how Prompt Engineering in Practice explains parameter →

Build AI Drug Discovery Pipelines

A model parameter is a numerical value that governs a model's mapping from inputs to outputs and is typically learned from data.

How it is used
Uses learned numerical values to map molecular features to predicted properties such as solubility, hERG blocking, or EGFR activity.
How deep it goes
Explains weights, bias, loss-driven updates, validation monitoring, and frozen inference while deferring formal distribution theory.
Examples
Demonstrates parameters with RDKit descriptors for solubility and Morgan fingerprints for EGFR activity prediction.
What you can do after
Build it from scratch by configuring a training loop that computes loss, propagates gradients, updates parameters, and evaluates validation performance.

Read how Build AI Drug Discovery Pipelines explains parameter →

Data Analysis with LLMs

A model parameter is a learned numerical value that determines a machine-learning model's behavior.

How it is used
Explains why trained models behave differently and why released models can be run locally while closed models are accessed through a provider.
How deep it goes
Identifies parameters as values produced by training, without explaining their mathematical structure or how training calculates them.
Examples
Contrasts privately held GPT-4o parameter values with released models that can run on dedicated infrastructure.
What you can do after
Evaluate/understand whether access to a model’s learned values matters when choosing hosted or local deployment.

Read how Data Analysis with LLMs explains parameter →

Building Specialized AI Systems

A learned numerical value that controls a model's computation.

How it is used
Explains the numerical values adjusted during training and selectively modified to specialize pretrained LLMs.
How deep it goes
Defines parameters as weights and biases, then works through loss-guided gradient-descent updates without detailing full optimization internals.
Examples
Uses trillion-scale LLMs, refund-response prompt-completion pairs, and a positive sentiment prediction with 30% probability.
What you can do after
Evaluate/understand how loss-guided updates and careful fine-tuning alter model behavior without rebuilding a model from scratch.

Read how Building Specialized AI Systems explains parameter →

The Well-Grounded Python Developer: How the pros use Python and Flask

A query string is the portion of a URL containing parameters appended after a question mark.

How it is used
Defines inputs to Python APIs and shows how a URL query-string value selects behavior in a blog-post handler.
How deep it goes
Explains positional and keyword inputs through calls and defaults, but does not develop URL query-string parsing.
Examples
Uses print, a full-name function, and a blog-post handler whose action query value selects a creation form.
What you can do after
Apply it to design callable functions with clear required and optional inputs and understand action-based blog-post requests.

Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains parameter →

Inside Deep Learning: Math, Algorithms, Models

A numerical value that controls a model's computation and may be selected or updated during learning.

How it is used
Uses parameters as the values adjusted to reduce a model’s loss during learning.
How deep it goes
Defines parameters, maps them to PyTorch objects, and demonstrates an SGD loop without detailing optimizer internals.
Examples
Demonstrates minimizing (x−2)² with SGD and representing linear regression with weight and bias parameters.
What you can do after
Apply via PyTorch by wrapping a tensor as nn.Parameter and updating it through an SGD training loop.

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

Grokking Bayes

A parameter is a quantity that controls the behavior of a model or probability distribution.

How it is used
Uses parameters to control distributions and models while expressing uncertainty about unknown values.
How deep it goes
Defines a distribution parameter with a worked Bernoulli example and develops a regression slope through its prior and likelihood.
Examples
Illustrates parameters with rain probability, a house-price slope, school coaching effects, and neural-network weights and biases.
What you can do after
Evaluate/understand how parameter choices affect probabilities or predictions and why uncertain parameters can be represented by distributions.

Read how Grokking Bayes explains parameter →

Build Python Web Apps with Streamlit

A query parameter is a named key-value item in a URL query string that conveys request information or application state.

How it is used
Enables deep links by synchronizing Streamlit widget state with values embedded in a URL.
How deep it goes
Defines URL structure and implements reading, writing, initialization, filtering, serialization, and type conversion.
Examples
Uses search URLs, dashboard date ranges, product filters, chart dimensions, and serialized lists and dates.
What you can do after
Build it from scratch with st.query_params to create shareable Streamlit dashboard links that restore widget selections.

Read how Build Python Web Apps with Streamlit explains parameter →

Software Testing with Generative AI

A learned numerical value that contributes to a model's statistical computations.

How it is used
Uses statistical weights and their parameter count to compare LLM scale, expected performance, and running cost.
How deep it goes
Defines weights and parameter counts, then stops short of explaining their mathematical or training mechanics.
Examples
Contrasts LLMs described as having 175 billion or 1 trillion parameters.
What you can do after
Evaluate/understand model-size claims without treating parameter count as a complete measure of quality.

Read how Software Testing with Generative AI explains parameter →

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

A fixed input value that specifies an optimization problem without being selected as a decision variable.

How it is used
Specifies fixed conditions in an optimization formulation while separating them from values selected during the search.
How deep it goes
Defines parameters through a ticket-pricing objective and distinguishes them from decision variables and boundary constraints.
Examples
Uses fixed costs, variable costs, ticket price, demand, and profit in an event-pricing formulation.
What you can do after
Evaluate optimization formulations by identifying fixed inputs, decision variables, objectives, and variable bounds.

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

Build a Large Language Model (From Scratch)

An adjustable value in a neural network that is learned during training.

How it is used
Uses trainable parameters to optimize an LLM during pretraining and later load weights for continued training or fine-tuning.
How deep it goes
Defines weights as trainable values and shows PyTorch access, but does not explain parameter-update mathematics or tensor shapes.
Examples
Uses a torch.nn.Linear layer, its .weight attribute, and model.parameters() as concrete parameter-access examples.
What you can do after
Apply it via PyTorch by inspecting layer weights and collecting model weights and biases for training.

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

Deep Learning with Python, Third Edition

A model parameter that is updated by backpropagation during training.

How it is used
Uses parameters to explain how neural networks learn transformations from training examples.
How deep it goes
Defines parameters, relates them to loss and backpropagation, and demonstrates PyTorch tracking without deriving gradient updates internally.
Examples
Uses PyTorch Parameter construction, linear regression, pretrained RoBERTa weights, and parameter-count summaries.
What you can do after
Evaluate trainable state, create a PyTorch Parameter, and understand how optimization changes model weights.

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

Distributed Machine Learning Patterns

A model parameter is a learned numerical value in a machine learning model that determines the model's behavior.

How it is used
Explains how learned values are updated during model training and coordinated across distributed workers.
How deep it goes
Defines parameters as weights and biases, then follows their gradient-driven updates through parameter-server and allreduce architectures.
Examples
Uses LeNet video classification, Fashion-MNIST training, worker data partitions, and replicated parameter copies as concrete examples.
What you can do after
Evaluate/understand how training parameters are represented, updated, replicated, and synchronized across workers.

Read how Distributed Machine Learning Patterns explains parameter →

Sutskever's List

A learned numerical value in a model, such as a weight or bias, that is adjusted during training.

How it is used
Defines learned weights and biases, then uses parameter counts to discuss model cost, overfitting, and data allocation.
How deep it goes
Defines weights and biases and relates parameter counts to engineering costs and token-to-parameter scaling.
Examples
Uses AlexNet's 60 million parameters and GPT-3's 175 billion parameters alongside their training contexts.
What you can do after
Evaluate model-size and data trade-offs by comparing parameter counts with training-token budgets.

Read how Sutskever's List explains parameter →

Machines that Think

A value specified or learned within a model that helps determine its behavior.

How it is used
Connects learned weights to model capacity and the transformation of inputs into outputs.
How deep it goes
Explains representational capacity, layer-level effects, and the distinction between parameter updates and inference-time conditioning.
Examples
Contrasts post-training events and omitted documents with information supplied in a prompt.
What you can do after
Enables evaluation of whether model size or available information supports a claim about capability or reliability.

Read how Machines that Think explains parameter →

Transformers in Action

A model parameter is a learned numerical value within a model that is optimized from training data.

How it is used
Uses parameters as the learned values adjusted when training and adapting language models.
How deep it goes
Explains gradient-based updates and low-rank matrix dimensions, including the distinction between illustrative SVD and learned adaptation matrices.
Examples
Illustrates a rank-5 approximation of a 6 × 6 weight matrix using singular value decomposition.
What you can do after
Evaluate how learning rates affect parameter updates and how low-rank adaptation changes which weights are trained.

Read how Transformers in Action explains parameter →

The AI Pocket Book

A learned model value optimized during training rather than fixed by hand.

How it is used
Defines the adjustable numerical values that let machine-learning models learn from data instead of relying on hand-written rules.
How deep it goes
Explains parameters through embeddings, projection matrices, parameter counts, and training, but avoids optimization derivations.
Examples
Uses token embedding tables, projection layers, billion-parameter counts, and a short PyTorch model as concrete examples.
What you can do after
Evaluate which model values are learned, estimate their counts, and distinguish parameterized operations from architecture choices.

Read how The AI Pocket Book explains parameter →

Machine Learning Algorithms in Depth

A weight matrix is a matrix of learned coefficients that parameterizes connections between neural-network units.

How it is used
Represents learned neural-network connections as parameters whose values change during training.
How deep it goes
Explains parameter updates through mini-batch gradients and learning rates, without detailing a weight matrix’s dimensions or individual entries.
Examples
Uses a Keras/TensorFlow convolutional network on CIFAR-100 to compare optimizers through loss and validation-accuracy curves.
What you can do after
Evaluate/understand how gradient direction and learning rate affect updates to neural-network parameters.

Read how Machine Learning Algorithms in Depth explains parameter →

Build a Text-to-Image Generator (from Scratch)

A model parameter is a numerical value used by a model that is typically learned or adjusted during training.

How it is used
Adjusts model behavior during training by minimizing prediction or reconstruction loss.
How deep it goes
Traces parameters through loss calculation, backpropagation, optimizer updates, counting, and saving, but does not derive their numerical internals.
Examples
Uses denoising U-Nets, FashionMNIST clothing images, attention layers, and a VAE encoder's learned mean and variance.
What you can do after
Operate/configure PyTorch training code that updates, counts, and saves model parameters.

Read how Build a Text-to-Image Generator (from Scratch) explains parameter →

LLMs in Production

A model parameter is a learned numerical value that determines part of a machine-learning model's computation.

How it is used
Guides LLM model-sizing, GPU-memory planning, and latency trade-offs.
How deep it goes
Explains parameter scale through memory estimates for inference and training, but stops short of optimization internals.
Examples
Uses LLaMA parameter variants and 7B memory calculations for inference, batching, and training.
What you can do after
Operate/configure GPU deployments by estimating memory requirements from parameter count, precision, tokens, batching, and training state.

Read how LLMs in Production explains parameter →

Introduction to Generative AI, Second Edition

A model parameter is a learned numerical value that determines how a machine-learning model transforms inputs, with parameter count indicating model scale.

How it is used
Uses learned values to describe how neural networks transform inputs and to indicate the scale of models.
How deep it goes
Defines weights, biases, training updates, and parameter counts, while deferring the precise mathematics of training.
Examples
Uses neural-network connections and large language models exceeding one trillion parameters as examples.
What you can do after
Evaluate model scale and understand how training adjusts numerical values that influence model behavior.

Read how Introduction to Generative AI, Second Edition explains parameter →

The Complete Obsolete Guide to Generative AI

A model parameter is a learned numerical value that determines part of a machine-learning model's behavior.

How it is used
Uses parameter counts to compare model capacity, hardware demands, and practical deployment choices.
How deep it goes
Defines parameter count and explains capacity tradeoffs, but stops short of numerical internals or training mechanics.
Examples
Uses GPT-3 family sizes, 7B and 3B model labels, separate weight files, and RedPajama launch commands.
What you can do after
Operate/configure a local model by matching its weight file and adjusting launcher parameters such as paths, context, threads, and sampling.

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

Fight Fraud with Machine Learning

A model parameter is a value learned from training data that determines a machine learning model's behavior.

How it is used
Frames learned weights and biases as the values that control model behavior during fraud-detection training.
How deep it goes
Explains parameter counts, learned-versus-supplied settings, and scaling to large models without detailing optimization internals.
Examples
Uses four-input logistic regression, a 25-unit hidden layer, and models ranging from millions to trillions of parameters.
What you can do after
Evaluate/understand parameter counts and distinguish learned parameters from developer-specified hyperparameters.

Read how Fight Fraud with Machine Learning explains parameter →

Designing Deep Learning Systems: A guide for software engineers

A numerical value in a model that is adjusted during training to determine its behavior.

How it is used
Uses trainable values to improve predictions through repeated model-training updates.
How deep it goes
Defines trainability, gradients, weights, biases, and saved state, but stops short of mathematical derivation.
Examples
Uses mini-batches, weights, biases, stochastic gradient descent, large parameter counts, and final model files.
What you can do after
Understand how training changes parameters and why parameter scale creates distributed-training requirements.

Read how Designing Deep Learning Systems: A guide for software engineers explains parameter →

Build a DeepSeek Model (From Scratch)

A model parameter is a learned numerical value that determines part of a machine-learning model's computation.

How it is used
Explains how learned values support model computation during training and fixed-value token generation during inference.
How deep it goes
Defines learned and fixed parameters, then quantifies their storage and inference costs without detailing parameter-update algorithms.
Examples
Uses GPT-2, DeepSeek-R1, 671-billion-parameter storage, FP16 memory estimates, and NVIDIA GPU comparisons.
What you can do after
Evaluate how parameter count, activation, precision, and storage affect model deployment and inference cost.

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

Context Engineering

A model parameter is a learned numerical value, such as a weight or bias, that determines how a model transforms its inputs.

How it is used
Defines the learned values that shape how an LLM transforms token sequences.
How deep it goes
Defines weights and biases, contrasts hyperparameters, and cautions against treating parameter count as a quality or compute measure.
Examples
Uses weights, biases, and 8B or 70B parameter counts as examples.
What you can do after
Understand what model parameters encode and distinguish learned values from practitioner-chosen configuration.

Read how Context Engineering explains parameter →

AI Governance

A model parameter is a setting that controls a model's behavior during generation or operation.

How it is used
Stabilizes generated answers when equivalent cases should receive consistent treatment.
How deep it goes
Specifies temperature and random-seed adjustments, their creative-range trade-off, and their limit short of full determinism.
Examples
Uses a zero-temperature setting and a fixed random seed as consistency examples.
What you can do after
Configure model parameters to improve consistency while accounting for reduced creative range and remaining nondeterminism.

Read how AI Governance explains parameter →

Also covered in

What to know first

Related concepts

Questions about parameter

What is parameter?

A parameter is a value or named input that specifies or influences the behavior, computation, or output of a function, model, or system.

Which Manning books explain parameter?

Grokking Machine Learning, Deep Learning with PyTorch, Second Edition, Natural Language Processing in Action, Second Edition, Math and Architectures of Deep Learning, Grokking AI Algorithms, Second Edition, Timeless Algorithms, The Foundational Ideas, Outlier Detection in Python, The Design of Web APIs, Second Edition and 33 more.

What should I know before learning parameter?

Manning books that teach parameter usually introduce language model, generation, transformer architecture and prompt first.

What is the difference between parameter and hyperparameter?

A parameter is a value or named input that specifies or influences the behavior, computation, or output of a function, model, or system. A hyperparameter is a setting chosen outside ordinary parameter learning that controls a model, algorithm, or learning procedure.

What kinds of parameter are there?

Kinds of parameter include optional parameter and fixed parameter.

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.