Робота з даними та регуляризація в PyTorch

import torch
from torch.utils.data import Dataset
import pandas as pd

class CSVDataset(Dataset):
    """Dataset для завантаження даних з CSV файлу."""
    
    def __init__(self, csv_path, feature_columns, target_column):
        # Завантажуємо CSV (можна зробити ледачим для великих файлів)
        self.data = pd.read_csv(csv_path)
        self.feature_columns = feature_columns
        self.target_column = target_column
    
    def __len__(self):
        """Повертає кількість прикладів у датасеті."""
        return len(self.data)
    
    def __getitem__(self, idx):
        """Повертає один приклад за індексом."""
        # Вибираємо рядок
        row = self.data.iloc[idx]
        
        # Ознаки
        features = torch.tensor(
            row[self.feature_columns].values,
            dtype=torch.float32
        )
        
        # Мітка
        target = torch.tensor(
            row[self.target_column],
            dtype=torch.float32
        )
        
        return features, target

# Приклад використання (імітуємо CSV)
import io
csv_data = """age,income,score,purchased
25,50000,0.7,1
32,75000,0.9,1
45,60000,0.5,0
28,55000,0.6,0"""

# Зберігаємо у тимчасовий файл
with open('/tmp/data.csv', 'w') as f:
    f.write(csv_data)

dataset = CSVDataset(
    csv_path='/tmp/data.csv',
    feature_columns=['age', 'income', 'score'],
    target_column='purchased'
)

print(f"Розмір датасету: {len(dataset)}")
print(f"\nПерший приклад:")
features, target = dataset[0]
print(f"  Ознаки: {features}")
print(f"  Мітка: {target}")

import torch
from torch.utils.data import Dataset
from PIL import Image
import os

class ImageFolderDataset(Dataset):
    """Dataset для завантаження зображень з папки."""
    
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        
        # Знаходимо всі зображення
        self.image_paths = []
        self.labels = []
        
        # Структура: root_dir/class_name/image.jpg
        for class_idx, class_name in enumerate(sorted(os.listdir(root_dir))):
            class_dir = os.path.join(root_dir, class_name)
            if not os.path.isdir(class_dir):
                continue
            
            for img_name in os.listdir(class_dir):
                if img_name.endswith(('.jpg', '.jpeg', '.png')):
                    self.image_paths.append(os.path.join(class_dir, img_name))
                    self.labels.append(class_idx)
    
    def __len__(self):
        return len(self.image_paths)
    
    def __getitem__(self, idx):
        # Завантажуємо зображення ЛИШЕ коли потрібно (lazy loading)
        img_path = self.image_paths[idx]
        image = Image.open(img_path).convert('RGB')
        label = self.labels[idx]
        
        # Застосовуємо трансформації (якщо є)
        if self.transform:
            image = self.transform(image)
        
        return image, label

# Демонстрація (без реального файлу)
print("ImageFolderDataset створено")
print("Приклад структури:")
print("  data/")
print("    cats/")
print("      cat1.jpg")
print("      cat2.jpg")
print("    dogs/")
print("      dog1.jpg")
print("      dog2.jpg")

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

# Створюємо простий датасет
X = torch.randn(100, 10)
y = torch.randint(0, 2, (100,))

dataset = TensorDataset(X, y)

# DataLoader з різними параметрами
loader = DataLoader(
    dataset,
    batch_size=16,        # розмір батча
    shuffle=True,         # перемішувати перед кожною епохою
    num_workers=0,        # кількість процесів для завантаження (0 = головний процес)
    pin_memory=False,     # оптимізація для GPU
    drop_last=False       # відкинути неповний останній батч
)

print(f"Датасет: {len(dataset)} прикладів")
print(f"Батчів: {len(loader)}")
print(f"Розмір батча: {loader.batch_size}\n")

# Ітерація по батчах
for batch_idx, (batch_X, batch_y) in enumerate(loader):
    print(f"Батч {batch_idx + 1}: X={batch_X.shape}, y={batch_y.shape}")
    if batch_idx == 2:  # показуємо лише перші 3 батчі
        break

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

# Генеруємо дані з різними масштабами
torch.manual_seed(42)
X_train = torch.randn(1000, 5) * torch.tensor([10.0, 100.0, 1.0, 0.1, 1000.0])
y_train = torch.randn(1000, 1)

# ПРАВИЛЬНО: обчислюємо статистики лише на train
mean = X_train.mean(dim=0, keepdim=True)
std = X_train.std(dim=0, keepdim=True)

# Застосовуємо до train
X_train_scaled = (X_train - mean) / std

print("До стандартизації:")
print(f"  Mean: {X_train.mean(dim=0)}")
print(f"  Std: {X_train.std(dim=0)}\n")

print("Після стандартизації:")
print(f"  Mean: {X_train_scaled.mean(dim=0)}")
print(f"  Std: {X_train_scaled.std(dim=0)}")

from torch.utils.data import random_split

# Датасет
dataset = TensorDataset(torch.randn(1000, 10), torch.randint(0, 2, (1000,)))

# Розділення: 70% train, 15% val, 15% test
train_size = int(0.7 * len(dataset))
val_size = int(0.15 * len(dataset))
test_size = len(dataset) - train_size - val_size

train_dataset, val_dataset, test_dataset = random_split(
    dataset, 
    [train_size, val_size, test_size],
    generator=torch.Generator().manual_seed(42)  # для відтворюваності
)

print(f"Train: {len(train_dataset)} прикладів")
print(f"Val: {len(val_dataset)} прикладів")
print(f"Test: {len(test_dataset)} прикладів")

# DataLoaders
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# Симуляція overfitting
epochs = list(range(1, 51))
train_loss = [1.0 - i * 0.019 for i in epochs]  # постійно зменшується
val_loss = [1.0 - i * 0.018 if i < 15 else 0.73 + (i - 15) * 0.01 for i in epochs]

print("Симптоми перенавчання:")
print(f"  Епоха 15: Train loss = {train_loss[14]:.3f}, Val loss = {val_loss[14]:.3f}")
print(f"  Епоха 50: Train loss = {train_loss[49]:.3f}, Val loss = {val_loss[49]:.3f}")
print(f"\n✓ Train loss продовжує зменшуватися")
print(f"✗ Val loss починає зростати після епохи 15")

import torch
import torch.nn as nn

class NetworkWithDropout(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, dropout_p=0.5):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.dropout1 = nn.Dropout(p=dropout_p)
        
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.dropout2 = nn.Dropout(p=dropout_p)
        
        self.fc3 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout1(x)  # Dropout після активації
        
        x = torch.relu(self.fc2(x))
        x = self.dropout2(x)
        
        x = self.fc3(x)
        return x

model = NetworkWithDropout(10, 128, 3, dropout_p=0.3)
X = torch.randn(5, 10)

# Режим train: dropout активний
model.train()
out_train = model(X)
print(f"Train mode (dropout ON): {out_train[0]}")

# Режим eval: dropout вимкнений
model.eval()
with torch.no_grad():
    out_eval = model(X)
print(f"Eval mode (dropout OFF): {out_eval[0]}")

import torch
import torch.nn as nn

class NetworkWithBatchNorm(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.bn1 = nn.BatchNorm1d(hidden_size)
        
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.bn2 = nn.BatchNorm1d(hidden_size)
        
        self.fc3 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.bn1(x)  # BatchNorm перед активацією
        x = torch.relu(x)
        
        x = self.fc2(x)
        x = self.bn2(x)
        x = torch.relu(x)
        
        x = self.fc3(x)
        return x

model = NetworkWithBatchNorm(10, 64, 3)
X = torch.randn(32, 10)

output = model(X)
print(f"Вихід: {output.shape}")
print(f"\nBatchNorm параметри (навчаються):")
print(f"  gamma (scale): {model.bn1.weight.shape}")
print(f"  beta (shift): {model.bn1.bias.shape}")

import torch.optim as optim

model = nn.Linear(10, 1)

# Без weight decay
optimizer_no_wd = optim.Adam(model.parameters(), lr=0.001)

# З weight decay
optimizer_with_wd = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

# Або AdamW (decoupled weight decay — краще)
optimizer_adamw = optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)

print("Оптимізатори створено з різними налаштуваннями weight decay")
print(f"  No WD: weight_decay = {optimizer_no_wd.param_groups[0].get('weight_decay', 0)}")
print(f"  Adam WD: weight_decay = {optimizer_with_wd.param_groups[0]['weight_decay']}")
print(f"  AdamW: weight_decay = {optimizer_adamw.param_groups[0]['weight_decay']}")

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

# Генеруємо невеликий датасет (схильний до overfitting)
torch.manual_seed(42)
X = torch.randn(200, 20)
y = (X.sum(dim=1, keepdim=True) > 0).float()

dataset = TensorDataset(X, y)
train_ds, val_ds = random_split(dataset, [150, 50])

train_loader = DataLoader(train_ds, batch_size=16, shuffle=True)
val_loader = DataLoader(val_ds, batch_size=16, shuffle=False)

# Модель БЕЗ регуляризації
class PlainModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(20, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 1)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Модель З регуляризацією
class RegularizedModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(20, 128)
        self.bn1 = nn.BatchNorm1d(128)
        self.dropout1 = nn.Dropout(0.3)
        
        self.fc2 = nn.Linear(128, 64)
        self.bn2 = nn.BatchNorm1d(64)
        self.dropout2 = nn.Dropout(0.3)
        
        self.fc3 = nn.Linear(64, 1)
    
    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

# Тренування обох моделей
def train_model(model, train_loader, val_loader, epochs=50, use_wd=False):
    criterion = nn.BCEWithLogitsLoss()
    if use_wd:
        optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)
    else:
        optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    train_losses, val_losses = [], []
    
    for epoch in range(epochs):
        # Train
        model.train()
        train_loss = 0
        for X_batch, y_batch in train_loader:
            optimizer.zero_grad()
            output = model(X_batch)
            loss = criterion(output, y_batch)
            loss.backward()
            optimizer.step()
            train_loss += loss.item()
        
        # Validation
        model.eval()
        val_loss = 0
        with torch.no_grad():
            for X_batch, y_batch in val_loader:
                output = model(X_batch)
                loss = criterion(output, y_batch)
                val_loss += loss.item()
        
        train_losses.append(train_loss / len(train_loader))
        val_losses.append(val_loss / len(val_loader))
    
    return train_losses, val_losses

# Тренуємо обидві моделі
print("Тренування моделі БЕЗ регуляризації...")
plain_model = PlainModel()
plain_train, plain_val = train_model(plain_model, train_loader, val_loader)

print("Тренування моделі З регуляризацією...")
reg_model = RegularizedModel()
reg_train, reg_val = train_model(reg_model, train_loader, val_loader, use_wd=True)

print(f"\nРезультати:")
print(f"  Без регуляризації: Train={plain_train[-1]:.4f}, Val={plain_val[-1]:.4f}")
print(f"  З регуляризацією: Train={reg_train[-1]:.4f}, Val={reg_val[-1]:.4f}")
print(f"\n✓ Регуляризація зменшила розрив між train та val loss!")