Привет, Хабр!
Стандартные loss‑функции, такие как MSE или CrossEntropy, хороши, но часто им не хватает гибкости для сложных задач. Допустим, есть тот же проект с огромным дисбалансом классов, или хочется внедрить специфическую регуляризацию прямо в функцию потерь. Стандартный функционал тут бессилен — тут на помощь приходят кастомные loss'ы.
Custom Loss Functions в TensorFlow/Keras
TensorFlow/Keras радуют удобным API, но за простоту приходится платить вниманием к деталям.
Focal Loss
Focal Loss помогает сместить фокус обучения на сложные примеры, снижая влияние легко классифицируемых данных:
import tensorflow as tf
from tensorflow.keras import backend as K
def focal_loss(gamma=2., alpha=0.25):
"""
Реализация Focal Loss для задач с дисбалансом классов.
:param gamma: фокусирующий параметр для усиления влияния сложных примеров.
:param alpha: коэффициент балансировки классов.
:return: функция потерь, принимающая (y_true, y_pred).
"""
def focal_loss_fixed(y_true, y_pred):
# Защита от log(0) – обрезаем значения предсказаний.
y_pred = K.clip(y_pred, K.epsilon(), 1. - K.epsilon())
# Вычисляем кросс-энтропию для каждого примера.
cross_entropy = -y_true * tf.math.log(y_pred)
# Применяем вес для "тяжёлых" примеров.
weight = alpha * tf.pow(1 - y_pred, gamma)
loss = weight * cross_entropy
# Усредняем по батчу и классам.
return tf.reduce_mean(tf.reduce_sum(loss, axis=-1))
return focal_loss_fixed
# Пример использования Focal Loss:
if __name__ == "__main__":
# Тестовые данные для отладки (да, я тоже люблю маленькие эксперименты)
y_true = tf.constant([[1, 0], [0, 1]], dtype=tf.float32)
y_pred = tf.constant([[0.9, 0.1], [0.2, 0.8]], dtype=tf.float32)
loss_fn = focal_loss(gamma=2.0, alpha=0.25)
loss_value = loss_fn(y_true, y_pred)
print("Focal Loss:", loss_value.numpy())Интеграция кастомного loss в модель Keras
Создадим простую CNN‑модель для распознавания изображений и подключим Focal Loss:
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
def create_model(input_shape=(28, 28, 1), num_classes=10):
model = Sequential([
Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape),
MaxPooling2D(pool_size=(2, 2)),
Flatten(),
Dense(128, activation='relu'),
Dense(num_classes, activation='softmax')
])
return model
# Компилируем модель с кастомной функцией потерь
model = create_model()
model.compile(optimizer='adam', loss=focal_loss(gamma=2.0, alpha=0.25), metrics=['accuracy'])
# Создадим тестовые данные (набор из случайных изображений и меток)
import numpy as np
X_train = np.random.rand(100, 28, 28, 1)
y_train = tf.keras.utils.to_categorical(np.random.randint(0, 10, 100), num_classes=10)
print("Запускаем обучение модели с кастомным Focal Loss...")
model.fit(X_train, y_train, epochs=3, batch_size=16)Модель обучается и градиенты сходятся.
Нюансы вычисления градиентов
Нельзя забывать — любые операции, выполняемые с numpy, ломают автоматическое вычисление градиентов. Пример плохой практики:
import numpy as np
import tensorflow as tf
def loss_with_numpy(y_true, y_pred):
# Плохая практика: переводим тензоры в numpy и разрываем градиентный поток.
y_true_np = y_true.numpy() # Ой-ой, ошибка внутри GradientTape!
y_pred_np = y_pred.numpy()
loss_np = np.mean((y_true_np - y_pred_np) ** 2)
return tf.constant(loss_np, dtype=tf.float32)
if __name__ == "__main__":
x = tf.constant([[1.0], [2.0]])
y_true = tf.constant([[1.5], [2.5]])
with tf.GradientTape() as tape:
tape.watch(x)
y_pred = x * 2
try:
loss = loss_with_numpy(y_true, y_pred)
grad = tape.gradient(loss, x)
print("Gradient:", grad)
except Exception as e:
print("Ошибка при вычислении градиента:", e)Оставайтесь в мире тензоров — TensorFlow умеет всё, что нужно, если вы не решите подмешать туда numpy.
Custom Loss Functions в PyTorch
Реализация кастомной loss через torch.autograd.Function
Начнем с простейшей реализации кастомной loss‑функции, которая считает квадратичную ошибку:
import torch
class CustomLossFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, input, target):
"""
Прямой проход: вычисляем MSE.
"""
ctx.save_for_backward(input, target)
loss = torch.mean((input - target) ** 2)
return loss
@staticmethod
def backward(ctx, grad_output):
"""
Обратный проход: аккуратно считаем градиенты.
"""
input, target = ctx.saved_tensors
grad_input = grad_output * 2 * (input - target) / input.numel()
return grad_input, None
# Тестовый пример использования:
if __name__ == "__main__":
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = torch.tensor([1.5, 2.5, 3.5])
loss = CustomLossFunction.apply(x, y)
print("Custom Loss (PyTorch):", loss.item())
loss.backward()
print("Gradient (PyTorch):", x.grad)Focal Loss в PyTorch
Focal Loss существует не только в TensorFlow. В PyTorch можно сделать не хуже:
import torch
import torch.nn as nn
import torch.nn.functional as F
class FocalLoss(nn.Module):
def __init__(self, alpha=0.25, gamma=2.0, reduction='mean'):
super(FocalLoss, self).__init__()
self.alpha = alpha
self.gamma = gamma
self.reduction = reduction
def forward(self, inputs, targets):
# Если inputs – логиты, используем sigmoid для преобразования
BCE_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction='none')
pt = torch.exp(-BCE_loss)
focal_loss = self.alpha * (1 - pt) ** self.gamma * BCE_loss
if self.reduction == 'mean':
return focal_loss.mean()
elif self.reduction == 'sum':
return focal_loss.sum()
else:
return focal_loss
# Тестируем Focal Loss в PyTorch:
if __name__ == "__main__":
inputs = torch.tensor([[0.2, -1.0], [1.5, 0.3]], requires_grad=True)
targets = torch.tensor([[0, 1], [1, 0]], dtype=torch.float32)
criterion = FocalLoss(alpha=0.25, gamma=2.0)
loss = criterion(inputs, targets)
print("Focal Loss (PyTorch):", loss.item())
loss.backward()
print("Gradients (Focal Loss):", inputs.grad)Работа с эмбеддингами
Для задач, где нужно сравнивать схожесть объектов, подойдут Contrastive и Triplet Loss. Реализуем их в PyTorch.
Contrastive Loss
class ContrastiveLoss(nn.Module):
def __init__(self, margin=1.0):
super(ContrastiveLoss, self).__init__()
self.margin = margin
def forward(self, output1, output2, label):
# Евклидова дистанция между эмбеддингами
euclidean_distance = F.pairwise_distance(output1, output2)
loss_contrastive = torch.mean((1 - label) * torch.pow(euclidean_distance, 2) +
(label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2))
return loss_contrastive
# Пример использования Contrastive Loss:
if __name__ == "__main__":
output1 = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)
output2 = torch.tensor([[1.5, 2.5], [2.5, 3.5]], requires_grad=True)
# label: 0 для похожих пар, 1 для непохожих.
label = torch.tensor([0, 1], dtype=torch.float32)
criterion = ContrastiveLoss(margin=1.0)
loss = criterion(output1, output2, label)
print("Contrastive Loss:", loss.item())
loss.backward()Triplet Loss
class TripletLoss(nn.Module):
def __init__(self, margin=1.0):
super(TripletLoss, self).__init__()
self.margin = margin
def forward(self, anchor, positive, negative):
pos_distance = F.pairwise_distance(anchor, positive, p=2)
neg_distance = F.pairwise_distance(anchor, negative, p=2)
losses = torch.relu(pos_distance - neg_distance + self.margin)
return losses.mean()
# Пример использования Triplet Loss:
if __name__ == "__main__":
anchor = torch.tensor([[1.0, 2.0], [2.0, 3.0]], requires_grad=True)
positive = torch.tensor([[1.1, 2.1], [1.9, 2.9]], requires_grad=True)
negative = torch.tensor([[3.0, 4.0], [4.0, 5.0]], requires_grad=True)
criterion = TripletLoss(margin=1.0)
loss = criterion(anchor, positive, negative)
print("Triplet Loss:", loss.item())
loss.backward()Если вам хочется поделиться опытом — пишите в комментариях.
Все актуальные методы и инструменты DS и ML можно освоить на онлайн-курсах OTUS: в каталоге можно посмотреть список всех программ, а в календаре — записаться на открытые уроки.