What is the formula for hinge loss?

For a sample with true label y ∈ {−1, +1} and decision-function score f(x), the hinge loss is ℓ = max(0, 1 − y·f(x)). The quantity m = y·f(x) is the margin. If the point is correctly classified and at least one unit past the boundary (m ≥ 1) the loss is 0; otherwise it grows linearly as the margin shrinks or goes negative.

What is the difference between hinge loss and squared hinge loss?

Standard hinge loss is max(0, 1 − m); squared hinge loss squares that value: max(0, 1 − m)². Squaring penalises margin violations more steeply and gives a smooth, differentiable loss everywhere, which some optimisers prefer. Both share the same zero region (m ≥ 1). scikit-learn's LinearSVC exposes both via the `loss` parameter ('hinge' and 'squared_hinge').

Why does hinge loss use labels −1 and +1 instead of 0 and 1?

The margin m = y·f(x) only has the right sign when y is ±1: a correct prediction makes y and f(x) share a sign, so m is positive. With labels 0 and 1 the product would collapse the negative class to 0 and break the margin. This tool maps {0,1} labels to {−1,+1} for you (0 → −1, 1 → +1), matching scikit-learn's requirement that y_true be in {−1, +1}.

Is hinge loss the same as SVM loss?

Hinge loss is the data-fit term of a linear support vector machine. The full soft-margin SVM objective adds an L2 regularisation term, ½‖w‖² + C·Σℓ_i. This calculator reports only the hinge (data-fit) part. It evaluates a given set of scores, it does not train weights, choose C, or apply kernels.

When is hinge loss zero?

Hinge loss is exactly zero for a sample when its margin m = y·f(x) is at least 1, the point is on the correct side of the hyperplane and outside the margin band. Points inside the margin (0 ≤ m < 1) or misclassified (m < 0) incur positive loss. This is why an SVM only cares about the support vectors near or across the margin.

What decision score should I enter: a probability?

No. Enter the raw decision-function value f(x), the signed distance from the separating hyperplane, which in scikit-learn comes from `decision_function`, not `predict_proba`. Hinge loss is defined on these unbounded scores, not on calibrated 0–1 probabilities. If you have probabilities, log loss (cross-entropy) is the matching metric instead.

How does the calculator handle sample weights?

Add an optional third number on a row (label, score, weight) to weight that sample. The mean then becomes the weighted average Σ wᵢ·ℓᵢ / Σ wᵢ and the sum becomes Σ wᵢ·ℓᵢ, exactly as scikit-learn's `sample_weight` argument works. Leave the weight off and every sample counts equally.

Does this match scikit-learn's hinge_loss exactly?

Yes for the binary case. It uses the same definition, max(0, 1 − y·f(x)) with y ∈ {−1, +1} and a mean over samples, that sklearn.metrics.hinge_loss documents. The default example returns a mean hinge loss of 0.75, which agrees with sklearn on the same inputs. The multiclass Crammer–Singer variant (a score matrix per sample) is out of scope for this version.

Machine learning · Metrics

Hinge Loss Calculator (SVM / Squared Hinge Loss)

Paste your true labels and decision scores to get the hinge loss max(0, 1 − y·f(x)) , mean or sum, standard or squared, with a per-sample breakdown that shows which points fall inside the margin. Matches scikit-learn's hinge_loss. No signup, runs in your browser.

By Induwara Ashinsana— Co-Founder, Ryzera TechnologiesUpdated Jul 12, 2026

Hinge lossSVM / squared hinge

scikit-learn verified

Samples, one per line: label, score (optional third value = sample weight)

The score is the decision-function value f(x), a signed distance, not a probability. Separate with a comma, space, or | . Up to 2,000 rows.

Examples

Label convention

Loss variant

Reduction

Hinge · mean

0.75

4 samples

Mean squared hinge

0.995

for comparison

Margin violations

3 / 4

samples with m < 1

Cross-check

✓ matches

via (x+|x|)/2 identity

Reading: 3 of 4 samples fall inside the margin (m < 1) and contribute loss. Loss is dominated by the sample on line 4.

Per-sample breakdown

#	y	Score f(x)	Margin	Hinge	Sq. hinge	Margin
1	+1	0.8	0.8	0.2	0.04	violated
2	−1	-1.2	1.2	0	0	safe
3	+1	-0.3	-0.3	1.3	1.69	violated
4	−1	0.5	-0.5	1.5	2.25	violated

Computed in your browser, no data is uploaded.

How it works

Hinge loss is the loss function behind the support vector machine (SVM). For each sample it measures how badly a linear classifier violates the margin, the band of width 2 around the separating hyperplane. This calculator follows the definition published in scikit-learn's sklearn.metrics.hinge_loss reference and the soft-margin formulation introduced by Cortes and Vapnik (1995).

Map the labels. Each true label must be ±1. If your data uses {0, 1}, the tool maps 0 → −1 and 1 → +1 so the margin gets the correct sign (scikit-learn requires y_true ∈ {−1, +1}).
Compute the margin. For every sample, m = y · f(x), where f(x) is the decision-function score (a signed distance), not a probability. A large positive margin means confidently correct; a negative margin means misclassified.
Apply the hinge. Standard hinge: ℓ = max(0, 1 − m). Squared hinge: ℓ = max(0, 1 − m)². Any sample with m ≥ 1 contributes exactly 0. It is correct and safely outside the margin.
Reduce. The mean (1/N)·Σ ℓᵢ is scikit-learn's default; the sum Σ ℓᵢ is also offered. If you supply per-sample weights, the mean becomes the weighted average Σ wᵢ·ℓᵢ / Σ wᵢ, matching the metric's sample_weight argument.

Every result is verified two ways. The per-sample loss is computed both with Math.max(0, 1 − m) and with the algebraic identity max(0, x) = (x + |x|) / 2; the two agree to floating-point tolerance, which the “Cross-check” tile reports. Because hinge loss consumes decision scores rather than calibrated probabilities, it is the wrong tool for a model that outputs probabilities, reach for log loss (cross-entropy) there instead.

Worked examples

Mixed classifier (the default inputs)

labels {−1,+1}, mean reduction

Samples (y, f): (+1, 0.8) (−1, −1.2) (+1, −0.3) (−1, 0.5)
Margins m = y·f(x): 0.8, 1.2, −0.3, −0.5
Hinge: max(0,1−0.8)=0.2, max(0,1−1.2)=0, max(0,1.3)=1.3, max(0,1.5)=1.5
Mean hinge = (0.2 + 0 + 1.3 + 1.5) / 4 = 3.0 / 4 = 0.75
Squared: (0.04 + 0 + 1.69 + 2.25) / 4 = 3.98 / 4 = 0.995
Margin violated (m < 1) for samples 1, 3, 4 → 3 of 4

Confident, all-correct classifier

every margin ≥ 1

Samples (y, f): (+1, 2.0) (−1, −3.0)
Margins: 2.0 and 3.0, both ≥ 1
Hinge: max(0, 1 − 2.0) = 0 and max(0, 1 − 3.0) = 0
Mean hinge = 0.0, loss vanishes even though the scores aren't probabilities

On the margin (off-by-one edge case)

a boundary point contributes nothing

Sample (y, f): (+1, 1.0)
Margin m = 1·1.0 = 1.0
Hinge: max(0, 1 − 1.0) = max(0, 0) = 0
m < 1 is FALSE at exactly 1, so the margin is NOT counted as violated
A point sitting precisely on the margin edge adds zero loss

Frequently asked questions

Sources & references

Definitions and worked examples were last cross-checked against the scikit-learn documentation on 2026-07-12. The binary hinge and squared-hinge formulas here reproduce sklearn.metrics.hinge_loss to the digits shown.

Related tools

Cross-Entropy Loss Calc

Compute cross-entropy (log) loss for binary and multi-class classification from labels and predicted probabilities or logits. Shows per-sample loss, the mean log-loss metric, perplexity and full step-by-step working, matches scikit-learn log_loss and PyTorch CrossEntropyLoss, entirely in the browser.

Open tool

Huber Loss Calculator

Compute Huber loss L_δ(a) = 0.5·a² if |a| ≤ δ, else δ·(|a| − 0.5·δ), and the PyTorch Smooth L1 loss, from predicted and actual values. Shows the reduced loss, per-element quadratic-vs-linear region split, MSE and MAE for context, and full working, matches torch.nn.HuberLoss / SmoothL1Loss, cross-checked via the SmoothL1(β) = Huber(δ)/β identity, entirely in the browser.

Open tool

Focal Loss Calculator

Compute focal loss FL(p_t) = −α_t(1 − p_t)^γ ln(p_t) for binary and multiclass predictions. Shows the focal loss, plain cross-entropy, modulating factor, α-weight, down-weighting ratio and batch mean, with full working, the loss that trains RetinaNet, cross-checked against torchvision sigmoid_focal_loss, entirely in the browser.

Open tool

Comments & feedback

Spotted a bug or want an improvement? Tell us, our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] , most fixes ship within 24 hours.