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
Machine Learing & deep Learning Fundamentals en Neural Network Programming - Deep Learing width Pytorch
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.58934815227985Epoch) 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