Parameter
A model parameter is a numerical value, such as a weight or bias, that is learned or set to determine how a model computes outputs.
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.
Deep Learning with PyTorch, Second Edition
A learnable numeric value in a model.
- How it is used
- Uses learnable values to fit predictions to targets and to reuse knowledge stored in pretrained models.
- How deep it goes
- Works from a two-parameter training loop through gradients and updates to tracked tensors and convolutional weight shapes.
- Examples
- Demonstrates temperature calibration with scalar tensors, inspection of linear-layer parameters, and a 16-filter convolution’s weight tensor.
- What you can do after
- Apply it via PyTorch by inspecting module parameters, passing them to an optimizer, and saving trained values with `state_dict`.
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
- Controls each feature's contribution to a neuron's prediction and supplies values that training can adjust.
- How deep it goes
- Works through a numerical perceptron and PyTorch update loop, then visualizes optimization; it does not derive recurrent-network gradients.
- Examples
- Uses weighted word counts for a perceptron, a PyTorch name classifier, and an error-surface skiing analogy.
- What you can do after
- Build it from scratch as a weighted-sum perceptron, then apply it via PyTorch to train and inspect predictions.
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 inputs to neurons and represent relationships learned from training examples.
- How deep it goes
- Works from weighted Perceptron inputs through matrix multiplication, initialization, and training updates, without developing an abstract proof.
- Examples
- Traces a four-input, five-neuron weight matrix and a four-to-eight-dimensional feed-forward projection.
- What you can do after
- Evaluate/understand how initialized and trained weights alter predictions, and distinguish learned weights from configured algorithm settings.
Read how Grokking AI Algorithms, Second Edition 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.
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.
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
- Supplies optional request choices, including a game's language or a week selected for navigation.
- How deep it goes
- Explains query-string syntax and shows Go handler retrieval; leaves creation in the selected language unimplemented.
- Examples
- Uses `?lang=en` for game creation and proposes `?week=` for previous or next week navigation.
- What you can do after
- Apply it via Go's `r.URL.Query().Get` to read an optional request value in a handler.
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
- Stores learned values that determine how neural-network layers transform inputs into predictions.
- How deep it goes
- Walks through random initialization and loss-driven updates in a training loop, while deferring detailed backpropagation mechanics.
- Examples
- Uses a weight matrix and bias in a layer transformation, plus word weights in a bag-of-words review model.
- What you can do after
- Apply it via Keras `model$trainable_weights` when retrieving gradients for trainable parameters in a custom training loop.
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 learned weights to connect training updates with image classification, image generation, and pretrained text generation.
- How deep it goes
- Works through optimizer updates, weight-matrix shapes, and checkpoint copying without deriving optimization algorithms.
- Examples
- Uses image-classifier updates and a GPT-2XL Conv1D-to-linear-layer weight transfer with transposed tensor shapes.
- What you can do after
- Apply it via PyTorch and Hugging Face Transformers to load compatible pretrained GPT-2XL weights for text generation.
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.
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 →
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.
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 optimized to reduce neural-network loss and improve predictions.
- How deep it goes
- Explains parameter notation, tensor representation, gradients, and the PyTorch optimization loop, but defers optimizer internals.
- Examples
- Demonstrates scalar quadratic minimization, SGD code, linear-layer weights and biases, and frozen versus trainable transfer-learning parameters.
- What you can do after
- Operate PyTorch parameters by constructing nn.Parameter values, computing losses, and updating them with SGD.
Read how Inside Deep Learning: Math, Algorithms, Models 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.
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.
Transformers in Action
A model parameter is a learned numerical value within a model that is optimized from training data.
- How it is used
- Serves as the learned value updated during language-model training or selectively adapted for a downstream task.
- How deep it goes
- Defines weights and biases, explains gradient-based updates, and develops LoRA's matrix update; does not detail individual attention-weight calculations.
- Examples
- Uses attention weights, learning-rate comparisons, an SVD-based matrix approximation, and an Unsloth LoRA configuration.
- What you can do after
- Apply it via Unsloth by choosing a LoRA rank and target modules while keeping pretrained weights fixed.
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.
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.
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 →
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 →
Related concepts
- hyperparametercontrasts with · A hyperparameter is a setting chosen outside ordinary parameter learning that controls a model, algorithm, or learning procedure.
- gradient descentused by · Gradient descent is an iterative optimization method that updates parameters opposite the gradient of an objective function to reduce its value.
- optional function argumentincludes · An optional function argument is an input corresponding to a parameter that a caller is not required to supply because omission is permitted by the function's interface.
- optimizationconfigured by · Optimization is the systematic selection or adjustment of values, actions, or system designs to improve a specified objective, often subject to constraints.
- fixed parameterincludes · A fixed parameter is an input with a predetermined value that cannot be changed by the automation initiator.
- prompt templateused by · A prompt template is a reusable structure for organizing instructions, context, and variable inputs supplied to a language model.
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.