Просунуті теми PyTorch — GPU, оптимізація та deployment

import torch
import time

# Розмір матриць
size = 5000

# Створюємо матриці на CPU
A_cpu = torch.randn(size, size)
B_cpu = torch.randn(size, size)

# Вимірюємо час на CPU
start = time.time()
C_cpu = torch.matmul(A_cpu, B_cpu)
cpu_time = time.time() - start

print(f"CPU обчислення:")
print(f"  Розмір матриці: {size}×{size}")
print(f"  Час: {cpu_time:.3f} сек\n")

# Якщо доступна GPU
if torch.cuda.is_available():
    # Переміщуємо на GPU
    A_gpu = A_cpu.cuda()
    B_gpu = B_cpu.cuda()
    
    # "Розігрів" GPU (перші операції завжди повільніші)
    _ = torch.matmul(A_gpu, B_gpu)
    torch.cuda.synchronize()
    
    # Вимірюємо час на GPU
    start = time.time()
    C_gpu = torch.matmul(A_gpu, B_gpu)
    torch.cuda.synchronize()  # Чекаємо завершення операції на GPU
    gpu_time = time.time() - start
    
    print(f"GPU обчислення:")
    print(f"  Назва GPU: {torch.cuda.get_device_name(0)}")
    print(f"  Час: {gpu_time:.3f} сек")
    print(f"  Прискорення: {cpu_time / gpu_time:.1f}×")
else:
    print("GPU недоступна на цій системі")

import torch

# Перевірка доступності CUDA (NVIDIA GPU)
print(f"CUDA доступна: {torch.cuda.is_available()}")

if torch.cuda.is_available():
    print(f"Кількість GPU: {torch.cuda.device_count()}")
    print(f"Поточна GPU: {torch.cuda.current_device()}")
    print(f"Назва GPU: {torch.cuda.get_device_name(0)}")
    
    # Інформація про пам'ять
    total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
    print(f"Загальна пам'ять: {total_memory:.2f} GB")

# Створення тензора на CPU (за замовчуванням)
x_cpu = torch.tensor([1.0, 2.0, 3.0])
print(f"Тензор на CPU:")
print(f"  Значення: {x_cpu}")
print(f"  device: {x_cpu.device}")
print(f"  dtype: {x_cpu.dtype}\n")

# Переміщення на GPU
if torch.cuda.is_available():
    # Спосіб 1: метод .cuda()
    x_gpu_1 = x_cpu.cuda()
    print(f"Після .cuda():")
    print(f"  device: {x_gpu_1.device}\n")
    
    # Спосіб 2: метод .to() (рекомендовано)
    device = torch.device('cuda')
    x_gpu_2 = x_cpu.to(device)
    print(f"Після .to('cuda'):")
    print(f"  device: {x_gpu_2.device}\n")
    
    # Повернення на CPU
    x_back_cpu = x_gpu_2.cpu()
    print(f"Після .cpu():")
    print(f"  device: {x_back_cpu.device}")

import torch
import torch.nn as nn

# Визначаємо модель
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 1)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Створюємо модель (за замовчуванням на CPU)
model = SimpleModel()
print("Модель створено на CPU")

# Перевіряємо, де знаходяться параметри
first_param = next(model.parameters())
print(f"Параметри моделі на: {first_param.device}\n")

# Переміщуємо на GPU
if torch.cuda.is_available():
    device = torch.device('cuda')
    model = model.to(device)
    
    first_param = next(model.parameters())
    print(f"Після .to('cuda'):")
    print(f"  Параметри моделі на: {first_param.device}")
    print(f"  Кількість параметрів: {sum(p.numel() for p in model.parameters())}")

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader

# Визначаємо device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Використовуємо пристрій: {device}\n")

# Генеруємо синтетичні дані
torch.manual_seed(42)
X_train = torch.randn(1000, 20)
y_train = (X_train.sum(dim=1, keepdim=True) > 0).float()

# DataLoader
train_dataset = TensorDataset(X_train, y_train)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# Модель
model = nn.Sequential(
    nn.Linear(20, 64),
    nn.ReLU(),
    nn.Dropout(0.3),
    nn.Linear(64, 32),
    nn.ReLU(),
    nn.Linear(32, 1)
).to(device)  # ✅ Модель на GPU

# Loss та optimizer
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Тренування
num_epochs = 10

for epoch in range(num_epochs):
    model.train()
    epoch_loss = 0.0
    
    for batch_X, batch_y in train_loader:
        # ✅ Переміщуємо дані на GPU
        batch_X = batch_X.to(device)
        batch_y = batch_y.to(device)
        
        # Training step
        optimizer.zero_grad()
        outputs = model(batch_X)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()
        
        epoch_loss += loss.item()
    
    avg_loss = epoch_loss / len(train_loader)
    print(f"Епоха {epoch+1}/{num_epochs}: Loss = {avg_loss:.4f}")

print("\n✓ Тренування завершено")

import torch
import torch.nn as nn
import torch.optim as optim
from torch.cuda.amp import autocast, GradScaler

# Перевірка підтримки
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    
    # Tensor Cores (для прискорення FP16) доступні на GPU від GTX 1660 / RTX 2000
    capability = torch.cuda.get_device_capability(0)
    print(f"Compute Capability: {capability[0]}.{capability[1]}")
    
    if capability[0] >= 7:
        print("✓ Tensor Cores підтримуються (оптимальне прискорення)")
    else:
        print("⚠ Tensor Cores не підтримуються (прискорення буде меншим)")

device = torch.device('cuda')

# Модель
model = nn.Sequential(
    nn.Linear(1000, 2000),
    nn.ReLU(),
    nn.Linear(2000, 1000),
    nn.ReLU(),
    nn.Linear(1000, 10)
).to(device)

optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

# ✅ GradScaler для mixed precision
scaler = GradScaler()

# Синтетичні дані
X = torch.randn(128, 1000).to(device)
y = torch.randint(0, 10, (128,)).to(device)

# Training step БЕЗ mixed precision
optimizer.zero_grad()
outputs = model(X)
loss = criterion(outputs, y)
loss.backward()
optimizer.step()

print(f"Без AMP: Loss = {loss.item():.4f}")

# Training step З mixed precision
optimizer.zero_grad()

# ✅ autocast автоматично використовує FP16 де можливо
with autocast():
    outputs = model(X)
    loss = criterion(outputs, y)

# ✅ Масштабування градієнтів (для запобігання underflow)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

print(f"З AMP: Loss = {loss.item():.4f}")
print("\n✓ Mixed precision не впливає на точність loss")

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
from torch.cuda.amp import autocast, GradScaler
import time

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

# Дані
X_train = torch.randn(10000, 512)
y_train = torch.randint(0, 10, (10000,))

train_dataset = TensorDataset(X_train, y_train)
train_loader = DataLoader(train_dataset, batch_size=256, shuffle=True, pin_memory=True)

# Модель
model = nn.Sequential(
    nn.Linear(512, 1024),
    nn.ReLU(),
    nn.Linear(1024, 512),
    nn.ReLU(),
    nn.Linear(512, 10)
).to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scaler = GradScaler()

# Тренування З mixed precision
print("Тренування з Mixed Precision:")
start = time.time()

for epoch in range(3):
    for batch_X, batch_y in train_loader:
        batch_X = batch_X.to(device, non_blocking=True)
        batch_y = batch_y.to(device, non_blocking=True)
        
        optimizer.zero_grad()
        
        with autocast():
            outputs = model(batch_X)
            loss = criterion(outputs, batch_y)
        
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()
    
    print(f"  Епоха {epoch+1}: Loss = {loss.item():.4f}")

amp_time = time.time() - start
print(f"Час з AMP: {amp_time:.2f} сек\n")

# Порівняння (БЕЗ AMP)
model = model.to(device)  # Перезавантажуємо модель
optimizer = optim.Adam(model.parameters(), lr=0.001)

print("Тренування БЕЗ Mixed Precision:")
start = time.time()

for epoch in range(3):
    for batch_X, batch_y in train_loader:
        batch_X = batch_X.to(device)
        batch_y = batch_y.to(device)
        
        optimizer.zero_grad()
        outputs = model(batch_X)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()
    
    print(f"  Епоха {epoch+1}: Loss = {loss.item():.4f}")

no_amp_time = time.time() - start
print(f"Час БЕЗ AMP: {no_amp_time:.2f} сек\n")

print(f"Прискорення: {no_amp_time / amp_time:.2f}×")

import torch
import time

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

model = nn.Sequential(
    nn.Linear(1000, 2000),
    nn.ReLU(),
    nn.Linear(2000, 1000)
).to(device)

X = torch.randn(128, 1000).to(device)

# Простий профайлінг через time
def profile_function(func, name, iterations=100):
    # Warmup
    for _ in range(10):
        func()
    
    if device.type == 'cuda':
        torch.cuda.synchronize()
    
    start = time.time()
    for _ in range(iterations):
        func()
    
    if device.type == 'cuda':
        torch.cuda.synchronize()
    
    elapsed = (time.time() - start) / iterations
    print(f"{name}: {elapsed*1000:.3f} ms")

# Профілювання різних операцій
profile_function(lambda: model(X), "Forward pass")
profile_function(lambda: X @ X.T, "Matrix multiplication")
profile_function(lambda: torch.relu(X), "ReLU activation")

import torch
from torch.profiler import profile, ProfilerActivity

model = nn.Sequential(
    nn.Linear(100, 200),
    nn.ReLU(),
    nn.Linear(200, 10)
).to(device)

X = torch.randn(32, 100).to(device)

# Профілювання з детальними метриками
with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA]) as prof:
    for _ in range(10):
        output = model(X)

# Топ-5 найповільніших операцій
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=5))

from torch.utils.data import TensorDataset, DataLoader
import time

# Датасет
X_train = torch.randn(10000, 100)
y_train = torch.randint(0, 2, (10000,))
dataset = TensorDataset(X_train, y_train)

# Тестуємо різні налаштування
def benchmark_dataloader(num_workers, pin_memory):
    loader = DataLoader(
        dataset,
        batch_size=128,
        shuffle=True,
        num_workers=num_workers,
        pin_memory=pin_memory
    )
    
    start = time.time()
    for _ in range(3):  # 3 епохи
        for batch_X, batch_y in loader:
            if torch.cuda.is_available():
                batch_X = batch_X.cuda()
                batch_y = batch_y.cuda()
    elapsed = time.time() - start
    
    return elapsed

print("Оптимізація DataLoader:\n")
results = []

for num_workers in [0, 2, 4, 8]:
    for pin_memory in [False, True]:
        time_taken = benchmark_dataloader(num_workers, pin_memory)
        results.append((num_workers, pin_memory, time_taken))
        print(f"num_workers={num_workers}, pin_memory={pin_memory}: {time_taken:.3f} сек")

# Знаходимо оптимальні налаштування
best = min(results, key=lambda x: x[2])
print(f"\nОптимальні налаштування:")
print(f"  num_workers={best[0]}, pin_memory={best[1]}, час={best[2]:.3f} сек")

import torch
import torch.nn as nn

# Визначаємо модель
class MyModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Створюємо та тренуємо модель
model = MyModel(input_size=10, hidden_size=20, output_size=3)
print("Модель створено\n")

# Переглядаємо state_dict
print("State dict містить:")
for name, param in model.state_dict().items():
    print(f"  {name}: {param.shape}")

# ✅ Збереження state_dict
torch.save(model.state_dict(), 'model_weights.pth')
print("✓ State dict збережено у 'model_weights.pth'\n")

# Завантаження у нову модель
model_new = MyModel(input_size=10, hidden_size=20, output_size=3)
model_new.load_state_dict(torch.load('model_weights.pth'))
model_new.eval()  # Режим evaluation

print("✓ State dict завантажено у нову модель")

# Перевірка, що параметри ідентичні
X = torch.randn(5, 10)
output_original = model(X)
output_loaded = model_new(X)

print(f"\nПорівняння виходів:")
print(f"  Різниця: {(output_original - output_loaded).abs().max().item():.10f}")
print("  ✓ Моделі ідентичні")

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

model = MyModel(10, 20, 3)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Імітація тренування
current_epoch = 10
best_val_loss = 0.1234
train_losses = [0.5, 0.4, 0.3, 0.25, 0.2]

# ✅ Збереження повного checkpoint
checkpoint = {
    'epoch': current_epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'best_val_loss': best_val_loss,
    'train_losses': train_losses
}

torch.save(checkpoint, 'checkpoint.pth')
print("✓ Checkpoint збережено\n")

# Відновлення тренування
checkpoint_loaded = torch.load('checkpoint.pth')

model_new = MyModel(10, 20, 3)
optimizer_new = optim.Adam(model_new.parameters())

model_new.load_state_dict(checkpoint_loaded['model_state_dict'])
optimizer_new.load_state_dict(checkpoint_loaded['optimizer_state_dict'])

epoch = checkpoint_loaded['epoch']
best_val_loss = checkpoint_loaded['best_val_loss']
train_losses = checkpoint_loaded['train_losses']

print(f"✓ Тренування відновлено:")
print(f"  Епоха: {epoch}")
print(f"  Best val loss: {best_val_loss:.4f}")
print(f"  Train losses: {train_losses}")
print(f"\n→ Можна продовжувати з епохи {epoch + 1}")

import torch
import torch.nn as nn

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 20)
        self.fc2 = nn.Linear(20, 3)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleModel()
model.eval()

# ✅ Tracing: записуємо операції з прикладом входу
example_input = torch.randn(1, 10)
traced_model = torch.jit.trace(model, example_input)

# Збереження
traced_model.save('model_traced.pt')
print("✓ TorchScript модель (traced) збережено\n")

# Завантаження та використання
loaded_model = torch.jit.load('model_traced.pt')
output = loaded_model(example_input)

print(f"Вихід traced моделі: {output.shape}")
print(f"Значення: {output}")

import torch
import torch.nn as nn

class ConditionalModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(10, 3)
    
    def forward(self, x):
        # Умовна логіка
        if x.sum() > 0:
            x = x * 2
        x = torch.relu(self.fc(x))
        return x

model = ConditionalModel()

# ✅ Scripting: парсить Python код
scripted_model = torch.jit.script(model)

scripted_model.save('model_scripted.pt')
print("✓ TorchScript модель (scripted) збережено\n")

# Перевірка з різними входами
x_positive = torch.randn(1, 10) + 5  # сума > 0
x_negative = torch.randn(1, 10) - 5  # сума < 0

loaded_model = torch.jit.load('model_scripted.pt')

print(f"Вхід (сума > 0): {loaded_model(x_positive).sum():.4f}")
print(f"Вхід (сума < 0): {loaded_model(x_negative).sum():.4f}")
print("\n✓ Умовна логіка працює коректно")

import torch
import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc = nn.Linear(16 * 16 * 16, 10)
    
    def forward(self, x):
        x = torch.relu(self.conv(x))
        x = self.pool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

model = MyModel()
model.eval()

# Приклад входу (batch_size=1, channels=3, height=32, width=32)
dummy_input = torch.randn(1, 3, 32, 32)

# ✅ Експорт у ONNX
torch.onnx.export(
    model,                      # модель
    dummy_input,                # приклад входу
    'model.onnx',               # шлях до файлу
    input_names=['input'],      # імена входів
    output_names=['output'],    # імена виходів
    dynamic_axes={              # динамічні розміри (для різних batch_size)
        'input': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    },
    opset_version=14            # версія ONNX операцій
)

print("✓ Модель експортовано у ONNX\n")

# Перевірка через ONNX Runtime
try:
    import onnxruntime as ort
    
    session = ort.InferenceSession('model.onnx')
    
    # Inference
    ort_inputs = {session.get_inputs()[0].name: dummy_input.numpy()}
    ort_outputs = session.run(None, ort_inputs)
    
    # Порівняння з PyTorch
    pytorch_output = model(dummy_input).detach().numpy()
    
    diff = abs(pytorch_output - ort_outputs[0]).max()
    print(f"Максимальна різниця PyTorch vs ONNX: {diff:.6f}")
    print("✓ ONNX модель працює коректно")
    
except ImportError:
    print("⚠ Встановіть onnxruntime для перевірки:")
    print("  pip install onnxruntime")