Mini-batch Gradient Descent та ефективна обробка даних

def batch_gradient_descent(X, y, lr=0.5, epochs=50):
    """Batch GD: градієнт по всьому датасету"""
    w = np.array([0.0, -2.5, -2.5])  # Початкова точка
    trajectory = [w.copy()]
    
    for epoch in range(epochs):
        gradient = compute_gradient(X, y, w)
        w = w - lr * gradient
        trajectory.append(w.copy())
    
    return np.array(trajectory)

def stochastic_gradient_descent(X, y, lr=0.05, epochs=50):
    """SGD: градієнт по одному прикладу"""
    w = np.array([0.0, -2.5, -2.5])
    trajectory = [w.copy()]
    
    for epoch in range(epochs):
        # Перемішаємо дані
        indices = np.random.permutation(len(X))
        for i in indices:
            X_single = X[i:i+1]
            y_single = y[i:i+1]
            gradient = compute_gradient(X_single, y_single, w)
            w = w - lr * gradient
            if len(trajectory) < epochs * 10:  # Зберігаємо кожні 40 оновлень
                if i % 40 == 0:
                    trajectory.append(w.copy())
    
    return np.array(trajectory)

def mini_batch_gradient_descent(X, y, batch_size=32, lr=0.3, epochs=50):
    """Mini-batch GD: градієнт по невеликому батчу"""
    w = np.array([0.0, -2.5, -2.5])
    trajectory = [w.copy()]
    
    n_batches = len(X) // batch_size
    
    for epoch in range(epochs):
        indices = np.random.permutation(len(X))
        for i in range(n_batches):
            batch_indices = indices[i * batch_size : (i+1) * batch_size]
            X_batch = X[batch_indices]
            y_batch = y[batch_indices]
            gradient = compute_gradient(X_batch, y_batch, w)
            w = w - lr * gradient
            if epoch % 4 == 0:  # Зберігаємо кожну 4-ту епоху
                trajectory.append(w.copy())
    
    return np.array(trajectory)

# Запускаємо три алгоритми
traj_batch = batch_gradient_descent(X_bias, y, lr=0.5, epochs=50)
traj_sgd = stochastic_gradient_descent(X_bias, y, lr=0.05, epochs=50)
traj_minibatch = mini_batch_gradient_descent(X_bias, y, batch_size=32, lr=0.3, epochs=50)

print(f"Траєкторія Batch GD: {len(traj_batch)} точок")
print(f"Траєкторія SGD: {len(traj_sgd)} точок")
print(f"Траєкторія Mini-batch GD: {len(traj_minibatch)} точок")

# Візуалізація траєкторій на контурній карті
fig, axes = plt.subplots(1, 3, figsize=(18, 6))

for idx, (ax, traj, title, color) in enumerate([
    (axes[0], traj_batch, 'Batch Gradient Descent', '#3b82f6'),
    (axes[1], traj_sgd, 'Stochastic GD (SGD)', '#ef4444'),
    (axes[2], traj_minibatch, 'Mini-batch GD', '#22c55e')
]):
    # Контурна карта
    contour = ax.contour(W0, W1, Z, levels=20, cmap='gray', alpha=0.3, linewidths=0.5)
    
    # Траєкторія оптимізації
    ax.plot(traj[:, 1], traj[:, 2], 'o-', color=color, linewidth=2, 
            markersize=4, alpha=0.7, label='Траєкторія')
    
    # Початкова точка
    ax.plot(traj[0, 1], traj[0, 2], 'o', color='black', markersize=12, 
            label='Старт', zorder=5)
    
    # Кінцева точка
    ax.plot(traj[-1, 1], traj[-1, 2], '*', color='gold', markersize=20, 
            label='Фініш', zorder=5, edgecolor='black', linewidth=1.5)
    
    ax.set_xlabel('w₁', fontsize=12)
    ax.set_ylabel('w₂', fontsize=12)
    ax.set_title(title, fontsize=14, fontweight='bold')
    ax.grid(alpha=0.3)
    ax.legend(fontsize=10)
    ax.set_xlim([-3, 3])
    ax.set_ylim([-3, 3])

plt.tight_layout()
plt.show()

# Виведемо фінальні втрати
print("\n📊 Фінальні результати:")
print(f"Batch GD:      Loss = {compute_loss(X_bias, y, traj_batch[-1]):.6f}")
print(f"SGD:           Loss = {compute_loss(X_bias, y, traj_sgd[-1]):.6f}")
print(f"Mini-batch GD: Loss = {compute_loss(X_bias, y, traj_minibatch[-1]):.6f}")

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

# Проста CNN модель
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.pool(x)  # 28x28 → 14x14
        x = self.relu(self.conv2(x))
        x = self.pool(x)  # 14x14 → 7x7
        x = x.view(x.size(0), -1)  # Flatten
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Ініціалізація моделі, loss та optimizer
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# DataLoader
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)

print(f"Пристрій: {device}")
print(f"Кількість параметрів моделі: {sum(p.numel() for p in model.parameters()):,}")
print(f"Батчів в епосі: {len(train_loader)}")

# Функція навчання однієї епохи
def train_one_epoch(model, loader, criterion, optimizer, device):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    
    for batch_idx, (images, labels) in enumerate(loader):
        # Перенесення даних на GPU
        images, labels = images.to(device), labels.to(device)
        
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward pass та оптимізація
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # Статистика
        running_loss += loss.item()
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()
        
        # Виведення прогресу кожні 100 батчів
        if (batch_idx + 1) % 100 == 0:
            print(f"  Батч [{batch_idx+1}/{len(loader)}] | "
                  f"Loss: {running_loss / (batch_idx+1):.4f} | "
                  f"Acc: {100. * correct / total:.2f}%")
    
    epoch_loss = running_loss / len(loader)
    epoch_acc = 100. * correct / total
    return epoch_loss, epoch_acc

# Навчання 3 епохи
print("🚀 Початок навчання...\n")
for epoch in range(3):
    print(f"Епоха {epoch + 1}/3:")
    loss, acc = train_one_epoch(model, train_loader, criterion, optimizer, device)
    print(f"✅ Епоха завершена | Середня втрата: {loss:.4f} | Точність: {acc:.2f}%\n")

print("🎉 Навчання завершено!")

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Графік 1: Втрати по епохах
ax1 = axes[0]
for bs in batch_sizes:
    ax1.plot(range(1, 11), results[bs]['train_loss'], 
             marker='o', linewidth=2, label=f'Batch {bs}')
ax1.set_xlabel('Епоха', fontsize=12)
ax1.set_ylabel('Train Loss', fontsize=12)
ax1.set_title('Динаміка втрат', fontsize=14, fontweight='bold')
ax1.legend(fontsize=11)
ax1.grid(alpha=0.3)

# Графік 2: Точність по епохах
ax2 = axes[1]
for bs in batch_sizes:
    ax2.plot(range(1, 11), results[bs]['train_acc'], 
             marker='s', linewidth=2, label=f'Batch {bs}')
ax2.set_xlabel('Епоха', fontsize=12)
ax2.set_ylabel('Train Accuracy (%)', fontsize=12)
ax2.set_title('Динаміка точності', fontsize=14, fontweight='bold')
ax2.legend(fontsize=11)
ax2.grid(alpha=0.3)

# Графік 3: Час виконання епохи
ax3 = axes[2]
avg_times = [sum(results[bs]['epoch_time']) / 10 for bs in batch_sizes]
colors = ['#3b82f6', '#22c55e', '#f59e0b', '#ef4444']
bars = ax3.bar([str(bs) for bs in batch_sizes], avg_times, color=colors, alpha=0.7)
ax3.set_xlabel('Batch Size', fontsize=12)
ax3.set_ylabel('Середній час епохи (секунди)', fontsize=12)
ax3.set_title('Швидкість навчання', fontsize=14, fontweight='bold')
ax3.grid(axis='y', alpha=0.3)

# Додамо значення на стовпчики
for bar, time_val in zip(bars, avg_times):
    height = bar.get_height()
    ax3.text(bar.get_x() + bar.get_width()/2., height,
             f'{time_val:.1f}s', ha='center', va='bottom', 
             fontsize=11, fontweight='bold')

plt.tight_layout()
plt.show()

# Підсумкова таблиця
print("📊 Порівняльна таблиця результатів:\n")
print(f"{'Batch Size':<12} | {'Фінал Loss':<12} | {'Фінал Acc':<12} | {'Час/Епоха':<12} | {'Загал Час':<12}")
print("-" * 72)

for bs in batch_sizes:
    final_loss = results[bs]['train_loss'][-1]
    final_acc = results[bs]['train_acc'][-1]
    avg_time = sum(results[bs]['epoch_time']) / 10
    total_time = sum(results[bs]['epoch_time'])
    
    print(f"{bs:<12} | {final_loss:<12.4f} | {final_acc:<12.2f} | "
          f"{avg_time:<12.2f} | {total_time:<12.1f}")