1.cnn
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
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
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')
本文主要讲述使用cnn,bpnn以及lstm去实现mnist数据集的分类
