Распределённое обучение в PyTorch
Когда модели становятся больше, а данных становится больше, один GPU больше не может удовлетворять требованиям обучения.
Распределённое обучение использует параллельные вычисления на нескольких GPU или даже нескольких машинах, что значительно сокращает время обучения.
В этом разделе подробно описаны методы распределённого обучения в PyTorch, включая DataParallel, DistributedDataParallel и распределённое обучение со смешанной точностью.
1. Основы распределённого обучения
1.1 Зачем нужно распределённое обучение
Масштаб моделей глубокого обучения растёт год от года, и время обучения соответственно увеличивается. Основная цель распределённого обучения:Распределить вычислительные задачи между несколькими вычислительными блоками, чтобы завершить обучение крупномасштабных моделей и обработку данных за приемлемое время.。
Распределённое обучение в основном решает две проблемы:
- Нехватка памяти: параметры больших моделей, состояния оптимизатора и градиенты требуют большого объёма памяти GPU.
- Чрезмерное время обучения: обучение большой модели на одном GPU может занять недели или даже месяцы.
1.2 Два основных режима распределённого обучения
Распределённое обучение в основном делится на два режима:
| Mode | Принцип | Сценарий применения |
|---|---|---|
| Параллелизм по данным | Каждый вычислительный блок хранит полную модель; разные вычислительные блоки обрабатывают разные данные. | Модель может поместиться в память GPU одной карты; большой объём данных требует ускоренного обучения; небольшие команды с ограниченными машинными ресурсами. |
| Параллелизм по модели | Разделите модель между несколькими вычислительными блоками; каждый вычислительный блок хранит только часть модели. | Модель слишком большая, чтобы поместиться на одной карте; выделенные кластеры, многомашинное обучение. |
В реальных производственных средах наиболее часто используется параллелизм данных. PyTorch предоставляет две реализации: DataParallel и DistributedDataParallel.
2. Руководство по использованию DataParallel
2.1 Одна машина, несколько GPU: DataParallel
DataParallel(DP)Это самый простой метод обучения с несколькими GPU, предоставляемый PyTorch. Он требует изменить всего несколько строк кода, чтобы обучаться с использованием нескольких GPU на одной машине.
Пример
import torch.nn as nn
import torch.optim as optim
# ── Определение модели ──────────────────────────────────────
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(128, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 10)
)
def forward(self, x):
return self.net(x)
# Проверка количества доступных GPU
print(f"Доступное количество GPU: {torch.cuda.device_count()}")
# Создание модели и перемещение её на GPU
model = SimpleModel()
# ── Способ 1: использование DataParallel (самый простой способ)───────
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
# Перемещение на GPU (если используется DataParallel, device_ids обрабатываются автоматически)
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)
# ── Цикл обучения ──────────────────────────────────────
def train_epoch_dp(model, loader, criterion, optimizer, device):
model.train()
total_loss = 0
correct = 0
total = 0
for inputs, labels in loader:
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)
_, predicted = outputs.max(1)
correct += predicted.eq(labels).sum().item()
total += labels.size(0)
return total_loss / total, correct / total
# Смоделированные данные
train_loader = [
(torch.randn(32, 128), torch.randint(0, 10, (32,))) for _ in range(10)
]
# Начать обучение
for epoch in range(3):
loss, acc = train_epoch_dp(model, train_loader, criterion, optimizer, device)
print(f"Эпоха {epoch+1}: Потери={loss:.4f}, Точность={acc:.4f}")
print("Обучение с DataParallel завершено!")
2.2 Как работает DataParallel
Рабочий процесс DataParallel выглядит следующим образом:
- Репликация модели: Копирование модели на каждый GPU.
- Распределение данных: Равномерно распределить данные батча по каждому GPU.
- Параллельные вычисления: Каждый GPU независимо выполняет прямой проход.
- Агрегация градиентов: Собрать градиенты со всех GPU на главном GPU.
- Обновление параметров: Главный GPU обновляет параметры и синхронизирует их с другими GPU.
Пример
model = nn.DataParallel(
module, # Модель для распараллеливания (обязательно)
device_ids=[0, 1, 2, 3], # Используемые ID устройств GPU; по умолчанию используются все GPU
output_device=0, # Устройство для сбора результатов вывода; по умолчанию первый GPU
dim=0 # Размерность, по которой разбиваются данные; по умолчанию размерность батча
)
# Проверить устройство текущей модели
print(f"Устройство модели: {next(model.parameters()).device}")
# Проверить фактически используемые устройства
print(f"Количество используемых GPU: {model.device_ids if hasattr(model, 'device_ids') else 'N/A'}")
DataParallel прост в использовании, но имеет две основные проблемы: 1) высокая нагрузка на память главного GPU (ему нужно агрегировать градиенты); 2) низкая эффективность коммуникации между GPU. Поэтому официально рекомендуется использовать DistributedDataParallel.
3. Подробное объяснение DistributedDataParallel
3.1 Основы DDP
DistributedDataParallel(DDP)Это метод распределённого обучения, рекомендованный PyTorch. По сравнению с DataParallel, DDP имеет следующие преимущества:
- Каждый GPU вычисляет градиенты независимо, без необходимости агрегировать их на главном GPU.
- Использует эффективный алгоритм синхронизации градиентов (Ring AllReduce).
- Поддерживает многомашинное обучение с несколькими GPU.
- Более высокая скорость обучения и более эффективное использование памяти.
3.2 Обучение DDP на одной машине с несколькими GPU
Пример
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
import os
# ── Инициализация распределённой среды ────────────────────────────
def setup(rank, world_size):
"""Настройка распределённой среды"""
# Установить GPU, используемый текущим процессом
torch.cuda.set_device(rank)
# Инициализация группы процессов
dist.init_process_group(
backend="nccl", # Использовать бэкенд NCCL (рекомендуется для GPU)
init_method="env://", # Метод инициализации через переменные окружения
world_size=world_size, # Общее количество процессов
rank=rank # Ранг текущего процесса
)
def cleanup():
"""Очистка распределённой среды"""
dist.destroy_process_group()
# ── Загрузчик данных (поддержка распределённых вычислений)───────────────────────
def get_distributed_loader(batch_size, world_size):
"""Создать загрузчик данных с поддержкой распределённых вычислений"""
from torch.utils.data import DataLoader, DistributedSampler
# Имитированный набор данных
dataset = torch.utils.data.TensorDataset(
torch.randn(100, 3, 32, 32),
torch.randint(0, 10, (100,))
)
# DistributedSampler автоматически разбивает данные
sampler = DistributedSampler(
dataset,
num_replicas=world_size,
rank=rank,
shuffle=True
)
loader = DataLoader(
dataset,
batch_size=batch_size,
sampler=sampler,
num_workers=2,
pin_memory=True
)
return loader
# ── Определение модели ──────────────────────────────────────
class ImageClassifier(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 32, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten()
)
self.classifier = nn.Linear(64, 10)
def forward(self, x):
x = self.features(x)
x = self.classifier(x)
return x
# ── Функция обучения DDP ──────────────────────────────────
def train_ddp(rank, world_size, epochs=3):
"""Основная функция для распределенного обучения"""
# Инициализация
setup(rank, world_size)
# Создать модель и переместить её на соответствующий GPU
model = ImageClassifier().cuda(rank)
# Обернуть её как DDP-модель
ddp_model = DDP(
model,
device_ids=[rank], # Указать устройство, используемое текущим процессом
output_device=rank,
find_unused_parameters=False # Обнаруживать ли неиспользуемые параметры
)
# Функция потерь и оптимизатор
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(ddp_model.parameters(), lr=1e-3)
# Получить загрузчик данных
loader = get_distributed_loader(batch_size=16, world_size=world_size)
# Цикл обучения
for epoch in range(epochs):
# Установить номер эпохи в начале каждой эпохи (используется для перемешивания данных)
loader.sampler.set_epoch(epoch)
for batch_idx, (inputs, labels) in enumerate(loader):
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
outputs = ddp_model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
if rank == 0 and batch_idx % 5 == 0:
print(f"Эпоха {epoch+1}, Батч {batch_idx}, Потери: {loss.item():.4f}")
# Очистка
if rank == 0:
print("Обучение завершено!")
очистка()
# Примечание: при фактическом выполнении необходимо указать rank и world_size через аргументы командной строки
# Этот код должен независимо выполняться в каждом процессе
3.3 Запуск распределённого обучения
Распределённое обучение PyTorch необходимо запускать черезtorchrunилиtorch.distributed.launch. Вот распространённые способы запуска:
Пример
# Файл: train_ddp.py
"""
Использование:
torchrun --nproc_per_node=4 train_ddp.py
"""
# Способ 2: Использование python -m (традиционный метод)
"""
python -m torch.distributed.launch --nproc_per_node=4 train_ddp.py
"""
# Способ 3: Запуск на нескольких узлах и нескольких GPU
# Машина 1 (главный узел)
torchrun --nnodes=2 --nproc_per_node=4 --node_rank=0 --master_addr=192.168.1.1 --master_port=29500 train_ddp.py
# Машина 2 (рабочий узел)
torchrun --nnodes=2 --nproc_per_node=4 --node_rank=1 --master_addr=192.168.1.1 --master_port=29500 train_ddp.py
# Описание параметров:
# --nproc_per_node: количество GPU на узел
# --nnodes: количество узлов
# --node_rank: индекс текущего узла (начиная с 0)
# --master_addr: IP-адрес главного узла
# --master_port: номер порта главного узла
3.4 Полный скрипт обучения с DDP
Пример
import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler
import argparse
import os
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int, default=-1, help="Автоматически передается torchrun")
parser.add_argument("--epochs", type=int, default=10)
parser.add_argument("--batch_size", type=int, default=32)
parser.add_argument("--lr", type=float, default=1e-3)
return parser.parse_args()
class TrainModel(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(128, 10)
)
def forward(self, x):
return self.net(x)
def setup(rank, world_size):
os.environ["MASTER_ADDR"] = "localhost"
os.environ["MASTER_PORT"] = "12355"
dist.init_process_group("nccl", rank=rank, world_size=world_size)
torch.cuda.set_device(rank)
def cleanup():
dist.destroy_process_group()
def train(rank, world_size, args):
setup(rank, world_size)
# Создание модели
model = TrainModel().cuda(rank)
model = DDP(model, device_ids=[rank])
# Оптимизатор и функция потерь
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.CrossEntropyLoss()
# Набор данных
dataset = torch.utils.data.TensorDataset(
torch.randn(1000, 3, 32, 32),
torch.randint(0, 10, (1000,))
)
# DistributedSampler гарантирует, что каждый процесс видит разные данные
sampler = DistributedSampler(
dataset,
num_replicas=world_size,
rank=rank,
shuffle=True
)
loader = DataLoader(
dataset,
batch_size=args.batch_size,
sampler=sampler,
num_workers=2,
pin_memory=True
)
# Цикл обучения
for epoch in range(args.epochs):
# Важно: устанавливайте epoch каждую эпоху, чтобы перемешивать разбиение данных
sampler.set_epoch(epoch)
model.train()
epoch_loss = 0
for inputs, labels in loader:
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
epoch_loss += loss.item()
# Синхронизируйте все процессы, чтобы каждый процесс завершил текущую эпоху
dist.barrier()
if rank == 0:
avg_loss = epoch_loss / len(loader)
print(f"Эпоха {epoch+1}/{args.epochs}, Потери: {avg_loss:.4f}")
очистка()
if __name__ == "__main__":
args = parse_args()
# Получить world_size из переменных окружения
world_size = int(os.environ["WORLD_SIZE"])
# Получить rank из переменных окружения (автоматически задается torchrun)
rank = int(os.environ["RANK"])
if torch.cuda.is_available():
train(rank, world_size, args)
else:
print("Для запуска распределенного обучения требуется среда CUDA")
Ключевой момент: в каждой эпохе нужно вызывать
sampler.set_epoch(epoch), чтобы разбиение данных перемешивалось, иначе несколько процессов увидят одни и те же данные.
4. Смешанная точность в распределенном обучении
4.1 Комбинация DDP + AMP
Сочетание распределённого обучения с обучением со смешанной точностью может дополнительно повысить скорость обучения. DDP в PyTorch 2.0+ полностью интегрирован с AMP.
Пример
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.cuda.amp import autocast, GradScaler
class AMPModel(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(128, 10)
)
def forward(self, x):
return self.net(x)
def train_ddp_amp(rank, world_size):
"""Распределённое обучение + обучение со смешанной точностью"""
# Инициализация
torch.cuda.set_device(rank)
dist.init_process_group("nccl", rank=rank, world_size=world_size)
# Создание модели
model = AMPModel().cuda(rank)
model = DDP(model, device_ids=[rank])
# Оптимизатор и GradScaler
optimizer = optim.Adam(model.parameters(), lr=1e-3)
scaler = GradScaler()
criterion = nn.CrossEntropyLoss()
# Цикл обучения
model.train()
for inputs, labels in loader:
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
# Используйте autocast для автоматического переключения точности
with autocast(device_type='cuda'):
outputs = model(inputs)
loss = criterion(outputs, labels)
# Используйте scaler для обработки масштабирования градиентов
scaler.scale(loss).backward()
# Обрезка градиентов (сначала требуется отменить масштабирование)
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
scaler.step(optimizer)
scaler.update()
dist.destroy_process_group()
# Команда запуска
# torchrun --nproc_per_node=4 train_ddp_amp.py
4.2 Синхронизация градиентов в распределённом обучении
DDP использует алгоритмRing AllReduceдля синхронизации градиентов, и это работает следующим образом:
- Каждый GPU разбивает градиенты на n частей (n — количество GPU)
- Каждый GPU обменивается одной частью градиента с соседним GPU
- После n повторений каждый GPU имеет полные градиенты
Пример
# 1. Установите размер буфера для бакетов градиентов
model = DDP(
model,
device_ids=[rank],
gradient_as_bucket_view=True, # Экономия памяти (PyTorch 1.8+)
broadcast_buffers=False, # Не выполнять broadcast буферов, чтобы снизить коммуникацию
bucket_cap_mb=25 # Размер бакета градиентов (MB)
)
# 2. Вручную синхронизируйте параметры модели (при необходимости)
# В некоторых сценариях параметры модели необходимо синхронизировать вручную
def sync_params(model):
for param in model.parameters():
dist.broadcast(param, src=0)
# 3. Проверить состояние синхронизации градиентов
# DDP автоматически обрабатывает синхронизацию градиентов; ручные операции не требуются
# Но это можно проверить следующим образом
for name, param in model.named_parameters():
if param.grad is not None:
print(f"{name}: grad requires_grad={param.grad.requires_grad}")
5. Модельный параллелизм и конвейеризация
5.1 Простой модельный параллелизм
Когда модель слишком велика, чтобы поместиться на одном GPU, её необходимо разделить между несколькими GPU.
Пример
class ModelParallel(nn.Module):
def __init__(self, num_gpus=2):
super().__init__()
self.num_gpus = num_gpus
# Часть 1: GPU 0
self.features1 = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2)
).to(f"cuda:0")
# Часть 2: GPU 1
self.features2 = nn.Sequential(
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool2d(1),
nn.Flatten()
).to(f"cuda:1")
# Классификатор: GPU 0
self.classifier = nn.Linear(128, 10).to(f"cuda:0")
def forward(self, x):
# Данные передаются между разными GPU
x = x.to("cuda:0")
x = self.features1(x)
x = x.to("cuda:1")
x = self.features2(x)
x = x.to("cuda:0")
x = self.classifier(x)
return x
# Использовать
model = ModelParallel(num_gpus=2)
output = model(torch.randn(1, 3, 32, 32))
print(f"Устройство вывода: {output.device}")
5.2 Конвейерный параллелизм
PyTorch предоставляетtorch.distributed.pipeline.syncмодуль (пакет PP) для реализации конвейерного параллелизма, разделяя модель по слоям для формирования вычислительного конвейера.
Пример
# pip install torch-pipeline
"""
# Примечание: встроенный конвейер PyTorch требует определённой версии или сторонней библиотеки
# Здесь мы демонстрируем концепцию с упрощённой реализацией
from torch.distributed.pipeline.sync import Pipe
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(128, 256)
self.layer2 = nn.Linear(256, 256)
self.layer3 = nn.Linear(256, 10)
def forward(self, x):
x = torch.relu(self.layer1(x))
x = torch.relu(self.layer2(x))
x = self.layer3(x)
return x
# Разделить модель между разными GPU по слоям
# layer1 -> GPU 0
# layer2 -> GPU 1
# layer3 -> GPU 2
model = SimpleModel()
model.layer1 = model.layer1.cuda(0)
model.layer2 = model.layer2.cuda(1)
model.layer3 = model.layer3.cuda(2)
# Используйте Pipeline для подключения модели
# Примечание: для фактического использования требуется установить соответствующую версию библиотеки pipeline
# from torch.distributed.pipeline.sync import Pipe
# model = Pipe(model, chunks=4)
"""
print("Конвейерный параллелизм требует дополнительной установки библиотеки torch-pipeline")
print("pip install torch-pipeline-sync")
6. Лучшие практики распределённого обучения
6.1 Советы по оптимизации производительности
| Пункт оптимизации | Техника | Описание |
|---|---|---|
| Оптимизация коммуникаций | Используйте бэкенд NCCL | NCCL — лучший выбор для GPU; быстрее, чем Gloo |
| Загрузка данных | Задайте num_workers и pin_memory | Задайте num_workers равным количеству ядер CPU; pin_memory ускоряет передачу данных из CPU в GPU |
| Синхронизация градиентов | Настройте bucket_cap_mb | Для больших моделей можно увеличить bucket; для меньших моделей можно уменьшить его, чтобы улучшить отзывчивость |
| Смешанная точность | DDP + AMP | Снижает объём обмена; повышает скорость обучения |
6.2 Типичные проблемы и решения
| Проблема | Причина | Решение |
|---|---|---|
| Медленный обмен данными | Недостаточная пропускная способность сети | Используйте InfiniBand или высокоскоростную сеть |
| Недостаточно памяти GPU | Слишком большой размер батча | Уменьшите размер пакета или используйте накопление градиентов |
| Несбалансированная нагрузка | Нерациональное разбиение модели | Настройте распределение слоёв так, чтобы оно было как можно более равномерным |
| Ошибка синхронизации | Градиент NaN | Проверьте настройки отсечения и масштабирования градиента |
6.3 Полный скрипт обучения на нескольких машинах с несколькими GPU
Пример
import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler
import argparse
import os
class TrainingConfig:
def __init__(self):
self.local_rank = -1
self.epochs = 30
self.batch_size = 32
self.lr = 1e-3
self.num_workers = 4
self.gradient_clip = 1.0
self.use_amp = True
def init_distributed(config):
"""Инициализация распределённой среды"""
# Получить конфигурацию из переменных окружения
local_rank = config.local_rank
# Конфигурация NCCL
os.environ["NCCL_DEBUG"] = "WARN"
torch.cuda.set_device(local_rank)
dist.init_process_group(backend="nccl")
return local_rank
def create_dataloader(dataset, config, world_size, rank):
"""Создать загрузчик данных"""
sampler = DistributedSampler(
dataset,
num_replicas=world_size,
rank=rank,
shuffle=True,
drop_last=True
)
loader = DataLoader(
dataset,
batch_size=config.batch_size,
sampler=sampler,
num_workers=config.num_workers,
pin_memory=True,
persistent_workers=True
)
return loader, sampler
def train_epoch(model, loader, criterion, optimizer, scaler, config, rank):
"""Обучить одну эпоху"""
model.train()
total_loss = 0
correct = 0
total = 0
for inputs, labels in loader:
inputs = inputs.cuda(rank, non_blocking=True)
labels = labels.cuda(rank, non_blocking=True)
optimizer.zero_grad()
if config.use_amp and scaler is not None:
# Обучение со смешанной точностью
with torch.cuda.amp.autocast():
outputs = model(inputs)
loss = criterion(outputs, labels)
scaler.scale(loss).backward()
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)
scaler.step(optimizer)
scaler.update()
else:
# Обычное обучение
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)
optimizer.step()
total_loss += loss.item() * inputs.size(0)
_, predicted = outputs.max(1)
correct += predicted.eq(labels).sum().item()
total += labels.size(0)
return total_loss / total, correct / total
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int, default=-1)
args = parser.parse_args()
config = TrainingConfig()
config.local_rank = args.local_rank
rank = init_distributed(config)
world_size = dist.get_world_size()
print(f"Инициализация процесса {rank}/{world_size} завершена")
# Создание модели
model = YourModel().cuda(rank)
model = DDP(model, device_ids=[rank])
# Оптимизатор
optimizer = optim.Adam(model.parameters(), lr=config.lr)
# GradScaler (если используется смешанная точность)
scaler = GradScaler() if config.use_amp else Отсутствует
# Набор данных (замените на свой набор данных)
dataset = YourDataset()
loader, sampler = create_dataloader(dataset, config, world_size, rank)
criterion = nn.CrossEntropyLoss()
# Цикл обучения
for epoch in range(config.epochs):
sampler.set_epoch(epoch)
loss, acc = train_epoch(model, loader, criterion, optimizer, scaler, config, rank)
# Выводить только на rank 0
if rank == 0:
print(f"Эпоха {epoch+1}/{config.epochs}: Потеря={loss:.4f}, Точность={acc:.4f}")
dist.destroy_process_group()
# Способ запуска:
# torchrun --nnodes=2 --nproc_per_node=4 --node_rank=0 --master_addr=192.168.1.1 --master_port=29500 train.py
# torchrun --nnodes=2 --nproc_per_node=4 --node_rank=1 --master_addr=192.168.1.1 --master_port=29500 train.py
Ключ к распределённому обучению: 1) выбрать подходящий режим параллелизма (параллелизм по данным против параллелизма по модели); 2) использовать DDP вместо DataParallel для лучшей производительности; 3) сочетать с обучением со смешанной точностью для дальнейшего ускорения; 4) правильно настроить загрузчик данных и параметры коммуникации.
7. Мониторинг и отладка распределённого обучения
7.1 Общие инструменты мониторинга
Пример
def monitor_training(rank, world_size):
"""Мониторинг состояния распределённого обучения"""
# 1. Проверить состояние группы процессов
print(f"Ранг: {rank}, Размер мира: {world_size}")
print(f"Бэкенд: {dist.get_backend()}")
print(f"Ранг: {dist.get_rank()}")
print(f"Устройство CUDA: {torch.cuda.current_device()}")
# 2. Мониторинг использования памяти GPU
if torch.cuda.is_available():
for i in range(torch.cuda.device_count()):
allocated = torch.cuda.memory_allocated(i) / 1024**2
reserved = torch.cuda.memory_reserved(i) / 1024**2
print(f"GPU {i}: выделено {allocated:.1f} MB, зарезервировано {reserved:.1f} MB")
# 3. Мониторинг синхронизации градиентов
# DDP автоматически записывает время синхронизации
# Подробное логирование можно включить, задав переменные окружения
# os.environ["NCCL_DEBUG"] = "INFO"
# Вызывайте периодически в цикле обучения
monitor_training(rank, dist.get_world_size())
7.2 Советы по отладке
- Сначала протестируйте на одной машине, затем масштабируйте на несколько машин
- Используйте
os.environ["NCCL_DEBUG"] = "INFO"Просмотр подробных журналов коммуникации - Убедитесь, что часы на всех машинах синхронизированы (с помощью NTP)
- Проверьте, разрешает ли брандмауэр порты связи NCCL
Другие расширенияХотя распределённое обучение добавляет сложности, улучшение производительности, которое оно приносит, значительно. Для обучения больших моделей это почти обязательная техника.