Pytorch实现cifar10多分类

dataiter = iter(testloader)

for i, (images,lables) in enumerate(dataiter):

    imshow(torchvision.utils.make_grid(images))

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

 

images,labels = images.to(device), labels.to(device)

outputs = net(images)

__, predicted = torch.max(outputs,1)

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

 

correct = 0

total = 0

with torch.no_grad():

    for data in testloader:

        images, labels = data

        images, labels = images.to(device), labels.to(device)

        outputs = net(images)

        _, predicted = torch.max(outputs.data, 1)

        total += labels.size(0)

        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))

 

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

        images, labels = images.to(device), labels.to(device)

        outputs = net(images)

        _, predicted = torch.max(outputs, 1)

        c = (predicted == labels).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]))

import torch.nn as nn

import torch.nn.functional as F

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

class Net(nn.Module):

    def __init__(self):

        super(Net, self).__init__()

        self.conv1 = nn.Conv2d(3,16,5)

        self.pool1 = nn.MaxPool2d(2,2)

        self.conv2 = nn.Conv2d(16,36,5)

        self.pool2 = nn.MaxPool2d(2,2)

        self.aap = nn.AdaptiveAvgPool2d(1)

        self.fc3 = nn.Linear(36,10)

    def forward(self, x):

        x = self.pool1(F.relu(self.conv1(x)))

        x = self.pool2(F.relu(self.conv2(x)))

        x = x.app(x)

        x = x.view(x.shape[0], -1)

        x = self.fc3(x)

        return x

net = Net()

net = net.to(device)

 

print("net_gvp have {} paramerters in total".format(sum(x.numel() for x in net.parameters())))

 

import torch.optim as optim

LR = 0.001

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

for epoch in range(10):

    running_loss = 0.0

    for i, data in enumerate(trainloader, 0):

        # 获取训练数据

        inputs, labels = data

        inputs, labels = inputs.to(device), labels.to(device)

        # 权重参数梯度清零

        optimizer.zero_grad()

        # 正向及反向传播

        outputs = net(inputs)

        loss = criterion(outputs, labels)

        loss.backward()

        optimizer.step()

        # 显示损失值

        running_loss += loss.item()

        if i % 2000 == 1999:

            print('[%d, %5d] loss: %.3f' %(epoch + 1, i + 1, running_loss / 2000))

            running_loss = 0.0

print('Finished Training')

import collections

import torch

from tensorboard import summary

from torch import nn

 

 

def paras_summary(input_size,model):

    def register_hook(module):

        def hook(module, input, output):

            class_name = str(module.__class__).split('.')[-1].split("'")[0]

            module_idx = len(summary)

            m_key = '%s-%i' % (class_name, module_idx + 1)

            summary[m_key] = collections.OrderedDict()

            summary[m_key]['input_shape'] = list(input[0].size())

            summary[m_key]['input_shape'][0] = -1

            summary[m_key]['output_shape'] = list(output.size())

            summary[m_key]['output_shape'][0] = -1

            params = 0

            if hasattr(module, 'weight'):

                params += torch.prod(torch.LongTensor(list(module.weight.size())))

                if module.weight.requires_grad:

                    summary[m_key]['trainable'] = True

                else:

                    summary[m_key]['trainable'] = False

            if hasattr(module, 'bias'):

                params += torch.prod(torch.LongTensor(list(module.bias.size())))

            summary[m_key]['nb_params'] = params

        if not isinstance(module, nn.Sequential) and \

           not isinstance(module, nn.ModuleList) and \

           not (module == model):

            hooks.append(module.register_forward_hook(hook))

    if isinstance(input_size[0],(list,tuple)):

        x = [torch.rand(1,*in_size) for in_size in input_size]

    else:

        x = torch.rand(1,*input_size)

    summary = collections.OrderedDict()

    hooks = []

    model.apply(register_hook)

    model(x)

    for h in hooks:

        h.remove()

    return summary