Script voor het voor het trainen van de Zelando Fashion-MNIST dataset met pytorch   terug naar de inleiding

In een poging om deep Learning en Pytorch te begrijpen heb ik gebruik gemaakt van de deeplizard video tutorials
 

Het importeren van de benodigde pakketten

 

import torch 
import torch.nn as nn 
import torch.nn.functional as F 
import torch.optim as optim 
 
import torchvision 
import torchvision.transforms as transforms 
#een cuda object maken om gebruik te make van de GPU 
cuda0 = torch.device('cuda:0')
 
De class met het netwerk en de forward functies
 
 

class Network(nn.Module): 
    def __init__(self): 
        super().__init__() 
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5) 
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=12, kernel_size=5) 
        self.fc1 = nn.Linear(in_features=12*4*4, out_features=120) 
        self.fc2 = nn.Linear(in_features=120, out_features=60) 
        self.out = nn.Linear(in_features=60, out_features=10) 
         
    def forward(self, t): 
        # 1) de input layer 
        t = t     # is het forwarden van de eerste laag er verandert niets 
        # t = tensor [1,28,28] alle waarden zijn 0.000 
         
        # 2) de eerste hidden conv layer 
        t = self.conv1(t) 
        t = F.relu(t) 
        t = F.max_pool2d(t, kernel_size=2, stride=2) 
         
        # 3) de tweede hidden conv layer 
        t = self.conv2(t) 
        t = F.relu(t) 
        t = F.max_pool2d(t, kernel_size=2, stride=2) 
         
        # 4) de vierde hidden lineare layer 
        t = t.reshape(-1, 12 * 4 * 4) 
        t = self.fc1(t) 
        t = F.relu(t) 
         
        # 5) de vijfde hidden lineare layer 
        t = self.fc2(t) 
        t = F.relu(t) 
         
        # 6) output layer 
        t = self.out(t) 
        #t = F.softmax(t, dim1) 
        return t
 
Het initialiseren en eventueel downloaden van de trainingset. De set bestaat uit 60.000 images/labels
De url van de fashion MNIST dataset zit in 
lib/python3.7/site-packages/torchvision/datasets/mnist.py,  in de class FashionMNIST(MNIST):
 
 

train_set = torchvision.datasets.FashionMNIST( 
    root='./data/FashionMNIST' 
    ,train=True 
    ,download=True 
    ,transform=transforms.Compose([ 
        transforms.ToTensor() 
    ]) 
)
 
het trainen van slechts 2 epoches in geneste loops. Het network object en de images en labels tensoren komen in de eerste GPU kern van de jetson nano
De training verloopt daardoor iets sneller.
 
 

def get_num_correct(preds, labels): 
    return preds.argmax(dim=1).eq(labels).sum().item() 
 
network = Network() 
network.to(cuda0) 
 
train_loader = torch.utils.data.DataLoader(train_set, batch_size=100) 
optimizer = optim.Adam(network.parameters(), lr=0.01) 
 
# met batch size is 100 zijn er 600 batches 
for epoch in range(2): 
 
    total_loss = 0 
    total_correct = 0 
 
    for batch in train_loader: 
        images, labels = batch[0].to(cuda0), batch[1].to(cuda0) 
 
        preds = network(images) 
        loss = F.cross_entropy(preds, labels) 
     
        optimizer.zero_grad() #de gradiens weer op 0.0 zetten want anders worden ze opgeteld 
        loss.backward() 
        optimizer.step() 
     
        total_loss += loss.item() 
        total_correct += get_num_correct(preds, labels) 
     
    print("Epoch)", epoch, "total_correct:", total_correct, "loss:", total_loss)
#Het getrainde model in de datamap opslaan 
torch.save(network.state_dict(),'data/fashion.pth') 
 
total_correct / len(train_set) 
 

Het training resultaat na 2 epoches

Epoch) 0 total_correct: 46871 loss: 345.99908232688904

Epoch) 1 total_correct: 51398 loss: 231.0633533000946

85 % van de 10 kledingstukken is na 2 epoches goed geclassificeerd

0.8566333333333334

Het training resultaat na 4 epoches

Epoch) 0 total_correct: 47854 loss: 324.58934815227985
Epoch) 1 total_correct: 51620 loss: 226.25721316039562
Epoch) 2 total_correct: 52349 loss: 206.25410433113575

Epoch) 3 total_correct: 52597 loss: 197.82615269720554

87 % van de 10 kledingstukken is na 4 epoches goed geclassificeerd

0.8766166666666667