Ускорение 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.
Пример
# Поддерживается ли 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 сразу возникнет ошибка.
Пример
# Метод 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 Базовые методы перемещения
Пример
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, а если у тензора есть градиенты, сначала также нужно отсоединить его:
Пример
arr = gpu_tensor.cpu().numpy()
# Преобразование GPU-тензора с градиентами в numpy
arr = gpu_tensor.detach().cpu().numpy()
3.2 Ограничение согласованности устройств
Тензоры на разных устройствах не могут напрямую участвовать в одной и той же операции.
Иначе будет выброшено исключениеRuntimeError:
Пример
b = torch.randn(3) # На CPU
# c = a + b # RuntimeError: Ожидается, что все тензоры находятся на одном устройстве
# Правильный подход: сначала привести к одному устройству
c = a + b.to("cuda")
Проверьте устройство, на котором находится тензор:
Пример
print(x.device) # cuda:0
print(x.is_cuda) # True
print(x.get_device()) # 0 (индекс GPU)
3.3 Проверка сравнения скорости
Пример
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.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.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) - Настройки DataLoader
pin_memory=Trueиnon_blocking=Trueускорить передачу данных - Использование на этапе валидации
torch.no_grad()отключите градиенты, чтобы сэкономить память
6. Обучение с использованием нескольких GPU
Когда памяти одной GPU недостаточно, рассмотрите возможность использования параллельного обучения на нескольких GPU.
Кроме того, использование нескольких GPU может дополнительно повысить скорость обучения. PyTorch предоставляет два основных подхода.
6.1 DataParallel
Это самый простой подход к использованию нескольких GPU.
Он использует один процесс, равномерно разделяет каждый батч между GPU, выполняет прямой проход параллельно и агрегирует градиенты на главной GPU для обновления. Его легко использовать, но главная GPU сильно загружена, загрузка GPU неравномерна, и он подходит для быстрого старта.
Пример
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получить к ним доступ через:
Пример
print(model.module.classifier)
# При сохранении модели рекомендуется сохранять model.module, чтобы её было легко загрузить на одном GPU
torch.save(model.module.state_dict(), "model.pth")
6.2 DistributedDataParallel
Это многопроцессный подход.
Каждый процесс привязан к одному GPU, каждая карта хранит полную копию модели, а градиенты синхронизируются через All-Reduce. Это рекомендуемое решение для промышленной эксплуатации и крупномасштабного обучения, значительно более эффективное, чем DataParallel.
Пример
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)
- Требуется очень мало изменений кода; всего три модификации
Пример
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 не нужен:
Пример
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
Пример
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 Накопление градиентов (имитация больших батчей)
Когда памяти недостаточно, накопление градиентов может имитировать больший размер батча без фактического увеличения использования памяти:
Пример
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
Причина: нехватка памяти, обычно из-за слишком большого размера батча, слишком большой модели или случайного накопления графов вычислений.
Пример
# Неправильный код
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 подготовит данные.
Шаги устранения неполадок:
- Запустите
nvidia-smiилиwatch -n 1 nvidia-smiНаблюдайте за загрузкой GPU- Загрузка стабильно ниже 80% указывает на узкое место в данных
- Увеличьте num_workers у DataLoader
- Включите pin_memory=True
- Перенесите предобработку данных на GPU (torchvision.transforms поддерживает операции на GPU)
- Предзагружайте наборы данных из небольших файлов в память
9.6 Использование PyTorch Profiler для выявления узких мест
Пример
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()Другие расширения