Mulai PyTorch dalam 3 menit!

Jangan membuatnya terlalu rumit dan lakukan dengan cepat… Ini adalah awal yang sederhana untuk PyTorch :D

Alur kerja ML melibatkan:

1. data
2. membuat model
3. mengoptimalkan parameter model
4. menyimpan model terlatih

1. Data

dua primitif untuk bekerja dengan data:

• obor.utils.data.DataLoader
• obor.utils.data.Dataset

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

Kumpulan data TorchVision(data visi dunia nyata seperti CIFAR, COCO › FashionMNIST):

• torchvision.datasets(2 argumen: transform dan target_transform)

# Download training data from open datasets.
training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
)

# Download test data from open datasets.
test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),
)

Kami meneruskan Dataset sebagai argumen ke DataLoader. Ini menggabungkan iterable pada kumpulan data kami, dan mendukung pengelompokan otomatis, pengambilan sampel, pengacakan, dan pemuatan data multiproses.

Setiap elemen dalam dataloader iterable akan mengembalikan 64 fitur dan label:

batch_size = 64

# Create data loaders.
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

for X, y in test_dataloader:
    print(f"Shape of X [N, C, H, W]: {X.shape}")
    print(f"Shape of y: {y.shape} {y.dtype}")
    break

2. Membuat Model

Untuk mendefinisikan NN kita membuat kelas yang mewarisi dari nn.Module.

• __init__ : lapisan NN
• forward : bagaimana data akan melewati NN

Untuk mempercepat operasi di jaringan saraf, kami memindahkannya ke GPU atau MPS jika tersedia.

# Get cpu, gpu or mps device for training.
device = (
    "cuda"
    if torch.cuda.is_available()
    else "mps"
    if torch.backends.mps.is_available()
    else "cpu"
)
print(f"Using {device} device")

# Define model
class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10)
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork().to(device)
print(model)

3. Mengoptimalkan Parameter Model

Untuk melatih model, kita membutuhkan

• fungsi kerugian
• pengoptimal

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)

Dalam satu putaran pelatihan;

model membuat prediksi pada set data pelatihan (diumpankan ke dalamnya dalam batch), dan melakukan backpropagasi kesalahan prediksi untuk menyesuaikan parameter model.

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    model.train()
    for batch, (X, y) in enumerate(dataloader):
        X, y = X.to(device), y.to(device)

        # Compute prediction error
        pred = model(X)
        loss = loss_fn(pred, y)

        # Backpropagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch % 100 == 0:
            loss, current = loss.item(), (batch + 1) * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

kinerja model terhadap kumpulan data pengujian:

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

Proses pelatihan dilakukan dalam beberapa iterasi (epoch). Selama setiap periode, model mempelajari parameter untuk membuat prediksi yang lebih baik.

Kami mencetak akurasi dan kerugian model pada setiap periode;

epochs = 5
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    test(test_dataloader, model, loss_fn)
print("Done!")

4. menyimpan model terlatih

Menyimpan Model

torch.save(model.state_dict(), "model.pth")
print("Saved PyTorch Model State to model.pth")

Memuat Model

model = NeuralNetwork()
model.load_state_dict(torch.load("model.pth"))

Model ini sekarang dapat digunakan untuk membuat prediksi.

classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]

model.eval()
x, y = test_data[0][0], test_data[0][1]
with torch.no_grad():
    pred = model(x)
    predicted, actual = classes[pred[0].argmax(0)], classes[y]
    print(f'Predicted: "{predicted}", Actual: "{actual}"')

Itu dia :)

Sumber: pytorch.org