liveBook · Manning

Logit

Also called log-odds

A logit is a real-valued quantity representing log-odds for a binary outcome or an unnormalized model score for a candidate outcome before probability normalization.

How 24 Manning books explain it

Timeless Algorithms, The Foundational Ideas

A logit is an unnormalized real-valued score that can be transformed into a probability.

How it is used
Uses logits as scores preceding classification decisions, attention weights, and language-model continuation probabilities.
How deep it goes
Works through weighted output scores, scaled attention scores, and their conversion using sigmoid or softmax.
Examples
Calculates a pedestrian-detection score and compares pronoun attention scores for a trophy and a box.
What you can do after
Evaluate and understand how scores become probabilities or attention weights before a decision or representation is formed.

Read how Timeless Algorithms, The Foundational Ideas explains logit →

Build AI Drug Discovery Pipelines

A logit is an unnormalized real-valued score for a possible output token before conversion to probabilities.

How it is used
Uses logits as vocabulary scores for reconstructing molecular SMILES strings and log-odds to interpret inhibitor predictions.
How deep it goes
Explains decoder output shapes and cross-entropy training, and relates binary logistic scores to odds and feature weights.
Examples
Uses a SMILES decoder and a CYP3A4 inhibitor feature with weight 0.45.
What you can do after
Apply it via PyTorch cross-entropy to train a decoder against token indices while ignoring padding.

Read how Build AI Drug Discovery Pipelines explains logit →

Statistics Slam Dunk

Log odds is the natural logarithm of the odds of an event, equal to the logarithm of its probability divided by its failure probability.

How it is used
Explains how logistic regression represents binary-outcome probabilities while avoiding impossible values below 0 or above 1.
How deep it goes
Defines the equation, demonstrates conversions, and connects coefficients to predictions, but does not develop the estimation mathematics.
Examples
Uses NBA playoff qualification, standardized points allowed, R glm() output, probability conversion, and classification metrics.
What you can do after
Apply it via base R glm() to model binary outcomes and interpret coefficients as changes in log odds and predicted probabilities.

Read how Statistics Slam Dunk explains logit →

Applied Reinforcement Learning

A logit is an unnormalized real-valued score that softmax transforms into an action probability.

How it is used
Scores discrete actions or candidate next tokens before they are converted into probabilities.
How deep it goes
Defines raw scores and works through softmax probabilities, action sampling, and policy updates.
Examples
Calculates production-level probabilities from three logits and describes selecting a next token from language-model scores.
What you can do after
Apply softmax to convert action scores into probabilities and sample an action.

Read how Applied Reinforcement Learning explains logit →

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

A logit is an unnormalized output score produced by a model before conversion into class probabilities.

How it is used
Uses final-layer scores to represent class evidence before probability conversion and classification.
How deep it goes
Defines logits and computes them through hidden-layer activation, output weights, and biases before applying softmax.
Examples
Uses a penguins classifier with four inputs, ten hidden units, three output classes, and NumPy forward-propagation code.
What you can do after
Apply it via Python and NumPy to compute class scores, probabilities, loss, and predictions.

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

Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI

The logit function maps a probability in (0,1) to its log-odds and is the inverse of the logistic sigmoid.

How it is used
Transforms class probabilities into log-odds for logistic regression and gradient-boosting optimization.
How deep it goes
Defines the log-odds mapping and demonstrates clipping, initialization, gradients, and sigmoid conversion in a working implementation.
Examples
Uses above-median binary classification, logistic regression pipelines, and a hand-built gradient boosting classifier.
What you can do after
Apply it via NumPy to convert probabilities into logits and recover probabilities with the sigmoid.

Read how Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI explains logit →

CUDA for LLMs

A logit is an arbitrary real-valued score supplied as input to a normalization or classification function.

How it is used
Defines the raw scores normalized into probabilities at classifier outputs and in transformer attention.
How deep it goes
Defines logits and traces max-shifted exponentiation and normalization, without detailing how the scores are generated.
Examples
Uses a four-value score vector to demonstrate stable softmax and a transformer output projection to vocabulary scores.
What you can do after
Understand how raw scores become probabilities through max-shifted softmax normalization.

Read how CUDA for LLMs explains logit →

Natural Language Processing in Action, Second Edition

A logit is an unconstrained real-valued score obtained by applying the inverse of the logistic or softmax probability transformation.

How it is used
Interprets the raw scores underlying next-token selection in a generative language model.
How deep it goes
Explains logits through tensor inspection and softmax conversion, but stops short of deriving neural-network training internals.
Examples
Uses GPT-2 outputs, a [1, 3, 50257] tensor shape, and ranked candidates for the prompt 'NLP is a'.
What you can do after
Diagnose next-token selection by extracting logits, applying softmax, and ranking vocabulary tokens.

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

LLMs in Production

A logit is an unnormalized real-valued score assigned to a candidate token before probability normalization.

How it is used
Uses logits to choose and sample the next token during language-model generation.
How deep it goes
Explains vocabulary scores, temperature adjustment, softmax, filtering, and selection strategies without deriving the underlying model internals.
Examples
Uses the prompt “I am a,” final-time-step generation code, and comparisons of argmax, multinomial, top-k, and top-p sampling.
What you can do after
Apply it via generation code to adjust, filter, normalize, and select candidate tokens.

Read how LLMs in Production explains logit →

Deep Learning with PyTorch, Second Edition

Unnormalized model scores produced before applying a probability normalization such as softmax, used here as the direct input to cross-entropy loss.

How it is used
Uses logits as training inputs to cross-entropy and converts them to probabilities for classification.
How deep it goes
Defines logits, demonstrates softmax conversion, and explains their loss-function role without developing deeper mathematical internals.
Examples
Demonstrates logits [1, -2, 3], softmax probabilities, and a PyTorch model returning linear scores alongside probabilities.
What you can do after
Apply it via cross-entropy loss during training and softmax during classification.

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

Rearchitecting LLMs

A logit is an unnormalized numerical score produced by a model before conversion into probabilities.

How it is used
Uses teacher and student logits to guide student training through knowledge distillation.
How deep it goes
Explains teacher and student inference, softmax conversion, KL-divergence loss, and weight updates.
Examples
Uses teacher and pruned-student outputs for the same text batch as the comparison example.
What you can do after
Apply PyTorch softmax and KL-divergence operations to train a student from teacher outputs.

Read how Rearchitecting LLMs explains logit →

Learn Generative AI with PyTorch

An unnormalized model output score produced before conversion to probabilities for sampling or selection.

How it is used
Controls next-token probabilities and sampling choices after a language model produces vocabulary-wide scores.
How deep it goes
Defines logits, places them before softmax, and demonstrates temperature and top-K processing without deriving their mathematics.
Examples
Demonstrates logits through sampled continuations from fixed prompts under unrestricted, top-K, low-temperature, and high-temperature settings.
What you can do after
Apply logits via PyTorch sampling code by scaling them, converting them with softmax, and selecting or filtering candidate tokens.

Read how Learn Generative AI with PyTorch explains logit →

Starting Data Analytics with Generative AI and Python

Log-odds are the natural logarithm of the odds of an event or ordered outcome category.

How it is used
Explains how predictors shift the odds of reaching higher categories in ordinal regression.
How deep it goes
Defines directional coefficient interpretation with a sleep example, but stops short of deriving logits mathematically.
Examples
Uses sleep and happiness levels, review-score classifications, coefficient output, and a Python ordinal-regression workflow.
What you can do after
Evaluate/understand how fitted ordinal-regression coefficients relate predictor changes to higher outcome categories.

Read how Starting Data Analytics with Generative AI and Python explains logit →

Ensemble Methods for Machine Learning

Log-odds are the natural logarithm of the odds of an event.

How it is used
Connects linear predictors to binary-class probabilities through odds and the sigmoid link.
How deep it goes
Defines odds and log-odds, derives the inverse link, and interprets coefficients but does not develop estimation theory.
Examples
Uses diabetes diagnosis coefficients and a breast-cancer classifier with standardized image-derived features.
What you can do after
Evaluate and understand how logistic-regression coefficients change class odds.

Read how Ensemble Methods for Machine Learning explains logit →

Server-Side WebAssembly

A logit is an unnormalized score produced for a candidate class or token before conversion into probabilities.

How it is used
Uses logits during language-model inference to choose the next token from a vocabulary.
How deep it goes
Explains raw scores, vocabulary slicing, softmax conversion, and weighted sampling, without deriving the underlying neural-network computation.
Examples
Uses an ONNX language model to extract final-token logits and sample a continuation from the resulting distribution.
What you can do after
Apply it via softmax and weighted sampling to generate the next token from model inference output.

Read how Server-Side WebAssembly explains logit →

Build a DeepSeek Model (From Scratch)

A logit is an unnormalized real-valued score assigned to a possible output token before conversion to probabilities.

How it is used
Uses final-row logits to select the next token and motivate inference optimizations such as KV caching.
How deep it goes
Traces logits from contextual representations through output projection to probability conversion, but does not derive projection internals.
Examples
Uses “The next day is” with a (4, 50257) logits matrix and “bright” as a possible selected token.
What you can do after
Apply logits by extracting the final row, converting it with softmax, and selecting or sampling the next token.

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

Build a Large Language Model (From Scratch)

The model’s unnormalized output scores over the vocabulary before conversion to probabilities or token selections.

How it is used
Uses logits as the intermediate representation connecting GPT inference with token selection and text generation.
How deep it goes
Explains the output head and tensor shape, but defers the detailed conversion from logits into selected tokens.
Examples
Demonstrates logits through a [2, 4, 50257] output tensor and a token-ID-to-text generation example.
What you can do after
Evaluate and understand how GPT outputs encode next-token scores before token selection and decoding.

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

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

A logit is an unnormalized real-valued score assigned to a class before conversion into probabilities.

How it is used
Uses class logits as the intermediate output for image classification before converting scores into probabilities.
How deep it goes
Traces logits from the CLS representation through a linear classifier head to argmax predictions and softmax probabilities.
Examples
Uses CIFAR-10 batches, ten class outputs, argmax predictions, and labels such as ship, plane, frog, and car.
What you can do after
Apply it via PyTorch to obtain class predictions from logits and convert those scores into probabilities with softmax.

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

Math and Architectures of Deep Learning

A vector of unnormalized class scores produced by a classifier before conversion to probabilities.

How it is used
Uses logits to select a classifier’s predicted class and feed scores into softmax and loss computation.
How deep it goes
Defines unbounded class scores, explains their normalization, and demonstrates numerical and PyTorch counterparts without deriving training gradients.
Examples
Uses a four-class image score vector and a 10-class LeNet output to illustrate prediction and probability conversion.
What you can do after
Apply logits by interpreting classifier outputs, identifying the maximal class, and converting scores with PyTorch softmax.

Read how Math and Architectures of Deep Learning explains logit →

Statistics Every Programmer Needs

Log odds are the natural logarithm of the odds of an event, calculated as the logarithm of its probability divided by the complement probability.

How it is used
Interprets how predictors relate quantitatively to the probability of a binary outcome in logistic regression.
How deep it goes
Defines the log-odds scale and coefficient interpretation, then connects it to sigmoid-based probability prediction without deriving estimation.
Examples
Uses predictor coefficients to explain one-unit changes in log odds and sigmoid transformations to produce binary-outcome probabilities.
What you can do after
Evaluate/understand logistic-regression coefficients as changes in binary-outcome log odds before probability conversion.

Read how Statistics Every Programmer Needs explains logit →

Human-in-the-Loop Machine Learning: Active learning and annotation for human-centered AI

A logit is an unnormalized score produced by a model before conversion into probabilities.

How it is used
Represents model output scores before softmax converts them into a probability distribution.
How deep it goes
Explains logits as pre-softmax scores and shows scale loss under softmax, without detailing how activation scale is used.
Examples
Uses four-class object-detection scores and shifted logits that yield the same softmax distribution.
What you can do after
Understand how softmax can discard output scale even when the resulting probability distributions remain unchanged.

Read how Human-in-the-Loop Machine Learning: Active learning and annotation for human-centered AI explains logit →

Hugging Face in Action

A logit is an unnormalized model output representing evidence for a class before conversion into normalized probabilities.

How it is used
Uses logits to compare class evidence and produce predictions in text-classification and image-labeling workflows.
How deep it goes
Defines raw class outputs and demonstrates argmax selection and softmax conversion, without deriving their mathematical foundations.
Examples
Demonstrates sentiment classification and CLIP matching among cat, dog, tiger, and train labels.
What you can do after
Apply via PyTorch and Hugging Face Transformers to inspect logits, select classes, and convert scores into probabilities.

Read how Hugging Face in Action explains logit →

Grokking Statistics

The logit function maps a probability to the natural logarithm of its odds, log(p/(1-p)).

How it is used
Interprets logistic-regression probabilities through odds and the model’s linear component.
How deep it goes
Connects definition, worked numbers, Python verification, and curve behavior without developing a formal derivation.
Examples
Uses toddler-meltdown probabilities at four and six hours, coefficient calculations, Python listings, and a curve comparison.
What you can do after
Evaluate logistic-regression outputs by converting probabilities to odds and checking their logit against β0 + β1x.

Read how Grokking Statistics explains logit →

Financial AI in Practice

The logarithm of the ratio of an event’s probability to the probability of its complement.

How it is used
Transforms weight-of-evidence features and model default probabilities into log-odds-based representations for credit scoring.
How deep it goes
Defines odds and demonstrates probability-to-score formulas with clipping and score-distribution visualization.
Examples
Uses WoE-coded features and a PDO example anchored at score 650, with 20 points doubling good-borrower odds.
What you can do after
Apply it via NumPy to convert predicted default probabilities into clipped, rounded credit scores.

Read how Financial AI in Practice explains logit →

Also covered in

What to know first

Related concepts

Questions about logit

What is logit?

A logit is a real-valued quantity representing log-odds for a binary outcome or an unnormalized model score for a candidate outcome before probability normalization.

Which Manning books explain logit?

Timeless Algorithms, The Foundational Ideas, Build AI Drug Discovery Pipelines, Statistics Slam Dunk, Applied Reinforcement Learning, Optimization Algorithms: AI techniques for design, planning, and control problems, Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI, CUDA for LLMs, Natural Language Processing in Action, Second Edition and 16 more.

What should I know before learning logit?

Manning books that teach logit usually introduce language model, classifier, softmax and vocabulary first.

What is the difference between logit and probability distribution?

A logit is a real-valued quantity representing log-odds for a binary outcome or an unnormalized model score for a candidate outcome before probability normalization. A probability distribution is a mathematical specification assigning probabilities or probability densities to the possible values or outcomes of a random variable.

What is logit also called?

Logit is also called log-odds.

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.