Как проверить и настроить GPU для эффективного обучения в PyTorch

import torch

# Проверка наличия доступных GPU
print(f"GPU доступен: {torch.cuda.is_available()}")

# Количество доступных GPU
print(f"Количество доступных GPU: {torch.cuda.device_count()}")

# Имя текущего GPU
if torch.cuda.is_available():
print(f"Текущий GPU: {torch.cuda.get_device_name(0)}")

# Индекс текущего активного устройства
print(f"Индекс текущего GPU: {torch.cuda.current_device()}")

# Создаем тензор и проверяем, на каком устройстве он находится
x = torch.rand(5, 3)
print(f"x находится на: {x.device}")

# Перемещаем тензор на GPU, если он доступен
if torch.cuda.is_available():
x = x.to('cuda')
print(f"x теперь находится на: {x.device}")

# Создаем модель
model = MyNeuralNetwork()

# Перемещаем модель на GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Также необходимо перемещать входные данные на то же устройство
inputs = inputs.to(device)
labels = labels.to(device)

# Для простой настройки нескольких GPU
if torch.cuda.device_count() > 1:
print(f"Используем {torch.cuda.device_count()} GPU!")
model = torch.nn.DataParallel(model)

# Перемещаем модель на GPU(s)
model = model.to(device)

# Пример использования смешанной точности для экономии памяти
from torch.cuda.amp import autocast, GradScaler

# Создаем скейлер градиентов
scaler = GradScaler()

for epoch in range(epochs):
for data, target in train_loader:
data, target = data.to(device), target.to(device)

# Включаем автоматический выбор precision для операций
with autocast():
output = model(data)
loss = loss_function(output, target)

# Скейлер помогает предотвратить underflow при работе с half-precision
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
optimizer.zero_grad()

# Проверка используемой памяти GPU
print(f"Всего памяти GPU: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} ГБ")
print(f"Выделено памяти: {torch.cuda.memory_allocated() / 1e9:.2f} ГБ")
print(f"Кэшировано памяти: {torch.cuda.memory_reserved() / 1e9:.2f} ГБ")

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

# Отслеживание максимального использования памяти
torch.cuda.reset_peak_memory_stats()
# Выполнение операций...
print(f"Пиковое использование памяти: {torch.cuda.max_memory_allocated() / 1e9:.2f} ГБ")

from torch.profiler import profile, record_function, ProfilerActivity

with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], 
record_shapes=True,
with_stack=True) as prof:
with record_function("model_inference"):
model(inputs)

print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))

import time

# Проверяем скорость передачи данных между CPU и GPU
def benchmark_data_transfer(size_mb=100, num_iterations=10):
size_bytes = size_mb * 1024 * 1024

# CPU -> GPU
cpu_to_gpu_times = []
for _ in range(num_iterations):
# Создаем большой тензор на CPU
x = torch.randn(size_bytes // 4, dtype=torch.float) # 4 байта на float

torch.cuda.synchronize() # Дожидаемся завершения всех CUDA операций
start = time.time()

x_gpu = x.cuda() # Передаем на GPU
torch.cuda.synchronize() # Дожидаемся завершения передачи

end = time.time()
cpu_to_gpu_times.append(end – start)

# GPU -> CPU
gpu_to_cpu_times = []
for _ in range(num_iterations):
# Создаем большой тензор на GPU
x_gpu = torch.randn(size_bytes // 4, dtype=torch.float, device='cuda')

torch.cuda.synchronize()
start = time.time()

x_cpu = x_gpu.cpu() # Передаем на CPU
torch.cuda.synchronize()

end = time.time()
gpu_to_cpu_times.append(end – start)

avg_cpu_to_gpu = sum(cpu_to_gpu_times) / len(cpu_to_gpu_times)
avg_gpu_to_cpu = sum(gpu_to_cpu_times) / len(gpu_to_cpu_times)

cpu_to_gpu_bandwidth = size_mb / avg_cpu_to_gpu
gpu_to_cpu_bandwidth = size_mb / avg_gpu_to_cpu

print(f"CPU -> GPU: {cpu_to_gpu_bandwidth:.2f} MB/s")
print(f"GPU -> CPU: {gpu_to_cpu_bandwidth:.2f} MB/s")

benchmark_data_transfer()

import torch
print(f"PyTorch версия: {torch.__version__}")
print(f"CUDA доступен: {torch.cuda.is_available()}")
print(f"cuDNN версия: {torch.backends.cudnn.version()}")
print(f"CUDA версия: {torch.version.cuda}")

# В терминале:
watch -n 1 nvidia-smi

import pynvml
import time

def monitor_gpu(interval=1, duration=60):
"""Мониторит состояние GPU с заданным интервалом в течение указанного времени."""
pynvml.nvmlInit()
device_count = pynvml.nvmlDeviceGetCount()

print(f"Найдено GPU: {device_count}")

end_time = time.time() + duration

while time.time() < end_time:
print("\n" + "="*50)
print(f"Время: {time.strftime('%H:%M:%S')}")

for i in range(device_count):
handle = pynvml.nvmlDeviceGetHandleByIndex(i)
name = pynvml.nvmlDeviceGetName(handle)
memory = pynvml.nvmlDeviceGetMemoryInfo(handle)
utilization = pynvml.nvmlDeviceGetUtilizationRates(handle)
temperature = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)

print(f"\nGPU {i}: {name.decode('utf-8')}")
print(f" Температура: {temperature}°C")
print(f" Использование GPU: {utilization.gpu}%")
print(f" Использование памяти: {memory.used/1024**2:.2f}/{memory.total/1024**2:.2f} MB ({memory.used/memory.total*100:.2f}%)")

# Получение информации о запущенных процессах
try:
processes = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
if processes:
print(" Запущенные процессы:")
for p in processes:
process_name = pynvml.nvmlSystemGetProcessName(p.pid)
print(f" PID {p.pid}: {process_name.decode('utf-8')}, Использовано памяти: {p.usedGpuMemory/1024**2:.2f} MB")
except:
print(" Не удалось получить информацию о процессах")

time.sleep(interval)

pynvml.nvmlShutdown()

# Мониторинг в течение 5 минут с интервалом 5 секунд
monitor_gpu(interval=5, duration=300)

import pytorch_lightning as pl
from pytorch_lightning.callbacks import DeviceStatsMonitor

# Создаем модель
model = MyLightningModel()

# Добавляем мониторинг устройств
trainer = pl.Trainer(
gpus=1,
callbacks=[DeviceStatsMonitor()],
max_epochs=10
)

# Обучаем модель с автоматическим мониторингом
trainer.fit(model, train_dataloader, val_dataloader)

import torch
from torch.utils.tensorboard import SummaryWriter
import time

def train_with_gpu_monitoring(model, train_loader, criterion, optimizer, epochs=5, log_interval=10):
writer = SummaryWriter()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = model.to(device)

# Глобальный счетчик шагов
global_step = 0

for epoch in range(epochs):
model.train()
epoch_start_time = time.time()

for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)

# Засекаем время начала
start_time = time.time()

optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

# Считаем время выполнения батча
batch_time = time.time() – start_time

# Логируем каждые log_interval батчей
if batch_idx % log_interval == 0:
# Логируем метрики производительности
writer.add_scalar('Performance/batch_time', batch_time, global_step)
writer.add_scalar('Training/loss', loss.item(), global_step)

# Логируем использование GPU
writer.add_scalar('GPU/memory_allocated_GB', torch.cuda.memory_allocated(0) / 1e9, global_step)
writer.add_scalar('GPU/memory_reserved_GB', torch.cuda.memory_reserved(0) / 1e9, global_step)

# Если доступно, логируем температуру и загрузку GPU
try:
import pynvml
pynvml.nvmlInit()
handle = pynvml.nvmlDeviceGetHandleByIndex(0)
temperature = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
utilization = pynvml.nvmlDeviceGetUtilizationRates(handle)

writer.add_scalar('GPU/temperature_C', temperature, global_step)
writer.add_scalar('GPU/utilization_percent', utilization.gpu, global_step)

pynvml.nvmlShutdown()
except:
pass

print(f'Epoch: {epoch}, Batch: {batch_idx}, Loss: {loss.item():.6f}, '
f'Batch time: {batch_time:.3f}s, '
f'GPU memory: {torch.cuda.memory_allocated(0)/1e9:.3f} GB')

global_step += 1

epoch_time = time.time() – epoch_start_time
writer.add_scalar('Performance/epoch_time', epoch_time, epoch)
print(f'Epoch {epoch} completed in {epoch_time:.2f}s')

writer.close()

# Использование pin_memory для ускорения передачи данных
train_loader = DataLoader(
train_dataset,
batch_size=batch_size,
shuffle=True,
pin_memory=True, # Закрепляет тензоры в памяти для быстрой передачи на GPU
num_workers=4 # Несколько процессов для загрузки данных
)

# Асинхронная передача данных на GPU
for data, labels in train_loader:
data = data.to(device, non_blocking=True)
labels = labels.to(device, non_blocking=True)
# Это позволит CPU продолжить работу, пока данные передаются

# Автоматический подбор оптимального размера батча
def find_optimal_batch_size(model, input_shape, max_batch_size=1024, start_batch=4):
device = next(model.parameters()).device
batch_size = start_batch

while batch_size <= max_batch_size:
try:
# Пробуем создать батч и выполнить прямой и обратный проход
dummy_input = torch.randn(batch_size, *input_shape, device=device)
output = model(dummy_input)
loss = output.sum()
loss.backward()

# Если успешно, удваиваем размер и пробуем снова
print(f"Batch size {batch_size} работает успешно")
batch_size *= 2

# Очищаем память
del dummy_input, output, loss
torch.cuda.empty_cache()

except RuntimeError as e:
if "out of memory" in str(e).lower():
# Возвращаем последний успешный размер батча
return batch_size // 2
else:
# Если ошибка не связана с памятью, пробрасываем ее дальше
raise e

return batch_size // 2

# Пример использования
input_shape = (3, 224, 224) # (channels, height, width) для изображений
optimal_batch = find_optimal_batch_size(model, input_shape)
print(f"Оптимальный размер батча: {optimal_batch}")

from torch.cuda.amp import autocast, GradScaler

# Инициализируем скейлер для обратного распространения с смешанной точностью
scaler = GradScaler()

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

# Автоматически использует FP16 там, где это безопасно
with autocast():
outputs = model(inputs)
loss = criterion(outputs, labels)

# Скейлер помогает предотвратить underflow при вычислении градиентов
scaler.scale(loss).backward()

# Обновляем веса с учетом скейлинга градиентов
scaler.step(optimizer)
scaler.update()
optimizer.zero_grad()

from torch.profiler import profile, record_function, ProfilerActivity

def profile_model(model, inputs, warmup=10, active=10):
"""Профилирование модели для выявления узких мест."""
model.eval()
inputs = inputs.to(next(model.parameters()).device)

# Разогреваем модель для стабильных измерений
for _ in range(warmup):
with torch.no_grad():
model(inputs)

# Выполняем профилирование
with profile(
activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
record_shapes=True,
profile_memory=True,
with_stack=True
) as prof:
for _ in range(active):
with record_function("model_inference"):
with torch.no_grad():
model(inputs)

# Выводим результаты профилирования
print("===== Профиль операторов =====")
print(prof.key_averages().table(
sort_by="cuda_time_total", 
row_limit=20
))

print("\n===== Профиль по стеку вызовов =====")
print(prof.key_averages(group_by_stack=True).table(
sort_by="cuda_time_total",
row_limit=10
))

# Экспортируем результаты для визуализации в TensorBoard
prof.export_chrome_trace("profile_trace.json")
print("\nТрейс профилирования сохранен в 'profile_trace.json'")
print("Его можно открыть в chrome://tracing/ или в TensorBoard")

return prof

# Пример использования
batch_size = 16
inputs = torch.randn(batch_size, 3, 224, 224, device=device)
profile_results = profile_model(model, inputs)

# Использование эффективных активаций
# ReLU → GELU или SiLU (Swish) для трансформеров
# tanh → GELU для рекуррентных сетей

# Пример замены в модели
class OptimizedModule(nn.Module):
def __init__(self, in_features, hidden_dim, out_features):
super().__init__()
self.linear1 = nn.Linear(in_features, hidden_dim)
# Заменяем ReLU на более эффективную для GPU активацию
self.act = nn.SiLU() # или nn.GELU()
self.linear2 = nn.Linear(hidden_dim, out_features)

def forward(self, x):
return self.linear2(self.act(self.linear1(x)))

# Включение cuDNN автотюнера
torch.backends.cudnn.benchmark = True # Находит наиболее эффективные алгоритмы для текущей конфигурации

# Для детерминированных результатов в ущерб производительности
# torch.backends.cudnn.deterministic = True
# torch.backends.cudnn.benchmark = False

# Для операций свертки предпочтительно использовать размеры, кратные 8
# Например, padding='same' вместо вычисленных вручную значений
conv = nn.Conv2d(64, 128, kernel_size=3, padding=1, stride=1)