pytorch+LSTM分类MINIST数据集
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as dsets
from torch.autograd import Variable
from torch.nn import Parameter
from torch import Tensor
import torch.nn.functional as F
import math
cuda = True # 用cuda计算
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
# 如果启用cuda运算，Tensor就用cuda.FloatTensor否则就用torch.FloatTensor
torch.manual_seed(123) # 设置一个随机数的种子，torch.rand(1)可以生成[0,1)之间的随机数
print(torch.cuda.is_available())
if torch.cuda.is_available():
torch.cuda.manual_seed_all(123) # 在所有GPU上设置随机数
"""
加载MNIST数据集
"""
train_data = dsets.MNIST(
root=r'D:\python\minist', # 存储路径
train=True,
transform=transforms.ToTensor(), # 把下载的数据改成Tensor形式
# 把(0-255)转换成(0-1)
download=False # 如果没下载就确认下载
)
test_data = dsets.MNIST(
root=r'D:\python\minist', # 存储路径
train=False,
transform=transforms.ToTensor(), # 把下载的数据改成Tensor形式
# 把(0-255)转换成(0-1)
download=False # 如果没下载就确认下载
)
print(train_data)
print(test_data)
"""
超参数的设定
"""
batch_size = 100 # 一批数据100个
num_epochs = 100 # 对全部数据训练的次数
"""
把数据做成迭代器,批处理数据
"""
train_loader = torch.utils.data.DataLoader(dataset=train_data,batch_size=batch_size,shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_data,batch_size=batch_size,shuffle=True)
"""
一个LSTM单元
"""
class LSTMCell(nn.Module):
def __init__(self,input_size,hidden_size):
super(LSTMCell,self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.x2h = nn.Linear(input_size,4*hidden_size,bias=True) # 28,4*128 这是对输入x进行运算的参数矩阵
# 4表示4个不同的w，U，遗忘门输出门各一个，输入门有两个
self.h2h = nn.Linear(hidden_size,4*hidden_size,bias=True) # 128,4*128 这是对h进行运算的参数矩阵
def forward(self, x,hx,cx):
# x:100,28
# hx:100,128
# cx:100,128
# x,hx,cx分别为 这一时刻的数据，上一时刻的隐状态，细胞状态
gates = self.x2h(x)+self.h2h(hx)
# 得到三个门的状态和细胞状态
# 切分成四个部分
ingate,forgetgate,cellgate,outgate = gates.chunk(4,1)
ingate = F.sigmoid(ingate) # 输入们用sigmoid对输入进行运算
forgetgate = F.sigmoid(forgetgate) # 遗忘门作sigmoid运算
outgate = F.sigmoid(outgate) # 输出门做sigmoid运算
cellgate = F.tanh(cellgate) # 细胞状态做一个tanh的运算
# 输出这一时刻的隐状态和细胞状态
cy = torch.mul(cx,forgetgate)+torch.mul(ingate,cellgate)
hy = torch.mul(outgate,F.tanh(cy))
return hy,cy
chunk的作用是对tensor进行分块处理
假设有这样一个tensor类型的数
data = torch.from_numpy(np.random.rand(3, 5))
print(str(data))
>>
tensor([[0.6742, 0.5700, 0.3519, 0.4603, 0.9590],
[0.9705, 0.8673, 0.8854, 0.9029, 0.5473],
[0.0199, 0.4729, 0.4001, 0.7581, 0.5045]], dtype=torch.float64)
横向分块
for i, data_i in enumerate(data.chunk(5, 1)): # 沿1轴分为5块
print(str(data_i))
>>
tensor([[0.6742],
[0.9705],
[0.0199]], dtype=torch.float64)
tensor([[0.5700],
[0.8673],
[0.4729]], dtype=torch.float64)
tensor([[0.3519],
[0.8854],
[0.4001]], dtype=torch.float64)
tensor([[0.4603],
[0.9029],
[0.7581]], dtype=torch.float64)
tensor([[0.9590],
[0.5473],
[0.5045]], dtype=torch.float64)
纵向分块
for i, data_i in enumerate(data.chunk(3, 0)): # 沿0轴分为3块
print(str(data_i))
>>
tensor([[0.6742, 0.5700, 0.3519, 0.4603, 0.9590]], dtype=torch.float64)
tensor([[0.9705, 0.8673, 0.8854, 0.9029, 0.5473]], dtype=torch.float64)
tensor([[0.0199, 0.4729, 0.4001, 0.7581, 0.5045]], dtype=torch.float64)
除不尽的情况
for i, data_i in enumerate(data.chunk(3, 1)): # 沿1轴分为3块，除不尽
print(str(data_i))
>>
tensor([[0.6742, 0.5700],
[0.9705, 0.8673],
[0.0199, 0.4729]], dtype=torch.float64)
tensor([[0.3519, 0.4603],
[0.8854, 0.9029],
[0.4001, 0.7581]], dtype=torch.float64)
tensor([[0.9590],
[0.5473],
[0.5045]], dtype=torch.float64)
"""
对定义好的单元进行循环
"""
class LSTMModel(nn.Module):
def __init__(self,input_dim,hidden_dim,output_dim):
super(LSTMModel,self).__init__()
self.hidden_dim = hidden_dim
self.lstm = LSTMCell(input_dim,hidden_dim)
self.fc = nn.Linear(hidden_dim,output_dim)# 手写数字识别是一个分类任务，需要连接一个分类的全连接层
def forward(self,x):
# 初始化hidden state
if torch.cuda.is_available(): # 如果cuda可用初始化之后需要加载到GPU里面去
h0 = Variable(torch.zeros(x.size(0), self.hidden_dim).cuda())
else:
h0 = Variable(torch.zeros(x.size(0),self.hidden_dim))
# 初始化cell state
if torch.cuda.is_available():
c0 = Variable(torch.zeros(x.size(0),self.hidden_dim).cuda())
else:
c0 = Variable(torch.zeros(x.size(0),self.hidden_dim))
outs = []
cn = c0 # 100,128
hn = h0 # 100,128
#X:100, 28, 28
for seq in range(x.size(1)): # 对序列长度进行遍历，每次循环一次lstm单元
hn,cn = self.lstm(x[:,seq,:],hn,cn)
outs.append(hn)
# 取最后的输出
out = outs[-1].squeeze()
# 经过全连接层
out = self.fc(out)
return out
"""
初始化模型
"""
# 每张图片按照28*28的序列数据输入
seq_dim = 28
input_dim = 28
hidden_dim = 128
output_dim = 10
model = LSTMModel(input_dim, hidden_dim, output_dim)
if torch.cuda.is_available():
model.cuda()
# 损失器
criterion = nn.CrossEntropyLoss()
# 优化器
learning_rate = 0.3
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)
"""
模型训练部分
"""
loss_list = []
iter = 0
for epoch in range(num_epochs):
for i, (images,labels) in enumerate(train_loader):
#批次化提取数据
if torch.cuda.is_available():
images = Variable(images.view(-1,seq_dim,input_dim).cuda())
labels = Variable(labels.cuda())
else:
images = Variable(images.view(-1,seq_dim,input_dim))
labels = Variable(labels)
# 清空梯度
optimizer.zero_grad()
# 计算损失
outputs = model(images)
loss = criterion(outputs, labels)
if torch.cuda.is_available():
loss.cuda()
# 梯度反向传播
loss.backward()
# 梯度更新
optimizer.step()
# 记录每一步的损失
loss_list.append(loss.item())
iter += 1
# 每轮有60000张图片，每次训练100张，就是需要600个iter
# 那100轮就是60000个iter，每500个iter打印一次，打印120次结果
# 每500次打印一次loss
if iter %500 == 0:
# 计算准确率
correct = 0
total = 0
for images,labels in test_loader:
if torch.cuda.is_available():
images = Variable(images.view(-1,seq_dim,input_dim).cuda())
else:
images = Variable(images.view(-1,seq_dim,input_dim))
with torch.no_grad():
outputs = model(images)
# 取最大值所在下标为预测标签
_,predicted = torch.max(outputs.data,1)
total += labels.size(0)
if torch.cuda.is_available():
correct += ((predicted == labels.cuda()).sum())
else:
correct += ((predicted == labels).sum())
accuracy = 100*correct/total
print("Iteration:{}. Loss: {}. Accuracy: {}%".format(iter,loss.item(),accuracy))
画图
import matplotlib.pyplot as plt
plt.xlabel("Iteration")
plt.ylabel("Loss (Crossentropy)")
plt.title("MNIST Learning curve for LSTM")
plt.plot(loss_list,label="LSTM")
plt.legend()
测试数据的最后一个batch的分类结果，非常正确！
完整
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as dsets
from torch.autograd import Variable
from torch.nn import Parameter
from torch import Tensor
import torch.nn.functional as F
import math
cuda = True # 用cuda计算
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
# 如果启用cuda运算，Tensor就用cuda.FloatTensor否则就用torch.FloatTensor
torch.manual_seed(123) # 设置一个随机数的种子，torch.rand(1)可以生成[0,1)之间的随机数
print(torch.cuda.is_available())
if torch.cuda.is_available():
torch.cuda.manual_seed_all(123) # 在所有GPU上设置随机数
"""
加载MNIST数据集
"""
train_data = dsets.MNIST(
root=r'D:\python\minist', # 存储路径
train=True,
transform=transforms.ToTensor(), # 把下载的数据改成Tensor形式
# 把(0-255)转换成(0-1)
download=False # 如果没下载就确认下载
)
test_data = dsets.MNIST(
root=r'D:\python\minist', # 存储路径
train=False,
transform=transforms.ToTensor(), # 把下载的数据改成Tensor形式
# 把(0-255)转换成(0-1)
download=False # 如果没下载就确认下载
)
print(train_data)
print(test_data)
"""
超参数的设定
"""
batch_size = 100 # 一批数据100个
num_epochs = 100 # 对全部数据训练的次数
"""
把数据做成迭代器,批处理数据
"""
train_loader = torch.utils.data.DataLoader(dataset=train_data,batch_size=batch_size,shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_data,batch_size=batch_size,shuffle=True)
"""
一个LSTM单元里面的运算
"""
class LSTMCell(nn.Module):
def __init__(self,input_size,hidden_size):
super(LSTMCell,self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.x2h = nn.Linear(input_size,4*hidden_size,bias=True) # 28,4*128 这是对输入x进行运算的参数矩阵
# 4表示4个不同的w，U，遗忘门输出门各一个，输入门有两个
self.h2h = nn.Linear(hidden_size,4*hidden_size,bias=True) # 128,4*128 这是对h进行运算的参数矩阵
def forward(self, x,hx,cx):
# x:100,28
# hx:100,128
# cx:100,128
# x,hx,cx分别为 这一时刻的输入数据，上一时刻的隐状态，细胞状态
gates = self.x2h(x)+self.h2h(hx)
# 得到三个门的状态和细胞状态
# 切分成四个部分
ingate,forgetgate,cellgate,outgate = gates.chunk(4,1)
ingate = F.sigmoid(ingate) # 输入们用sigmoid对输入进行运算
forgetgate = F.sigmoid(forgetgate) # 遗忘门作sigmoid运算
outgate = F.sigmoid(outgate) # 输出门做sigmoid运算
cellgate = F.tanh(cellgate) # 细胞状态做一个tanh的运算
# 输出这一时刻的隐状态和细胞状态
cy = torch.mul(cx,forgetgate)+torch.mul(ingate,cellgate)
hy = torch.mul(outgate,F.tanh(cy))
return cy,hy
"""
对定义好的单元进行循环
"""
class LSTMModel(nn.Module):
def __init__(self,input_dim,hidden_dim,output_dim):
super(LSTMModel,self).__init__()
self.hidden_dim = hidden_dim
self.lstm = LSTMCell(input_dim,hidden_dim)
self.fc = nn.Linear(hidden_dim,output_dim)# 手写数字识别是一个分类任务，需要连接一个分类的全连接层
def forward(self,x):
# 初始化hidden state
if torch.cuda.is_available(): # 如果cuda可用初始化之后需要加载到GPU里面去
h0 = Variable(torch.zeros(x.size(0), self.hidden_dim).cuda())
else:
h0 = Variable(torch.zeros(x.size(0),self.hidden_dim))
# 初始化cell state
if torch.cuda.is_available():
c0 = Variable(torch.zeros(x.size(0),self.hidden_dim).cuda())
else:
c0 = Variable(torch.zeros(x.size(0),self.hidden_dim))
outs = []
cn = c0 # 100,128
hn = h0 # 100,128
#X:100, 28, 28
for seq in range(x.size(1)): # 对序列长度进行遍历，每次循环一次lstm单元
hn,cn = self.lstm(x[:,seq,:],hn,cn)
outs.append(hn)
# 取最后的输出
out = outs[-1].squeeze()
# 经过全连接层
out = self.fc(out)
return out
"""
初始化模型
"""
# 每张图片按照28*28的序列数据输入
seq_dim = 28
input_dim = 28
hidden_dim = 128
output_dim = 10
model = LSTMModel(input_dim, hidden_dim, output_dim)
if torch.cuda.is_available():
model.cuda()
# 损失器
criterion = nn.CrossEntropyLoss()
# 优化器
learning_rate = 0.3
optimizer = torch.optim.SGD(model.parameters(),lr=learning_rate)
"""
模型训练部分
"""
loss_list = []
iter = 0
for epoch in range(num_epochs):
for i, (images,labels) in enumerate(train_loader):
#批次化提取数据
if torch.cuda.is_available():
images = Variable(images.view(-1,seq_dim,input_dim).cuda())
labels = Variable(labels.cuda())
else:
images = Variable(images.view(-1,seq_dim,input_dim))
labels = Variable(labels)
# 清空梯度
optimizer.zero_grad()
# 计算损失
outputs = model(images)
loss = criterion(outputs, labels)
if torch.cuda.is_available():
loss.cuda()
# 梯度反向传播
loss.backward()
# 梯度更新
optimizer.step()
# 记录每一步的损失
loss_list.append(loss.item())
iter += 1
# 每轮有60000张图片，每次训练100张，就是需要600个iter
# 那100轮就是60000个iter，每500个iter打印一次，打印120次结果
# 每500次打印一次loss
if iter %500 == 0:
# 计算准确率
correct = 0
total = 0
for images,labels in test_loader:
if torch.cuda.is_available():
images = Variable(images.view(-1,seq_dim,input_dim).cuda())
else:
images = Variable(images.view(-1,seq_dim,input_dim))
with torch.no_grad():
outputs = model(images)
# 取最大值所在下标为预测标签
_,predicted = torch.max(outputs.data,1)
total += labels.size(0)
if torch.cuda.is_available():
correct += ((predicted == labels.cuda()).sum())
else:
correct += ((predicted == labels).sum())
accuracy = 100*correct/total
print("Iteration:{}. Loss: {}. Accuracy: {}%".format(iter,loss.item(),accuracy))
import matplotlib.pyplot as plt
plt.xlabel("Iteration")
plt.ylabel("Loss (Crossentropy)")
plt.title("MNIST Learning curve for LSTM")
plt.plot(loss_list,label="LSTM")
plt.legend()