PyTorch: оценка и отладка моделей

Обучение и оптимизация моделей глубокого обучения требуют систематических методов оценки и отладки. В этом разделе рассказывается, как анализировать кривые потерь, выявлять переобучение и недообучение, использовать матрицы ошибок для оценки моделей классификации и распространённые методы отладки.


1. Анализ функции потерь

Функция потерь — ключевая метрика во время обучения, отражающая разрыв между предсказаниями модели и истинными значениями. Правильный анализ кривой потерь — ключ к отладке моделей.

1.1 Сравнение потерь при обучении и валидации

Сравнивая потери при обучении и потери при валидации, можно определить состояние модели:

  • Потери при обучении уменьшаются, потери при валидации уменьшаются: нормально, модель обучается
  • Потери при обучении уменьшаются, потери при валидации стабильны или растут: переобучение, требуется регуляризация
  • Потери при обучении не уменьшаются: проблема со скоростью обучения или с архитектурой модели
  • Потери при обучении колеблются: слишком большая скорость обучения или слишком маленький размер батча

1.2 Визуализация кривой потерь

Пример

import matplotlib.pyplot as plt
import numpy as np

def plot_training_history(history):
    """
Построение истории обучения
history: словарь, содержащий 'train_loss', 'val_loss', 'train_acc', 'val_acc'
    """

    fig, axes = plt.subplots(1, 2, figsize=(14, 5))

    # Кривая потерь
    axes[0].plot(history['train_loss'], label='Потери на обучении', alpha=0.8)
    axes[0].plot(history['val_loss'], label='Потери на валидации', alpha=0.8)
    axes[0].set_xlabel('Эпоха')
    axes[0].set_ylabel('Потери')
    axes[0].set_title('Потери на обучении и валидации')
    axes[0].legend()
    axes[0].grid(True, alpha=0.3)

    # Кривая точности
    axes[1].plot(history['train_acc'], label='Точность на обучении', alpha=0.8)
    axes[1].plot(history['val_acc'], label='Точность на валидации', alpha=0.8)
    axes[1].set_xlabel('Эпоха')
    axes[1].set_ylabel('Точность')
    axes[1].set_title('Точность на обучении и валидации')
    axes[1].legend()
    axes[1].grid(True, alpha=0.3)

    plt.tight_layout()
    plt.show()


# Имитация обучающих данных
history = {
    'train_loss': np.linspace(2.0, 0.2, 50) + np.random.normal(0, 0.05, 50),
    'val_loss': np.linspace(2.0, 0.3, 50) + np.random.normal(0, 0.08, 50),
    'train_acc': np.linspace(0.3, 0.95, 50),
    'val_acc': np.linspace(0.3, 0.88, 50),
}

plot_training_history(history)

1.3 Выявление переобучения

Когда потери на валидации начинают расти, а потери на обучении продолжают снижаться, это начало переобучения. В этот момент модель начинает "запоминать" обучающие данные вместо изучения общих закономерностей.

Пример

import matplotlib.pyplot as plt
import numpy as np

def detect_overfitting(history, patience=5):
    """
Обнаружение переобучения
patience: количество последовательных эпох с увеличением потери на валидации перед остановкой обучения
    """

    val_loss = history['val_loss']
    best_loss = float('inf')
    best_epoch = 0
    early_stop_epoch = None

    for epoch in range(patience, len(val_loss)):
        # Проверить последние эпохи patience
        recent_losses = val_loss[epoch - patience:epoch]
        current_loss = val_loss[epoch]

        # Если текущая потеря выше, чем последняя минимальная потеря
        if min(recent_losses) < current_loss:
            early_stop_epoch = epoch
            break

        if current_loss < best_loss:
            best_loss = current_loss
            best_epoch = epoch

    if early_stop_epoch:
        print(f"Обнаружено переобучение! Лучшая эпоха: {best_epoch}, следует остановиться на эпохе {early_stop_epoch}")
    else:
        print("Переобучение не обнаружено")

    return early_stop_epoch, best_epoch


# Пример переобучения
overfitting_history = {
    'train_loss': np.linspace(1.5, 0.1, 30),
    'val_loss': np.concatenate([np.linspace(1.5, 0.3, 15), np.linspace(0.3, 0.8, 15)]),
}

detect_overfitting(overfitting_history)

2. Обработка переобучения и недообучения

2.1 Решения проблемы переобучения

Метод Описание Реализация кода
Увеличение объёма данных Сбор большего объёма обучающих данных Аугментация данных
Dropout Случайное отключение нейронов nn.Dropout(0.5)
Затухание весов L2-регуляризация weight_decay=1e-4
Ранняя остановка Останавливать обучение, когда потеря на валидации перестаёт уменьшаться параметр patience
Уменьшить сложность модели Уменьшить количество слоёв или нейронов Уменьшить hidden_size
Аугментация данных Случайные преобразования для увеличения разнообразия данных Поворот, отражение, обрезка

2.2 Решения при недообучении

Метод Описание
Увеличить сложность модели Увеличьте количество слоёв или нейронов
Обучайте дольше Увеличьте количество эпох обучения
Уменьшите регуляризацию Уменьшите Dropout или weight_decay
Отрегулируйте скорость обучения Попробуйте более высокую скорость обучения

2.3 Реализация механизма ранней остановки

Пример

import torch
import torch.nn as nn
import torch.optim as optim

class EarlyStopping:
    """
Механизм ранней остановки: остановите обучение, когда потеря на валидации не уменьшается в течение нескольких эпох подряд
    """

    def __init__(self, patience=7, min_delta=0, mode='min'):
        """
patience: остановиться после скольких последовательных эпох без улучшения
min_delta: минимальное изменение, рассматриваемое как улучшение
mode: 'min' или 'max', следует ли минимизировать или максимизировать метрику
        """

        self.patience = patience
        self.min_delta = min_delta
        self.mode = mode
        self.counter = 0
        self.best_score = None
        self.early_stop = False

    def __call__(self, val_loss):
        score = -val_loss if self.mode == 'min' else val_loss

        if self.best_score is None:
            self.best_score = score
        elif score < self.best_score + self.min_delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_score = score
            self.counter = 0

        return self.early_stop


# Использовать раннюю остановку
def train_with_early_stopping(model, train_loader, val_loader, patience=7):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    early_stopping = EarlyStopping(patience=patience, mode='min')

    best_val_loss = float('inf')
    best_model_state = None

    for epoch in range(100):
        # Обучить
        model.train()
        train_loss = 0
        for inputs, labels in train_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            train_loss += loss.item()

        # Валидация
        model.eval()
        val_loss = 0
        with torch.no_grad():
            for inputs, labels in val_loader:
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)
                loss = criterion(outputs, labels)
                val_loss += loss.item()

        val_loss /= len(val_loader)

        print(f"Эпоха {epoch+1}: Потери на обучении={train_loss:.4f}, Потери на валидации={val_loss:.4f}")

        # Проверка ранней остановки
        if early_stopping(val_loss):
            print(f"Сработала ранняя остановка! Потери на валидации не уменьшались в течение {patience} последовательных эпох")

        # Сохранение лучшей модели
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            best_model_state = model.state_dict().copy()

    # Восстановление лучшей модели
    model.load_state_dict(best_model_state)
    return model

3. Матрица ошибок

Матрица ошибок — важный инструмент для оценки моделей классификации, показывающий связь между предсказаниями модели и истинными метками.

3.1 Вычисление матрицы ошибок

Пример

import torch
import numpy as np
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

def calculate_confusion_matrix(model, dataloader, device, num_classes):
    """
Вычислить матрицу ошибок
    """

    model.eval()
    all_preds = []
    all_labels = []

    with torch.no_grad():
        for inputs, labels in dataloader:
            inputs = inputs.to(device)
            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)

            all_preds.extend(preds.cpu().numpy())
            all_labels.extend(labels.numpy())

    cm = confusion_matrix(all_labels, all_preds)
    return cm


def plot_confusion_matrix(cm, class_names):
    """
Построить матрицу ошибок
    """

    plt.figure(figsize=(10, 8))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
                xticklabels=class_names, yticklabels=class_names)
    plt.xlabel('Предсказанная метка')
    plt.ylabel('Истинная метка')
    plt.title('Матрица ошибок')
    plt.tight_layout()
    plt.show()


# Пример использования
# Предположим, что есть 10 классов
class_names = [f'Класс {i}' for i in range(10)]
cm = np.array([
    [45, 1, 0, 0, 0, 0, 2, 1, 1, 0],
    [0, 42, 2, 0, 0, 0, 0, 3, 2, 1],
    [1, 1, 38, 3, 0, 0, 0, 2, 3, 2],
    [0, 0, 1, 41, 2, 1, 0, 1, 1, 3],
    [0, 0, 0, 1, 44, 0, 1, 0, 2, 2],
    [1, 0, 0, 0, 0, 43, 2, 1, 1, 2],
    [2, 1, 0, 0, 1, 1, 39, 2, 2, 2],
    [0, 2, 1, 1, 0, 0, 1, 40, 3, 2],
    [1, 2, 2, 0, 1, 1, 1, 2, 36, 4],
    [0, 1, 1, 2, 2, 2, 2, 1, 2, 37],
])

plot_confusion_matrix(cm, class_names)

3.2 Метрики оценки классификации

Из матрицы ошибок можно вычислить несколько метрик оценки:

Пример

import numpy as np

def classification_metrics(cm):
    """
Вычислите различные метрики оценки по матрице ошибок
    """

    # Точность
    accuracy = np.trace(cm) / np.sum(cm)

    # Вычислить precision, recall, F1 для каждого класса
    num_classes = cm.shape[0]
    precisions = []
    recalls = []
    f1s = []

    for i in range(num_classes):
        tp = cm[i, i]
        fp = np.sum(cm[:, i]) - tp
        fn = np.sum(cm[i, :]) - tp

        precision = tp / (tp + fp) if (tp + fp) > 0 else 0
        recall = tp / (tp + fn) if (tp + fn) > 0 else 0
        f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0

        precisions.append(precision)
        recalls.append(recall)
        f1s.append(f1)

    # Макро-усреднение
    macro_precision = np.mean(precisions)
    macro_recall = np.mean(recalls)
    macro_f1 = np.mean(f1s)

    # Взвешенное усреднение
    class_counts = np.sum(cm, axis=1)
    weights = class_counts / np.sum(class_counts)
    weighted_precision = np.average(precisions, weights=weights)
    weighted_recall = np.average(recalls, weights=weights)
    weighted_f1 = np.average(f1s, weights=weights)

    return {
        'accuracy': accuracy,
        'macro_precision': macro_precision,
        'macro_recall': macro_recall,
        'macro_f1': macro_f1,
        'weighted_precision': weighted_precision,
        'weighted_recall': weighted_recall,
        'weighted_f1': weighted_f1,
    }


# Вычисление метрик
metrics = classification_metrics(cm)

print("=" * 50)
print("Метрики оценки классификации")
print("=" * 50)
print(f"Accuracy: {metrics['accuracy']:.4f}")
print(f"Macro Precision: {metrics['macro_precision']:.4f}")
print(f"Макро-полнота: {metrics['macro_recall']:.4f}")
print(f"Макро F1: {metrics['macro_f1']:.4f}")
print(f"Взвешенная точность: {metrics['weighted_precision']:.4f}")
print(f"Взвешенная полнота: {metrics['weighted_recall']:.4f}")
print(f"Взвешенный F1: {metrics['weighted_f1']:.4f}")

3.3 Отчёт о классификации

Пример

from sklearn.metrics import classification_report

# Использовать отчёт о классификации из sklearn
y_true = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10  # Смоделировать истинные метки
y_pred = [0, 1, 2, 3, 4, 5, 6, 7, 8, 8] * 10  # Смоделировать предсказания

report = classification_report(y_true, y_pred, digits=4)
print(report)

4. Планирование скорости обучения

Скорость обучения — один из самых важных гиперпараметров для обучения моделей глубокого обучения. Правильное планирование скорости обучения может значительно повысить эффективность обучения.

4.1 Стратегии планирования скорости обучения

Стратегия Описание Применимые сценарии
StepLR Затухание с фиксированным шагом Когда оптимальная скорость обучения известна
MultiStepLR Затухание на указанных эпохах Неравномерное затухание
CosineAnnealingLR Косинусное охлаждение Плавная сходимость
ReduceLROnPlateau Затухание, когда потеря на валидации перестаёт уменьшаться Автоматическая настройка
Разогрев Сначала увеличение, затем уменьшение Стабилизация раннего обучения

4.2 Реализация планирования скорости обучения

Пример

import torch
import torch.optim as optim
import matplotlib.pyplot as plt

# Симуляция эпох обучения
epochs = 50

# 1. Step LR: уменьшение вдвое каждые 10 эпох
scheduler_step = optim.lr_scheduler.StepLR(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    step_size=10, gamma=0.5
)

# 2. MultiStep LR: уменьшение на заданных эпохах
scheduler_multistep = optim.lr_scheduler.MultiStepLR(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    milestones=[15, 30, 45], gamma=0.1
)

# 3. Косинусный отжиг
scheduler_cosine = optim.lr_scheduler.CosineAnnealingLR(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    T_max=50
)

# 4. ReduceLROnPlateau
scheduler_plateau = optim.lr_scheduler.ReduceLROnPlateau(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    mode='min', factor=0.5, patience=5
)

# Построение кривых скорости обучения
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Шаг LR
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler_step.step()
axes[0, 0].plot(lr_history)
axes[0, 0].set_title('Пошаговый LR')

# Переинициализация
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[15, 30, 45], гамма=0.1)
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler.step()
axes[0, 1].plot(lr_history)
axes[0, 1].set_title('Многошаговый LR')

# Косинус
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler.step()
axes[1, 0].plot(lr_history)
axes[1, 0].set_title('Косинусное затухание LR')

# Разогрев + косинус
def warmup_cosine(optimizer, warmup_epochs, total_epochs, min_lr=1e-6):
    def lr_lambda(epoch):
        if epoch < warmup_epochs
            return epoch / warmup_epochs
        return min_lr + 0.5 * (1 - min_lr⟦⟧+ np.) * (1 + np.cos(np.pi * (epoch - warmup_epochs) / (total_epochs - warmup_epochs)))

    return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = warmup_cos(optimizer, warmup_epochs=5, total_epochs=50)
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler.step()
axes[1, 1].plot(lr_history)
axes[1, 1].set_title('Разогрев + косинус')

for ax in axes.flatten:
    ax.set_xlabel('Эпоха')
    ax.set_ylabel('Скорость обучения')
    ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

5. Диагностика проблемы градиентов

5.1 Исчезновение и взрыв градиента

< h2 class="example">Пример
import torch
import torch.nn as nn

def analyze_gradients(model):
    """
Проанализировать градиенты каждого слоя в модели
    """

    grad_stats = {}

    for name, param in model.named_parameters():
        if param.grad is not None:
            grad = param.grad
            grad_stats[name] = {
                'mean': grad.mean().item(),
                'std': grad.std().item(),
                'max': grad.abs().max().item(),
                'min': grad.abs().min().item(),
                'norm': grad.norm().item(),
            }

    return grad_stats


def detect_gradient_issues(model):
    """
Обнаружение проблем с градиентами
    """

    issues = []
    grad_norms = []

    for param in model.parameters():
        if param.grad is not None:
            grad_norms.append(param.grad.norm().item())

    avg_grad_norm = sum(grad_norms) / len(grad_norms) if grad_norms else 0

    if avg_grad_norm < 1e-7:
        issues.append("Затухание градиентов: градиенты слишком малы, модель может быть неспособна обучаться")
    elif avg_grad_norm > 100:
        issues.append("Взрыв градиентов: градиенты слишком велики, обучение нестабильно")

    return issues, avg_grad_norm


# Пример: обнаружение градиентов
model = nn.Sequential(
    nn.Linear(100, 50),
    nn.ReLU(),
    nn.Linear(50, 50),
    nn.ReLU(),
    nn.Linear(50, 10)
)

# Симуляция прямого и обратного распространения
x = torch.randn(32, 100)
y = model(x)
loss = y.sum()
loss.backward()

issues, avg_norm = detect_gradient_issues(model)
print(f"Средняя норма градиента: {avg_norm:.6f}")
if issues:
    for issue in issues:
        print(f"Предупреждение: {issue}")
else:
    print("Состояние градиента в норме")

5.2 Отсечение градиентов

Пример

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.utils as utils

# Пример отсечения градиентов
def train_with_gradient_clipping(model, dataloader, max_norm=1.0):
    """
Обучение с отсечением градиентов
max_norm: максимальная норма градиента; градиенты, превышающие это значение, будут отсечены
    """

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=1e-3)

    model.train()
    for inputs, labels in dataloader:
        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, labels)

        loss.backward()

        # Отсечение градиентов: предотвращение взрыва градиентов
        utils.clip_grad_norm_(model.parameters(), max_norm=max_norm)

        optimizer.step()

    return model


# Поэлементное отсечение (более консервативное)
def clip_grad_by_value(model, clip_value=1.0):
    """
Отсечение градиентов по значению
    """

    for param in model.parameters():
        if param.grad is not None:
            param.grad.data.clamp_(min=-clip_value, max=clip_value)

6. Анализ производительности модели

6.1 Вычисление количества параметров и FLOPs

Пример

import torch
import torch.nn as nn
from thop import profile

def count_parameters(model):
    """Вычислить количество обучаемых параметров в модели"""
    total = sum(p.numel() for p in model.parameters())
    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    return total, trainable


def count_flops(model, input_size=(1, 3, 224, 224)):
    """Вычислить FLOPs (требуется библиотека thop)"""
    input_tensor = torch.randn(input_size)
    flops, params = profile(model, inputs=(input_tensor,), verbose=False)
    return flops, params


# Пример: анализ модели
model = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(64, 128, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(128, 256, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),
    nn.Flatten(),
    nn.Linear(256, 10)
)

total, trainable = count_parameters(model)
print(f"Всего параметров: {total:,}")
print(f"Обучаемых параметров: {trainable:,}")
print(f"Размер модели: {total * 4 / 1024 / 1024:.2f} MB")

# Расчёт FLOPs
try:
    flops, _ = count_flops(model)
    print(f"FLOPs: {flops / 1e9:.2f} G")
except ImportError:
    print("Установите библиотеку thop: pip install thop")

6.2 Тестирование скорости инференса

< h2 class="example">Пример
import torch
import time

def measure_inference_speed(model, input_size, device='cuda', num_iterations=100):
    """
Измерение скорости инференса
    """

    model.eval()
    model = model.to(device)

    # Прогрев
    dummy_input = torch.randn(input_size).to(device)
    with torch.no_grad():
        for _ in range(10):
            _ = model(dummy_input)

    # Измерение времени
    start = time.time()
    with torch.no_grad():
        for _ in range(num_iterations):
            _ = model(dummy_input)

    if device == 'cuda':
        torch.cuda.synchronize()

    end = time.time()
    avg_time = (end - start) / num_iterations * 1000  # ms

    return avg_time


# Пример использования
model = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),
    nn.Flatten(),
    nn.Linear(64, 10)
)

# Скорость инференса на CPU
cpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cpu')
print(f"Время инференса на CPU: {cpu_time:.2f} ms/image")

# Скорость инференса на GPU (если CUDA доступна)
if torch.cuda.is_available():
    gpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cuda')
    print(f"Время инференса на GPU: {gpu_time:.2f} ms/image")

6.3 Анализ использования памяти

Пример

import torch

def analyze_memory(model, input_size):
    """
Анализ использования памяти модели
    """

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)

    # Создать входные данные
    x = torch.randn(input_size).to(device)

    # Очистить кэш
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()

    # Прямое распространение
    with torch.no_grad():
        output = model(x)

    # Получить статистику памяти
    if torch.cuda.is_available():
        allocated = torch.cuda.memory_allocated() / 1024**2  # MB
        reserved = torch.cuda.memory_reserved() / 1024**2
        max_allocated = torch.cuda.max_memory_allocated() / 1024**2

        print(f"Текущее выделено: {allocated:.2f} MB")
        print(f"Зарезервированная память: {reserved:.2f} MB")
        print(f"Пиковое использование: {max_allocated:.2f} MB")
    else:
        print("Требуется поддержка CUDA")

    return output


# Пример использования
model = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 128, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(128, 256, kernel_size=3, padding=1),
    nn.ReLU(),
)
analyze_memory(model, (8, 3, 224, 224))

7. Распространённые проблемы и советы по отладке

7.1 Краткий справочник по проблемам обучения

Симптом Возможная причина Решение
Функция потерь не уменьшается Скорость обучения слишком мала/велика, проблемы с градиентами Настройте скорость обучения, проверьте градиенты
Колебания функции потерь Слишком большая скорость обучения, маленький размер батча Уменьшите скорость обучения, увеличьте размер пакета
Появляется NaN Деление на ноль, log(0), взрыв градиента Добавьте epsilon, отсечение градиентов
Переобучение Сложная модель, недостаточно данных Добавьте больше данных, добавьте регуляризацию
Недообучение Модель слишком простая, недостаточно обучения Увеличьте размер модели, обучайте дольше
Недостаточно памяти GPU Большой размер пакета, большая модель Уменьшите размер пакета, накопление градиентов

7.2 Сборник советов по отладке

Пример

import torch
import random
import numpy as np

def set_seed(seed=42):
    """Установите случайное зерно, чтобы обеспечить воспроизводимые результаты"""
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False


def debug_forward(model, x):
    """Отладьте прямое распространение и проверьте выходы каждого слоя"""
    print("=" * 50)
    print("Отладка прямого распространения")
    print("=" * 50)

    for name, layer in model.named_children():
        x = слой(x)
        if hasattr(x, 'shape'):
            print(f"{name}: shape={x.shape}, ", end='')
            if hasattr(x, 'mean'):
                print(f"среднее={x.mean().item():.4f}, стандартное отклонение={x.std().item():.4f}")
            if torch.isnan(x).any():
                print(f" &#x26a0;&#xfe0f; Обнаружено NaN!")
            if torch.isinf(x).any():
                print(f" &#x26a0;&#xfe0f; Обнаружено Inf!")
    print("=" * 50)


def debug_backward(model):
    """Отладка обратного распространения и проверка градиентов"""
    print("=" * 50)
    print("Отладка обратного распространения")
    print("=" * 50)

    for name, param in model.named_parameters():
        if param.grad is not None:
            grad_norm = param.grad.norm().item()
            if torch.isnan(param.grad).any():
                print(f"{name}: &#x26a0;&#xfe0f; Градиент NaN!")
            elif torch.isinf(param.grad).any():
                print(f"{name}: &#x26a0;&#xfe0f; Градиент Inf!")
            elif grad_norm > 10:
                print(f"{name}: &#x26a0;&#xfe0f; Взрыв градиента! norm={grad_norm:.2f}")
            elif grad_norm < 1e-7:
                print(f"{name}: &#x26a0;&#xfe0f; Исчезновение градиента! norm={grad_norm:.2e}")
            else:
                print(f"{name}: нормально norm={grad_norm:.4f}")
    print("=" * 50)


# Пример использования
set_seed(42)

model = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Linear(20, 20),
    nn.ReLU(),
    nn.Linear(20, 5)
)

x = torch.randn(2, 10)
y = model(x)

debug_forward(model, x)

loss = y.sum()
loss.backward()

debug_backward(model)

8. Использование PyTorch Profiler

PyTorch Profiler — официальный инструмент анализа производительности, который позволяет анализировать время выполнения и использование памяти каждой частью модели.

8.1 Базовое использование Profiler

Пример

import torch
import torch.nn as nn
from torch.profiler import profile, ProfilerActivity, schedule

# Простая модель
model = nn.Sequential(
    nn.Conv2d(3, 64, 3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 64, 3, padding=1),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),
    nn.Flatten(),
    nn.Linear(64, 10)
).cuda()

optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

# Использование профилировщика
with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    schedule=schedule(wait=1, warmup=1, active=3, repeat=1),
    on_trace_ready=torch.profiler.tensorboard_trace_handler('./logs'),
    record_shapes=True,
    profile_memory=True,
    with_stack=True
) as prof:
    for step in range(5):
        inputs = torch.randn(8, 3, 224, 224).cuda()
        labels = torch.randint(0, 10, (8,)).cuda()

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        prof.step()

# Вывести результаты
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))

8.2 Визуализация результатов профилировщика

Пример

# Экспорт файла трассировки Chrome
# Сгенерированный каталог ./logs можно открыть и просмотреть в браузере Chrome

# Или напрямую вывести различные метрики
print("=" * 80)
print("Топ 10 по времени CPU:")
print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))

print("\n" + "=" * 80)
print("Топ 10 по времени CUDA:")
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))

print("\n" + "=" * 80)
print("Топ 10 по использованию памяти:")
print(prof.key_averages().table(sort_by="self_cuda_memory_usage", row_limit=10))
Другие расширения