Python Pytorch深度学习之图像分类器

# 使用torchvision，加载并归一化CIFAR10
import torch
import torchvision
import torchvision.transforms as transforms

# torchvision数据集的输出是范围在[0,1]之间的PILImage,将他们转换成归一化范围为[-1,1]之间的张量Tensor
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=False,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=False,transform=transform)
testloader=torch.utils.data.DataLoader(testset,batch_size=4,shuffle=False,num_workers=2)
classes=("plane","car","bird","cat","deer","dog","frog","horse","ship","truck")

# 展示其中的训练照片
import matplotlib.pyplot as plt
import numpy as np
# 定义图片显示的function
def imshow(img):
    img=img/2+0.5
    npimg=img.numpy()
    plt.imshow(np.transpose(npimg,(1,2,0)))
    plt.show()
# 得到随机训练图像
dataiter=iter(trainloader)
images,labels=dataiter.next()
# 展示图片
imshow(torchvision.utils.make_grid(images))
#打印标签labels
print(' '.join("%5s"%classes[labels[j]] for j in range(4)))

#%%
# 定义卷积神经网络
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        # 1个输入，6个输出，5*5的卷积
        # 内核
        self.conv1=nn.Conv2d(3,6,5)#定义三个通道
        self.pool=nn.MaxPool2d(2,2)
        self.conv2=nn.Conv2d(6,16,5)
        # 映射函数：线性——y=Wx+b
        self.fc1=nn.Linear(16*5*5,120)#输入特征值：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
net=Net()

#%%
# 定义一个损失函数和优化器
import torch.optim as optim
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(), lr=0.001,momentum=0.9)

#%%训练网络
for epoch in range(2):
    running_loss=0.0
    for i,data in enumerate(trainloader,0):
        #得到输入
        inputs,labels=data
        # 将参数的梯度值置零
        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))#每2000个输出一次
print('Finished Training')

#%%
#在测试集上显示
outputs=net(images)
# 输出是预测与十个类的相似程度，与某一个类的近似程度越高，网络就越认为图像是属于这一类别
# 打印其中最相似类别类标
_, predictd=torch.max(outputs,1)
print('Predicted:',' '.join('%5s'% classes[predictd[j]]
                            for j in range(4)))

#%% 结果看起来还好55%，看看网络在整个数据集的表现
correct=0
total=0
with torch.no_grad():
    for data in testloader:
        images,labels=data
        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
        outputs=net(images)
        _, predictd=torch.max(outputs,1)
        c=(predictd==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]))