Что такое triplet loss?

Triplet Loss

Triplet Loss — это функция потерь для обучения моделей embeddings, где целью является обучить модель различать похожие объекты и непохожие. Активно используется для face recognition, person re-identification, metric learning.

Основная идея

Традиционный подход (классификация):

• Предсказываем класс (0-1000)
• Используем CrossEntropyLoss
• Проблема: не работает для новых классов, не обобщается

Triplet Loss подход:

• Не предсказываем класс
• Учим модель выводить embeddings
• Похожие объекты -> близкие embeddings (маленькое расстояние)
• Непохожие объекты -> далекие embeddings (большое расстояние)

Это позволяет:

• Работать с новыми классами (zero-shot learning)
• Обобщаться на любые объекты похожей природы
• Гибко сравнивать объекты

Определение: Triplet

Triplet состоит из трёх примеров:

1. Anchor (якорь) - исходный пример, например фото лица Alice
2. Positive (позитивный) - другое фото Alice (похожее)
3. Negative (негативный) - фото другого человека (непохожее)

Цель:

• Anchor closer к Positive (маленькое расстояние)
• Anchor farther от Negative (большое расстояние)

Embedding space (2D для визуализации):

        Positive
        /
Anchor
        \
        Negative

Хотим: distance(Anchor, Positive) << distance(Anchor, Negative)

Математическая формула

L = max(d(a, p) - d(a, n) + margin, 0)

Где:
- a = embedding anchor'а
- p = embedding positive'а
- n = embedding negative'а
- d = расстояние (обычно Euclidean)
- margin = "запас" безопасности (например, 0.5)

Объяснение:

• d(a, p) = расстояние anchor->positive (хотим маленькое)
• d(a, n) = расстояние anchor->negative (хотим большое)
• d(a, p) - d(a, n) = разница (хотим отрицательную)
• margin = добавляем запас, чтобы не был равен нулю
• max(..., 0) = если условие выполнено, loss = 0

Примеры

Хороший случай:

d(a, p) = 0.1  # Anchor и Positive близко
d(a, n) = 2.5  # Anchor и Negative далеко
margin = 0.5

loss = max(0.1 - 2.5 + 0.5, 0) = max(-1.9, 0) = 0
# Loss = 0, модель сделала хорошо!

Плохой случай (hard negative):

d(a, p) = 1.2  # Anchor и Positive далеко
d(a, n) = 1.5  # Anchor и Negative немного дальше
margin = 0.5

loss = max(1.2 - 1.5 + 0.5, 0) = max(0.2, 0) = 0.2
# Loss = 0.2, нужно приближать Positive к Anchor и отдалять Negative

Реализация PyTorch

import torch
import torch.nn as nn
import torch.nn.functional as F

class TripletLoss(nn.Module):
    def __init__(self, margin=1.0):
        super().__init__()
        self.margin = margin
    
    def forward(self, anchor, positive, negative):
        """
        anchor: [batch_size, embedding_dim]
        positive: [batch_size, embedding_dim]
        negative: [batch_size, embedding_dim]
        """
        # Euclidean distance
        distance_ap = F.pairwise_distance(anchor, positive, p=2)
        distance_an = F.pairwise_distance(anchor, negative, p=2)
        
        # Triplet loss
        loss = F.relu(distance_ap - distance_an + self.margin)
        return loss.mean()

# Использование
model = MyEmbeddingModel()  # Выводит embedding размера 128
loss_fn = TripletLoss(margin=0.5)
optimizer = torch.optim.Adam(model.parameters())

for epoch in range(100):
    for anchor, positive, negative in dataloader:
        anchor_embedding = model(anchor)
        positive_embedding = model(positive)
        negative_embedding = model(negative)
        
        loss = loss_fn(anchor_embedding, positive_embedding, negative_embedding)
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

Margin - ключевой гиперпараметр

Margin = 0.5 (маленький):

• Позволяет примерам быть ближе
• Быстрее обучается
• Риск: модель выучит слишком слабую семантику

Margin = 2.0 (большой):

• Требует, чтобы примеры были далеко друг от друга
• Медленнее обучается, сложнее сойтись
• Выучивает более отчётливую семантику

Практический совет: начните с margin=0.5-1.0, потом tune.

Проблема: Hard Negative Mining

Трудность triplet loss в том, что большинство triplets слишком легко:

# Типичный triplet (легко)
d(a, p) = 0.2
d(a, n) = 3.0
loss = 0  # уже хорошо, не обновляем

# Hard triplet (нужна работа)
d(a, p) = 1.5
d(a, n) = 1.7
loss = max(1.5 - 1.7 + 0.5, 0) = 0.3  # нужно учиться!

Решение: Hard Negative Mining

• Выбираем triplets, где negative ПОХОЖ на anchor (close to boundary)
• Это самые информативные примеры
• Ускоряет обучение, улучшает качество

def get_hard_triplets(embeddings, labels, margin=0.5):
    """
    embeddings: [N, embedding_dim]
    labels: [N] - метка класса каждого примера
    """
    # Вычислить все pairwise distances
    distances = torch.cdist(embeddings, embeddings, p=2)
    
    hard_triplets = []
    for i in range(len(embeddings)):
        # Положительные: тот же класс, но не сам себя
        positives = (labels == labels[i]) & (torch.arange(len(labels)) != i)
        # Негативные: другой класс
        negatives = labels != labels[i]
        
        if positives.sum() == 0 or negatives.sum() == 0:
            continue
        
        # Найти hard positive (максимальное расстояние)
        hard_positive_idx = distances[i][positives].argmax()
        # Найти hard negative (минимальное расстояние, но больше hard_positive + margin)
        neg_distances = distances[i][negatives]
        hard_negative_idx = neg_distances.argmin()
        
        hard_triplets.append((i, positives.nonzero()[hard_positive_idx].item(), 
                            negatives.nonzero()[hard_negative_idx].item()))
    
    return hard_triplets

Приложения

1. Face Recognition:

• Training: triplets лиц людей
• Inference: embeddings лиц, сравнение расстояниями
• Работает с миллионами лиц

2. Person Re-identification:

• Найти ту же человека на разных камерах
• Triplet loss обучает инвариантное к ракурсу представление

3. Metric Learning:

• Любая задача, где нужно сравнивать подобие
• Image retrieval ("найди похожие картинки")
• Siamese Networks

Варианты Loss

1. Batch Hard Triplet Loss:

• Выбираем hard examples из батча
• Нет нужды создавать triplets заранее
• Более efficient

2. Multi-class Triplet Loss:

• Несколько positives и negatives
• Более сильный сигнал

3. Quadruplet Loss:

• 4 примера: anchor, positive, negative, negative2
• Улучшает разделение между классами

Сравнение с CrossEntropyLoss

Практический совет

# Правильное использование Triplet Loss

# 1. Создай batch с примерами разных классов
batch = DataLoader(dataset, batch_size=32)

# 2. Выбери triplets (hard mining)
triplets = get_hard_triplets(batch)

# 3. Обучи embeddings
embeddings = model(batch)
anchor, positive, negative = triplets
loss = triplet_loss(embeddings[anchor], embeddings[positive], embeddings[negative])

# 4. На inference: просто embeddings!
query_embedding = model(query_image)
gallery_embeddings = model(gallery_images)
distances = torch.cdist(query_embedding, gallery_embeddings)
matches = distances.argmin(dim=1)  #找最近的图像

Triplet Loss изменил компьютерное зрение, позволив обучать модели, которые обобщаются на новые классы без переобучения. Это фундамент modern face recognition систем и person re-ID.