循环神经网络

最新推荐文章于 2024-05-16 18:18:12 发布
最新推荐文章于 2024-05-16 18:18:12 发布
阅读量519 收藏
点赞数
分类专栏： 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/the_Discovery/article/details/110392815
版权
本文详细介绍了PyTorch中RNNCell、RNN、LSTM和GRU的工作原理及使用方法，通过实例展示了如何构建和训练这些模型。内容涵盖张量维度、嵌入层以及不同类型的循环神经网络在序列数据预测中的应用。
摘要由CSDN通过智能技术生成

在这里插入图片描述

h 1 = R N N C e l l ( x 0 , h 1 ) h_1 = RNNCell(x_0, h_1) h1​=RNNCell(x0​,h1​)

本质上RNN就是一个共享权重可复用的LinearLayer

重点：掌握RNN张量的维度尺寸

input.shape = (batchSize, inputSize)
output.shape = (batchSize, hiddenSize)

output张量即hidden张量

dataset.shape = (sqeLen, batchSize, inputSize)

1. 使用RNNCell

import torch

batchSize = 1
seqLen = 3
inputSize = 4
hiddenSize = 2

cell = torch.nn.RNNCell(input_size=inputSize, hidden_size=hiddenSize)

# seqLen即每次输入的序列的长度，x1,x2,x3...
dataSet = torch.randn(seqLen, batchSize, inputSize)
hidden = torch.zeros(batchSize, hiddenSize)

# 完成一次序列长度的计算
for index, input in enumerate(dataSet):
    print('='*20, index, '='*20)
    print('Input size:', input.shape)

    hidden = cell(input, hidden)

    print('outputs size:', hidden.shape)
    print(hidden)

==================== 0 ====================
Input size: torch.Size([1, 4])
outputs size: torch.Size([1, 2])
tensor([[-0.4574,  0.2046]], grad_fn=<TanhBackward>)
==================== 1 ====================
Input size: torch.Size([1, 4])
outputs size: torch.Size([1, 2])
tensor([[-0.7797,  0.9349]], grad_fn=<TanhBackward>)
==================== 2 ====================
Input size: torch.Size([1, 4])
outputs size: torch.Size([1, 2])
tensor([[-0.9951,  0.2693]], grad_fn=<TanhBackward>)

2. 使用RNN

pyTorch模块的RNN相当于对RNNCell的迭代过程做了封装

在这里插入图片描述

上图是一个多层的RNN结构

# RNN网络的层数
numLayers = 1

cell = torch.nn.RNN(input_size=inputSize, hidden_size=hiddenSize,
                    num_layers=numLayers)

inputs = torch.randn(seqLen, batchSize, inputSize)
hidden = torch.zeros(numLayers, batchSize, hiddenSize)
out, hidden = cell(inputs, hidden)

print('output size:', out.shape)
print('output:', out)
print('hidden size:', hidden.shape)
print('hidden', hidden)

output size: torch.Size([3, 1, 2])
output: tensor([[[ 0.3408, -0.4484]],

        [[-0.8622, -0.9828]],

        [[ 0.5427,  0.7002]]], grad_fn=<StackBackward>)
hidden size: torch.Size([1, 1, 2])
hidden tensor([[[0.5427, 0.7002]]], grad_fn=<StackBackward>)

3. 使用RNN训练

input: ‘hello’

target: ‘ohlol’

import numpy as np

batchSize = 1
inputSize = 4
hiddenSize = 4

index2char = ['e','h','l','o']

xData = [1,0,2,2,3]
yData = [3,1,2,3,2]

oneHotLookup = np.diag(np.ones(4))

xOneHot = [oneHotLookup[x] for x in xData]
inputs = torch.Tensor(xOneHot).view(-1, batchSize, inputSize)
labels = torch.LongTensor(yData)

class Model(torch.nn.Module):
    def __init__(self,inputSize, hiddenSize, batchSize, numLayers):
        super(Model, self).__init__()
        self.numLayers = numLayers
        self.batchSize = batchSize
        self.inputSize = inputSize
        self.hiddenSize = hiddenSize
        self.rnn = torch.nn.RNN(input_size=self.inputSize,
                                hidden_size=self.hiddenSize,
                                num_layers=self.numLayers)
    def forward(self, input):
        hidden = torch.zeros(
            self.numLayers,
            self.batchSize,
            self.hiddenSize
        )
        out, _ = self.rnn(input, hidden)
        return out.view(-1, self.hiddenSize)
net = Model(inputSize, hiddenSize, batchSize, numLayers)

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)
for epoch in range(15):
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

    _, index = outputs.max(dim=1)
    index = index.data.numpy()
    print('Predicted', ''.join([index2char[x] for x in index]), end='')
    print(',Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

Predicted ehele,Epoch [1/15] loss = 1.516
Predicted eolll,Epoch [2/15] loss = 1.353
Predicted eolll,Epoch [3/15] loss = 1.236
Predicted lolll,Epoch [4/15] loss = 1.145
Predicted oolll,Epoch [5/15] loss = 1.070
Predicted oolol,Epoch [6/15] loss = 1.007
Predicted oolol,Epoch [7/15] loss = 0.952
Predicted oolol,Epoch [8/15] loss = 0.900
Predicted oolol,Epoch [9/15] loss = 0.849
Predicted oolol,Epoch [10/15] loss = 0.800
Predicted oolol,Epoch [11/15] loss = 0.755
Predicted ohlol,Epoch [12/15] loss = 0.717
Predicted ohlol,Epoch [13/15] loss = 0.684
Predicted ohlol,Epoch [14/15] loss = 0.652
Predicted ohlol,Epoch [15/15] loss = 0.621

4. 使用嵌入层

oneHot独热向量数据稀疏，维度高。需要将其数据转移到嵌入层中，便于计算。

numClass = 4
inputSize = 4
hiddenSize = 8
embeddingSize = 10
numLayers = 2
batchSize = 1
seqLen = 5
xData = [1,0,2,2,3]
yData = [3,1,2,3,2]
# input: seqLen, batchSize
inputs = torch.LongTensor(xData).view(5,1)
labels = torch.LongTensor(yData)
class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.emb = torch.nn.Embedding(inputSize, embeddingSize)
        self.rnn = torch.nn.RNN(input_size=embeddingSize,
                                hidden_size=hiddenSize,
                                num_layers=numLayers,
                                )
        self.fc = torch.nn.Linear(hiddenSize, numClass)
    def forward(self, x):
        # hidden: numLayers, batchSize, hiddenSize
        hidden = torch.zeros(numLayers, x.size(1), hiddenSize)
        x = self.emb(x)
        x, _ = self.rnn(x, hidden)
        x = self.fc(x)
        return x.view(-1, numClass)
net = Model()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)

for epoch in range(15):
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

    _, index = outputs.max(dim=1)
    index = index.data.numpy()
    print('Predicted', ''.join([index2char[x] for x in index]), end='')
    print(',Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

Predicted eleee,Epoch [1/15] loss = 1.450
Predicted ohlll,Epoch [2/15] loss = 1.006
Predicted ohlll,Epoch [3/15] loss = 0.738
Predicted ohlol,Epoch [4/15] loss = 0.502
Predicted ohlol,Epoch [5/15] loss = 0.327
Predicted ohlol,Epoch [6/15] loss = 0.223
Predicted ohlol,Epoch [7/15] loss = 0.152
Predicted ohlol,Epoch [8/15] loss = 0.105
Predicted ohlol,Epoch [9/15] loss = 0.074
Predicted ohlol,Epoch [10/15] loss = 0.053
Predicted ohlol,Epoch [11/15] loss = 0.038
Predicted ohlol,Epoch [12/15] loss = 0.028
Predicted ohlol,Epoch [13/15] loss = 0.021
Predicted ohlol,Epoch [14/15] loss = 0.016
Predicted ohlol,Epoch [15/15] loss = 0.012

5. 使用LSTM和GRU

5.1 LSTM长短期记忆网络

在这里插入图片描述

numClass = 4
inputSize = 4
hiddenSize = 8
embeddingSize = 10
numLayers = 2
batchSize = 1
seqLen = 5
xData = [1,0,2,2,3]
yData = [3,1,2,3,2]
# input: seqLen, batchSize
inputs = torch.LongTensor(xData).view(5,1)
labels = torch.LongTensor(yData)
class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.emb = torch.nn.Embedding(inputSize, embeddingSize)
        self.lstm = torch.nn.LSTM(input_size=embeddingSize,
                                hidden_size=hiddenSize,
                                num_layers=numLayers,
                                )
        self.fc = torch.nn.Linear(hiddenSize, numClass)
    def forward(self, x):
        # hidden.shape: numLayers, batchSize, hiddenSize
        # hidden.shape must equals to cell.shape
        hidden = torch.zeros(numLayers, x.size(1), hiddenSize)
        cell = torch.zeros(numLayers, x.size(1), hiddenSize)
        x = self.emb(x)
        x, _ = self.lstm(x, (hidden, cell))
        x = self.fc(x)
        return x.view(-1, numClass)
net = Model()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)

for epoch in range(15):
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

    _, index = outputs.max(dim=1)
    index = index.data.numpy()
    print('Predicted', ''.join([index2char[x] for x in index]), end='')
    print(',Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

Predicted eeeee,Epoch [1/15] loss = 1.533
Predicted eeeee,Epoch [2/15] loss = 1.464
Predicted ooooo,Epoch [3/15] loss = 1.389
Predicted ooooo,Epoch [4/15] loss = 1.302
Predicted ooooo,Epoch [5/15] loss = 1.212
Predicted oooll,Epoch [6/15] loss = 1.123
Predicted oolll,Epoch [7/15] loss = 1.036
Predicted ollll,Epoch [8/15] loss = 0.954
Predicted ollll,Epoch [9/15] loss = 0.879
Predicted ohlll,Epoch [10/15] loss = 0.804
Predicted ohlll,Epoch [11/15] loss = 0.735
Predicted ohlll,Epoch [12/15] loss = 0.685
Predicted ohlll,Epoch [13/15] loss = 0.637
Predicted ohlll,Epoch [14/15] loss = 0.586
Predicted ohlll,Epoch [15/15] loss = 0.533

5.2 GRU门控循环单元

在这里插入图片描述

numClass = 4
inputSize = 4
hiddenSize = 8
embeddingSize = 10
numLayers = 2
batchSize = 1
seqLen = 5
xData = [1,0,2,2,3]
yData = [3,1,2,3,2]
# input: seqLen, batchSize
inputs = torch.LongTensor(xData).view(5,1)
labels = torch.LongTensor(yData)
class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.emb = torch.nn.Embedding(inputSize, embeddingSize)
        self.gru = torch.nn.GRU(input_size=embeddingSize,
                                hidden_size=hiddenSize,
                                num_layers=numLayers,
                                )
        self.fc = torch.nn.Linear(hiddenSize, numClass)
    def forward(self, x):
        # hidden: numLayers, batchSize, hiddenSize
        hidden = torch.zeros(numLayers, x.size(1), hiddenSize)
        x = self.emb(x)
        x, _ = self.gru(x, hidden)
        x = self.fc(x)
        return x.view(-1, numClass)

net = Model()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)

for epoch in range(15):
    optimizer.zero_grad()
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

    _, index = outputs.max(dim=1)
    index = index.data.numpy()
    print('Predicted', ''.join([index2char[x] for x in index]), end='')
    print(',Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

Predicted hhhhh,Epoch [1/15] loss = 1.424
Predicted ohhll,Epoch [2/15] loss = 1.244
Predicted ohlll,Epoch [3/15] loss = 1.098
Predicted ollll,Epoch [4/15] loss = 0.988
Predicted ollll,Epoch [5/15] loss = 0.901
Predicted ohlll,Epoch [6/15] loss = 0.795
Predicted ohlll,Epoch [7/15] loss = 0.698
Predicted ohlll,Epoch [8/15] loss = 0.622
Predicted ohlll,Epoch [9/15] loss = 0.561
Predicted ohlll,Epoch [10/15] loss = 0.507
Predicted ohlll,Epoch [11/15] loss = 0.450
Predicted ohlll,Epoch [12/15] loss = 0.377
Predicted ohlol,Epoch [13/15] loss = 0.310
Predicted ohlol,Epoch [14/15] loss = 0.263
Predicted ohlol,Epoch [15/15] loss = 0.216
所追寻的风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
循环神经网络RNN
花有重开日，人无再少年
02-17 4573
RNN（Recurrent Neural Network）循环神经网络。 类比血液在体内循环，从过去一直被更新到现在。 RNN具有环路。这个环路可以使数据不断循环。通过数据的循环，RNN一边记住过去的数据，一边更新到最新的数据。 RNN层的循环结构 RNN层的循环结构和它的展开如下图所示。下面的多个RNN层都是同一个层；输出分叉了，也就是说同一个输出被复制了，其中的一个输出将成为自身的输入。 xt是t时刻的输入数据，输入t时刻的RNN层。各个时刻的RNN层接收t时刻的输入数据和前一个RNN层的输出数据。
循环神经网络RNN的ppt
06-08
循环神经网络RNN的ppt
RNN（循环神经网络）
weixin_63685622的博客
05-16 2154
RNN(Recurrent Neural Network), 中文称作循环神经网络,它一般以序列数据为输入，通过网络内部的结构设计有效捕捉序列之间的关系特征,一般也是以序列形式进行输出.RNN的循环机制使模型隐层上一时间步产生的结果,能够作为当下时间步输入的一部分(当下时间步的输入除了正常的输入外还包括上一步的隐层输出)对当下时间步的输出产生影响.结构：三层，输入、输出、隐藏层（循环在隐藏层）图中sigma为sigmiod函数，将值压缩在0-1之间。
keras.utils.to_categorical中的num_class参数（IndexError: index 5 is out of bounds for axis 1 with size 5）
Work hard
08-28 7583
keras.utils.to_categorical函数用来作什么？ 用来将整数型标签转化为onehot数据。 例如，原来使用数组labels=[[1],[2],[5],[4],[5],[2],[3]]表示标签，只有使用keras.utils.to_categorical函数将其转化为onehot数据后，才能交由网络进行训练。 keras.utils.to_categorical定义 to_cat...
CNN 二分类和五分类的一些注意事项
阅读修身
07-18 1236
1问题描述 在将自己的程序从二分类转换为五分类的时候，总是会出现一些问题。现在总结一下，以及更改方案。 2问题和解决方案 （1）重要的参数num_class必须从2改为5 y_train = keras.utils.to_categorical(y_train,num_classes=5) y_test = keras.utils.to_categorical(y_test,num_classes=5) （2）最末层的密集层需要由2改为5 y1 = ..
LSTM多GPU训练、pytorch 多GPU 数据并行模式踩坑日记， LSTM, nn.DataParallel()
目标：NLP算法工程师
05-12 2892
LSTM多GPU训练 pytorch 多GPU 数据并行模式踩坑日记 多GPU训练时遇到的BUG解决方法
第六章 循环神经网络
Silimere
08-25 661
1单选(2分) 在RNN前向传播过程中按时间展开，记忆体状态信息ht、参数矩阵和两个偏置项是变化的还是不变的？ A.ht和参数矩阵随时间刷新变化、偏置项固定不变； B.ht随时间刷新变化、参数矩阵和偏置项固定不变； C.三者都固定不变； D.三者都随时间刷新变化； 2单选(2分) 在tf.keras.layers.SimpleRNN()中，记忆体个数、return_sequences=False分别代表什么含义： A.记忆体个数代表RNN循环核中记忆体的个数
循环神经网络 Recurrent Neural Network ｜ RNN
JasonH2021的博客
07-07 5407
简单介绍了循环神经网络的基本概念，应用场景，优缺点，建模过程，类库方法和代码案例等
循环神经网络(RNN)
weixin_53619329的博客
04-30 2147
循环神经网络(RNN) 文章目录循环神经网络(RNN)注意！！！！！！！RNN模型的作用为什么要使用RNN而不是用MLP？RNN输入与输出RNN模型简单RNN模型LSTM(Long Short-Term Memory)长短期记忆模型GRU(Gated Recurrent Units)参考视频 注意！！！！！！！ 博主第一次发布的文章有点生疏，写得不够好，没有考虑到一些图片的大小以及一些小细节，本次文章主要是当成博主自己的心得笔记，如果能帮助到大家那更好，大伙嘴下留情啊！！！！！！！ 在文章的最后有参考视频，
循环神经网络图解
y1040468929的博客
03-31 1484
循环神经网络 RNN图解 求导 GRU图解 LSTM图解 Reference: [1] 动手学深度学习
基于循环神经网络来生成唐诗python源码（ 利用循环神经网络，实现唐诗生成任务）.zip
04-11
基于循环神经网络来生成唐诗python源码（ 利用循环神经网络，实现唐诗生成任务。生成诗歌 开头词汇是 “ 日 、 红 、 山 、 夜 、 湖、 海 、 月 ）.zip 基于循环神经网络来生成唐诗python源码（ 利用循环神经网络，...
循环神经网络进阶
01-06
循环神经网络进阶 当时间步数较大或者时间步较小时，循环神经网络的梯度较容易出现衰减或爆炸。虽然裁剪梯度可以应对梯度爆炸，但无法解决梯度衰减的问题。通常由于这个原因，循环神经网络在实际中较难捕捉时间序列...
财务报表，项目费用支出明细.xlsx
08-09
工资表，财务报表，对账表，付款申请，财务报告，费用支出表 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
ppap-第四版.pdf
08-09
ppap-第四版
铁路转辙机 ZD6 使用说明书
最新发布
08-09
铁路转辙机 ZD6 使用说明书
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值