Python实现cifar10多分类

from email import utils

 

import torch

import torchvision

import torchvision.transforms as transforms

 

transform = transforms.Compose(

    [transforms.ToTensor(),

     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset＝torchvision.datasets.CIFAR10(root='./data',train=True,

                                        download=True,transform=transform)

trainloader =torch.utils.data.DataLoader(trainset,batch_size=4,

                                         shuffle=True,num_workers=2)

 

testset =torchvision.datasets.CIFAR10(root='./data',train=False,

                                      download=True,transform=transform)

testloder=torch.utils.data.DataLoader(testset,batch_size=4,

                                      shuffle=False,num_workers=2)

 

classes = ('plane','car','bird','cat',

           'deer','dog','frog','horse','ship','truck')

 

print("===========================================================================")

import matplotlib.pyplot as plt

import numpy as np 

#显示图像

 

def imshow(img):

    img = img / 2 + 0.5 #unnormalize

    npimg = img.numpy()

    plt.imshow(np.transpose(npimg, (1, 2, 0)))

    plt.show()

 

 

#随机获取部分训练数据

dataiter=iter(trainloader)

#使用for循环来迭代数据

for images,labels in dataiter:

    imshow(torchvision,utils.make_grid(images))

 

 

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

构建网络

 print("========================================================================")

import torch.nn as nn

import torch.nn.functional as F

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

class NNNet(nn.Module):

    def __init__(self):

        super(NNNet, self).__init__()

        self.conv1=nn.Conv2d(in_channels=3,out_channels=16,kernel_size=5,stride=1)

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

      self.conv2=nn.Conv2d(in_channels=16,out_channels=32,kernel_size=3,stride=1)

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

        self.fc1=nn.Linear(1296,128)

        self.fc2=nn.Linear(128,10)

    def forward(self,x):

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

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

        x=x.view(-1,36*6*6)

        x=F.relu(self.fc2(F.relu(self.fc1(x))))

        return x

net=NNNet()

net=net.to(device)

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

print('=====================================================================')

import torch.optim as optim

LR=0.001

criterion=nn.CrossEntropyLoss()

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

print(net)

print("====================================================================")

nn.Sequential(*list(net.children())[:4])

 

训练模型

 

print("=========================================================================")

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')