Motivation

vLLM's PoolerConfig already supports logit_bias for classification models, enabling a bias offset on raw logits before activation. However, there is no corresponding scale parameter, which means vLLM cannot express the standard affine calibration transform:

calibrated_score = activation(scale * (logit - bias))

This transform is known as Platt scaling (Platt, 1999) — the most widely-used method for calibrating classifier outputs into well-calibrated probabilities. It fits two parameters (A and B) such that:

P(y=1|x) = sigmoid(A * f(x) + B)

where f(x) is the raw model output. This is equivalent to sigmoid(A * (f(x) - (-B/A))), i.e. scale and bias.

Reference: John Platt. "Probabilistic Outputs for Support Vector Machines and Comparisons to Regularized Likelihood Methods." Advances in Large Margin Classifiers, 1999.

Platt scaling is not limited to SVMs — it is routinely applied to neural network classifiers, cross-encoders, and reranking models to map raw logits into interpretable probability scores. Related techniques include:

• Temperature scaling (Guo et al., 2017) — a special case where only scale is learned (bias=0)
• SentenceTransformers cross-encoder activation functions — vLLM already supports loading these via sbert_ce_default_activation_function, but they are limited to parameterless functions like torch.nn.modules.activation.Sigmoid

Current State

vLLM's pooler heads (ClassifierPoolerHead, TokenClassifierPoolerHead) apply:

if self.logit_bias is not None:
    logits -= self.logit_bias          # ← bias exists
# no scale                              # ← scale is missing
if self.activation is not None:
    logits = self.activation(logits)    # ← sigmoid/softmax exists

This supports sigmoid(logit - bias) but NOT sigmoid(scale * (logit - bias)).

Proposal

Add logit_scale: float | None = None to PoolerConfig, passed through to classifier pooler heads. When set, logits are scaled after bias subtraction and before activation:

if self.logit_bias is not None:
    logits -= self.logit_bias
if self.logit_scale is not None:
    logits *= self.logit_scale
if self.activation is not None:
    logits = self.activation(logits)

Default: None (no scaling) — fully backward compatible.

Usage

# No calibration (current behavior, unchanged)
--pooler-config '{"use_activation": true}'

# Bias only (current behavior, unchanged)
--pooler-config '{"use_activation": true, "logit_bias": 0.3}'

# Full Platt scaling (new)
--pooler-config '{"use_activation": true, "logit_bias": 0.3, "logit_scale": 5.0}'

# Temperature scaling (new, special case with bias=0)
--pooler-config '{"use_activation": true, "logit_scale": 2.0}'

Use Cases

1. Cross-encoder rerankers with calibrated scores

Reranking models often produce raw logits that are not calibrated to a [0, 1] probability range. Platt scaling is the standard post-hoc calibration method — two parameters learned on a validation set without retraining the model. With logit_scale, models can ship calibration parameters in their config and produce calibrated scores out of the box.

2. Temperature scaling for confidence calibration

Modern neural networks are often overconfident (Guo et al., 2017). Temperature scaling divides logits by a learned temperature T, equivalent to logit_scale = 1/T. This is the simplest and most effective calibration method for classification models.

3. Score normalization across model versions

When deploying multiple model versions (e.g. v3 and v4 of a reranker), their raw score distributions differ. Affine calibration allows normalizing scores to a consistent range without retraining, enabling seamless model swaps in production.

4. Domain adaptation without fine-tuning

A cross-encoder trained on one domain can be calibrated for a different domain by fitting logit_scale and logit_bias on a small validation set. This is cheaper than fine-tuning and preserves the model weights.

Scope

• 5 files changed, ~17 lines added
• vllm/config/pooler.py — add logit_scale field
• vllm/model_executor/layers/pooler/seqwise/heads.py — apply scale in ClassifierPoolerHead
• vllm/model_executor/layers/pooler/seqwise/poolers.py — pass scale from config
• vllm/model_executor/layers/pooler/tokwise/heads.py — apply scale in TokenClassifierPoolerHead
• vllm/model_executor/layers/pooler/tokwise/poolers.py — pass scale from config
• Zero behavior change for existing models (default is None)
• No new dependencies

References

• Platt, J. (1999). "Probabilistic Outputs for Support Vector Machines and Comparisons to Regularized Likelihood Methods." Advances in Large Margin Classifiers.
• Guo, C. et al. (2017). "On Calibration of Modern Neural Networks." ICML 2017.
• vLLM PoolerConfig.logit_bias — existing precedent for per-model logit adjustment.