使用cnn,bpnn,lstm实现mnist数据集的分类

华夏仁家

1.cnn

1. import torch
2. import torch.nn as nn
3. import torch.nn.functional as F
4. import torch.optim as optim
5. from torchvision import datasets, transforms
7. # 设置随机数种子
8. torch.manual_seed(0)
10. # 超参数
11. EPOCH = 1  # 训练整批数据的次数
12. BATCH_SIZE = 50
13. DOWNLOAD_MNIST = False  # 表示还没有下载数据集，如果数据集下载好了就写False
15. # 加载 MNIST 数据集
16. train_dataset = datasets.MNIST(
17.     root="./mnist",
18.     train=True,#True表示是训练集
19.     transform=transforms.ToTensor(),
20.     download=False)
21. test_dataset = datasets.MNIST(
22.     root="./mnist",
23.     train=False,#Flase表示测试集
24.     transform=transforms.ToTensor(),
25.     download=False)
27. # 将数据集放入 DataLoader 中
28. train_loader = torch.utils.data.DataLoader(
29.     dataset=train_dataset,
30.     batch_size=100,#每个批次读取的数据样本数
31.     shuffle=True)#是否将数据打乱，在这种情况下为True，表示每次读取的数据是随机的
32. test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)
34. # 为了节约时间, 我们测试时只测试前2000个
35. test_x = torch.unsqueeze(test_dataset.test_data, dim=1).type(torch.FloatTensor)[
36.          :2000] / 255.  # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
37. test_y = test_dataset.test_labels[:2000]
39. # 定义卷积神经网络模型
40. class CNN(nn.Module):
41.     def __init__(self):
42.         super(CNN, self).__init__()
43.         self.conv1 = nn.Conv2d(#输入图像的大小为（28,28,1）
44.             in_channels=1,#当前输入特征图的个数
45.             out_channels=32,#输出特征图的个数
46.             kernel_size=3,#卷积核大小，在一个3*3空间里对当前输入的特征图像进行特征提取
47.             stride=1,#步长：卷积窗口每隔一个单位滑动一次
48.             padding=1)#如果希望卷积后大小跟原来一样，需要设置padding=(kernel_size-1)/2
49.         #第一层结束后图像大小为（28,28,32）32是输出图像个数，28计算方法为（h-k+2p)/s+1=(28-3+2*1)/1 +1=28
50.         self.pool = nn.MaxPool2d(kernel_size=2, stride=2)#可以缩小输入图像的尺寸，同时也可以防止过拟合
51.         #通过池化层之后图像大小变为（14,14,32）
52.         self.conv2 = nn.Conv2d(#输入图像大小为（14,14,32）
53.             in_channels=32,#第一层的输出特征图的个数当做第二层的输入特征图的个数
54.             out_channels=64,
55.             kernel_size=3,
56.             stride=1,
57.             padding=1)#二层卷积之后图像大小为（14,14,64)
59.         self.fc = nn.Linear(64 * 7 * 7, 10)#10表示最终输出的
61.     # 下面定义x的传播路线
62.     def forward(self, x):
63.         x = self.pool(F.relu(self.conv1(x)))# x先通过conv1
64.         x = self.pool(F.relu(self.conv2(x)))# 再通过conv2
65.         x = x.view(-1, 64 * 7 * 7)
66.         x = self.fc(x)
67.         return x
69. # 实例化卷积神经网络模型
70. model = CNN()
72. # 定义损失函数和优化器
73. criterion = nn.CrossEntropyLoss()
74. #lr（学习率）是控制每次更新的参数的大小的超参数
75. optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
77. # 训练模型
78. for epoch in range(1):
79.     for i, (images, labels) in enumerate(train_loader):
80.         outputs = model(images)  # 先将数据放到cnn中计算output
81.         loss = criterion(outputs, labels)# 输出和真实标签的loss，二者位置不可颠倒
82.         optimizer.zero_grad()# 清除之前学到的梯度的参数
83.         loss.backward()  # 反向传播，计算梯度
84.         optimizer.step()#应用梯度
85.         if i % 50 == 0:
86.             data_all = model(test_x)#不分开写就会出现ValueError: too many values to unpack (expected 2)
87.             last_layer = data_all
88.             test_output = data_all
89.             pred_y = torch.max(test_output, 1)[1].data.numpy()
90.             accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
91.             print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.4f' % accuracy)
93. # print 10 predictions from test data
94. data_all1 = model(test_x[:10])
95. test_output = data_all1
96. _ = data_all1
97. pred_y = torch.max(test_output, 1)[1].data.numpy()
98. print(pred_y, 'prediction number')
99. print(test_y[:10].numpy(), 'real number')

复制代码

2.bpnn

1. import torch
2. from torch.autograd import Variable
3. import torch.nn as nn
4. import torch.nn.functional as func
5. #import matplotlib.pyplot as plt
6. import torch.utils.data as Data
7. import torchvision
9. # 超参数
11. EPOCH = 2 # 训练一个回合
12. BATCH_SIZE = 50 # 每次取样50个进行训练
13. LR = 0.001 # 学习率0.01
14. # DOWNLOAD_MNIST = False
16. # 提取训练数据
17. # 将图像格式转为tensor格式
18. train_data = torchvision.datasets.MNIST(
19.     root='./mnist',
20.     train=True,
21.     transform=torchvision.transforms.ToTensor(),
22.     # download = DOWNLOAD_MNIST,
23. )
25. # 选取相应批次的图像
26. train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
28. # 加载测试图像
29. test_data = torchvision.datasets.MNIST(
30.     root='./mnist',
31.     train=False,
32.     transform=torchvision.transforms.ToTensor(),
33. )
35. test_loader = Data.DataLoader(dataset=test_data,batch_size=BATCH_SIZE)
38. class BPNN(nn.Module):
39.     def __init__(self):
40.         super(BPNN, self).__init__()
41.         # 创建容器
42.         # 按照sequential内模块的顺序执行
43.         self.conv1 = nn.Sequential(
44.             # 二维卷积
45.             nn.Linear(28,64),
46.             nn.ReLU(),
47.         )
48.         self.conv2 = nn.Sequential(
49.             nn.Linear(64,128),
50.             nn.ReLU(),
51.         )
52.         self.conv3 = nn.Sequential(
53.             nn.Linear(128, 32),
54.             nn.ReLU(),
55.         )
56.         # 全连接层
57.         self.out = nn.Linear(32 * 28, 10)
59.     def forward(self, x):
60.         x = self.conv1(x)
61.         x = self.conv2(x)
62.         x = self.conv3(x)
63.         x = x.view(x.size(0), -1)  # 相当于维度转换，这里保留0维（batch_size），将后面的三个维度展平
64.         output = self.out(x)
65.         return output
68. bpnn = BPNN()
70. # Adam优化器
71. optimizer = torch.optim.Adam(bpnn.parameters(), lr=LR)
72. # loss函数
73. loss_func = nn.CrossEntropyLoss()
74. # 迭代训练
75. for epoch in range(EPOCH):
76.     for step, (batch_x, batch_y) in enumerate(train_loader):
77.         # b_x = Variable(batch_x)
78.         # b_y = Variable(batch_y)
80.         out = bpnn(batch_x)
81.         loss = loss_func(out, batch_y)
82.         optimizer.zero_grad()  # 梯度降为0
83.         loss.backward()  # 误差反向传递
84.         optimizer.step()  # 以学习效率优化梯度
86. equal = 0
87. i = 0
88. for step,(test_x,test_y) in enumerate(test_loader):
89.     if step % 10 == 0:
90.         i += 1
91.         test_output = bpnn(test_x)
92.         pred_y = torch.max(test_output, 1)[1].data.squeeze()
93.         acc = (pred_y == test_y).sum().float() / test_y.size(0)
94.         print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy())
95.         equal += acc.numpy()
96. print(equal/i)
98. test_output = bpnn(test_x[:10])
99. pred_y = torch.max(test_output, 1)[1].data.squeeze()
100. print(pred_y, 'prediction number')
101. print(test_y[:10].numpy(), 'real number')

复制代码

3.lstm

1. import torch
2. from torch import nn
3. import torchvision.datasets as dsets
4. import torchvision.transforms as transforms
5. import matplotlib.pyplot as plt
6. import numpy as np
8. torch.manual_seed(1)  # reproducible
10. # Hyper Parameters
11. EPOCH = 1  # 训练整批数据多少次, 为了节约时间, 我们只训练一次
12. BATCH_SIZE = 64
13. TIME_STEP = 28  # rnn 时间步数 / 图片高度
14. INPUT_SIZE = 28  # rnn 每步输入值 / 图片每行像素
15. LR = 0.01  # learning rate
16. DOWNLOAD_MNIST = False  # 如果你已经下载好了mnist数据就写上 Fasle
18. # Mnist 手写数字
19. train_data = dsets.MNIST(
20.     root='./mnist/',  # 保存或者提取位置
21.     train=True,  # this is training data
22.     transform=transforms.ToTensor(),  # 转换 PIL.Image or numpy.ndarray 成
23.     # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
24.     download=DOWNLOAD_MNIST,  # 没下载就下载, 下载了就不用再下了
25. )
27. test_data = dsets.MNIST(root='./mnist/', train=False)
29. # 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
30. train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
32. # 为了节约时间, 我们测试时只测试前2000个
33. test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[
34.          :2000] / 255.  # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
35. test_y = test_data.test_labels[:2000]
38. class RNN(nn.Module):
39.     def __init__(self):
40.         super(RNN, self).__init__()
42.         self.rnn = nn.LSTM(  # LSTM 效果要比 nn.RNN() 好多了
43.             input_size=28,  # 图片每行的数据像素点
44.             hidden_size=64,  # rnn hidden unit
45.             num_layers=1,  # 有几层 RNN layers
46.             batch_first=True,  # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
47.         )
49.         self.out = nn.Linear(64, 10)  # 输出层，接入线性层
51.     def forward(self, x):  # 必须有这个方法
52.         # x shape (batch, time_step, input_size)
53.         # r_out shape (batch, time_step, output_size)
54.         # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
55.         # h_c shape (n_layers, batch, hidden_size)
56.         r_out, (h_n, h_c) = self.rnn(x, None)  # None 表示 hidden state 会用全0的 state
57.         # 当RNN运行结束时刻，(h_n, h_c)表示最后的一组hidden states，这里用不到
59.         # 选取最后一个时间点的 r_out 输出
60.         # 这里 r_out[:, -1, :] 的值也是 h_n 的值
61.         out = self.out(r_out[:, -1, :])  # (batch_size, time step, input)，这里time step选择最后一个时刻
62.         # output_np = out.detach().numpy()  # 可以使用numpy的sciview监视每次结果
63.         return out
66. rnn = RNN()
67. print(rnn)
69. optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)  # optimize all parameters
70. loss_func = nn.CrossEntropyLoss()  # the target label is not one-hotted
72. # training and testing
73. for epoch in range(EPOCH):
74.     for step, (x, b_y) in enumerate(train_loader):  # gives batch data
75.         b_x = x.view(-1, 28, 28)  # reshape x to (batch, time_step, input_size)
77.         output = rnn(b_x)  # rnn output
78.         loss = loss_func(output, b_y)  # cross entropy loss
79.         optimizer.zero_grad()  # clear gradients for this training step
80.         loss.backward()  # backpropagation, compute gradients
81.         optimizer.step()  # apply gradients
83.         # output_np = output.detach().numpy()
85.         if step % 50 == 0:
86.             test_x = test_x.view(-1, 28, 28)
87.             test_output = rnn(test_x)
88.             pred_y = torch.max(test_output, 1)[1].data.squeeze()
89.             acc = (pred_y == test_y).sum().float() / test_y.size(0)
90.             print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy())
92. test_output = rnn(test_x[:10].view(-1, 28, 28))
93. pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
94. print(pred_y, 'prediction number')
95. print(test_y[:10], 'real number')

复制代码

来源:https://www.cnblogs.com/twq46/p/17115263.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！