liveBook · Manning

Input

An input is information, a value, or an action supplied to a system, program, or computation for processing or to influence its behavior.

How 18 Manning books explain it

Grokking Machine Learning

A property or characteristic of a data example that a model can use to make predictions.

How it is used
Supplies the properties a predictive model uses to estimate a label, from email classifications to house prices.
How deep it goes
Defines features as table columns, works through a weighted house-price input, and develops categorical and numerical preprocessing.
Examples
Uses email size and words, pet properties, house room counts, and passenger columns as concrete inputs.
What you can do after
Apply it via Pandas and Scikit-Learn to prepare feature columns, separate them from labels, and train and evaluate models.

Read how Grokking Machine Learning explains input →

Learn AI-Assisted Python Programming, Second Edition

A parameter is a named input specified by a function definition that receives information when the function is called.

How it is used
Characterizes books for supervised-learning predictions about unknown authors.
How deep it goes
Defines features, works through sentence-length calculation, and uses simple punctuation rules while deferring more accurate phrase analysis.
Examples
Uses average sentence length, punctuation-based sentence complexity, average word length, repetition, and weighted signature comparisons.
What you can do after
Apply it by calculating descriptive values and assembling signatures for machine-learning comparisons.

Read how Learn AI-Assisted Python Programming, Second Edition explains input →

Get Programming: Learn to code with Python

Information supplied to a program or software component for processing.

How it is used
Uses input to start calculations, guide user interactions, and specify what reusable tasks receive.
How deep it goes
Works through prompting, storing, converting, and testing inputs, then explains parameter values in function calls.
Examples
Uses a square calculator, a name mashup, function calls, and a file of names and phone numbers.
What you can do after
Build it from scratch: prompt for and process user responses, supply function arguments, and test varied inputs.

Read how Get Programming: Learn to code with Python explains input →

Fight Fraud with Machine Learning

A feature is an input variable representing a measurable property of an instance for a machine-learning model.

How it is used
Uses input properties to detect fraud through rules or trained classifiers.
How deep it goes
Works through feature ranking, distribution analysis, engineered columns, and threshold-based rules; defers detailed feature-extraction implementations beyond audio conversion.
Examples
Uses phishing-email fields, webpage hyperlink and dash counts, transaction columns, and MFCC matrices from voice samples.
What you can do after
Apply it via scikit-learn and plotting tools to rank numerical inputs, inspect distributions, choose rule thresholds, and assess accuracy.

Read how Fight Fraud with Machine Learning explains input →

Statistics Every Programmer Needs

A feature is an input attribute of an observation used by a predictive model to make decisions or generate predictions.

How it is used
Supplies observed attributes for predicting a numeric response with linear regression or a binary outcome with logistic regression.
How deep it goes
Defines predictors by their relationship to targets, demonstrates Python input selection, and evaluates significance and multicollinearity; does not develop general feature engineering.
Examples
Uses Stage 1 split times to predict Stage 2 times and raisin morphology to predict variety.
What you can do after
Apply it via statsmodels by selecting predictors, fitting regression models, and reviewing significance and multicollinearity before retaining features.

Read how Statistics Every Programmer Needs explains input →

Machine Learning System Design

An input variable or derived input representation provided to a machine-learning model.

How it is used
Uses features and learned representations as inputs that supply patterns for model learning and prediction.
How deep it goes
Explains feature generation and selection through transformations, practical criteria, and design examples rather than algorithm derivations.
Examples
Illustrates inputs with retail sales lags and promotion calendars, plus image-search distances and prospective user signals.
What you can do after
Evaluate feature candidates against prediction quality, interpretability, computation time, and pipeline stability.

Read how Machine Learning System Design explains input →

Grokking Machine Learning, Second Edition

A property or characteristic of data used as an input to a model or, when selected for prediction, as a target label.

How it is used
Uses inputs as the properties from which supervised models predict labels.
How deep it goes
Defines inputs as table columns, then explains weights, preprocessing, and decision-tree threshold splits.
Examples
Uses pets, house rooms and prices, spam emails, and app recommendations with platform and age.
What you can do after
Apply it via scikit-learn after selecting, scaling, and encoding housing inputs for linear regression.

Read how Grokking Machine Learning, Second Edition explains input →

AI-Powered Search

A feature is a numerical attribute of a document, query, or query-document relationship used to represent evidence for ranking.

How it is used
Uses numerical features as evidence in manual scoring functions and learned search-ranking models.
How deep it goes
Defines features and explains logging, domain selection, training coverage, interactions, and evaluation trade-offs.
Examples
Compares title scores, overview scores, and release years for movie judgments, and examines missing promotion values in product training data.
What you can do after
Evaluate and understand ranking features, their training-data coverage, and their contribution to search relevance.

Read how AI-Powered Search explains input →

Math and Architectures of Deep Learning

A measured or encoded property used as an input variable to a machine-learning model.

How it is used
Frames real-world problems as functions that transform quantifiable inputs into predicted classes or values.
How deep it goes
Defines numeric input variables, vector instances, continuous versus categorical forms, and min-max normalization without detailing feature engineering.
Examples
Uses cat-object hardness and sharpness, stock-selling variables, driving-speed variables, and face images.
What you can do after
Evaluate/understand how numeric properties become input vectors that a trained model maps to predictions.

Read how Math and Architectures of Deep Learning explains input →

Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu

An input value is a value supplied to configure a Terraform input variable.

How it is used
Uses input values to customize reusable modules and distinguish environments without editing their configuration.
How deep it goes
Explains declarations, defaults, validation, references, module arguments, and root assignment methods; defers more complex module behavior.
Examples
Uses an AWS instance’s subnet and instance type, a subnet data lookup, and HCL and JSON variable files.
What you can do after
Apply it via Terraform variable blocks, module arguments, and variable files to configure reusable infrastructure with checked inputs.

Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains input →

The Well-Grounded Rubyist, Fourth Edition

A parameter is a named input in a method definition or block that receives a corresponding argument when the callable is invoked.

How it is used
Defines how Ruby methods and blocks receive values supplied by calls or yields.
How deep it goes
Works through required, default-valued, and starred binding and ordering; defers full treatment of keyword arguments.
Examples
Uses a Celsius converter, mixed method signatures, and iteration with `times`.
What you can do after
Practice/perform method signature design and predict which values bind to positional, default-valued, and starred parameters.

Read how The Well-Grounded Rubyist, Fourth Edition explains input →

Knowledge Graphs and LLMs in Action

A feature is an input variable or measurable attribute selected from data for training a predictive model.

How it is used
Uses measurable attributes or graph-derived values as inputs for predictive models and node or pair classification.
How deep it goes
Explains manual metrics, neighborhood scope, metapath weighting, and shortest-path computation, while deferring detailed representation-learning treatment.
Examples
Uses weather measurements, a fraud-detection network, geodesic hop counts, and metapaths linking metformin with type 2 diabetes.
What you can do after
Build it from scratch by extracting interpretable graph metrics, shortest-path indicators, or degree-weighted metapath values for model inputs.

Read how Knowledge Graphs and LLMs in Action explains input →

The Design of Web APIs, Second Edition

An input is information or a business concept necessary to achieve a step in a user-oriented workflow.

How it is used
Identifies what users must provide for workflow steps and carries those needs into API operations and requests.
How deep it goes
Traces inputs from coarse business concepts through merged action inputs, HTTP placement, and schemas, deferring property-level detail until data modeling.
Examples
Uses shopping-cart and catalog scenarios, a product-reference parameter, money-transfer changes, and a trail-segment exercise.
What you can do after
Practice/perform input identification, request placement, and schema description while checking consumer usability and change compatibility.

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

100 C++ Mistakes and How to Avoid Them

A parameter list is the ordered sequence of parameters declared by a function or constructor.

How it is used
Uses parameter lists to design clear, safe function and constructor interfaces.
How deep it goes
Explains passing trade-offs, evaluation-order pitfalls, and a parameter-object alternative with corrected C++ examples.
Examples
Uses string concatenation, an increasing-values loop, and a constructor with name and date fields.
What you can do after
Apply parameter-design practices to clarify calls, avoid unintended modification, and separate side effects from argument expressions.

Read how 100 C++ Mistakes and How to Avoid Them explains input →

Grokking Algorithms, Second Edition

A feature is an observable attribute or input variable used to characterize an item for comparison or prediction.

How it is used
Represents fruits, users, or days as comparable inputs for KNN classification or regression.
How deep it goes
Works through numeric vectors, distance, and feature-selection trade-offs, but defers cosine similarity.
Examples
Uses fruit size and color, movie-category ratings, bakery conditions, and stock-market guesses.
What you can do after
Practice/perform feature extraction and selection by representing items numerically and choosing relevant, balanced inputs for KNN.

Read how Grokking Algorithms, Second Edition explains input →

Pro Angular 16

An input property is a directive or component property that receives a value from a template binding.

How it is used
Supplies changing template data to directives and components so they can adapt host elements, templates, or rendered content.
How deep it goes
Defines binding syntax, decorator aliases, lifecycle timing, component usage, and testing, but does not detail decorator configuration beyond the basic alias.
Examples
Uses conditional table classes, a themed custom button, template outlet context data, and a host component for testing.
What you can do after
Apply it via Angular bindings and @Input decorators, then test received values through a host component and rendered output.

Read how Pro Angular 16 explains input →

The Art of AI Product Development

A feature is an input variable representing a measurable property of an example supplied to a machine-learning model.

How it is used
Uses input features to represent examples for clustering, classification, and reusable prompt templates.
How deep it goes
Explains feature relevance, scaling, refinement, and interpretation, but does not detail mathematical representations or implementation code.
Examples
Uses customer purchase behavior, browsing activity, product preferences, user profiles, and dynamic prompt variables as examples.
What you can do after
Apply it by selecting, scaling, and refining variables that make model outputs more relevant, interpretable, and actionable.

Read how The Art of AI Product Development explains input →

Digital Twins in Action

A feature is an input variable or measurable property used to characterize an instance in analytical or machine learning processing.

How it is used
Uses features to turn operational measurements into inputs for analytical models and forecasts.
How deep it goes
Explains feature transformations and demonstrates column selection and model training, without detailing the calculations for each transformation.
Examples
Uses temperature deviations and lagged indoor temperatures to illustrate contextual and temporal features.
What you can do after
Apply it via scikit-learn by selecting feature columns and training a one-hour-ahead temperature forecast.

Read how Digital Twins in Action explains input →

Also covered in

What to know first

Related concepts

Questions about input

What is input?

An input is information, a value, or an action supplied to a system, program, or computation for processing or to influence its behavior.

Which Manning books explain input?

Grokking Machine Learning, Learn AI-Assisted Python Programming, Second Edition, Get Programming: Learn to code with Python, Fight Fraud with Machine Learning, Statistics Every Programmer Needs, Machine Learning System Design, Grokking Machine Learning, Second Edition, AI-Powered Search and 10 more.

What should I know before learning input?

Manning books that teach input usually introduce function, language model, Python and generation first.

What is the difference between input and command-line argument?

An input is information, a value, or an action supplied to a system, program, or computation for processing or to influence its behavior. A command-line argument is a value or option supplied to a program when it is invoked, providing input or affecting its behavior.

What is input a kind of?

Input is a kind of constant. A constant is a value or named binding treated as fixed rather than reassigned or modified during a computation, whether this is enforced by a language or followed by convention.

What is input part of?

Input is part of function declaration. A function declaration is a source-language construct that introduces a function by specifying its name and parameter interface, and may also provide its implementation.

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.