Getting Started with Pytorch-1

Working with data

PyTorch has two?primitives to work with data:?torch.utils.data.DataLoader?and?torch.utils.data.Dataset.

?Dataset?stores the samples and their corresponding labels, and?DataLoader?wraps an iterable around the?Dataset.

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

PyTorch offers domain-specific libraries such as?"TorchText,?TorchVision, and?TorchAudio", all of which include datasets. For this tutorial, we will be using a TorchVision dataset.

The?torchtext?package consists of data processing utilities and popular datasets for natural language.Torchaudio is a library for audio and signal processing with PyTorch. It provides I/O, signal and data processing functions, datasets, model implementations and application components.

The?torchvision?package consists of popular datasets, model architectures, and common image transformations for computer vision.The?torchvision.datasets?module contains?Dataset?objects for many real-world vision data like CIFAR, COCO.?Every TorchVision?Dataset?includes two arguments:?transform?and?target_transform?to modify the samples and labels respectively.

# 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(),
).        

Then with DataLoader,here the dataset has passed as an argument.This wraps an iterable over dataset and support automatic batching,sampling ,shuffling and multiprocess data loading.The bath size of 64,i.e.,each element in the dataloader itrable will return a batch of 64 features and labels.

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        

Output:

Shape of X [N, C, H, W]: torch.Size([64, 1, 28, 28]
Shape of y: torch.Size([64]) torch.int64)        

Creating Models

To define a neural network in PyTorch, create a class that inherits from?nn.Module. Then define the layers of the network in the?__init__?function and specify how data will pass through the network in the?forward?function. To accelerate operations in the neural network, move it to the GPU or MPS if available.

# 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")
        

Out:

Using cuda 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)
        

Out:

NeuralNetwork(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
  )
)        

Optimizing the Model Parameters

To train a model, we need a?loss function?and an?optimizer.

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

In a single training loop, the model makes predictions on the training dataset (fed to it in batches), and backpropagates the prediction error to adjust the model’s parameters

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
? ? ? ? loss.backward()
? ? ? ? optimizer.step()
? ? ? ? optimizer.zero_grad()


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

check the model’s performance against the test dataset to ensure it is learning.

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"):        

The training process is conducted over several iterations (epochs). During each epoch, the model learns parameters to make better predictions.

epochs = 
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!")5        

Saving Models

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

Loading Model

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

This model can now be used to make predictions

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():
? ? x = x.to(device)
? ? pred = model(x)
? ? predicted, actual = classes[pred[0].argmax(0)], classes[y]
? ? print(f'Predicted: "{predicted}", Actual: "{actual}"')[        

Saving and Loading Model Weights

import torch
import torchvision.models as models
        

model = models.vgg16(weights='IMAGENET1K_V1'
torch.save(model.state_dict(), 'model_weights.pth'))        

model = models.vgg16() 
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()