Parameter
A parameter is a value or named input that specifies or influences the behavior, computation, or output of a function, model, or system.
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 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.
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.
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.
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.
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.
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.
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.
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.
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 →
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.
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.
Also covered in
- Quantization and Fast InferenceIn early access (MEAP)
- Practical Automation with PowerShell: Effective scripting from the console to the cloud
- Pro ASP.NET Core 7, Tenth Edition
- Secrets of the JavaScript Ninja, Third EditionIn early access (MEAP)
- React Hooks in Action: With Suspense and Concurrent Mode
- Secure APIs
- Applied Reinforcement LearningIn early access (MEAP)
- 100 SQL Server Mistakes and How to Avoid Them
- API Design Patterns
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- Learn SQL in a Month of Lunches
- Effective Conversational AI
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.
- generationGeneration is the production of an output by a computational model from supplied input or context, often using patterns learned from data.
- transformer architectureA transformer is a neural-network architecture that uses attention-based interactions and position-wise transformations to model relationships among elements of sequences or other structured inputs.
- promptA prompt is text or other input supplied to an AI model to provide instructions, context, or other information that guides its response or generated output.
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 in the direction opposite an objective function’s gradient to reduce the objective’s value.
- function argumentcontrasts with · A function argument is a value or expression supplied when a function or method is invoked, providing input to the called operation.
- optional parameterincludes · An optional parameter is a function or method parameter that a caller may omit, typically because a default value or other defined behavior applies when it is absent.
- Bernoulli distributionused by · A Bernoulli distribution is a discrete probability distribution for one binary outcome, assigning probability p to one outcome and 1−p to the other.
- fixed parameterincludes · A fixed parameter is an input with a predetermined value that cannot be changed by the automation initiator.
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.








































