Побудова та тренування нейронних мереж у PyTorch

import torch

# Вручну визначаємо параметри
w1 = torch.randn(10, 20, requires_grad=True)
b1 = torch.randn(20, requires_grad=True)
w2 = torch.randn(20, 1, requires_grad=True)
b2 = torch.randn(1, requires_grad=True)

# Forward pass вручну
def forward(X):
    h = X @ w1 + b1
    h = torch.relu(h)
    y = h @ w2 + b2
    return y

X = torch.randn(32, 10)
y_pred = forward(X)
print(f"Вихід: {y_pred.shape}")

import torch
import torch.nn as nn

class SimpleNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 20)
        self.fc2 = nn.Linear(20, 1)
    
    def forward(self, X):
        h = torch.relu(self.fc1(X))
        y = self.fc2(h)
        return y

model = SimpleNetwork()
X = torch.randn(32, 10)
y_pred = model(X)
print(f"Вихід: {y_pred.shape}")
print(f"Кількість параметрів: {sum(p.numel() for p in model.parameters())}")

import torch
import torch.nn as nn

class MyFirstNetwork(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()  # Обов'язково викликати конструктор батьківського класу!
        
        # Визначаємо шари
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        # Описуємо forward pass
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# Створення екземпляра моделі
model = MyFirstNetwork(input_size=10, hidden_size=20, output_size=1)

# Виклик моделі (автоматично викликає forward)
X = torch.randn(5, 10)  # батч з 5 прикладів
output = model(X)

print(f"Вхід: {X.shape}")
print(f"Вихід: {output.shape}")

import torch
import torch.nn as nn

model = MyFirstNetwork(10, 20, 1)

# Отримання всіх параметрів
print("Всі параметри:")
for name, param in model.named_parameters():
    print(f"  {name}: {param.shape}")

# Загальна кількість параметрів
total_params = sum(p.numel() for p in model.parameters())
print(f"Загальна кількість параметрів: {total_params}")

# Кількість параметрів, що навчаються
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"Параметри, що навчаються: {trainable_params}")

# state_dict — словник усіх параметрів
print("State dict:")
for key, value in model.state_dict().items():
    print(f"  {key}: {value.shape}")

import torch
import torch.nn as nn

# Linear(in_features, out_features)
# Виконує операцію: y = xW^T + b
layer = nn.Linear(in_features=10, out_features=5)

X = torch.randn(3, 10)  # батч з 3 прикладів
output = layer(X)

print(f"Вхід: {X.shape}")
print(f"Вага: {layer.weight.shape}")  # (out, in)
print(f"Зміщення: {layer.bias.shape}")
print(f"Вихід: {output.shape}")

import torch
import torch.nn as nn

x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])

# ReLU: max(0, x)
relu = nn.ReLU()
print(f"ReLU: {relu(x)}")

# LeakyReLU: max(0.01x, x)
leaky_relu = nn.LeakyReLU(negative_slope=0.01)
print(f"LeakyReLU: {leaky_relu(x)}")

# Sigmoid: 1 / (1 + e^(-x))
sigmoid = nn.Sigmoid()
print(f"Sigmoid: {sigmoid(x)}")

# Tanh: (e^x - e^(-x)) / (e^x + e^(-x))
tanh = nn.Tanh()
print(f"Tanh: {tanh(x)}")

import torch
import torch.nn as nn

class DeepNetwork(nn.Module):
    def __init__(self, input_size, hidden_sizes, output_size, dropout_p=0.3):
        super().__init__()
        
        # Перший шар
        self.fc1 = nn.Linear(input_size, hidden_sizes[0])
        self.bn1 = nn.BatchNorm1d(hidden_sizes[0])
        self.dropout1 = nn.Dropout(dropout_p)
        
        # Другий шар
        self.fc2 = nn.Linear(hidden_sizes[0], hidden_sizes[1])
        self.bn2 = nn.BatchNorm1d(hidden_sizes[1])
        self.dropout2 = nn.Dropout(dropout_p)
        
        # Вихідний шар
        self.fc3 = nn.Linear(hidden_sizes[1], output_size)
    
    def forward(self, x):
        # Перший блок
        x = self.fc1(x)
        x = self.bn1(x)
        x = torch.relu(x)
        x = self.dropout1(x)
        
        # Другий блок
        x = self.fc2(x)
        x = self.bn2(x)
        x = torch.relu(x)
        x = self.dropout2(x)
        
        # Вихід
        x = self.fc3(x)
        return x

model = DeepNetwork(input_size=10, hidden_sizes=[64, 32], output_size=3)
print(model)

import torch.nn as nn

# Той самий DeepNetwork, але через Sequential
model = nn.Sequential(
    nn.Linear(10, 64),
    nn.BatchNorm1d(64),
    nn.ReLU(),
    nn.Dropout(0.3),
    
    nn.Linear(64, 32),
    nn.BatchNorm1d(32),
    nn.ReLU(),
    nn.Dropout(0.3),
    
    nn.Linear(32, 3)
)

print(model)
print(f"\nКількість параметрів: {sum(p.numel() for p in model.parameters())}")

import torch
import torch.nn as nn

class DynamicNetwork(nn.Module):
    def __init__(self, input_size, hidden_sizes, output_size):
        super().__init__()
        
        # ModuleList — для змінної кількості шарів
        self.hidden_layers = nn.ModuleList()
        
        prev_size = input_size
        for hidden_size in hidden_sizes:
            self.hidden_layers.append(nn.Linear(prev_size, hidden_size))
            prev_size = hidden_size
        
        self.output_layer = nn.Linear(prev_size, output_size)
    
    def forward(self, x):
        for layer in self.hidden_layers:
            x = torch.relu(layer(x))
        x = self.output_layer(x)
        return x

# Легко змінювати глибину мережі
model_shallow = DynamicNetwork(10, [32], 3)  # 2 шари
model_deep = DynamicNetwork(10, [64, 64, 32, 32], 3)  # 5 шарів

print(f"Shallow: {sum(p.numel() for p in model_shallow.parameters())} параметрів")
print(f"Deep: {sum(p.numel() for p in model_deep.parameters())} параметрів")

# ModuleDict — для розгалужень
class MultiPathNetwork(nn.Module):
    def __init__(self, input_size, output_size):
        super().__init__()
        
        # Два паралельні шляхи обробки
        self.paths = nn.ModuleDict({
            'path_a': nn.Sequential(
                nn.Linear(input_size, 64),
                nn.ReLU(),
                nn.Linear(64, 32)
            ),
            'path_b': nn.Sequential(
                nn.Linear(input_size, 32),
                nn.ReLU()
            )
        })
        
        # Об'єднання шляхів
        self.merger = nn.Linear(32 + 32, output_size)
    
    def forward(self, x):
        out_a = self.paths['path_a'](x)
        out_b = self.paths['path_b'](x)
        
        # Конкатенація виходів
        merged = torch.cat([out_a, out_b], dim=1)
        output = self.merger(merged)
        return output

model = MultiPathNetwork(10, 3)
X = torch.randn(5, 10)
output = model(X)
print(f"Вихід: {output.shape}")

import torch
import torch.nn as nn

# Погана ініціалізація: всі ваги = 0
model_bad = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Linear(20, 1)
)

# Обнулюємо всі ваги
for param in model_bad.parameters():
    nn.init.constant_(param, 0.0)

X = torch.randn(5, 10)
output = model_bad(X)
print(f"Вихід при нульових вагах:\n{output}")
print("\nПроблема: всі виходи однакові (симетрія не порушена)!")

# Xavier (для tanh, sigmoid)
def init_xavier(model):
    for name, param in model.named_parameters():
        if 'weight' in name:
            nn.init.xavier_uniform_(param)
        elif 'bias' in name:
            nn.init.zeros_(param)

model = nn.Sequential(
    nn.Linear(10, 20),
    nn.Tanh(),
    nn.Linear(20, 1)
)

init_xavier(model)
print("Xavier ініціалізація:")
print(f"  fc1.weight mean: {model[0].weight.mean():.6f}")
print(f"  fc1.weight std: {model[0].weight.std():.6f}")

# He initialization (для ReLU)
def init_he(model):
    for name, param in model.named_parameters():
        if 'weight' in name:
            nn.init.kaiming_uniform_(param, nonlinearity='relu')
        elif 'bias' in name:
            nn.init.zeros_(param)

model = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Linear(20, 1)
)

init_he(model)
print("He ініціалізація:")
print(f"  fc1.weight mean: {model[0].weight.mean():.6f}")
print(f"  fc1.weight std: {model[0].weight.std():.6f}")

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

# Проста модель
model = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Linear(20, 1)
)

# Генеруємо фейкові дані
X = torch.randn(32, 10)  # батч з 32 прикладів
y = torch.randn(32, 1)

# Функція втрат та оптимізатор
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# ============= TRAINING LOOP =============
# Крок 1: Обнулити градієнти
optimizer.zero_grad()

# Крок 2: Forward pass
predictions = model(X)

# Крок 3: Обчислити втрати
loss = criterion(predictions, y)

# Крок 4: Backward pass (обчислити градієнти)
loss.backward()

# Крок 5: Оновити параметри
optimizer.step()

# Крок 6: Логування
print(f"Loss: {loss.item():.4f}")

import torch
import torch.nn as nn

y_true = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])
y_pred = torch.tensor([1.2, 2.1, 2.5, 4.3, 5.8])

# MSE (Mean Squared Error) — найпопулярніша для регресії
mse = nn.MSELoss()
print(f"MSE Loss: {mse(y_pred, y_true):.4f}")

# MAE (Mean Absolute Error) — стійка до викидів
mae = nn.L1Loss()
print(f"MAE Loss: {mae(y_pred, y_true):.4f}")

# Smooth L1 Loss (Huber Loss) — компроміс між MSE та MAE
smooth_l1 = nn.SmoothL1Loss()
print(f"Smooth L1: {smooth_l1(y_pred, y_true):.4f}")

import torch
import torch.nn as nn

# Справжні мітки (0 або 1)
y_true = torch.tensor([0.0, 1.0, 1.0, 0.0, 1.0])

# Передбачення моделі (логіти — ДО sigmoid)
logits = torch.tensor([-2.3, 1.5, 0.8, -1.1, 2.7])

# BCEWithLogitsLoss — включає sigmoid (РЕКОМЕНДОВАНО)
criterion = nn.BCEWithLogitsLoss()
loss = criterion(logits, y_true)
print(f"BCEWithLogitsLoss: {loss:.4f}")

# Альтернатива: BCELoss (потрібен sigmoid вручну)
probs = torch.sigmoid(logits)
criterion_bce = nn.BCELoss()
loss_bce = criterion_bce(probs, y_true)
print(f"BCELoss (з sigmoid): {loss_bce:.4f}")

import torch
import torch.nn as nn

# Справжні мітки класів (індекси)
y_true = torch.tensor([0, 2, 1, 0, 2])

# Передбачення моделі (логіти для 3 класів)
logits = torch.tensor([
    [2.1, 0.3, 0.5],  # найбільший логіт для класу 0
    [0.1, 0.4, 3.2],  # найбільший логіт для класу 2
    [0.5, 2.8, 0.2],  # найбільший логіт для класу 1
    [1.9, 0.6, 0.3],  # клас 0
    [0.2, 0.5, 2.1]   # клас 2
])

# CrossEntropyLoss — включає LogSoftmax (СТАНДАРТ)
criterion = nn.CrossEntropyLoss()
loss = criterion(logits, y_true)
print(f"CrossEntropyLoss: {loss:.4f}")

# Передбачені класи
predicted_classes = logits.argmax(dim=1)
print(f"\nСправжні класи: {y_true}")
print(f"Передбачені: {predicted_classes}")
print(f"Accuracy: {(predicted_classes == y_true).float().mean():.2%}")

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

model = nn.Linear(10, 1)

# Базовий SGD
optimizer = optim.SGD(model.parameters(), lr=0.01)

# SGD з momentum
optimizer_momentum = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# SGD з Nesterov momentum
optimizer_nesterov = optim.SGD(
    model.parameters(), 
    lr=0.01, 
    momentum=0.9, 
    nesterov=True
)

# SGD з weight decay (L2 regularization)
optimizer_wd = optim.SGD(
    model.parameters(),
    lr=0.01,
    momentum=0.9,
    weight_decay=1e-4
)

print("SGD варіанти створено")

import torch.optim as optim

model = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 1))

# Adam — адаптивний learning rate
optimizer_adam = optim.Adam(model.parameters(), lr=0.001)

# AdamW — Adam з decoupled weight decay (кращий)
optimizer_adamw = optim.AdamW(
    model.parameters(),
    lr=0.001,
    betas=(0.9, 0.999),      # коефіцієнти для моментів
    eps=1e-8,                 # для стабільності
    weight_decay=0.01         # L2 regularization
)

print(f"Adam параметрів: {len(list(optimizer_adam.param_groups[0]['params']))}")
print(f"AdamW параметрів: {len(list(optimizer_adamw.param_groups[0]['params']))}")

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(10, 20),
    nn.BatchNorm1d(20),
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(20, 1)
)

X = torch.randn(5, 10)

# Режим тренування
model.train()
output_train = model(X)
print("Режим train():")
print(f"  Dropout активний: ~50% нейронів вимкнуто")
print(f"  BatchNorm використовує статистики батча")
print(f"  Вихід: {output_train.T}\n")

# Режим evaluation
model.eval()
with torch.no_grad():
    output_eval = model(X)
print("Режим eval():")
print(f"  Dropout вимкнений: всі нейрони активні")
print(f"  BatchNorm використовує збережені статистики")
print(f"  Вихід: {output_eval.T}")

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

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

X_val = torch.randn(200, 10)
y_val = (X_val.sum(dim=1, keepdim=True) > 0).float()

# DataLoader для батчів
train_dataset = TensorDataset(X_train, y_train)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

val_dataset = TensorDataset(X_val, y_val)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

# Модель
model = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Dropout(0.3),
    nn.Linear(20, 1)
)

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

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

for epoch in range(num_epochs):
    # ========== TRAINING ==========
    model.train()
    train_loss = 0.0
    
    for batch_X, batch_y in train_loader:
        optimizer.zero_grad()
        predictions = model(batch_X)
        loss = criterion(predictions, batch_y)
        loss.backward()
        optimizer.step()
        
        train_loss += loss.item()
    
    train_loss /= len(train_loader)
    
    # ========== VALIDATION ==========
    model.eval()
    val_loss = 0.0
    correct = 0
    total = 0
    
    with torch.no_grad():
        for batch_X, batch_y in val_loader:
            predictions = model(batch_X)
            loss = criterion(predictions, batch_y)
            val_loss += loss.item()
            
            # Обчислення accuracy
            predicted_classes = (torch.sigmoid(predictions) > 0.5).float()
            correct += (predicted_classes == batch_y).sum().item()
            total += batch_y.size(0)
    
    val_loss /= len(val_loader)
    val_accuracy = correct / total
    
    print(f"Епоха {epoch+1}/{num_epochs}")
    print(f"  Train Loss: {train_loss:.4f}")
    print(f"  Val Loss: {val_loss:.4f}, Val Accuracy: {val_accuracy:.2%}\n")

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

# Модель (продовжуємо попередній приклад)
model = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 1))
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.BCEWithLogitsLoss()

# Early stopping параметри
best_val_loss = float('inf')
patience = 3  # скільки епох чекати без покращення
patience_counter = 0

for epoch in range(50):  # максимум 50 епох
    # ... тренування (код вище) ...
    train_loss = 0.15  # приклад
    val_loss = 0.18 - epoch * 0.002  # імітуємо покращення
    
    # Model checkpointing
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        patience_counter = 0
        
        # Зберігаємо найкращу модель
        torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'val_loss': val_loss
        }, 'best_model.pt')
        
        print(f"Епоха {epoch+1}: Val loss покращився до {val_loss:.4f} ✓ Збережено")
    else:
        patience_counter += 1
        print(f"Епоха {epoch+1}: Val loss не покращився ({patience_counter}/{patience})")
        
        if patience_counter >= patience:
            print(f"\nEarly stopping на епосі {epoch+1}")
            break

print(f"\nНайкраща val loss: {best_val_loss:.4f}")

import torch
import torch.nn as nn

# Імітуємо передбачення бінарної класифікації
y_true = torch.tensor([0, 1, 1, 0, 1, 0, 1, 1, 0, 0])
logits = torch.tensor([-1.2, 2.3, 0.8, -0.5, 1.9, -2.1, 0.3, 1.5, -0.8, -1.5])
y_pred = (torch.sigmoid(logits) > 0.5).long()

# Accuracy
accuracy = (y_pred == y_true).float().mean()
print(f"Accuracy: {accuracy:.2%}")

# Precision, Recall, F1 (вручну)
tp = ((y_pred == 1) & (y_true == 1)).sum().item()
fp = ((y_pred == 1) & (y_true == 0)).sum().item()
fn = ((y_pred == 0) & (y_true == 1)).sum().item()
tn = ((y_pred == 0) & (y_true == 0)).sum().item()

precision = tp / (tp + fp) if (tp + fp) > 0 else 0
recall = tp / (tp + fn) if (tp + fn) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0

print(f"\nПрецизія: {precision:.2%}")
print(f"Повнота (Recall): {recall:.2%}")
print(f"F1-Score: {f1:.2%}")

# Confusion Matrix
print(f"\nConfusion Matrix:")
print(f"  TP: {tp}, FP: {fp}")
print(f"  FN: {fn}, TN: {tn}")