Leer Hinge Loss and Margin-based Classification | Classification Loss Functions

The hinge loss is a fundamental loss function in margin-based classification, particularly in support vector machines (SVMs). Its mathematical definition is:

L_{hinge}(y, f(x)) = \max(0, 1 - y f(x))\ \ \text{for} \ \ y \in \{-1, 1\}

Here, $y$ represents the true class label (either $-1$ or $1$ ), and $f(x)$ is the prediction score from your classifier. The loss is zero when the prediction is not only correct but also confidently correct—meaning the product $y f(x)$ is at least $1$ . If $y f(x)$ is less than $1$ , the loss increases linearly as the prediction moves further from the desired margin.


              123456789101112131415
            
import numpy as np
import matplotlib.pyplot as plt

score = np.linspace(-2, 2, 400)   # f(x)
y = 1                             # visualize for the positive class

hinge = np.maximum(0, 1 - y * score)

plt.plot(score, hinge)
plt.title("Hinge Loss for y = 1")
plt.xlabel("Prediction Score f(x)")
plt.ylabel("Loss")
plt.axvline(1, color="gray", linestyle="--", label="Margin boundary")
plt.legend()
plt.show()

This clearly shows:

Loss = 0 when score ≥ 1 (correct & confident);
Linear penalty when score < 1;
Very steep penalty when the score is negative (wrong side).

Note

Hinge loss encourages a margin of separation between classes, not just correct classification. This margin-based approach means that even correctly classified examples can still incur loss if they are too close to the decision boundary, promoting more robust and generalizable classifiers.

Geometrically, hinge loss leads to margin maximization. In SVMs, the goal is not only to separate classes but to maximize the distance (margin) between the closest points of each class and the decision boundary. A larger margin typically results in a classifier that is less sensitive to small changes or noise in the input data, thereby improving robustness. This geometric interpretation distinguishes hinge loss from other loss functions that only penalize incorrect classifications without considering the confidence or distance from the boundary.


              12345678
            
import numpy as np

scores = np.array([-1.5, -0.2, 0.3, 1.0, 2.0])
y = 1
loss = np.maximum(0, 1 - y * scores)

for s, l in zip(scores, loss):
    print(f"score={s:>4} → hinge loss={l:.2f}")

Shows the key behavior:

Score ≥ 1 → no loss;
Slightly positive score but < 1 → small loss;
Wrong side of the boundary → large penalty.

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 3

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Suggested prompts:

Can you explain why hinge loss is preferred in SVMs over other loss functions?

How does hinge loss compare to cross-entropy loss in classification tasks?

Can you show how hinge loss behaves for the negative class (y = -1)?

Awesome!

Completion rate improved to 6.67

Veeg om het menu te tonen