[Introduction to Pytorch] I tried categorizing Cifar10 with VGG16 ♬

Since Pytorch is the best for a while, I tried to categorize MNIST and Cifar 10 while looking at the following reference.

What i did

・ Pytorch installation ・ Try moving MNIST ・ Try moving Cifar10 ・ Try to move with VGG16

・ Pytorch installation

If you enter the following reference page according to your environment, the command will be specified automatically. 【reference】 ⓪https://pytorch.org/ pytorch_install.jpg So, in the Uwan environment, I was able to install it with the following command.

(keras-gpu) C:\Users\user\pytorch>conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

Actually, I had a little problem here. I installed it in the (keras-gpu) environment because various tools are also installed. Then, although the installation was successful, the following three events occurred.

    1. keras environment removed
  1. Some Libs have been downgraded
    1. Some have been updated In other words, the Keras-gpu environment seems to have been destroyed. Therefore, we strongly recommend that you install it in a normal conda environment. The crispness is that when the installation is complete, the standard output is erased and the display changes to done.

・ Try moving MNIST

I think that this will work if you follow the reference (1) below, so I will omit it. 【reference】 ① MNIST with PyTorch However, an error may occur when reading data. It is according to the following reference ② ** "2. Error related to DataLoader settings. BrokenPipeError: [Errno 32] Broken pipe -> This case could be avoided by setting num_workers = 0 based on the reference URL②. "** So, changing the code to num_workers = 0 eliminated the error.

② [I checked the operation of PyTorch (15)](https://start0x00url.net/2018/11/08/pytorch-%E3%81%AE%E5%8B%95%E4%BD%9C% E7% A2% BA% E8% AA% 8D% E3% 82% 92% E3% 81% 97% E3% 81% A6% E3% 81% BF% E3% 81% 9F% EF% BC% 88% EF% BC% 91% EF% BC% 95% EF% BC% 89 /)

・ Try moving Cifar10

A code example of Cifar10 is shown in detail in the reference below. However, for unknown reasons, this code didn't work much. 【reference】 ③TRAINING A CLASSIFIER So, I extended the above MNIST code to Cifar 10 while looking at the code in ③. The result is as follows. First, the Lib etc. to be used are as follows

'''
PyTorch Cifar10 sample
'''
import argparse
import time
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
import torchvision
import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10  #MNIST
import torch.optim as optim
from torchsummary import summary
#from Net_cifar10 import Net_cifar10
from Net_vgg16 import VGG16
import matplotlib.pyplot as plt
import numpy as np

The following is an image drawing function.

# functions to show an image
def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.pause(1)

The following are argument-related functions that give initial values.

def parser():
    '''
    argument
    '''
    parser = argparse.ArgumentParser(description='PyTorch Cifar10')
    parser.add_argument('--epochs', '-e', type=int, default=20,
                        help='number of epochs to train (default: 2)')
    parser.add_argument('--lr', '-l', type=float, default=0.01,
                        help='learning rate (default: 0.01)')
    args = parser.parse_args()
    return args

Below is the main () function. First is the data reading part. You can see that Classes are different between MNIST and Cifar 10. I also learned with bach_size = 32.

def main():
    '''
    main
    '''
    args = parser()
    transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    trainset = CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=32,  #batch_size=4
                                          shuffle=True, num_workers=0) #num_workers=2
    testset = CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=32,   #batch_size=4
                                         shuffle=False, num_workers=0) #num_workers=2
    #classes = tuple(np.linspace(0, 9, 10, dtype=np.uint8))
    classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Next, the images and labels of the training data are displayed and printed.

    # get some random training images
    dataiter = iter(trainloader)
    images, labels = dataiter.next()
    # show images
    imshow(torchvision.utils.make_grid(images))
    # print labels
    print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

The following defines device in preparation for calculations using the GPU.

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") #for gpu
    # Assuming that we are on a CUDA machine, this should print a CUDA device:
    print(device)

Define the model. Here, I made some definitions and looked at the changes. summary(model,(3,32,32)) As shown in Reference ④, you can get the same information as Keras model.summary (). 【reference】 ④ Visdom and torch summary to assist Pytorch model construction and evaluation Visdom seems to be a tool that can display graphs like tensorboard, but I have not used it this time.

    # model
    #net = Net_cifar10()
    #net = VGG13()
    net = VGG16()
    model = net.to(device)  #for gpu
    summary(model,(3,32,32))

The criterion and optimizer are defined below. In addition, it seems that the parameters are different between MNIST and Cifar10.

    # define loss function and optimier
    criterion = nn.CrossEntropyLoss()
    #optimizer = optim.SGD(net.parameters(),lr=args.lr, momentum=0.99, nesterov=True)
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

You will learn below. I just commented out the code for the cpu and left it. At the time of MNIST, the accuracy was evaluated for the Test data at the end, but like Keras etc., it is evaluated every time or once every 200 times at the same timing as the learning loss.

    # train
    for epoch in range(args.epochs):
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs; data is a list of [inputs, labels]
            #inputs, labels = data  #for cpu
            inputs, labels = data[0].to(device), data[1].to(device) #for gpu
            # zero the parameter gradients
            optimizer.zero_grad()

            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()
            if i % 200 == 199:    # print every 2000 mini-batches
                # test
                correct = 0
                total = 0
                with torch.no_grad():
                    for (images, labels) in testloader:
                        outputs = net(images.to(device)) #for gpu
                        _, predicted = torch.max(outputs.data, 1)
                        total += labels.size(0)
                        correct += (predicted == labels.to(device)).sum().item()
                #print('Accuracy: {:.2f} %'.format(100 * float(correct/total)))
                
                print('[%d, %5d] loss: %.3f '% (epoch + 1, i + 1, running_loss / 200), 'Accuracy: {:.2f} %'.format(100 * float(correct/total)))
                running_loss = 0.0

When you finish learning, save the resulting net.state_dict ().

    print('Finished Training')
    PATH = './cifar_net.pth'
    torch.save(net.state_dict(), PATH)

Below, the accuracy of Test is calculated and output again.

    # test
    correct = 0
    total = 0
    with torch.no_grad():
        for (images, labels) in testloader:
            outputs = net(images.to(device)) #for gpu
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels.to(device)).sum().item()
    print('Accuracy: {:.2f} %'.format(100 * float(correct/total)))

Below you will see the Test data, predict and display the results.

    dataiter = iter(testloader)
    images, labels = dataiter.next()
    # print images
    imshow(torchvision.utils.make_grid(images))
    print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
    
    outputs = net(images.to(device))
    _, predicted = torch.max(outputs, 1)

    print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

Finally, calculate the accuracy of the forecast for each class.

    class_correct = list(0. for i in range(10))
    class_total = list(0. for i in range(10))
    with torch.no_grad():
        for data in testloader:
            images, labels = data #for cpu
            #inputs, labels = data[0].to(device), data[1].to(device) #for gpu
            outputs = net(images.to(device))
            _, predicted = torch.max(outputs, 1)
            c = (predicted == labels.to(device)).squeeze()
            for i in range(4):
                label = labels[i]
                class_correct[label] += c[i].item()
                class_total[label] += 1

    for i in range(10):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))

When main () finishes, the time required for the calculation is displayed.

if __name__ == '__main__':
    start_time = time.time()
    main()
    print('elapsed time: {:.3f} [sec]'.format(time.time() - start_time))

The model used on the Pytorch page is as follows, and the simple one is used.

Net_cifar10.py


import torch.nn as nn
import torch.nn.functional as F

class Net_cifar10(nn.Module):
    def __init__(self):
        super(Net_cifar10, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

・ Try to move with VGG16

There are various models of Pytorch's VGG family when you google, but the following reference is easy to understand. 【reference】 ⑤ PyTorch 0.4.1 examples (code explanation): Image classification – Oxford flower 17 species (VGG) However, only VGG13 is illustrated here. So, referring to Previous Uwan article, I extended it to VGG16 as follows.

Net_vgg16.py


import torch.nn as nn
import torch.nn.functional as F

class VGG16(nn.Module):
    def __init__(self): # , num_classes):
        super(VGG16, self).__init__()
        num_classes=10

        self.block1_output = nn.Sequential (
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block2_output = nn.Sequential (
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block3_output = nn.Sequential (
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block4_output = nn.Sequential (
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block5_output = nn.Sequential (
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.classifier = nn.Sequential(
            nn.Linear(512, 512),  #512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(512, 32 ),  #4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(32, num_classes),  #4096
        )

    def forward(self, x):
        x = self.block1_output(x)
        x = self.block2_output(x)
        x = self.block3_output(x)
        x = self.block4_output(x)
        x = self.block5_output(x)
        #print(x.size())
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

In addition, the calculation examples of Cifar10 for various models are posted.

Summary

・ I tried to categorize Cifar10 with Pytorch ・ Initially, there were some errors, but somehow it became possible to calculate stably.

・ I would like to move an example unique to Pytorch.

bonus

(keras-gpu) C:\Users\user\pytorch\cifar10>python pytorch_cifar10_.py
Files already downloaded and verified
Files already downloaded and verified
cuda:0
[1,   200] loss: 2.303  Accuracy: 13.34 %
[1,   400] loss: 2.299  Accuracy: 14.55 %
[1,   600] loss: 2.296  Accuracy: 14.71 %
[1,   800] loss: 2.284  Accuracy: 16.72 %
[1,  1000] loss: 2.248  Accuracy: 17.70 %
[1,  1200] loss: 2.144  Accuracy: 24.59 %
[1,  1400] loss: 2.039  Accuracy: 27.71 %
[2,   200] loss: 1.943  Accuracy: 30.32 %
[2,   400] loss: 1.900  Accuracy: 31.92 %
[2,   600] loss: 1.883  Accuracy: 32.70 %
[2,   800] loss: 1.831  Accuracy: 34.42 %
[2,  1000] loss: 1.802  Accuracy: 34.84 %
[2,  1200] loss: 1.776  Accuracy: 35.06 %
[2,  1400] loss: 1.733  Accuracy: 37.69 %
[3,   200] loss: 1.688  Accuracy: 37.61 %
[3,   400] loss: 1.657  Accuracy: 38.20 %
[3,   600] loss: 1.627  Accuracy: 41.01 %
[3,   800] loss: 1.636  Accuracy: 41.60 %
[3,  1000] loss: 1.596  Accuracy: 41.73 %
[3,  1200] loss: 1.582  Accuracy: 41.52 %
[3,  1400] loss: 1.543  Accuracy: 43.17 %
[4,   200] loss: 1.517  Accuracy: 44.28 %
[4,   400] loss: 1.508  Accuracy: 45.50 %
[4,   600] loss: 1.503  Accuracy: 45.83 %
[4,   800] loss: 1.493  Accuracy: 46.98 %
[4,  1000] loss: 1.480  Accuracy: 45.65 %
[4,  1200] loss: 1.472  Accuracy: 47.23 %
[4,  1400] loss: 1.465  Accuracy: 47.72 %
[5,   200] loss: 1.440  Accuracy: 47.90 %
[5,   400] loss: 1.406  Accuracy: 50.01 %
[5,   600] loss: 1.419  Accuracy: 49.09 %
[5,   800] loss: 1.393  Accuracy: 50.10 %
[5,  1000] loss: 1.362  Accuracy: 49.50 %
[5,  1200] loss: 1.367  Accuracy: 49.13 %
[5,  1400] loss: 1.392  Accuracy: 51.04 %
[6,   200] loss: 1.336  Accuracy: 52.19 %
[6,   400] loss: 1.329  Accuracy: 52.20 %
[6,   600] loss: 1.312  Accuracy: 51.44 %
[6,   800] loss: 1.315  Accuracy: 51.34 %
[6,  1000] loss: 1.323  Accuracy: 52.54 %
[6,  1200] loss: 1.323  Accuracy: 53.76 %
[6,  1400] loss: 1.302  Accuracy: 53.15 %
[7,   200] loss: 1.257  Accuracy: 53.11 %
[7,   400] loss: 1.258  Accuracy: 53.91 %
[7,   600] loss: 1.262  Accuracy: 54.56 %
[7,   800] loss: 1.280  Accuracy: 55.07 %
[7,  1000] loss: 1.249  Accuracy: 54.81 %
[7,  1200] loss: 1.255  Accuracy: 54.41 %
[7,  1400] loss: 1.234  Accuracy: 55.69 %
[8,   200] loss: 1.213  Accuracy: 56.52 %
[8,   400] loss: 1.214  Accuracy: 56.52 %
[8,   600] loss: 1.213  Accuracy: 56.60 %
[8,   800] loss: 1.202  Accuracy: 55.38 %
[8,  1000] loss: 1.200  Accuracy: 57.14 %
[8,  1200] loss: 1.190  Accuracy: 56.84 %
[8,  1400] loss: 1.173  Accuracy: 57.08 %
[9,   200] loss: 1.144  Accuracy: 57.51 %
[9,   400] loss: 1.170  Accuracy: 57.25 %
[9,   600] loss: 1.136  Accuracy: 56.35 %
[9,   800] loss: 1.169  Accuracy: 58.69 %
[9,  1000] loss: 1.141  Accuracy: 57.84 %
[9,  1200] loss: 1.146  Accuracy: 56.51 %
[9,  1400] loss: 1.150  Accuracy: 57.88 %
[10,   200] loss: 1.128  Accuracy: 58.77 %
[10,   400] loss: 1.123  Accuracy: 58.69 %
[10,   600] loss: 1.120  Accuracy: 59.92 %
[10,   800] loss: 1.102  Accuracy: 58.37 %
[10,  1000] loss: 1.104  Accuracy: 59.26 %
[10,  1200] loss: 1.101  Accuracy: 59.45 %
[10,  1400] loss: 1.106  Accuracy: 59.75 %
[11,   200] loss: 1.081  Accuracy: 58.35 %
[11,   400] loss: 1.098  Accuracy: 59.52 %
[11,   600] loss: 1.040  Accuracy: 60.00 %
[11,   800] loss: 1.083  Accuracy: 60.39 %
[11,  1000] loss: 1.073  Accuracy: 60.55 %
[11,  1200] loss: 1.074  Accuracy: 61.02 %
[11,  1400] loss: 1.075  Accuracy: 60.78 %
[12,   200] loss: 1.027  Accuracy: 59.02 %
[12,   400] loss: 1.052  Accuracy: 60.14 %
[12,   600] loss: 1.025  Accuracy: 61.39 %
[12,   800] loss: 1.047  Accuracy: 59.45 %
[12,  1000] loss: 1.047  Accuracy: 61.99 %
[12,  1200] loss: 1.055  Accuracy: 60.82 %
[12,  1400] loss: 1.023  Accuracy: 62.17 %
[13,   200] loss: 0.994  Accuracy: 61.23 %
[13,   400] loss: 1.008  Accuracy: 61.94 %
[13,   600] loss: 1.014  Accuracy: 61.18 %
[13,   800] loss: 1.013  Accuracy: 62.04 %
[13,  1000] loss: 1.018  Accuracy: 61.59 %
[13,  1200] loss: 1.010  Accuracy: 61.81 %
[13,  1400] loss: 0.998  Accuracy: 61.81 %
[14,   200] loss: 0.961  Accuracy: 61.17 %
[14,   400] loss: 0.985  Accuracy: 61.63 %
[14,   600] loss: 0.977  Accuracy: 62.18 %
[14,   800] loss: 0.996  Accuracy: 61.84 %
[14,  1000] loss: 0.978  Accuracy: 61.70 %
[14,  1200] loss: 0.974  Accuracy: 61.63 %
[14,  1400] loss: 0.980  Accuracy: 62.09 %
[15,   200] loss: 0.935  Accuracy: 61.29 %
[15,   400] loss: 0.944  Accuracy: 63.11 %
[15,   600] loss: 0.936  Accuracy: 62.98 %
[15,   800] loss: 0.961  Accuracy: 62.76 %
[15,  1000] loss: 0.961  Accuracy: 62.42 %
[15,  1200] loss: 0.956  Accuracy: 61.82 %
[15,  1400] loss: 0.975  Accuracy: 62.35 %
[16,   200] loss: 0.901  Accuracy: 63.24 %
[16,   400] loss: 0.906  Accuracy: 62.88 %
[16,   600] loss: 0.924  Accuracy: 63.13 %
[16,   800] loss: 0.905  Accuracy: 62.71 %
[16,  1000] loss: 0.930  Accuracy: 62.22 %
[16,  1200] loss: 0.950  Accuracy: 62.95 %
[16,  1400] loss: 0.953  Accuracy: 63.11 %
[17,   200] loss: 0.894  Accuracy: 63.93 %
[17,   400] loss: 0.896  Accuracy: 63.65 %
[17,   600] loss: 0.880  Accuracy: 62.02 %
[17,   800] loss: 0.889  Accuracy: 63.14 %
[17,  1000] loss: 0.897  Accuracy: 63.36 %
[17,  1200] loss: 0.918  Accuracy: 63.98 %
[17,  1400] loss: 0.925  Accuracy: 63.66 %
[18,   200] loss: 0.853  Accuracy: 63.52 %
[18,   400] loss: 0.852  Accuracy: 62.60 %
[18,   600] loss: 0.877  Accuracy: 64.43 %
[18,   800] loss: 0.872  Accuracy: 63.48 %
[18,  1000] loss: 0.879  Accuracy: 63.45 %
[18,  1200] loss: 0.905  Accuracy: 63.76 %
[18,  1400] loss: 0.897  Accuracy: 63.30 %
[19,   200] loss: 0.823  Accuracy: 63.08 %
[19,   400] loss: 0.833  Accuracy: 63.93 %
[19,   600] loss: 0.855  Accuracy: 62.89 %
[19,   800] loss: 0.845  Accuracy: 63.44 %
[19,  1000] loss: 0.872  Accuracy: 63.94 %
[19,  1200] loss: 0.861  Accuracy: 64.28 %
[19,  1400] loss: 0.853  Accuracy: 64.58 %
[20,   200] loss: 0.817  Accuracy: 63.54 %
[20,   400] loss: 0.809  Accuracy: 63.82 %
[20,   600] loss: 0.813  Accuracy: 63.07 %
[20,   800] loss: 0.815  Accuracy: 64.33 %
[20,  1000] loss: 0.852  Accuracy: 64.66 %
[20,  1200] loss: 0.850  Accuracy: 63.97 %
[20,  1400] loss: 0.844  Accuracy: 64.47 %
Finished Training
Accuracy: 64.12 %
GroundTruth:    cat  ship  ship plane
Predicted:    cat  ship  ship  ship
Accuracy of plane : 61 %
Accuracy of   car : 80 %
Accuracy of  bird : 50 %
Accuracy of   cat : 53 %
Accuracy of  deer : 50 %
Accuracy of   dog : 52 %
Accuracy of  frog : 66 %
Accuracy of horse : 67 %
Accuracy of  ship : 82 %
Accuracy of truck : 75 %
elapsed time: 602.200 [sec]
import torch.nn as nn
import torch.nn.functional as F

class VGG13(nn.Module):
    def __init__(self): # , num_classes):
        super(VGG13, self).__init__()
        num_classes=10

        self.block1_output = nn.Sequential (
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block2_output = nn.Sequential (
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block3_output = nn.Sequential (
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block4_output = nn.Sequential (
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.block5_output = nn.Sequential (
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.classifier = nn.Sequential(
            nn.Linear(512, 512),  #512 * 7 * 7, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(512, 32 ),  #4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(32, num_classes),  #4096
        )

    def forward(self, x):
        x = self.block1_output(x)
        x = self.block2_output(x)
        x = self.block3_output(x)
        x = self.block4_output(x)
        x = self.block5_output(x)
        #print(x.size())

        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x
(keras-gpu) C:\Users\user\pytorch\cifar10>python pytorch_cifar10_.py
Files already downloaded and verified
Files already downloaded and verified
cuda:0
[1,   200] loss: 2.156  Accuracy: 24.39 %
[1,   400] loss: 1.869  Accuracy: 33.88 %
[1,   600] loss: 1.728  Accuracy: 39.04 %
[1,   800] loss: 1.578  Accuracy: 43.44 %
[1,  1000] loss: 1.496  Accuracy: 47.75 %
[1,  1200] loss: 1.436  Accuracy: 52.35 %
[1,  1400] loss: 1.363  Accuracy: 54.04 %
[2,   200] loss: 1.231  Accuracy: 57.80 %
[2,   400] loss: 1.209  Accuracy: 58.82 %
[2,   600] loss: 1.163  Accuracy: 61.31 %
[2,   800] loss: 1.131  Accuracy: 61.99 %
[2,  1000] loss: 1.115  Accuracy: 62.97 %
[2,  1200] loss: 1.084  Accuracy: 63.12 %
[2,  1400] loss: 1.028  Accuracy: 65.87 %
[3,   200] loss: 0.925  Accuracy: 65.56 %
[3,   400] loss: 0.928  Accuracy: 66.94 %
[3,   600] loss: 0.910  Accuracy: 68.22 %
[3,   800] loss: 0.916  Accuracy: 67.86 %
[3,  1000] loss: 0.902  Accuracy: 69.14 %
[3,  1200] loss: 0.848  Accuracy: 69.07 %
[3,  1400] loss: 0.883  Accuracy: 70.32 %
[4,   200] loss: 0.752  Accuracy: 71.35 %
[4,   400] loss: 0.782  Accuracy: 71.42 %
[4,   600] loss: 0.757  Accuracy: 71.67 %
[4,   800] loss: 0.767  Accuracy: 72.89 %
[4,  1000] loss: 0.767  Accuracy: 73.36 %
[4,  1200] loss: 0.746  Accuracy: 73.61 %
[4,  1400] loss: 0.764  Accuracy: 73.88 %
[5,   200] loss: 0.647  Accuracy: 74.12 %
[5,   400] loss: 0.627  Accuracy: 74.62 %
[5,   600] loss: 0.618  Accuracy: 74.07 %
[5,   800] loss: 0.663  Accuracy: 75.19 %
[5,  1000] loss: 0.661  Accuracy: 74.28 %
[5,  1200] loss: 0.649  Accuracy: 76.79 %
[5,  1400] loss: 0.650  Accuracy: 74.59 %
[6,   200] loss: 0.556  Accuracy: 77.10 %
[6,   400] loss: 0.543  Accuracy: 75.73 %
[6,   600] loss: 0.528  Accuracy: 76.50 %
[6,   800] loss: 0.552  Accuracy: 76.03 %
[6,  1000] loss: 0.568  Accuracy: 77.13 %
[6,  1200] loss: 0.580  Accuracy: 76.73 %
[6,  1400] loss: 0.563  Accuracy: 76.20 %
[7,   200] loss: 0.475  Accuracy: 77.29 %
[7,   400] loss: 0.470  Accuracy: 77.17 %
[7,   600] loss: 0.503  Accuracy: 77.16 %
[7,   800] loss: 0.484  Accuracy: 77.60 %
[7,  1000] loss: 0.485  Accuracy: 78.23 %
[7,  1200] loss: 0.491  Accuracy: 78.32 %
[7,  1400] loss: 0.480  Accuracy: 78.08 %
[8,   200] loss: 0.386  Accuracy: 78.60 %
[8,   400] loss: 0.413  Accuracy: 78.82 %
[8,   600] loss: 0.401  Accuracy: 78.03 %
[8,   800] loss: 0.421  Accuracy: 78.75 %
[8,  1000] loss: 0.450  Accuracy: 77.68 %
[8,  1200] loss: 0.439  Accuracy: 78.55 %
[8,  1400] loss: 0.420  Accuracy: 79.05 %
[9,   200] loss: 0.315  Accuracy: 79.21 %
[9,   400] loss: 0.366  Accuracy: 78.72 %
[9,   600] loss: 0.374  Accuracy: 79.63 %
[9,   800] loss: 0.378  Accuracy: 79.75 %
[9,  1000] loss: 0.371  Accuracy: 78.52 %
[9,  1200] loss: 0.377  Accuracy: 79.65 %
[9,  1400] loss: 0.396  Accuracy: 79.51 %
[10,   200] loss: 0.306  Accuracy: 79.25 %
[10,   400] loss: 0.320  Accuracy: 79.06 %
[10,   600] loss: 0.341  Accuracy: 79.20 %
[10,   800] loss: 0.340  Accuracy: 79.21 %
[10,  1000] loss: 0.327  Accuracy: 78.73 %
[10,  1200] loss: 0.334  Accuracy: 79.49 %
[10,  1400] loss: 0.335  Accuracy: 79.33 %
[11,   200] loss: 0.253  Accuracy: 78.67 %
[11,   400] loss: 0.267  Accuracy: 79.47 %
[11,   600] loss: 0.278  Accuracy: 79.17 %
[11,   800] loss: 0.294  Accuracy: 80.12 %
[11,  1000] loss: 0.311  Accuracy: 79.86 %
[11,  1200] loss: 0.299  Accuracy: 80.65 %
[11,  1400] loss: 0.297  Accuracy: 80.39 %
[12,   200] loss: 0.226  Accuracy: 80.51 %
[12,   400] loss: 0.237  Accuracy: 80.22 %
[12,   600] loss: 0.253  Accuracy: 79.49 %
[12,   800] loss: 0.261  Accuracy: 79.71 %
[12,  1000] loss: 0.252  Accuracy: 80.68 %
[12,  1200] loss: 0.272  Accuracy: 80.75 %
[12,  1400] loss: 0.281  Accuracy: 80.64 %
[13,   200] loss: 0.201  Accuracy: 80.44 %
[13,   400] loss: 0.234  Accuracy: 80.49 %
[13,   600] loss: 0.220  Accuracy: 79.90 %
[13,   800] loss: 0.221  Accuracy: 80.00 %
[13,  1000] loss: 0.236  Accuracy: 80.46 %
[13,  1200] loss: 0.216  Accuracy: 80.66 %
[13,  1400] loss: 0.239  Accuracy: 80.45 %
[14,   200] loss: 0.168  Accuracy: 80.75 %
[14,   400] loss: 0.203  Accuracy: 77.86 %
[14,   600] loss: 0.231  Accuracy: 80.50 %
[14,   800] loss: 0.192  Accuracy: 80.81 %
[14,  1000] loss: 0.195  Accuracy: 80.73 %
[14,  1200] loss: 0.209  Accuracy: 81.04 %
[14,  1400] loss: 0.207  Accuracy: 80.03 %
[15,   200] loss: 0.142  Accuracy: 81.15 %
[15,   400] loss: 0.169  Accuracy: 80.88 %
[15,   600] loss: 0.174  Accuracy: 80.52 %
[15,   800] loss: 0.167  Accuracy: 80.88 %
[15,  1000] loss: 0.208  Accuracy: 80.02 %
[15,  1200] loss: 0.181  Accuracy: 81.65 %
[15,  1400] loss: 0.198  Accuracy: 81.14 %
[16,   200] loss: 0.125  Accuracy: 81.02 %
[16,   400] loss: 0.142  Accuracy: 81.41 %
[16,   600] loss: 0.172  Accuracy: 80.92 %
[16,   800] loss: 0.157  Accuracy: 82.58 %
[16,  1000] loss: 0.140  Accuracy: 81.21 %
[16,  1200] loss: 0.179  Accuracy: 80.29 %
[16,  1400] loss: 0.185  Accuracy: 81.94 %
[17,   200] loss: 0.125  Accuracy: 80.94 %
[17,   400] loss: 0.155  Accuracy: 80.92 %
[17,   600] loss: 0.140  Accuracy: 81.45 %
[17,   800] loss: 0.169  Accuracy: 81.80 %
[17,  1000] loss: 0.162  Accuracy: 81.31 %
[17,  1200] loss: 0.141  Accuracy: 81.42 %
[17,  1400] loss: 0.185  Accuracy: 80.21 %
[18,   200] loss: 0.140  Accuracy: 81.76 %
[18,   400] loss: 0.129  Accuracy: 80.78 %
[18,   600] loss: 0.135  Accuracy: 81.52 %
[18,   800] loss: 0.139  Accuracy: 82.01 %
[18,  1000] loss: 0.149  Accuracy: 81.43 %
[18,  1200] loss: 0.134  Accuracy: 81.39 %
[18,  1400] loss: 0.162  Accuracy: 80.56 %
[19,   200] loss: 0.102  Accuracy: 82.01 %
[19,   400] loss: 0.100  Accuracy: 80.91 %
[19,   600] loss: 0.148  Accuracy: 80.74 %
[19,   800] loss: 0.115  Accuracy: 82.43 %
[19,  1000] loss: 0.110  Accuracy: 81.74 %
[19,  1200] loss: 0.115  Accuracy: 80.78 %
[19,  1400] loss: 0.142  Accuracy: 81.88 %
[20,   200] loss: 0.109  Accuracy: 82.20 %
[20,   400] loss: 0.112  Accuracy: 81.65 %
[20,   600] loss: 0.139  Accuracy: 81.70 %
[20,   800] loss: 0.109  Accuracy: 82.88 %
[20,  1000] loss: 0.116  Accuracy: 82.73 %
[20,  1200] loss: 0.112  Accuracy: 82.07 %
[20,  1400] loss: 0.123  Accuracy: 82.28 %
Finished Training
Accuracy: 82.00 %
GroundTruth:    cat  ship  ship plane
Predicted:    cat  ship  ship plane
Accuracy of plane : 88 %
Accuracy of   car : 91 %
Accuracy of  bird : 75 %
Accuracy of   cat : 55 %
Accuracy of  deer : 84 %
Accuracy of   dog : 70 %
Accuracy of  frog : 84 %
Accuracy of horse : 81 %
Accuracy of  ship : 92 %
Accuracy of truck : 87 %
elapsed time: 6227.035 [sec]
(keras-gpu) C:\Users\user\pytorch\cifar10>pip install torchsummary
Collecting torchsummary
  Downloading https://files.pythonhosted.org/packages/7d/18/1474d06f721b86e6a9b9d7392ad68bed711a02f3b61ac43f13c719db50a6/torchsummary-1.5.1-py3-none-any.whl
Installing collected packages: torchsummary
Successfully installed torchsummary-1.5.1

(keras-gpu) C:\Users\user\pytorch\cifar10>python pytorch_cifar10_.py
Files already downloaded and verified
Files already downloaded and verified
cuda:0
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [-1, 64, 32, 32]           1,792
       BatchNorm2d-2           [-1, 64, 32, 32]             128
              ReLU-3           [-1, 64, 32, 32]               0
            Conv2d-4           [-1, 64, 32, 32]          36,928
       BatchNorm2d-5           [-1, 64, 32, 32]             128
              ReLU-6           [-1, 64, 32, 32]               0
         MaxPool2d-7           [-1, 64, 16, 16]               0
            Conv2d-8          [-1, 128, 16, 16]          73,856
       BatchNorm2d-9          [-1, 128, 16, 16]             256
             ReLU-10          [-1, 128, 16, 16]               0
           Conv2d-11          [-1, 128, 16, 16]         147,584
      BatchNorm2d-12          [-1, 128, 16, 16]             256
             ReLU-13          [-1, 128, 16, 16]               0
        MaxPool2d-14            [-1, 128, 8, 8]               0
           Conv2d-15            [-1, 256, 8, 8]         295,168
      BatchNorm2d-16            [-1, 256, 8, 8]             512
             ReLU-17            [-1, 256, 8, 8]               0
           Conv2d-18            [-1, 256, 8, 8]         590,080
      BatchNorm2d-19            [-1, 256, 8, 8]             512
             ReLU-20            [-1, 256, 8, 8]               0
        MaxPool2d-21            [-1, 256, 4, 4]               0
           Conv2d-22            [-1, 512, 4, 4]       1,180,160
      BatchNorm2d-23            [-1, 512, 4, 4]           1,024
             ReLU-24            [-1, 512, 4, 4]               0
           Conv2d-25            [-1, 512, 4, 4]       2,359,808
      BatchNorm2d-26            [-1, 512, 4, 4]           1,024
             ReLU-27            [-1, 512, 4, 4]               0
        MaxPool2d-28            [-1, 512, 2, 2]               0
           Conv2d-29            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-30            [-1, 512, 2, 2]           1,024
             ReLU-31            [-1, 512, 2, 2]               0
           Conv2d-32            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-33            [-1, 512, 2, 2]           1,024
             ReLU-34            [-1, 512, 2, 2]               0
        MaxPool2d-35            [-1, 512, 1, 1]               0
           Linear-36                  [-1, 512]         262,656
             ReLU-37                  [-1, 512]               0
          Dropout-38                  [-1, 512]               0
           Linear-39                   [-1, 32]          16,416
             ReLU-40                   [-1, 32]               0
          Dropout-41                   [-1, 32]               0
           Linear-42                   [-1, 10]             330
================================================================
Total params: 9,690,282
Trainable params: 9,690,282
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.01
Forward/backward pass size (MB): 5.97
Params size (MB): 36.97
Estimated Total Size (MB): 42.95
----------------------------------------------------------------
(keras-gpu) C:\Users\user\pytorch\cifar10>python pytorch_cifar10_.py
Files already downloaded and verified
Files already downloaded and verified
cuda:0
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [-1, 64, 32, 32]           1,792
       BatchNorm2d-2           [-1, 64, 32, 32]             128
              ReLU-3           [-1, 64, 32, 32]               0
            Conv2d-4           [-1, 64, 32, 32]          36,928
       BatchNorm2d-5           [-1, 64, 32, 32]             128
              ReLU-6           [-1, 64, 32, 32]               0
         MaxPool2d-7           [-1, 64, 16, 16]               0
            Conv2d-8          [-1, 128, 16, 16]          73,856
       BatchNorm2d-9          [-1, 128, 16, 16]             256
             ReLU-10          [-1, 128, 16, 16]               0
           Conv2d-11          [-1, 128, 16, 16]         147,584
      BatchNorm2d-12          [-1, 128, 16, 16]             256
             ReLU-13          [-1, 128, 16, 16]               0
        MaxPool2d-14            [-1, 128, 8, 8]               0
           Conv2d-15            [-1, 256, 8, 8]         295,168
      BatchNorm2d-16            [-1, 256, 8, 8]             512
             ReLU-17            [-1, 256, 8, 8]               0
           Conv2d-18            [-1, 256, 8, 8]         590,080
      BatchNorm2d-19            [-1, 256, 8, 8]             512
             ReLU-20            [-1, 256, 8, 8]               0
        MaxPool2d-21            [-1, 256, 4, 4]               0
           Conv2d-22            [-1, 512, 4, 4]       1,180,160
      BatchNorm2d-23            [-1, 512, 4, 4]           1,024
             ReLU-24            [-1, 512, 4, 4]               0
           Conv2d-25            [-1, 512, 4, 4]       2,359,808
      BatchNorm2d-26            [-1, 512, 4, 4]           1,024
             ReLU-27            [-1, 512, 4, 4]               0
        MaxPool2d-28            [-1, 512, 2, 2]               0
           Conv2d-29            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-30            [-1, 512, 2, 2]           1,024
             ReLU-31            [-1, 512, 2, 2]               0
           Conv2d-32            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-33            [-1, 512, 2, 2]           1,024
             ReLU-34            [-1, 512, 2, 2]               0
        MaxPool2d-35            [-1, 512, 1, 1]               0
           Linear-36                 [-1, 4096]       2,101,248
             ReLU-37                 [-1, 4096]               0
          Dropout-38                 [-1, 4096]               0
           Linear-39                 [-1, 4096]      16,781,312
             ReLU-40                 [-1, 4096]               0
          Dropout-41                 [-1, 4096]               0
           Linear-42                   [-1, 10]          40,970
================================================================
Total params: 28,334,410
Trainable params: 28,334,410
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.01
Forward/backward pass size (MB): 6.14
Params size (MB): 108.09
Estimated Total Size (MB): 114.24
----------------------------------------------------------------
[1,   200] loss: 1.935  Accuracy: 37.73 %
[1,   400] loss: 1.564  Accuracy: 46.54 %
[1,   600] loss: 1.355  Accuracy: 51.21 %
[1,   800] loss: 1.243  Accuracy: 57.66 %
[1,  1000] loss: 1.149  Accuracy: 61.24 %
[1,  1200] loss: 1.081  Accuracy: 64.30 %
[1,  1400] loss: 1.037  Accuracy: 65.43 %
[2,   200] loss: 0.876  Accuracy: 68.62 %
[2,   400] loss: 0.840  Accuracy: 68.47 %
[2,   600] loss: 0.819  Accuracy: 70.76 %
[2,   800] loss: 0.812  Accuracy: 70.56 %
[2,  1000] loss: 0.776  Accuracy: 72.58 %
[2,  1200] loss: 0.772  Accuracy: 72.98 %
[2,  1400] loss: 0.737  Accuracy: 73.90 %
[3,   200] loss: 0.590  Accuracy: 74.99 %
[3,   400] loss: 0.589  Accuracy: 74.98 %
[3,   600] loss: 0.575  Accuracy: 76.83 %
[3,   800] loss: 0.603  Accuracy: 76.16 %
[3,  1000] loss: 0.586  Accuracy: 75.61 %
[3,  1200] loss: 0.594  Accuracy: 77.48 %
[3,  1400] loss: 0.575  Accuracy: 77.80 %
[4,   200] loss: 0.421  Accuracy: 76.95 %
[4,   400] loss: 0.474  Accuracy: 79.14 %
[4,   600] loss: 0.450  Accuracy: 78.46 %
[4,   800] loss: 0.458  Accuracy: 78.70 %
[4,  1000] loss: 0.436  Accuracy: 78.99 %
[4,  1200] loss: 0.460  Accuracy: 78.49 %
[4,  1400] loss: 0.439  Accuracy: 79.29 %
[5,   200] loss: 0.324  Accuracy: 80.00 %
[5,   400] loss: 0.326  Accuracy: 79.82 %
[5,   600] loss: 0.340  Accuracy: 79.58 %
[5,   800] loss: 0.355  Accuracy: 79.85 %
[5,  1000] loss: 0.353  Accuracy: 78.64 %
[5,  1200] loss: 0.358  Accuracy: 79.53 %
[5,  1400] loss: 0.375  Accuracy: 80.18 %
[6,   200] loss: 0.197  Accuracy: 80.41 %
[6,   400] loss: 0.240  Accuracy: 79.51 %
[6,   600] loss: 0.253  Accuracy: 80.12 %
[6,   800] loss: 0.257  Accuracy: 79.99 %
[6,  1000] loss: 0.280  Accuracy: 80.19 %
[6,  1200] loss: 0.290  Accuracy: 80.65 %
[6,  1400] loss: 0.279  Accuracy: 80.54 %
[7,   200] loss: 0.163  Accuracy: 80.61 %
[7,   400] loss: 0.159  Accuracy: 80.54 %
[7,   600] loss: 0.214  Accuracy: 80.71 %
[7,   800] loss: 0.207  Accuracy: 80.06 %
[7,  1000] loss: 0.230  Accuracy: 80.94 %
[7,  1200] loss: 0.202  Accuracy: 80.87 %
[7,  1400] loss: 0.229  Accuracy: 80.88 %
[8,   200] loss: 0.111  Accuracy: 81.43 %
[8,   400] loss: 0.117  Accuracy: 80.23 %
[8,   600] loss: 0.141  Accuracy: 81.27 %
[8,   800] loss: 0.144  Accuracy: 80.94 %
[8,  1000] loss: 0.162  Accuracy: 81.23 %
[8,  1200] loss: 0.186  Accuracy: 80.36 %
[8,  1400] loss: 0.172  Accuracy: 81.31 %
[9,   200] loss: 0.115  Accuracy: 82.08 %
[9,   400] loss: 0.093  Accuracy: 81.80 %
[9,   600] loss: 0.110  Accuracy: 80.76 %
[9,   800] loss: 0.124  Accuracy: 80.36 %
[9,  1000] loss: 0.121  Accuracy: 81.47 %
[9,  1200] loss: 0.127  Accuracy: 82.10 %
[9,  1400] loss: 0.126  Accuracy: 82.00 %
[10,   200] loss: 0.069  Accuracy: 81.54 %
[10,   400] loss: 0.076  Accuracy: 81.65 %
[10,   600] loss: 0.086  Accuracy: 81.65 %
[10,   800] loss: 0.096  Accuracy: 81.21 %
[10,  1000] loss: 0.097  Accuracy: 81.36 %
[10,  1200] loss: 0.125  Accuracy: 81.14 %
[10,  1400] loss: 0.115  Accuracy: 81.67 %
[11,   200] loss: 0.065  Accuracy: 82.97 %
[11,   400] loss: 0.072  Accuracy: 82.64 %
[11,   600] loss: 0.068  Accuracy: 81.99 %
[11,   800] loss: 0.078  Accuracy: 82.35 %
[11,  1000] loss: 0.092  Accuracy: 80.93 %
[11,  1200] loss: 0.097  Accuracy: 82.51 %
[11,  1400] loss: 0.089  Accuracy: 82.36 %
[12,   200] loss: 0.052  Accuracy: 82.49 %
[12,   400] loss: 0.044  Accuracy: 82.01 %
[12,   600] loss: 0.059  Accuracy: 82.71 %
[12,   800] loss: 0.060  Accuracy: 82.39 %
[12,  1000] loss: 0.073  Accuracy: 82.73 %
[12,  1200] loss: 0.057  Accuracy: 82.53 %
[12,  1400] loss: 0.067  Accuracy: 82.27 %
[13,   200] loss: 0.050  Accuracy: 82.59 %
[13,   400] loss: 0.051  Accuracy: 82.51 %
[13,   600] loss: 0.046  Accuracy: 83.08 %
[13,   800] loss: 0.041  Accuracy: 82.59 %
[13,  1000] loss: 0.057  Accuracy: 82.74 %
[13,  1200] loss: 0.072  Accuracy: 82.47 %
[13,  1400] loss: 0.055  Accuracy: 82.31 %
[14,   200] loss: 0.046  Accuracy: 82.98 %
[14,   400] loss: 0.048  Accuracy: 82.69 %
[14,   600] loss: 0.036  Accuracy: 82.45 %
[14,   800] loss: 0.066  Accuracy: 82.31 %
[14,  1000] loss: 0.047  Accuracy: 82.56 %
[14,  1200] loss: 0.057  Accuracy: 82.21 %
[14,  1400] loss: 0.052  Accuracy: 81.95 %
[15,   200] loss: 0.045  Accuracy: 82.63 %
[15,   400] loss: 0.042  Accuracy: 82.32 %
[15,   600] loss: 0.033  Accuracy: 82.95 %
[15,   800] loss: 0.045  Accuracy: 82.65 %
[15,  1000] loss: 0.050  Accuracy: 82.56 %
[15,  1200] loss: 0.051  Accuracy: 81.83 %
[15,  1400] loss: 0.056  Accuracy: 82.11 %
[16,   200] loss: 0.029  Accuracy: 82.95 %
[16,   400] loss: 0.024  Accuracy: 82.57 %
[16,   600] loss: 0.036  Accuracy: 81.98 %
[16,   800] loss: 0.036  Accuracy: 82.66 %
[16,  1000] loss: 0.042  Accuracy: 82.54 %
[16,  1200] loss: 0.032  Accuracy: 82.41 %
[16,  1400] loss: 0.041  Accuracy: 82.57 %
[17,   200] loss: 0.028  Accuracy: 82.20 %
[17,   400] loss: 0.027  Accuracy: 83.26 %
[17,   600] loss: 0.025  Accuracy: 83.30 %
[17,   800] loss: 0.027  Accuracy: 82.94 %
[17,  1000] loss: 0.037  Accuracy: 81.51 %
[17,  1200] loss: 0.031  Accuracy: 82.83 %
[17,  1400] loss: 0.034  Accuracy: 82.57 %
[18,   200] loss: 0.030  Accuracy: 82.78 %
[18,   400] loss: 0.024  Accuracy: 83.46 %
[18,   600] loss: 0.020  Accuracy: 83.02 %
[18,   800] loss: 0.016  Accuracy: 83.47 %
[18,  1000] loss: 0.030  Accuracy: 82.85 %
[18,  1200] loss: 0.031  Accuracy: 82.56 %
[18,  1400] loss: 0.040  Accuracy: 82.16 %
[19,   200] loss: 0.023  Accuracy: 82.91 %
[19,   400] loss: 0.015  Accuracy: 82.99 %
[19,   600] loss: 0.017  Accuracy: 83.53 %
[19,   800] loss: 0.025  Accuracy: 82.35 %
[19,  1000] loss: 0.033  Accuracy: 82.55 %
[19,  1200] loss: 0.040  Accuracy: 82.92 %
[19,  1400] loss: 0.029  Accuracy: 82.75 %
[20,   200] loss: 0.020  Accuracy: 82.80 %
[20,   400] loss: 0.016  Accuracy: 83.21 %
[20,   600] loss: 0.017  Accuracy: 82.76 %
[20,   800] loss: 0.017  Accuracy: 82.93 %
[20,  1000] loss: 0.018  Accuracy: 83.16 %
[20,  1200] loss: 0.024  Accuracy: 83.23 %
[20,  1400] loss: 0.023  Accuracy: 82.91 %
Finished Training
Accuracy: 82.15 %
GroundTruth:    cat  ship  ship plane
Predicted:    cat  ship  ship plane
Accuracy of plane : 84 %
Accuracy of   car : 91 %
Accuracy of  bird : 69 %
Accuracy of   cat : 59 %
Accuracy of  deer : 81 %
Accuracy of   dog : 76 %
Accuracy of  frog : 90 %
Accuracy of horse : 86 %
Accuracy of  ship : 94 %
Accuracy of truck : 88 %
elapsed time: 2177.621 [sec]
(keras-gpu) C:\Users\user\pytorch\cifar10>python pytorch_cifar10_.py
Files already downloaded and verified
Files already downloaded and verified
cuda:0
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [-1, 64, 32, 32]           1,792
       BatchNorm2d-2           [-1, 64, 32, 32]             128
              ReLU-3           [-1, 64, 32, 32]               0
            Conv2d-4           [-1, 64, 32, 32]          36,928
       BatchNorm2d-5           [-1, 64, 32, 32]             128
              ReLU-6           [-1, 64, 32, 32]               0
         MaxPool2d-7           [-1, 64, 16, 16]               0
            Conv2d-8          [-1, 128, 16, 16]          73,856
       BatchNorm2d-9          [-1, 128, 16, 16]             256
             ReLU-10          [-1, 128, 16, 16]               0
           Conv2d-11          [-1, 128, 16, 16]         147,584
      BatchNorm2d-12          [-1, 128, 16, 16]             256
             ReLU-13          [-1, 128, 16, 16]               0
        MaxPool2d-14            [-1, 128, 8, 8]               0
           Conv2d-15            [-1, 256, 8, 8]         295,168
      BatchNorm2d-16            [-1, 256, 8, 8]             512
             ReLU-17            [-1, 256, 8, 8]               0
           Conv2d-18            [-1, 256, 8, 8]         590,080
      BatchNorm2d-19            [-1, 256, 8, 8]             512
             ReLU-20            [-1, 256, 8, 8]               0
        MaxPool2d-21            [-1, 256, 4, 4]               0
           Conv2d-22            [-1, 512, 4, 4]       1,180,160
      BatchNorm2d-23            [-1, 512, 4, 4]           1,024
             ReLU-24            [-1, 512, 4, 4]               0
           Conv2d-25            [-1, 512, 4, 4]       2,359,808
      BatchNorm2d-26            [-1, 512, 4, 4]           1,024
             ReLU-27            [-1, 512, 4, 4]               0
        MaxPool2d-28            [-1, 512, 2, 2]               0
           Conv2d-29            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-30            [-1, 512, 2, 2]           1,024
             ReLU-31            [-1, 512, 2, 2]               0
           Conv2d-32            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-33            [-1, 512, 2, 2]           1,024
             ReLU-34            [-1, 512, 2, 2]               0
        MaxPool2d-35            [-1, 512, 1, 1]               0
           Linear-36                   [-1, 10]           5,130
================================================================
Total params: 9,416,010
Trainable params: 9,416,010
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.01
Forward/backward pass size (MB): 5.96
Params size (MB): 35.92
Estimated Total Size (MB): 41.89
----------------------------------------------------------------
[1,   200] loss: 1.694  Accuracy: 45.04 %
[1,   400] loss: 1.393  Accuracy: 52.05 %
[1,   600] loss: 1.245  Accuracy: 59.09 %
[1,   800] loss: 1.119  Accuracy: 63.34 %
[1,  1000] loss: 1.034  Accuracy: 67.15 %
[1,  1200] loss: 0.987  Accuracy: 64.93 %
[1,  1400] loss: 0.922  Accuracy: 69.80 %
[2,   200] loss: 0.732  Accuracy: 71.40 %
[2,   400] loss: 0.765  Accuracy: 70.54 %
[2,   600] loss: 0.730  Accuracy: 72.81 %
[2,   800] loss: 0.703  Accuracy: 74.63 %
[2,  1000] loss: 0.726  Accuracy: 74.41 %
[2,  1200] loss: 0.695  Accuracy: 75.12 %
[2,  1400] loss: 0.676  Accuracy: 76.17 %
[3,   200] loss: 0.484  Accuracy: 76.41 %
[3,   400] loss: 0.496  Accuracy: 76.92 %
[3,   600] loss: 0.519  Accuracy: 76.57 %
[3,   800] loss: 0.521  Accuracy: 76.75 %
[3,  1000] loss: 0.523  Accuracy: 77.10 %
[3,  1200] loss: 0.499  Accuracy: 77.52 %
[3,  1400] loss: 0.506  Accuracy: 78.88 %
[4,   200] loss: 0.320  Accuracy: 79.10 %
[4,   400] loss: 0.348  Accuracy: 78.58 %
[4,   600] loss: 0.368  Accuracy: 78.86 %
[4,   800] loss: 0.398  Accuracy: 79.05 %
[4,  1000] loss: 0.387  Accuracy: 79.22 %
[4,  1200] loss: 0.409  Accuracy: 79.54 %
[4,  1400] loss: 0.416  Accuracy: 78.79 %
[5,   200] loss: 0.212  Accuracy: 79.96 %
[5,   400] loss: 0.243  Accuracy: 80.23 %
[5,   600] loss: 0.257  Accuracy: 79.61 %
[5,   800] loss: 0.270  Accuracy: 79.62 %
[5,  1000] loss: 0.297  Accuracy: 79.50 %
[5,  1200] loss: 0.282  Accuracy: 79.86 %
[5,  1400] loss: 0.307  Accuracy: 79.68 %
[6,   200] loss: 0.159  Accuracy: 80.35 %
[6,   400] loss: 0.168  Accuracy: 78.92 %
[6,   600] loss: 0.176  Accuracy: 80.20 %
[6,   800] loss: 0.198  Accuracy: 79.92 %
[6,  1000] loss: 0.203  Accuracy: 79.62 %
[6,  1200] loss: 0.196  Accuracy: 80.84 %
[6,  1400] loss: 0.223  Accuracy: 80.23 %
[7,   200] loss: 0.117  Accuracy: 80.72 %
[7,   400] loss: 0.112  Accuracy: 80.82 %
[7,   600] loss: 0.111  Accuracy: 80.64 %
[7,   800] loss: 0.134  Accuracy: 80.78 %
[7,  1000] loss: 0.137  Accuracy: 79.52 %
[7,  1200] loss: 0.160  Accuracy: 80.54 %
[7,  1400] loss: 0.149  Accuracy: 80.22 %
[8,   200] loss: 0.080  Accuracy: 80.49 %
[8,   400] loss: 0.080  Accuracy: 79.94 %
[8,   600] loss: 0.081  Accuracy: 81.20 %
[8,   800] loss: 0.087  Accuracy: 79.86 %
[8,  1000] loss: 0.107  Accuracy: 79.85 %
[8,  1200] loss: 0.128  Accuracy: 81.13 %
[8,  1400] loss: 0.124  Accuracy: 80.82 %
[9,   200] loss: 0.064  Accuracy: 81.60 %
[9,   400] loss: 0.070  Accuracy: 81.56 %
[9,   600] loss: 0.076  Accuracy: 80.87 %
[9,   800] loss: 0.079  Accuracy: 81.40 %
[9,  1000] loss: 0.109  Accuracy: 79.99 %
[9,  1200] loss: 0.112  Accuracy: 80.14 %
[9,  1400] loss: 0.092  Accuracy: 80.49 %
[10,   200] loss: 0.075  Accuracy: 81.39 %
[10,   400] loss: 0.052  Accuracy: 80.67 %
[10,   600] loss: 0.055  Accuracy: 80.81 %
[10,   800] loss: 0.048  Accuracy: 81.62 %
[10,  1000] loss: 0.050  Accuracy: 81.03 %
[10,  1200] loss: 0.072  Accuracy: 80.54 %
[10,  1400] loss: 0.092  Accuracy: 80.93 %
[11,   200] loss: 0.051  Accuracy: 81.15 %
[11,   400] loss: 0.042  Accuracy: 81.66 %
[11,   600] loss: 0.052  Accuracy: 81.73 %
[11,   800] loss: 0.044  Accuracy: 81.80 %
[11,  1000] loss: 0.045  Accuracy: 81.38 %
[11,  1200] loss: 0.041  Accuracy: 81.75 %
[11,  1400] loss: 0.051  Accuracy: 81.69 %
[12,   200] loss: 0.043  Accuracy: 82.13 %
[12,   400] loss: 0.026  Accuracy: 82.22 %
[12,   600] loss: 0.038  Accuracy: 81.66 %
[12,   800] loss: 0.030  Accuracy: 82.17 %
[12,  1000] loss: 0.040  Accuracy: 81.41 %
[12,  1200] loss: 0.036  Accuracy: 82.57 %
[12,  1400] loss: 0.040  Accuracy: 81.92 %
[13,   200] loss: 0.028  Accuracy: 82.66 %
[13,   400] loss: 0.028  Accuracy: 83.11 %
[13,   600] loss: 0.028  Accuracy: 81.71 %
[13,   800] loss: 0.023  Accuracy: 83.15 %
[13,  1000] loss: 0.018  Accuracy: 82.23 %
[13,  1200] loss: 0.025  Accuracy: 82.45 %
[13,  1400] loss: 0.030  Accuracy: 82.09 %
[14,   200] loss: 0.019  Accuracy: 82.08 %
[14,   400] loss: 0.029  Accuracy: 81.89 %
[14,   600] loss: 0.029  Accuracy: 82.36 %
[14,   800] loss: 0.019  Accuracy: 82.19 %
[14,  1000] loss: 0.020  Accuracy: 81.79 %
[14,  1200] loss: 0.028  Accuracy: 81.67 %
[14,  1400] loss: 0.037  Accuracy: 81.56 %
[15,   200] loss: 0.029  Accuracy: 82.03 %
[15,   400] loss: 0.024  Accuracy: 82.66 %
[15,   600] loss: 0.024  Accuracy: 82.21 %
[15,   800] loss: 0.022  Accuracy: 81.62 %
[15,  1000] loss: 0.024  Accuracy: 82.61 %
[15,  1200] loss: 0.028  Accuracy: 82.36 %
[15,  1400] loss: 0.032  Accuracy: 82.21 %
[16,   200] loss: 0.018  Accuracy: 82.14 %
[16,   400] loss: 0.013  Accuracy: 82.07 %
[16,   600] loss: 0.016  Accuracy: 82.62 %
[16,   800] loss: 0.014  Accuracy: 82.77 %
[16,  1000] loss: 0.017  Accuracy: 82.30 %
[16,  1200] loss: 0.031  Accuracy: 82.07 %
[16,  1400] loss: 0.021  Accuracy: 82.14 %
[17,   200] loss: 0.021  Accuracy: 82.37 %
[17,   400] loss: 0.019  Accuracy: 81.47 %
[17,   600] loss: 0.016  Accuracy: 82.76 %
[17,   800] loss: 0.014  Accuracy: 82.85 %
[17,  1000] loss: 0.012  Accuracy: 82.11 %
[17,  1200] loss: 0.021  Accuracy: 82.27 %
[17,  1400] loss: 0.025  Accuracy: 81.77 %
[18,   200] loss: 0.017  Accuracy: 82.24 %
[18,   400] loss: 0.015  Accuracy: 82.22 %
[18,   600] loss: 0.010  Accuracy: 82.42 %
[18,   800] loss: 0.011  Accuracy: 83.26 %
[18,  1000] loss: 0.014  Accuracy: 82.56 %
[18,  1200] loss: 0.020  Accuracy: 82.53 %
[18,  1400] loss: 0.025  Accuracy: 82.08 %
[19,   200] loss: 0.017  Accuracy: 82.10 %
[19,   400] loss: 0.014  Accuracy: 82.57 %
[19,   600] loss: 0.012  Accuracy: 82.03 %
[19,   800] loss: 0.014  Accuracy: 82.27 %
[19,  1000] loss: 0.010  Accuracy: 82.89 %
[19,  1200] loss: 0.006  Accuracy: 82.79 %
[19,  1400] loss: 0.010  Accuracy: 82.54 %
[20,   200] loss: 0.006  Accuracy: 83.22 %
[20,   400] loss: 0.005  Accuracy: 83.32 %
[20,   600] loss: 0.010  Accuracy: 82.79 %
[20,   800] loss: 0.008  Accuracy: 82.95 %
[20,  1000] loss: 0.007  Accuracy: 83.04 %
[20,  1200] loss: 0.017  Accuracy: 82.34 %
[20,  1400] loss: 0.022  Accuracy: 81.85 %
Finished Training
Accuracy: 82.37 %
GroundTruth:    cat  ship  ship plane
Predicted:    cat  ship  ship plane
Accuracy of plane : 79 %
Accuracy of   car : 88 %
Accuracy of  bird : 75 %
Accuracy of   cat : 65 %
Accuracy of  deer : 79 %
Accuracy of   dog : 79 %
Accuracy of  frog : 81 %
Accuracy of horse : 84 %
Accuracy of  ship : 88 %
Accuracy of truck : 91 %
elapsed time: ...
(keras-gpu) C:\Users\user\pytorch\cifar10>python pytorch_cifar10_.py
Files already downloaded and verified
Files already downloaded and verified
cuda:0
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [-1, 64, 32, 32]           1,792
       BatchNorm2d-2           [-1, 64, 32, 32]             128
              ReLU-3           [-1, 64, 32, 32]               0
            Conv2d-4           [-1, 64, 32, 32]          36,928
       BatchNorm2d-5           [-1, 64, 32, 32]             128
              ReLU-6           [-1, 64, 32, 32]               0
         MaxPool2d-7           [-1, 64, 16, 16]               0
            Conv2d-8          [-1, 128, 16, 16]          73,856
       BatchNorm2d-9          [-1, 128, 16, 16]             256
             ReLU-10          [-1, 128, 16, 16]               0
           Conv2d-11          [-1, 128, 16, 16]         147,584
      BatchNorm2d-12          [-1, 128, 16, 16]             256
             ReLU-13          [-1, 128, 16, 16]               0
        MaxPool2d-14            [-1, 128, 8, 8]               0
           Conv2d-15            [-1, 256, 8, 8]         295,168
      BatchNorm2d-16            [-1, 256, 8, 8]             512
             ReLU-17            [-1, 256, 8, 8]               0
           Conv2d-18            [-1, 256, 8, 8]         590,080
      BatchNorm2d-19            [-1, 256, 8, 8]             512
             ReLU-20            [-1, 256, 8, 8]               0
           Conv2d-21            [-1, 256, 8, 8]         590,080
      BatchNorm2d-22            [-1, 256, 8, 8]             512
             ReLU-23            [-1, 256, 8, 8]               0
        MaxPool2d-24            [-1, 256, 4, 4]               0
           Conv2d-25            [-1, 512, 4, 4]       1,180,160
      BatchNorm2d-26            [-1, 512, 4, 4]           1,024
             ReLU-27            [-1, 512, 4, 4]               0
           Conv2d-28            [-1, 512, 4, 4]       2,359,808
      BatchNorm2d-29            [-1, 512, 4, 4]           1,024
             ReLU-30            [-1, 512, 4, 4]               0
           Conv2d-31            [-1, 512, 4, 4]       2,359,808
      BatchNorm2d-32            [-1, 512, 4, 4]           1,024
             ReLU-33            [-1, 512, 4, 4]               0
        MaxPool2d-34            [-1, 512, 2, 2]               0
           Conv2d-35            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-36            [-1, 512, 2, 2]           1,024
             ReLU-37            [-1, 512, 2, 2]               0
           Conv2d-38            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-39            [-1, 512, 2, 2]           1,024
             ReLU-40            [-1, 512, 2, 2]               0
           Conv2d-41            [-1, 512, 2, 2]       2,359,808
      BatchNorm2d-42            [-1, 512, 2, 2]           1,024
             ReLU-43            [-1, 512, 2, 2]               0
        MaxPool2d-44            [-1, 512, 1, 1]               0
           Linear-45                   [-1, 10]           5,130
================================================================
Total params: 14,728,266
Trainable params: 14,728,266
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.01
Forward/backward pass size (MB): 6.57
Params size (MB): 56.18
Estimated Total Size (MB): 62.76
----------------------------------------------------------------
[1,   200] loss: 1.799  Accuracy: 40.17 %
[1,   400] loss: 1.469  Accuracy: 48.53 %
[1,   600] loss: 1.295  Accuracy: 58.68 %
[1,   800] loss: 1.183  Accuracy: 59.18 %
[1,  1000] loss: 1.091  Accuracy: 63.12 %
[1,  1200] loss: 1.016  Accuracy: 67.31 %
[1,  1400] loss: 0.943  Accuracy: 67.08 %
[2,   200] loss: 0.774  Accuracy: 69.65 %
[2,   400] loss: 0.773  Accuracy: 72.26 %
[2,   600] loss: 0.739  Accuracy: 72.27 %
[2,   800] loss: 0.742  Accuracy: 73.00 %
[2,  1000] loss: 0.716  Accuracy: 73.47 %
[2,  1200] loss: 0.730  Accuracy: 75.37 %
[2,  1400] loss: 0.686  Accuracy: 75.08 %
[3,   200] loss: 0.530  Accuracy: 75.96 %
[3,   400] loss: 0.532  Accuracy: 76.04 %
[3,   600] loss: 0.557  Accuracy: 76.72 %
[3,   800] loss: 0.540  Accuracy: 77.04 %
[3,  1000] loss: 0.560  Accuracy: 76.86 %
[3,  1200] loss: 0.541  Accuracy: 78.71 %
[3,  1400] loss: 0.534  Accuracy: 77.87 %
[4,   200] loss: 0.367  Accuracy: 78.03 %
[4,   400] loss: 0.385  Accuracy: 78.14 %
[4,   600] loss: 0.399  Accuracy: 77.48 %
[4,   800] loss: 0.421  Accuracy: 80.07 %
[4,  1000] loss: 0.423  Accuracy: 79.78 %
[4,  1200] loss: 0.419  Accuracy: 77.99 %
[4,  1400] loss: 0.435  Accuracy: 77.94 %
[5,   200] loss: 0.251  Accuracy: 79.96 %
[5,   400] loss: 0.263  Accuracy: 80.21 %
[5,   600] loss: 0.305  Accuracy: 79.52 %
[5,   800] loss: 0.325  Accuracy: 79.28 %
[5,  1000] loss: 0.328  Accuracy: 79.60 %
[5,  1200] loss: 0.310  Accuracy: 80.36 %
[5,  1400] loss: 0.321  Accuracy: 79.35 %
[6,   200] loss: 0.197  Accuracy: 80.52 %
[6,   400] loss: 0.175  Accuracy: 81.41 %
[6,   600] loss: 0.205  Accuracy: 79.99 %
[6,   800] loss: 0.225  Accuracy: 80.46 %
[6,  1000] loss: 0.226  Accuracy: 81.30 %
[6,  1200] loss: 0.268  Accuracy: 80.72 %
[6,  1400] loss: 0.260  Accuracy: 80.55 %
[7,   200] loss: 0.137  Accuracy: 81.70 %
[7,   400] loss: 0.154  Accuracy: 80.79 %
[7,   600] loss: 0.159  Accuracy: 81.09 %
[7,   800] loss: 0.163  Accuracy: 80.51 %
[7,  1000] loss: 0.181  Accuracy: 81.27 %
[7,  1200] loss: 0.188  Accuracy: 81.19 %
[7,  1400] loss: 0.175  Accuracy: 81.94 %
[8,   200] loss: 0.097  Accuracy: 81.12 %
[8,   400] loss: 0.127  Accuracy: 80.91 %
[8,   600] loss: 0.122  Accuracy: 81.28 %
[8,   800] loss: 0.136  Accuracy: 81.21 %
[8,  1000] loss: 0.128  Accuracy: 81.71 %
[8,  1200] loss: 0.144  Accuracy: 81.51 %
[8,  1400] loss: 0.152  Accuracy: 81.56 %
[9,   200] loss: 0.079  Accuracy: 82.23 %
[9,   400] loss: 0.082  Accuracy: 81.96 %
[9,   600] loss: 0.082  Accuracy: 81.99 %
[9,   800] loss: 0.088  Accuracy: 81.79 %
[9,  1000] loss: 0.095  Accuracy: 81.77 %
[9,  1200] loss: 0.105  Accuracy: 82.10 %
[9,  1400] loss: 0.119  Accuracy: 82.12 %
[10,   200] loss: 0.068  Accuracy: 82.85 %
[10,   400] loss: 0.054  Accuracy: 82.08 %
[10,   600] loss: 0.075  Accuracy: 81.81 %
[10,   800] loss: 0.077  Accuracy: 81.26 %
[10,  1000] loss: 0.088  Accuracy: 81.52 %
[10,  1200] loss: 0.092  Accuracy: 82.67 %
[10,  1400] loss: 0.086  Accuracy: 81.33 %
[11,   200] loss: 0.058  Accuracy: 82.81 %
[11,   400] loss: 0.054  Accuracy: 82.56 %
[11,   600] loss: 0.061  Accuracy: 82.24 %
[11,   800] loss: 0.076  Accuracy: 82.50 %
[11,  1000] loss: 0.073  Accuracy: 82.36 %
[11,  1200] loss: 0.058  Accuracy: 82.78 %
[11,  1400] loss: 0.081  Accuracy: 81.89 %
[12,   200] loss: 0.052  Accuracy: 82.33 %
[12,   400] loss: 0.034  Accuracy: 82.74 %
[12,   600] loss: 0.039  Accuracy: 82.18 %
[12,   800] loss: 0.049  Accuracy: 82.51 %
[12,  1000] loss: 0.054  Accuracy: 82.29 %
[12,  1200] loss: 0.051  Accuracy: 83.02 %
[12,  1400] loss: 0.058  Accuracy: 82.70 %
[13,   200] loss: 0.053  Accuracy: 82.71 %
[13,   400] loss: 0.060  Accuracy: 82.67 %
[13,   600] loss: 0.043  Accuracy: 82.62 %
[13,   800] loss: 0.049  Accuracy: 82.43 %
[13,  1000] loss: 0.051  Accuracy: 82.64 %
[13,  1200] loss: 0.064  Accuracy: 82.29 %
[13,  1400] loss: 0.060  Accuracy: 82.71 %
[14,   200] loss: 0.039  Accuracy: 82.99 %
[14,   400] loss: 0.031  Accuracy: 82.65 %
[14,   600] loss: 0.029  Accuracy: 83.03 %
[14,   800] loss: 0.029  Accuracy: 83.56 %
[14,  1000] loss: 0.036  Accuracy: 83.31 %
[14,  1200] loss: 0.035  Accuracy: 83.16 %
[14,  1400] loss: 0.050  Accuracy: 81.60 %
[15,   200] loss: 0.029  Accuracy: 83.00 %
[15,   400] loss: 0.020  Accuracy: 83.58 %
[15,   600] loss: 0.021  Accuracy: 83.13 %
[15,   800] loss: 0.030  Accuracy: 82.34 %
[15,  1000] loss: 0.030  Accuracy: 82.31 %
[15,  1200] loss: 0.028  Accuracy: 82.54 %
[15,  1400] loss: 0.038  Accuracy: 82.27 %
[16,   200] loss: 0.027  Accuracy: 82.22 %
[16,   400] loss: 0.027  Accuracy: 82.48 %
[16,   600] loss: 0.029  Accuracy: 82.61 %
[16,   800] loss: 0.034  Accuracy: 82.41 %
[16,  1000] loss: 0.043  Accuracy: 82.86 %
[16,  1200] loss: 0.034  Accuracy: 83.38 %
[16,  1400] loss: 0.035  Accuracy: 83.11 %
[17,   200] loss: 0.022  Accuracy: 83.67 %
[17,   400] loss: 0.024  Accuracy: 82.72 %
[17,   600] loss: 0.023  Accuracy: 82.82 %
[17,   800] loss: 0.016  Accuracy: 83.68 %
[17,  1000] loss: 0.019  Accuracy: 83.34 %
[17,  1200] loss: 0.025  Accuracy: 82.77 %
[17,  1400] loss: 0.034  Accuracy: 83.47 %
[18,   200] loss: 0.021  Accuracy: 83.69 %
[18,   400] loss: 0.020  Accuracy: 83.29 %
[18,   600] loss: 0.014  Accuracy: 83.81 %
[18,   800] loss: 0.020  Accuracy: 83.58 %
[18,  1000] loss: 0.028  Accuracy: 82.57 %
[18,  1200] loss: 0.029  Accuracy: 82.51 %
[18,  1400] loss: 0.030  Accuracy: 82.37 %
[19,   200] loss: 0.022  Accuracy: 83.79 %
[19,   400] loss: 0.012  Accuracy: 83.80 %
[19,   600] loss: 0.012  Accuracy: 83.77 %
[19,   800] loss: 0.017  Accuracy: 83.51 %
[19,  1000] loss: 0.016  Accuracy: 83.54 %
[19,  1200] loss: 0.011  Accuracy: 83.88 %
[19,  1400] loss: 0.011  Accuracy: 83.56 %
[20,   200] loss: 0.018  Accuracy: 82.86 %
[20,   400] loss: 0.023  Accuracy: 83.04 %
[20,   600] loss: 0.026  Accuracy: 83.26 %
[20,   800] loss: 0.020  Accuracy: 82.70 %
[20,  1000] loss: 0.016  Accuracy: 83.13 %
[20,  1200] loss: 0.021  Accuracy: 82.92 %
[20,  1400] loss: 0.029  Accuracy: 82.57 %
Finished Training
Accuracy: 83.03 %
GroundTruth:    cat  ship  ship plane
Predicted:    cat  ship  ship plane
Accuracy of plane : 87 %
Accuracy of   car : 93 %
Accuracy of  bird : 76 %
Accuracy of   cat : 59 %
Accuracy of  deer : 80 %
Accuracy of   dog : 77 %
Accuracy of  frog : 85 %
Accuracy of horse : 85 %
Accuracy of  ship : 92 %
Accuracy of truck : 93 %
elapsed time: 2412.977 [sec]

Recommended Posts

[Introduction to Pytorch] I tried categorizing Cifar10 with VGG16 ♬
[Introduction to Pytorch] I played with sinGAN ♬
I tried to implement CVAE with PyTorch
I tried to detect Mario with pytorch + yolov3
I tried to implement reading Dataset with PyTorch
I tried to move Faster R-CNN quickly with pytorch
I tried to implement and learn DCGAN with PyTorch
I tried to implement SSD with PyTorch now (Dataset)
[Introduction to AWS] I tried playing with voice-text conversion ♪
[Details (?)] Introduction to pytorch ~ CNN CIFAR10 ~
I tried to explain Pytorch dataset
I tried implementing DeepPose with PyTorch
I tried to classify MNIST by GNN (with PyTorch geometric)
I tried to implement SSD with PyTorch now (model edition)
I tried to implement Autoencoder with TensorFlow
I tried to get started with Hy
[Python] Introduction to CNN with Pytorch MNIST
I tried batch normalization with PyTorch (+ note)
I tried to implement sentence classification by Self Attention with PyTorch
I tried implementing DeepPose with PyTorch PartⅡ
I tried to solve TSP with QAOA
I tried fMRI data analysis with python (Introduction to brain information decoding)
I implemented the VGG16 model in Keras and tried to identify CIFAR10
I tried to predict next year with AI
I tried to use lightGBM, xgboost with Boruta
I tried image recognition of CIFAR-10 with Keras-Learning-
I tried to learn logical operations with TF Learn
I tried to move GAN (mnist) with keras
I tried image recognition of CIFAR-10 with Keras-Image recognition-
I tried to save the data with discord
I tried to detect motion quickly with OpenCV
I tried to integrate with Keras in TFv1.1
I tried to get CloudWatch data with Python
I tried to output LLVM IR with Python
I tried to detect an object with M2Det!
I tried to automate sushi making with python
I tried to predict Titanic survival with PyCaret
I tried to operate Linux with Discord Bot
I tried to study DP with Fibonacci sequence
I tried to start Jupyter with Amazon lightsail
I tried to judge Tsundere with Naive Bayes
[Introduction to PID] I tried to control and play ♬
Introduction to Lightning pytorch
I tried to debug.
I tried to paste
[Introduction to AWS] I tried porting the conversation app and playing with text2speech @ AWS ♪
I tried to implement Cifar10 with SONY Deep Learning library NNabla [Nippon Hurray]
I tried to compare the accuracy of Japanese BERT and Japanese Distil BERT sentence classification with PyTorch & Introduction of BERT accuracy improvement technique
I tried to learn the sin function with chainer
I tried to move machine learning (ObjectDetection) with TouchDesigner
I tried to create a table only with Django
I tried to extract features with SIFT of OpenCV
I tried to implement Minesweeper on terminal with python
I tried to get started with blender python script_Part 01
I tried to touch the CSV file with Python
I tried to draw a route map with Python
I tried to solve the soma cube with python
I tried to automatically read and save with VOICEROID2
I tried to get started with blender python script_Part 02
I tried to generate ObjectId (primary key) with pymongo
I tried to implement an artificial perceptron with python