← Materiały bloku: Dwa dni z uczeniem maszynowym  ·  podgląd notatnika pytmlp.ipynb  ·  pobierz plik .ipynb

MLP w pytorch -- minimalny przykład

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

Definicja sieci

class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.layers = nn.Sequential(
            nn.Flatten(),
            nn.Linear(28*28, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )
    
    def forward(self, x):
        return self.layers(x)

Wczytanie danych

transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=64, shuffle=False)

100%|██████████| 9.91M/9.91M [00:01<00:00, 6.06MB/s]
100%|██████████| 28.9k/28.9k [00:00<00:00, 275kB/s]
100%|██████████| 1.65M/1.65M [00:00<00:00, 2.45MB/s]
100%|██████████| 4.54k/4.54k [00:00<00:00, 2.22MB/s]

Inicjalizacja modelu

model = MLP()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
criterion = nn.CrossEntropyLoss()

Pętla treningowa

def train(model, loader, optimizer, criterion):
    model.train()
    for data, target in loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

Pętla testowa

def test(model, loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for data, target in loader:
            output = model(data)
            _, predicted = torch.max(output.data, 1)
            total += target.size(0)
            correct += (predicted == target).sum().item()
    print(f'Accuracy: {100 * correct / total}%')

Wykonanie treningu, podgląd na wydzielonym zbiorze skuteczności

for epoch in range(10):
    train(model, train_loader, optimizer, criterion)
    test(model, test_loader)

Accuracy: 92.7%
Accuracy: 95.94%
Accuracy: 96.05%
Accuracy: 96.91%
Accuracy: 97.02%
Accuracy: 97.45%
Accuracy: 96.72%
Accuracy: 97.64%
Accuracy: 97.58%
Accuracy: 97.52%