Что такое функция ошибки?

Функция ошибки (Loss Function)

Функция ошибки (loss function) — это математическая функция, которая измеряет, насколько хорошо модель предсказывает целевые значения. Она является центральной концепцией в машинном обучении, определяя качество модели и направление её оптимизации.

Общая концепция

Для каждого примера модель делает предсказание y_pred, а правильный ответ y_true:

Loss = f(y_true, y_pred)

Цель обучения: найти веса модели, которые минимизируют функцию ошибки.

Основные типы функций ошибки

1. Mean Squared Error (MSE) — для регрессии

Наиболее популярная для задач предсказания непрерывных значений:

import numpy as np
from sklearn.metrics import mean_squared_error

y_true = np.array([3.0, -0.5, 2.0, 7.0])
y_pred = np.array([2.5, 0.0, 2.0, 8.0])

# MSE = (1/n) * sum((y_true - y_pred)^2)
mse = mean_squared_error(y_true, y_pred)
print(f'MSE: {mse}')  # Output: 0.375

# В TensorFlow
import tensorflow as tf
loss_fn = tf.keras.losses.MeanSquaredError()
loss = loss_fn(y_true, y_pred)

Плюсы: Гладкая функция, хорошо оптимизируется Минусы: Чувствительна к выбросам (outliers)

2. Mean Absolute Error (MAE) — для регрессии

Менее чувствительна к выбросам:

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(y_true, y_pred)
print(f'MAE: {mae}')  # Менее 'штрафует' большие ошибки

3. Cross-Entropy Loss — для классификации

Золотой стандарт для задач классификации:

import tensorflow as tf
from sklearn.metrics import log_loss

y_true = [0, 1, 1, 0]
y_pred_proba = [0.1, 0.9, 0.8, 0.2]  # Вероятности

# Cross-Entropy Loss = -mean(y_true * log(y_pred) + (1 - y_true) * log(1 - y_pred))
ce_loss = log_loss(y_true, y_pred_proba)
print(f'Cross-Entropy: {ce_loss}')

# В TensorFlow (для бинарной классификации)
loss_fn = tf.keras.losses.BinaryCrossentropy()
loss = loss_fn(y_true, y_pred_proba)

# Для многоклассовой классификации
y_true_categorical = tf.keras.utils.to_categorical([0, 2, 1, 0], 3)
y_pred_categorical = tf.keras.utils.to_categorical([0, 2, 1, 0], 3)
loss_fn = tf.keras.losses.CategoricalCrossentropy()

Почему она хороша:

• Штрафует неправильные уверенные предсказания
• Поощряет модель быть более уверенной в правильных предсказаниях

4. Focal Loss — для несбалансированной классификации

Снижает вес легко классифицируемых примеров:

import tensorflow as tf

# Focal Loss особенно полезна для задач типа detection
loss_fn = tf.keras.losses.BinaryFocalCrossentropy(alpha=0.25, gamma=2.0)

5. Huber Loss — гибрид MSE и MAE

Одновременно гладкая (как MSE) и устойчива к выбросам (как MAE):

import tensorflow as tf

loss_fn = tf.keras.losses.Huber(delta=1.0)

Практический пример: выбор loss function

import tensorflow as tf
from tensorflow.keras import layers, Sequential

# Задача 1: Регрессия (предсказание цены)
model_regression = Sequential([
    layers.Dense(64, activation='relu', input_shape=(10,)),
    layers.Dense(1)  # Выходной слой
])

model_regression.compile(
    optimizer='adam',
    loss='mse',  # Mean Squared Error для регрессии
    metrics=['mae']
)

# Задача 2: Бинарная классификация (спам/не спам)
model_binary = Sequential([
    layers.Dense(64, activation='relu', input_shape=(100,)),
    layers.Dense(1, activation='sigmoid')  # Sigmoid для бинарной
])

model_binary.compile(
    optimizer='adam',
    loss='binary_crossentropy',  # Cross-entropy для классификации
    metrics=['accuracy']
)

# Задача 3: Многоклассовая классификация (MNIST 0-9)
model_multiclass = Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dense(10, activation='softmax')  # Softmax для многоклассовой
])

model_multiclass.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

Влияние на процесс оптимизации

Как loss влияет на градиенты:

# Loss определяет направление обновления весов
# dW = -learning_rate * dL/dW

# Пример: если loss = MSE
# dL/dW зависит от (y_true - y_pred)
# Большая ошибка -> больший градиент -> большее обновление

Градиент для MSE:

# dMSE/dW = -2/n * sum((y_true - y_pred) * dy_pred/dW)
# Если y_true=10, y_pred=2, то (y_true - y_pred) = 8 (большой сигнал)

Custom Loss Function

Для специальных задач можно написать собственную функцию:

import tensorflow as tf

def custom_loss(y_true, y_pred):
    # Пример: квадратичная ошибка с весом
    return tf.reduce_mean(tf.square(y_true - y_pred) * y_true)

model = Sequential([...]) 
model.compile(
    optimizer='adam',
    loss=custom_loss,
    metrics=['mae']
)

# Или через класс
class WeightedMSE(tf.keras.losses.Loss):
    def call(self, y_true, y_pred):
        mse = tf.square(y_true - y_pred)
        weights = tf.where(y_true > 0, 2.0, 1.0)  # Взвешивание
        return tf.reduce_mean(mse * weights)

model.compile(
    optimizer='adam',
    loss=WeightedMSE(),
    metrics=['mae']
)

Таблица выбора Loss Function

Best Practices

1. Выбирай loss в зависимости от задачи, не наоборот
2. Нормализуй выходы (особенно для MSE)
3. Если классы несбалансированы, используй Weighted Loss или Focal Loss
4. Мониторь loss во время обучения (он должен уменьшаться)
5. Используй разные loss для train и eval если нужно