脚本之家,脚本语言编程技术及教程分享平台!
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - PyTorch: Softmax多分类实战操作

PyTorch: Softmax多分类实战操作

2020-07-08 11:13AI小白入门 Python

这篇文章主要介绍了PyTorch: Softmax多分类实战操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧

多分类一种比较常用的做法是在最后一层加softmax归一化,值最大的维度所对应的位置则作为该样本对应的类。本文采用PyTorch框架,选用经典图像数据集mnist学习一波多分类。

MNIST数据集

MNIST 数据集(手写数字数据集)来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据。MNIST数据集下载地址:http://yann.lecun.com/exdb/mnist/。手写数字的MNIST数据库包括60,000个的训练集样本,以及10,000个测试集样本。

PyTorch: Softmax多分类实战操作

其中:

train-images-idx3-ubyte.gz (训练数据集图片)

train-labels-idx1-ubyte.gz (训练数据集标记类别)

t10k-images-idx3-ubyte.gz: (测试数据集)

t10k-labels-idx1-ubyte.gz(测试数据集标记类别)

PyTorch: Softmax多分类实战操作

MNIST数据集是经典图像数据集,包括10个类别(0到9)。每一张图片拉成向量表示,如下图784维向量作为第一层输入特征。

PyTorch: Softmax多分类实战操作

Softmax分类

softmax函数的本质就是将一个K 维的任意实数向量压缩(映射)成另一个K维的实数向量,其中向量中的每个元素取值都介于(0,1)之间,并且压缩后的K个值相加等于1(变成了概率分布)。在选用Softmax做多分类时,可以根据值的大小来进行多分类的任务,如取权重最大的一维。softmax介绍和公式网上很多,这里不介绍了。下面使用Pytorch定义一个多层网络(4个隐藏层,最后一层softmax概率归一化),输出层为10正好对应10类。

PyTorch: Softmax多分类实战操作

PyTorch实战

?
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
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable
 
# Training settings
batch_size = 64
 
# MNIST Dataset
train_dataset = datasets.MNIST(root='./mnist_data/',
                train=True,
                transform=transforms.ToTensor(),
                download=True)
 
test_dataset = datasets.MNIST(root='./mnist_data/',
               train=False,
               transform=transforms.ToTensor())
 
# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                      batch_size=batch_size,
                      shuffle=True)
 
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                     batch_size=batch_size,
                     shuffle=False)
class Net(nn.Module):
  def __init__(self):
    super(Net, self).__init__()
    self.l1 = nn.Linear(784, 520)
    self.l2 = nn.Linear(520, 320)
    self.l3 = nn.Linear(320, 240)
    self.l4 = nn.Linear(240, 120)
    self.l5 = nn.Linear(120, 10)
 
  def forward(self, x):
    # Flatten the data (n, 1, 28, 28) --> (n, 784)
    x = x.view(-1, 784)
    x = F.relu(self.l1(x))
    x = F.relu(self.l2(x))
    x = F.relu(self.l3(x))
    x = F.relu(self.l4(x))
    return F.log_softmax(self.l5(x), dim=1)
    #return self.l5(x)
model = Net()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
def train(epoch):
 
  # 每次输入barch_idx个数据
  for batch_idx, (data, target) in enumerate(train_loader):
    data, target = Variable(data), Variable(target)
 
    optimizer.zero_grad()
    output = model(data)
    # loss
    loss = F.nll_loss(output, target)
    loss.backward()
    # update
    optimizer.step()
    if batch_idx % 200 == 0:
      print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
        epoch, batch_idx * len(data), len(train_loader.dataset),
        100. * batch_idx / len(train_loader), loss.data[0]))
def test():
  test_loss = 0
  correct = 0
  # 测试集
  for data, target in test_loader:
    data, target = Variable(data, volatile=True), Variable(target)
    output = model(data)
    # sum up batch loss
    test_loss += F.nll_loss(output, target).data[0]
    # get the index of the max
    pred = output.data.max(1, keepdim=True)[1]
    correct += pred.eq(target.data.view_as(pred)).cpu().sum()
 
  test_loss /= len(test_loader.dataset)
  print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, len(test_loader.dataset),
    100. * correct / len(test_loader.dataset)))
 
for epoch in range(1,6):
  train(epoch)
  test()
 
输出结果:
Train Epoch: 1 [0/60000 (0%)]   Loss: 2.292192
Train Epoch: 1 [12800/60000 (21%)]  Loss: 2.289466
Train Epoch: 1 [25600/60000 (43%)]  Loss: 2.294221
Train Epoch: 1 [38400/60000 (64%)]  Loss: 2.169656
Train Epoch: 1 [51200/60000 (85%)]  Loss: 1.561276
 
Test set: Average loss: 0.0163, Accuracy: 6698/10000 (67%)
 
Train Epoch: 2 [0/60000 (0%)]   Loss: 0.993218
Train Epoch: 2 [12800/60000 (21%)]  Loss: 0.859608
Train Epoch: 2 [25600/60000 (43%)]  Loss: 0.499748
Train Epoch: 2 [38400/60000 (64%)]  Loss: 0.422055
Train Epoch: 2 [51200/60000 (85%)]  Loss: 0.413933
 
Test set: Average loss: 0.0065, Accuracy: 8797/10000 (88%)
 
Train Epoch: 3 [0/60000 (0%)]   Loss: 0.465154
Train Epoch: 3 [12800/60000 (21%)]  Loss: 0.321842
Train Epoch: 3 [25600/60000 (43%)]  Loss: 0.187147
Train Epoch: 3 [38400/60000 (64%)]  Loss: 0.469552
Train Epoch: 3 [51200/60000 (85%)]  Loss: 0.270332
 
Test set: Average loss: 0.0045, Accuracy: 9137/10000 (91%)
 
Train Epoch: 4 [0/60000 (0%)]   Loss: 0.197497
Train Epoch: 4 [12800/60000 (21%)]  Loss: 0.234830
Train Epoch: 4 [25600/60000 (43%)]  Loss: 0.260302
Train Epoch: 4 [38400/60000 (64%)]  Loss: 0.219375
Train Epoch: 4 [51200/60000 (85%)]  Loss: 0.292754
 
Test set: Average loss: 0.0037, Accuracy: 9277/10000 (93%)
 
Train Epoch: 5 [0/60000 (0%)]   Loss: 0.183354
Train Epoch: 5 [12800/60000 (21%)]  Loss: 0.207930
Train Epoch: 5 [25600/60000 (43%)]  Loss: 0.138435
Train Epoch: 5 [38400/60000 (64%)]  Loss: 0.120214
Train Epoch: 5 [51200/60000 (85%)]  Loss: 0.266199
 
Test set: Average loss: 0.0026, Accuracy: 9506/10000 (95%)
Process finished with exit code 0

随着训练迭代次数的增加,测试集的精确度还是有很大提高的。并且当迭代次数为5时,使用这种简单的网络可以达到95%的精确度。

以上这篇PyTorch: Softmax多分类实战操作就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。

原文链接:https://blog.csdn.net/m0_37306360/article/details/79309849

延伸 · 阅读

精彩推荐