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

1.cnn#

Copy

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

2.bpnn#

Copy

import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision import datasets, transforms import torchvision DOWNLOAD_MNIST = False # 表示还没有下载数据集，如果数据集下载好了就写False BATCH_SIZE = 50 LR = 0.01 # 学习率 # 下载mnist手写数据集 train_loader = torchvision.datasets.MNIST( root='./mnist/', # 保存或提取的位置 会放在当前文件夹中 train=True, # true说明是用于训练的数据，false说明是用于测试的数据 transform=torchvision.transforms.ToTensor(), # 转换PIL.Image or numpy.ndarray download=DOWNLOAD_MNIST, # 已经下载了就不需要下载了 ) test_loader = torchvision.datasets.MNIST( root='./mnist/', train=False # 表明是测试集 ) train_data = torch.utils.data.DataLoader(dataset=train_loader, batch_size=BATCH_SIZE, shuffle=True) # 为了节约时间, 我们测试时只测试前2000个 test_x = torch.unsqueeze(test_loader.test_data, dim=1).type(torch.FloatTensor)[ :2000] / 255. # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1) test_y = test_loader.test_labels[:2000] # 定义模型 class BPNN(nn.Module): def __init__(self): super(BPNN, self).__init__() self.fc1 = nn.Linear(28 * 28, 512)#定义了一个全连接层fc1，该层的输入是28 * 28个数字，输出是512个数字 self.fc2 = nn.Linear(512, 512) self.fc3 = nn.Linear(512, 10) def forward(self, x):#x是输入的图像 x = x.view(-1, 28 * 28)#将输入x的形状转换为二维，分别是batch_size和28 * 28 x = F.relu(self.fc1(x))#将x通过第1个全连接层fc1进行计算，并将结果通过ReLU激活函数处理 x = F.relu(self.fc2(x)) x = self.fc3(x) #Softmax函数是一种分类模型中常用的激活函数，它能将输入数据映射到(0,1)范围内，并且满足所有元素的和为1 return F.log_softmax(x, dim=1)#dim=1表示对每一行的数据进行运算 # 初始化模型 bpnn = BPNN() print(bpnn) # 定义损失函数和优化器 optimizer = torch.optim.Adam(bpnn.parameters(), lr=LR) # optimize all parameters loss_func = nn.CrossEntropyLoss() # the target label is not one-hotted # # criterion = nn.NLLLoss() # optimizer = optim.SGD(bpnn.parameters(), lr=0.01, momentum=0.5) # 训练模型 for epoch in range(1): for step, (b_x,b_y) in enumerate(train_data): b_x = b_x.view(-1, 28, 28) # reshape x to (batch, time_step, input_size) output = bpnn(b_x) loss = loss_func(output, b_y) optimizer.zero_grad() loss.backward() optimizer.step() if step % 50 == 0: test_x = test_x.view(-1, 28, 28) test_output = bpnn(test_x) pred_y = torch.max(test_output, 1)[1].data.squeeze() acc = (pred_y == test_y).sum().float() / test_y.size(0) print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy()) test_output = bpnn(test_x[:10].view(-1, 28, 28)) pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze() print(pred_y, 'prediction number') print(test_y[:10], 'real number') # # 评估模型 # bpnn.eval() # correct = 0 # with torch.no_grad(): # for data, target in test_loader: # output = bpnn(data) # pred = output.argmax(dim=1, keepdim=True) # correct += pred.eq(target.view_as(pred)).sum().item() # # print('Test accuracy:', correct / len(test_loader.dataset))

3.lstm#

Copy

import torch from torch import nn import torchvision.datasets as dsets import torchvision.transforms as transforms import matplotlib.pyplot as plt import numpy as np torch.manual_seed(1) # reproducible # Hyper Parameters EPOCH = 1 # 训练整批数据多少次, 为了节约时间, 我们只训练一次 BATCH_SIZE = 64 TIME_STEP = 28 # rnn 时间步数 / 图片高度 INPUT_SIZE = 28 # rnn 每步输入值 / 图片每行像素 LR = 0.01 # learning rate DOWNLOAD_MNIST = False # 如果你已经下载好了mnist数据就写上 Fasle # Mnist 手写数字 train_data = dsets.MNIST( root='./mnist/', # 保存或者提取位置 train=True, # this is training data transform=transforms.ToTensor(), # 转换 PIL.Image or numpy.ndarray 成 # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间 download=DOWNLOAD_MNIST, # 没下载就下载, 下载了就不用再下了 ) test_data = dsets.MNIST(root='./mnist/', train=False) # 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28) train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True) # 为了节约时间, 我们测试时只测试前2000个 test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[ :2000] / 255. # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1) test_y = test_data.test_labels[:2000] #LSTM默认input(seq_len,batch,feature) class Lstm(nn.Module): def __init__(self): super(Lstm, self).__init__() self.Lstm = nn.LSTM( # LSTM 效果要比 nn.RNN() 好多了 input_size=28, # 图片每行的数据像素点,输入特征的大小 hidden_size=64, # lstm模块的数量相当于bp网络影藏层神经元的个数 num_layers=1, # 隐藏层的层数 batch_first=True, # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size) ) self.out = nn.Linear(64, 10) # 输出层，接入线性层 def forward(self, x): # 必须有这个方法 # x shape (batch, time_step, input_size) # r_out shape (batch, time_step, output_size)包含每个序列的输出结果 # h_n shape (n_layers, batch, hidden_size)只包含最后一个序列的输出结果，LSTM 有两个 hidden states, h_n 是分线, h_c 是主线 # h_c shape (n_layers, batch, hidden_size)只包含最后一个序列的输出结果 r_out, (h_n, h_c) = self.Lstm(x, None) # None 表示 hidden state 会用全0的 state # 当RNN运行结束时刻，(h_n, h_c)表示最后的一组hidden states，这里用不到 # 选取最后一个时间点的 r_out 输出 # 这里 r_out[:, -1, :] 的值也是 h_n 的值 out = self.out(r_out[:, -1, :]) # (batch_size, time step, input)，这里time step选择最后一个时刻 # output_np = out.detach().numpy() # 可以使用numpy的sciview监视每次结果 return out Lstm = Lstm() print(Lstm) optimizer = torch.optim.Adam(Lstm.parameters(), lr=LR) # optimize all parameters loss_func = nn.CrossEntropyLoss() # the target label is not one-hotted # training and testing for epoch in range(EPOCH): for step, (x, b_y) in enumerate(train_loader): # gives batch data b_x = x.view(-1, 28, 28) # reshape x to (batch, time_step, input_size) output = Lstm(b_x) # rnn output loss = loss_func(output, b_y) # cross entropy loss optimizer.zero_grad() # clear gradients for this training step loss.backward() # backpropagation, compute gradients optimizer.step() # apply gradients # output_np = output.detach().numpy() if step % 50 == 0: test_x = test_x.view(-1, 28, 28) test_output = Lstm(test_x) pred_y = torch.max(test_output, 1)[1].data.squeeze() acc = (pred_y == test_y).sum().float() / test_y.size(0) print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy()) test_output = Lstm(test_x[:10].view(-1, 28, 28)) pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze() print(pred_y, 'prediction number') print(test_y[:10], 'real number')