Ускорение PyTorch на GPU / CUDA

Основные операции глубокого обучения — это крупномасштабное матричное умножение и поэлементные операции. CPU предназначены для обработки сложной последовательной логики, обычно имея от 8 до 64 ядер; GPU, напротив, имеют тысячи простых параллельных ядер, что делает их естественно подходящими для такого рода высокопараллельных численных вычислений. PyTorch через NVIDIACUDA(Compute Unified Device Architecture) фреймворк вызывает GPU, что может ускорить обучение в десятки или даже сотни раз.


1. Различия между CPU и GPU

Ускорение обучения на GPU в основном обусловлено двумя аспектами: во-первых, параллельным выполнением большого числа одинаковых вычислений; во-вторых, память GPU с высокой пропускной способностью позволяет передавать данные намного быстрее, чем память CPU.

Для вычислительно интенсивных операций, таких как матричное умножение, эффект ускорения особенно значителен.

Пункт сравнения Процессор GPU(NVIDIA)
Количество ядер 8-64 больших ядер Тысячи малых ядер (CUDA Cores)
Цель проектирования Последовательная обработка с низкой задержкой Параллельные вычисления с высокой пропускной способностью
Пропускная способность памяти ~50~100 GB/s ~500~3000 GB/s
Скорость умножения матриц Базовый уровень 10x-100x быстрее
Интерфейс PyTorch "cpu" "cuda"

Если используется Apple Silicon (M1/M2/M3), PyTorch черезmpsбэкенд поддерживает ускорение Metal GPU. Использование почти идентично CUDA; просто измените устройство на"mps"。


2. Проверка окружения CUDA

Перед использованием GPU необходимо убедиться, установлен ли в текущем окружении PyTorch с поддержкой CUDA.

Также проверьте, есть ли в системе доступные устройства GPU.

Пример

import torch

# Поддерживается ли CUDA
print("CUDA доступна:", torch.cuda.is_available())

# Количество устройств GPU
print("Количество GPU:", torch.cuda.device_count())

# Индекс текущего GPU по умолчанию
print("Текущий GPU:", torch.cuda.current_device())

# Название модели GPU
print("Модель GPU:", torch.cuda.get_device_name(0))

# Версия PyTorch и версия CUDA, с которой он был скомпилирован
print("Версия PyTorch:", torch.__version__)
print("Версия CUDA:", torch.version.cuda)

Пример вывода:

CUDA 可用: True
GPU 数量: 1
当前 GPU: 0
GPU 型号: NVIDIA GeForce RTX 4090
PyTorch 版本: 2.3.0+cu121
CUDA 版本: 12.1

2.1 Динамический выбор устройства (рекомендуемый подход)

Жёсткое кодирование в коде"cuda"Это приведёт к тому, что на машинах без GPU сразу возникнет ошибка.

Пример

import torch

# Метод 1: классический подход, лучшая совместимость
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Метод 2: рекомендуется для PyTorch 2.0+, автоматически поддерживает CUDA / MPS / CPU
device = (
    "cuda" if torch.cuda.is_available()
    else "mps" if torch.backends.mps.is_available()
    else "cpu"
)

print(f"Используется устройство: {device}")

3. Перемещение тензоров между устройствами

Тензоры в PyTorch по умолчанию создаются на CPU.

Чтобы использовать вычисления на GPU, нужно явно переместить тензоры на GPU или создать их непосредственно на GPU.

3.1 Базовые методы перемещения

Пример

import torch

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

# Создать тензор на CPU
cpu_tensor = torch.tensor([1.0, 2.0, 3.0])
print(cpu_tensor.device)   # cpu

# Способ 1: .to(device) — рекомендуемый, наиболее универсальный
gpu_tensor = cpu_tensor.to(device)

# Способ 2: .cuda() — только для среды CUDA
gpu_tensor = cpu_tensor.cuda()

# Способ 3: укажите устройство напрямую при создании
gpu_tensor = torch.tensor([1.0, 2.0, 3.0], device=device)
gpu_tensor = torch.randn(3, 4, device=device)

# Переместить обратно на CPU (для вывода, преобразования в numpy, сохранения и т. д.)
back_to_cpu = gpu_tensor.cpu()

print(gpu_tensor.device)    # cuda:0
print(back_to_cpu.device)   # cpu

При преобразовании GPU-тензора в numpy сначала необходимо переместить его обратно на CPU, а если у тензора есть градиенты, сначала также нужно отсоединить его:

Пример

# Преобразование обычного GPU-тензора в numpy
arr = gpu_tensor.cpu().numpy()

# Преобразование GPU-тензора с градиентами в numpy
arr = gpu_tensor.detach().cpu().numpy()

3.2 Ограничение согласованности устройств

Тензоры на разных устройствах не могут напрямую участвовать в одной и той же операции.

Иначе будет выброшено исключениеRuntimeError:

Пример

a = torch.randn(3).to("cuda")
b = torch.randn(3)           # На CPU

# c = a + b # RuntimeError: Ожидается, что все тензоры находятся на одном устройстве

# Правильный подход: сначала привести к одному устройству
c = a + b.to("cuda")

Проверьте устройство, на котором находится тензор:

Пример

x = torch.randn(3, 4).to(device)

print(x.device)           # cuda:0
print(x.is_cuda)          # True
print(x.get_device())     # 0 (индекс GPU)

3.3 Проверка сравнения скорости

Пример

import torch
import time

device = torch.device("cuda")
n = 5000

# Умножение матриц на CPU
a_cpu = torch.randn(n, n)
b_cpu = torch.randn(n, n)
start = time.time()
c_cpu = torch.matmul(a_cpu, b_cpu)
print(f"Время CPU: {time.time() - start:.3f}s")

# Умножение матриц на GPU
a_gpu = a_cpu.to(device)
b_gpu = b_cpu.to(device)
torch.cuda.synchronize()    # Убедитесь, что передача данных завершена перед запуском таймера
start = time.time()
c_gpu = torch.matmul(a_gpu, b_gpu)
torch.cuda.synchronize()    # Дождитесь завершения выполнения на GPU перед остановкой таймера
print(f"Время GPU: {time.time() - start:.3f}s")

Пример вывода:

CPU 耗时: 1.847s
GPU 耗时: 0.021s

Вычисления на GPUвыполняются асинхронно— после возврата вызова Python операция на GPU может быть не завершена. При измерении времени необходимо вызватьtorch.cuda.synchronize()чтобы дождаться фактического завершения GPU; иначе результаты измерений будут неточными.


4. Перемещение модели на GPU

Все параметры модели (weight、bias) по сути являются тензорами.

Эти параметры также нужно переместить на GPU, чтобы выполнять прямое и обратное распространение на GPU.

Вызов.to(device)ко всей модели, и PyTorch автоматически обойдёт и переместит все внутренние параметры.

Пример

import torch
import torch.nn as nn

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

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10),
        )

    def forward(self, x):
        return self.net(x)

# Переместить модель на GPU, достаточно вызвать один раз
model = SimpleNet().to(device)

# Проверить, что все параметры находятся на GPU
for name, param in model.named_parameters():
    print(f"{name}: {param.device}")
# net.0.weight: cuda:0
# net.0.bias: cuda:0
# ...

# Входные данные также должны находиться на том же устройстве
x = torch.randn(32, 784).to(device)
output = model(x)
print(output.shape)   # torch.Size([32, 10])

Когда модель находится на GPU, а входные данные всё ещё на CPU, прямой проход вызовет ошибку. Обязательно, после того как DataLoader прочитает каждый батч,inputsиlabelsвызовите .to(device) для всех них..to(device)。


5. Полный рабочий процесс обучения

Ниже приведён стандартный шаблон обучения на GPU, который включает загрузку данных, обучение модели и оценку на валидации.

Пример

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 1. Конфигурация устройства
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Устройство обучения: {device}")

# 2. Загрузка данных
# pin_memory=True: Фиксирует данные в памяти, чтобы ускорить передачу CPU -> GPU
# num_workers: Многопроцессная предварительная загрузка для сокращения времени ожидания данных
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,)),
])
train_dataset = datasets.MNIST(root="./data", train=True,
                                download=True, transform=transform)
test_dataset  = datasets.MNIST(root="./data", train=False,
                                download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=256, shuffle=True,
                          num_workers=4, pin_memory=True)
test_loader  = DataLoader(test_dataset,  batch_size=256, shuffle=False,
                          num_workers=4, pin_memory=True)

# 3. Определение модели
class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 256), nn.ReLU(), nn.Dropout(0.5),
            nn.Linear(256, 10),
        )

    def forward(self, x):
        return self.classifier(self.features(x))

model     = CNN().to(device)     # Переместить модель на GPU
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 4. Функция обучения
def train_epoch(model, loader, optimizer, criterion):
    model.train()
    total_loss, correct = 0.0, 0
    for inputs, labels in loader:
        # non_blocking=True: Асинхронная передача, CPU может продолжать подготовку следующего батча данных
        inputs = inputs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

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

        total_loss += loss.item() * inputs.size(0)
        correct += (outputs.argmax(1) == labels).sum().item()

    n = len(loader.dataset)
    return total_loss / n, correct / n

# 5. Функция валидации
def eval_epoch(model, loader, criterion):
    model.eval()
    total_loss, correct = 0.0, 0
    with torch.no_grad():
        for inputs, labels in loader:
            inputs = inputs.to(device, non_blocking=True)
            labels = labels.to(device, non_blocking=True)
            outputs = model(inputs)
            loss    = criterion(outputs, labels)
            total_loss += loss.item() * inputs.size(0)
            correct += (outputs.argmax(1) == labels).sum().item()
    n = len(loader.dataset)
    return total_loss / n, correct / n

# 6. Основной цикл обучения
for epoch in range(1, 11):
    train_loss, train_acc = train_epoch(model, train_loader, optimizer, criterion)
    val_loss,   val_acc   = eval_epoch(model,  test_loader,  criterion)
    print(f"Эпоха {epoch:02d} | "
          f"Потери на обучении: {train_loss:.4f}, Точность: {train_acc:.4f} | "
          f"Потери на валидации: {val_loss:.4f}, Точность: {val_acc:.4f}")

Ключевые моменты:

  • deviceПеременные объявляются в самом верху кода, используются глобально и никогда не задаются жёстко"cuda"
  • Модель.to(device)нужно вызвать только один раз
  • Для каждого батча,inputsиlabelsтакже должно быть.to(device)
  • Настройки DataLoaderpin_memory=Trueиnon_blocking=Trueускорить передачу данных
  • Использование на этапе валидацииtorch.no_grad()отключите градиенты, чтобы сэкономить память

6. Обучение с использованием нескольких GPU

Когда памяти одной GPU недостаточно, рассмотрите возможность использования параллельного обучения на нескольких GPU.

Кроме того, использование нескольких GPU может дополнительно повысить скорость обучения. PyTorch предоставляет два основных подхода.

6.1 DataParallel

Это самый простой подход к использованию нескольких GPU.

Он использует один процесс, равномерно разделяет каждый батч между GPU, выполняет прямой проход параллельно и агрегирует градиенты на главной GPU для обновления. Его легко использовать, но главная GPU сильно загружена, загрузка GPU неравномерна, и он подходит для быстрого старта.

Пример

import torch
import torch.nn as nn

model = CNN()

if torch.cuda.device_count() > 1:
    print(f"Используется {torch.cuda.device_count()} GPU")
    model = nn.DataParallel(model)

    # Вы также можете указать, какие GPU использовать
    # model = nn.DataParallel(model, device_ids=[0, 1])

model = model.to("cuda")

# Последующий код обучения точно такой же, как для одного GPU
# DataParallel автоматически равномерно распределяет батч между GPU и агрегирует результаты

Если вам нужно получить доступ к атрибутам исходной модели (таким как пользовательские методы), необходимо.moduleполучить к ним доступ через:

Пример

# После того как модель обёрнута с помощью DataParallel, исходная модель находится в model.module
print(model.module.classifier)

# При сохранении модели рекомендуется сохранять model.module, чтобы её было легко загрузить на одном GPU
torch.save(model.module.state_dict(), "model.pth")

6.2 DistributedDataParallel

Это многопроцессный подход.

Каждый процесс привязан к одному GPU, каждая карта хранит полную копию модели, а градиенты синхронизируются через All-Reduce. Это рекомендуемое решение для промышленной эксплуатации и крупномасштабного обучения, значительно более эффективное, чем DataParallel.

Пример

import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data.distributed import DistributedSampler

def main(rank, world_size):
    # Инициализируйте группу процессов; бэкенд NCCL оптимизирован для GPU NVIDIA
    dist.init_process_group(backend="nccl", rank=rank, world_size=world_size)

    # Привяжите каждый процесс к соответствующему GPU
    torch.cuda.set_device(rank)
    device = torch.device(f"cuda:{rank}")

    # Оберните с помощью DDP после перемещения модели на соответствующий GPU
    model = CNN().to(device)
    model = DDP(model, device_ids=[rank])

    # Используйте DistributedSampler в DataLoader, чтобы гарантировать, что данные не пересекаются между GPU
    sampler = DistributedSampler(train_dataset,
                                  num_replicas=world_size, rank=rank)
    loader  = DataLoader(train_dataset, batch_size=64,
                         sampler=sampler, pin_memory=True)

    # Логика обучения идентична обучению на одной GPU
    # ...

    dist.destroy_process_group()

# Как запускать (рекомендуется: torchrun):
# torchrun --nproc_per_node=4 train_ddp.py
Пункт сравнения DataParallel DistributedDataParallel
Количество процессов Один процесс Многопроцессный (один на GPU)
Бэкенд связи Ограничение GIL в Python NCCL (эффективный)
Основная нагрузка на GPU Высокая (агрегация градиентов) Сбалансированная (All-Reduce)
Изменения кода Минимальный Умеренный
Применимые сценарии Быстрое экспериментирование Обучение в продакшене

7. Обучение со смешанной точностью AMP

Обучение по умолчанию использует точность float32 (FP32).

Автоматическая смешанная точность (AMP)Использует float16 (FP16) или bfloat16 (BF16) для некоторых вычислений, обеспечивая значительные преимущества почти без потери точности:

  • Использование памяти сокращено примерно на 50%
  • Скорость обучения повышена в 2–3 раза (аппаратное ускорение Tensor Core)
  • Требуется очень мало изменений кода; всего три модификации

Пример

from torch.cuda.amp import autocast, GradScaler

model     = CNN().to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
scaler    = GradScaler()    # Масштабировщик градиентов FP16 для предотвращения ухода градиентов в ноль из-за антипереполнения

for epoch in range(num_epochs):
    model.train()
    for inputs, labels in train_loader:
        inputs = inputs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)

        optimizer.zero_grad()

        # Изменение 1: автоматический выбор FP16/FP32 внутри области autocast
        with autocast(device_type="cuda"):
            outputs = model(inputs)
            loss    = criterion(outputs, labels)

        # Изменение 2: масштабировать loss с помощью scaler перед обратным распространением
        scaler.scale(loss).backward()

        # Изменение 3: scaler обновляет параметры и автоматически обрабатывает масштабирование градиентов внутри
        scaler.step(optimizer)
        scaler.update()

7.1 Выбор между FP16 и BF16

Формат Биты точности Биты экспоненты Подходящее оборудование Характеристики
float16 10 бит 5 бит Серия RTX 20/30/40 Требуется GradScaler для предотвращения переполнения
bfloat16 7 бит 8 бит A100 / H100 / RTX 4090 Тот же диапазон, что и FP32, более стабильное обучение

Если ваш GPU поддерживает BF16, используйте его предпочтительно; GradScaler не нужен:

Пример

# Использование BF16 (PyTorch 2.0+)
with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
    outputs = model(inputs)
    loss    = criterion(outputs, labels)

loss.backward()
optimizer.step()

8. Советы по оптимизации производительности

В этом разделе представлены несколько методов оптимизации использования памяти и скорости обучения.

8.1 Управление памятью GPU

Пример

# Просмотр текущего использования памяти
print(f"Выделено: {torch.cuda.memory_allocated() / 1024**2:.1f} MB")
print(f"В кэше: {torch.cuda.memory_reserved() / 1024**2:.1f} MB")

# Вывести подробный отчёт об использовании памяти
print(torch.cuda.memory_summary())

# Очистить пул кэша (не освобождает выделенную память)
torch.cuda.empty_cache()

# Используйте inference_mode во время инференса (быстрее, чем no_grad, полностью отключает движок градиентов)
with torch.inference_mode():
    output = model(x)

# Градиентный чекпоинтинг: обмен повторных вычислений на память (обычно используется при обучении больших моделей)
from torch.utils.checkpoint import checkpoint
output = checkpoint(model_block, x)

8.2 Оптимизация DataLoader

Пример

loader = DataLoader(
    dataset,
    batch_size=256,
    num_workers=4,              # Многопроцессная предварительная загрузка; рекомендуется установить 50% от количества ядер CPU
    pin_memory=True,            # Закреплённая память для ускорения передачи CPU -> GPU
    persistent_workers=True,    # Сохранять рабочие процессы активными, чтобы избежать повторного создания процессов каждую эпоху
    prefetch_factor=2,          # Количество батчей, предварительно загружаемых на каждый рабочий процесс
)

8.3 Компиляция модели с torch.compile (PyTorch 2.0+)

Одна строка кода компилирует и оптимизирует граф вычислений, повышая скорость на 30%–200% (в зависимости от архитектуры модели):

Пример

# Компилировать модель; первый запуск имеет накладные расходы на компиляцию, последующие итерации значительно быстрее
model = torch.compile(model)

# Компромиссы между различными режимами компиляции
model = torch.compile(model, mode="default")          # Сбалансированный, подходит для большинства сценариев
model = torch.compile(model, mode="reduce-overhead")  # Снижает накладные расходы на планирование
model = torch.compile(model, mode="max-autotune")     # Максимальная оптимизация, большее время компиляции

8.4 Накопление градиентов (имитация больших батчей)

Когда памяти недостаточно, накопление градиентов может имитировать больший размер батча без фактического увеличения использования памяти:

Пример

accumulation_steps = 8    # Обновлять параметры каждые 8 батчей, что эквивалентно batch_size × 8

for i, (inputs, labels) in enumerate(train_loader):
    inputs = inputs.to(device)
    labels = labels.to(device)

    outputs = model(inputs)
    loss    = criterion(outputs, labels) / accumulation_steps   # Разделить loss поровну
    loss.backward()    # Накопление градиентов без обнуления

    if (i + 1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad()    # Обнулять градиенты только после обновления параметров

8.5 Стратегии при нехватке памяти GPU

Стратегия Метод Эффект
Уменьшение размера батча 256 -> 64 Линейно снижает потребление памяти
Смешанная точность AMP + FP16/BF16 Потребление памяти сокращается примерно на 50%
Накопление градиентов Обновление каждые N шагов Имитация большого батча без увеличения памяти
Контрольные точки градиентов torch.utils.checkpoint Значительно снижает потребление памяти, но уменьшает скорость обучения
Заморозить некоторые параметры Заморозить backbone при трансферном обучении Снижает потребление памяти при обратном распространении

9. Распространённые ошибки и устранение неполадок

В этом разделе обобщены наиболее распространённые ошибки при обучении на GPU и способы их решения.

9.1 RuntimeError: ожидалось, что все тензоры находятся на одном устройстве

Причина: тензоры, участвующие в операции, находятся на разных устройствах (один на CPU, другой на GPU).

Пример

# Диагностика: выведите устройство каждого тензора
print(inputs.device, labels.device, next(model.parameters()).device)

# Решение: убедитесь, что .to(device) выполняется для каждого батча
inputs = inputs.to(device)
labels = labels.to(device)

9.2 RuntimeError: нехватка памяти CUDA

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

Пример

# Частая ошибка: loss.item() не вызывается в цикле, из-за чего накапливаются графы вычислений
# Неправильный код
total_loss += loss           # loss — это тензор, который хранит весь граф вычислений

# Правильный код
total_loss += loss.item()    # .item() извлекает скаляр Python и освобождает граф вычислений

# Другие шаги по устранению неполадок:
# 1. Уменьшите batch_size
# 2. Убедитесь, что цикл валидации использует torch.no_grad()
# 3. Вызовите torch.cuda.empty_cache(), чтобы очистить кэш
# 4. Используйте torch.cuda.memory_summary(), чтобы определить источник использования памяти GPU

9.3 Нельзя вызвать numpy() для Tensor, требующего grad

Причина: тензоры с градиентами нельзя напрямую преобразовать в numpy-массивы.

Пример

# Неправильный код
arr = gpu_tensor.numpy()

# Правильный код
arr = gpu_tensor.detach().cpu().numpy()

9.4 Ошибка CUDA: сработал assert на стороне устройства

Причина: обычно это значения меток вне допустимых границ (например, 10 классов, но значение метки равно 10) или индекс массива выходит за границы. Сообщение об ошибке создаётся на GPU, и место отображения по умолчанию неточно.

Пример

# Установите переменную среды, чтобы ошибки выбрасывались на точной строке кода (выполнение становится синхронным, медленнее)
import os
os.environ["CUDA_LAUNCH_BLOCKING"] = "1"

9.5 Скорость обучения не увеличивается (низкая загрузка GPU)

Причина: загрузка данных становится узким местом; GPU большую часть времени ждёт, пока CPU подготовит данные.

Шаги устранения неполадок:

  1. Запуститеnvidia-smiилиwatch -n 1 nvidia-smiНаблюдайте за загрузкой GPU
    • Загрузка стабильно ниже 80% указывает на узкое место в данных
  2. Увеличьте num_workers у DataLoader
  3. Включите pin_memory=True
  4. Перенесите предобработку данных на GPU (torchvision.transforms поддерживает операции на GPU)
  5. Предзагружайте наборы данных из небольших файлов в память

9.6 Использование PyTorch Profiler для выявления узких мест

Пример

from torch.profiler import profile, ProfilerActivity

with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    record_shapes=True,
) as prof:
    for i, (inputs, labels) in enumerate(train_loader):
        if i >= 10:
            break
        inputs = inputs.to(device)
        labels = labels.to(device)
        loss   = criterion(model(inputs), labels)
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# Сортировать по времени CUDA, вывести первые 15 элементов
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=15))

10. Краткий справочник по API

Ниже приведена краткая справочная таблица по распространённым API PyTorch, связанным с GPU.

10.1 Управление устройствами

Действие Code
Проверка доступности CUDA torch.cuda.is_available()
Выбор устройства torch.device("cuda" if ... else "cpu")
Количество GPU torch.cuda.device_count()
Название GPU torch.cuda.get_device_name(0)
Установить текущий GPU torch.cuda.set_device(0)
Дождаться завершения работы GPU torch.cuda.synchronize()

10.2 Операции с тензорами

Действие Code
Переместить тензор на GPU tensor.to(device)илиtensor.cuda()
Переместить тензор на CPU tensor.cpu()
Просмотреть текущее устройство tensor.device
Находится ли он на GPU tensor.is_cuda
Преобразовать тензор GPU в numpy tensor.detach().cpu().numpy()
Асинхронная передача tensor.to(device, non_blocking=True)

10.3 Операции с моделью

Действие Code
Переместить модель на GPU model.to(device)
Включить режим обучения model.train()
Включить режим инференса model.eval()
Ускорение с помощью компиляции torch.compile(model)
Отключить градиенты with torch.no_grad():
Режим инференса with torch.inference_mode():

10.4 Управление памятью GPU

Действие Code
Выделенная память GPU torch.cuda.memory_allocated()
Кэшированная память GPU torch.cuda.memory_reserved()
Отчёт о памяти GPU torch.cuda.memory_summary()
Очистить кэш torch.cuda.empty_cache()

10.5 Краткий справочник по основным принципам

1. 用 device 变量统一管理,不要硬编码 "cuda"
2. 模型和数据必须在同一设备上,每个 batch 都要 .to(device)
3. 验证和推理时一定使用 torch.no_grad() 或 torch.inference_mode()
4. 生产训练推荐开启 AMP 混合精度,几乎免费获得 2x 加速
5. DataLoader 设置 pin_memory=True 和 num_workers >= 4 减少数据瓶颈
6. PyTorch 2.0+ 可以用 torch.compile(model) 一行提速 30%+
7. GPU 计算是异步的,精确计时需要调用 torch.cuda.synchronize()
Другие расширения