黑马程序员人工智能NLP基础教程1——pytorch_黑马 nlp

pytorch构建分类器

import numpy as np
import matplotlib.pyplot as plt
import torch
import torchvision

#构建展示图像的函数
def imshow(img):
    img = img/2+0.5  #固定格式
    npimg = img.numpy()  #将图像tensor类型转换为numpy类型才能显示
    plt.imshow(np.transpose(npimg,(1,2,0)))
    plt.show()

#从数据地带其中读取一张图像
dataiter = iter(trainloader)
images,labels = dataiter.next()

# #展示图像
# imshow(torchvision.utils.make_grid(images))
# #打印标签
# 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__()
        #定义两个卷积层
        self.conv1 = nn.Conv2d(3,6,5)
        self.vonv2 = nn.Conv2d(6,16,5)
        #定义两个池化层
        self.pool = nn.MaxPool2d(2,2)
        #定义三个全连接层
        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 = 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()
#print(net)
#定义损失函数，选用交叉熵损失函数
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
#定义优化器，选用随机梯度下降优化器  momentum:动量
optimizer = optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

#编写训练代码
for epoch in range(2):
    running_loss = 0.0
    #按批次迭代训练模型
    for i,data enumerate(trainloder,0):
        #从data中取出含有输入图像的张量inputs，标签张量labels
        inputs,labels = data
        #第一步将梯度清零
        optimizer.zero_grad()
        #第二步将输入图像进入网络中，得到输出张量
        outputs = net(inputs)
        #计算损失值
        loss = criterion(outputs,labels)
        #进行反向传播和梯度更新
        loss.backward()
        optimizer.step()
        #打印训练的信息
        running_loss+=loss.item()
        if(i+1)%2000==0:
            print('[%d,%5d] loss:%.3f'%(epoch+1,i+1,running_loss/2000))
            running_loss=0.0

print('Finished Training.')


#设定模型的保存位置
PATH = '。/cifar_net.pth'
#保存模型的状态字典
torch.save(net.state_dict(),PATH)

#在测试集中取出一个批次的数据，做图像和标签的展示
dataiter = iter(testloader)
images,label = dataiter.next()
#打印原始图像
imshow(torchvision.utils.make_grid(images))
#打印真实的标签
print('GroundTruth:',''.join('%5s'% classes[labels[j]] for j in range(4)))

#加载模型参数，在测试阶段
net.load_state_dict(torch.load(PATH))
#利用模型对图像进行预测
outputs = net(images)
#模型有10个类别的输出，选区其中概率最大的那个类型为预测值
_,predicted = torch.max(outputs,1)
#打印预测标签
print('GroundTruth:',''.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
        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)
        _,predicted = torch.max(outputs,1)
        c = (predicted == labels).squeeze()  #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 the &5s :%2d %%' %(classes[i],100*class_correct[i]/class_total[i]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129