学会区分 RNN 的 output 和 state

已于 2022-05-28 23:14:59 修改
阅读量2.5k 收藏 20
点赞数 11
分类专栏： tensorflow 机器学习 算法 文章标签： rnn lstm tensorflow
于 2018-03-07 19:02:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taoqick/article/details/79475350
版权
算法 同时被 3 个专栏收录
474 篇文章 6 订阅
订阅专栏
机器学习
73 篇文章 0 订阅
订阅专栏
tensorflow
19 篇文章 0 订阅
订阅专栏

若干年后，看到了pytorch对RNN的抽象，非常优雅，见这个正余弦预测code的注释：

"""
View more, visit my tutorial page: https://mofanpy.com/tutorials/
My Youtube Channel: https://www.youtube.com/user/MorvanZhou

Dependencies:
torch: 0.4
matplotlib
numpy
"""
import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step
INPUT_SIZE = 1      # rnn input size
LR = 0.02           # learning rate

# show data
steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)  # float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)
plt.plot(steps, y_np, 'r-', label='target (cos)')
plt.plot(steps, x_np, 'b-', label='input (sin)')
plt.legend(loc='best')
plt.show()


class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()

        self.rnn = nn.RNN(
            input_size=INPUT_SIZE,
            hidden_size=32,     # rnn hidden unit
            num_layers=1,       # number of rnn layer
            batch_first=True,   # input & output will has batch size as 1s dimension. e.g. (batch, time_step, input_size)
        )
        self.out = nn.Linear(32, 1)

    def forward(self, x, h_state):

        # x (batch, time_step, input_size)
        # h_state (n_layers, batch, hidden_size)
        # r_out (batch, time_step, hidden_size)
        r_out, h_state = self.rnn(x, h_state)
        # self.rnn实际上本身就是有n_layers*time_step个网状RNN单元：n_layers是向上堆叠的，time_step是时间维度堆叠的，也就是先后顺序
        # batch是batch_size，把训练数据分成若干批，每批有多大
        # input_size是某个timestamp输入有多少维：这个例子是正余弦预测例子是1维；如果把一行像素当成输入，维度就是这行像素的个数
        # hidden_size就是RNN内部会当成多少维。所有神经网络都是输入维度input_size->内部维度->output_size

        #下面这一大堆实际上只是先把hidden_size维弄成1维，因为最终预测是1维的，来了3种方法：

        # outs = []    # save all predictions
        # for time_step in range(r_out.size(1)):    # 每个time_step分别过FeedForward
        #     outs.append(self.out(r_out[:, time_step, :]))
        # return torch.stack(outs, dim=1), h_state

        # 第二种方法，先把r_out (batch, time_step, hidden_size)弄成(-1, hidden_size)的二维tensor，过FeedForward，再reshape回来
        # instead, for simplicity, you can replace above codes by follows
        r_out = r_out.view(-1, 32)
        print('r_out.view(-1, 32) shape={}'.format(r_out.shape))
        outs = self.out(r_out)
        outs = outs.view(-1, TIME_STEP, 1)
        return outs, h_state

        # 第三种方法，全连接在Pytorch里只关心in_features有多少维->out_features有多少维就行了
        # 如果print RNN这个instance就会发现，RNN网络结构实际上只关心in_features有多少维->out_features有多少维，self.out关心这件事情就够了
        # or even simpler, since nn.Linear can accept inputs of any dimension 
        # and returns outputs with same dimension except for the last
        # outs = self.out(r_out)
        # return outs, h_state

rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.MSELoss()

h_state = None      # for initial hidden state

plt.figure(1, figsize=(12, 5))
plt.ion()           # continuously plot

for step in range(100):
    start, end = step * np.pi, (step+1)*np.pi   # time range
    # use sin predicts cos
    steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)  # float32 for converting torch FloatTensor
    x_np = np.sin(steps)
    y_np = np.cos(steps)

    x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])    # shape (batch, time_step, input_size)
    y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

    prediction, h_state = rnn(x, h_state)   # rnn output
    # !! next step is important !!
    h_state = h_state.data        # repack the hidden state, break the connection from last iteration
    print('prediction.shape={}'.format(prediction.shape))

    loss = loss_func(prediction, y)         # calculate loss
    optimizer.zero_grad()                   # clear gradients for this training step
    loss.backward()                         # backpropagation, compute gradients
    optimizer.step()                        # apply gradients

    # plotting
    plt.plot(steps, y_np.flatten(), 'r-')
    plt.plot(steps, prediction.data.numpy().flatten(), 'b-')
    plt.draw(); plt.pause(0.05)

plt.ioff()
plt.show()

​​​​​​​

写这篇文章的起因是，有人问调用 outputs, last_state = tf.nn.static_rnn(cell,inputs) 之后，last_state 和outputs[-1] 相等吗？如果不想等，为什么会不等呢？

 

其实这也是学习 RNN 的一大难点。我个人认为，学习RNN 最难的地方就是弄明白它的输入和输出是什么。一个简单的回答是，对于一个 RNN 单元，它每次接受一个当前输入 x_t 和前一步的隐层状态 s_{t-1}，然后产生一个新的隐层状态 s_t，也即：s_t = f(x_t,s_{t-1})，其中 f 代表某个函数，对应于 RNN 内部的运算过程。

这种说法并没有错，但是不够好，因为很多时候，把 RNN 的输出和状态区分开来，理解起来会更加顺畅。也就是说，我们认为RNN 是这样一个单元：y_t, s_t = f(x_t, s_{t-1}) ，画成图的话，就是这样：

 

 

这也是本文所要强调的地方：务必要区分 RNN 的输出和状态。这么做有什么用呢？先看

先看一个最基本的例子，考虑 Vanilla RNN/GRU Cell（vanillaRNN 就是最普通的 RNN，对应于 TensorFlow 里的 BasicRNNCell），工作过程如下：

 

这时，s_t = y_t = h_t，区分这俩确实没用。

 

但是！如果是 LSTM 呢？对于 LSTM，它的循环部件其实有两部分，一个是内部 cell 的值，另一个是根据cell 和 output gate 计算出的 hiddenstate，输出层只利用 hidden state 的信息，而不直接利用cell。这样一来，LSTM 的工作过程就是：

其中真正用于循环的状态 s_t 其实是 (c_t, h_t) 组成的 tuple（就是 TensorFlow 里的 LSTMStateTuple，当然，如果你选择不用 tuple 表示 LSTM 的内部状态，也可以把 c_t 和 h_t 拼起来，合起来拼成一个 Tensor，这样的话它的状态就是一个 Tensor 了，这时做别的计算可能会方便一些，这个其实就是TensorFlow 里的 state_is_tuple 这个开关。），而输出y_t 仅仅是 h_t（例如网络后面再接一个全连接层然后用softmax 做分类，这个全连接层的输入仅仅是 h_t，而没有c_t），这时就可以看到区分 RNN 的输出和状态的意义了。

当然，这种抽象的意义不止于此。如果是一个多层的 Vanilla RNN/GRU Cell，那么一种简单的抽象办法就是，把多层Cell 当成一个整体，当成一层大的 Cell，然后原先各层之间的关系都当成这个大的Cell 的内部计算过程/数据流动过程，这样对外而言，多层的RNN 和单层的 RNN 接口就是一模一样的：在外部看来，多层RNN 只是一个内部计算更复杂的单层 RNN。图示如下：

 

大方框表示把多层 RNN 整体视为一层大的 Cell，而里面的小方框则对应于原先的每一层 RNN。这时，如果把大方框视为一个整体，那么这个整体进行循环所需要的状态就是各层的状态组成的集合，或者说把各层的状态放在一起组成一个tuple：（这里为什么要用 tuple 呢？直接把它们拼成一个 Tensor 不行吗，tuple 还得一个一个遍历，这多麻烦？答案是，不行。因为多层RNN 并不需要每一层都一样大，例如有可能最底层维度比较高，隐层单元数较大，越往上则隐层维度越小。这样一来，每一层的状态维度都不一样，没法concat 成一个 Tensor 啊！）；而这个大的 RNN单元的输出则只有原先的最上层 RNN 的输出，即整体的  。

在这个例子里，大 RNN 单元的输出和状态显然不一样。在这种视角下，多层RNN 和单层 RNN 可以用一个统一的视角来看待，世界清爽了许多。事实上，在TensorFlow 里，MultiRNNCell 就是RNNCell 的一个子类，它把多层的 RNN 当成一个整体、当成一个内部结构更复杂的单层RNN 来看待。我在文章最开始提到的代表 RNN 内部计算的函数f，其实就是 RNNCell 的 __call__ 方法。

 

再来看最后一个例子，多层 LSTM：

 

 

和之前的例子类似，把多层 LSTM 看成一个整体，这个整体的输出就是最上层LSTM 的输出：  ；而这个整体进行循环所依赖的状态则是每一层状态组合成的tuple，而每一层状态本身又是一个 (c, h) tuple，所以最后结果就是一个tuple 的 tuple，如图所示。

 

这样一来，便可以回答两个问题：

其一是，outputs, last_state = tf.nn.static_rnn(cell,inputs) 之后，last_state 和outputs[-1] 相等吗？

outputs 是 RNN Cell 的 output 组成的列表，假设一共有 T 个时间步，那么 outputs = [y_1, y_2, ..., y_T]，因此outputs[-1] = y_T；而 last_state 则是最后一步的隐层状态，即s_T。

那么，到底 outputs[-1] 等不等于last_state 呢？或者说 y_T 等不等于 s_T 呢？看一下上面四个图就可以知道，当且仅当使用单层 Vanilla RNN/GRU 的时候，他们才相等。

 

其二是，LSTM 作为一个 state 和 output 不一样的奇葩，导致我们经常需要操作那个 (c, h)tuple，或者在 tuple 和 Tensor 之间转换。有一段很常用的转换代码是这样的：

lstm_state_as_tensor_shape = [num_layers,2, batch_size, hidden_size]

initial_state = tf.zeros(lstm_state_as_tensor_shape)

unstack_state = tf.unstack(initial_state,axis=0)

tuple_state = tuple([tf.contrib.rnn.LSTMStateTuple(unstack_state[idx][0], unstack_state[idx][1]) foridx in range(num_layers)])

inputs = tf.unstack(inputs, num=num_steps,axis=1)

outputs, state_out = tf.contrib.rnn.static_rnn(cell,inputs, initial_state=tuple_state)

对着上面最后一张多层 LSTM 的图琢磨琢磨，就知道这几行代码到底是如何把Tensor 转换成多层 LSTM 的状态的了。

From: https://zhuanlan.zhihu.com/p/28919765

taoqick
关注
专栏目录
【NLP】第16章 使用RNN 和注意力的自然语言处理
sikh_0529的博客
09-22 1万+
什么时候Alan Turing 在 1950 年设想了他著名的，他的目标是评估机器匹配人类智能的能力。他本可以测试很多东西，比如识别图片中的猫、下棋、作曲或逃离迷宫的能力，但有趣的是，他选择了语言任务。更具体地说，他设计了一个聊天机器人，能够愚弄其对话者认为它是人类。这个测试确实有它的弱点：一组硬编码的规则可以欺骗毫无戒心或天真的人（例如，机器可以给出模糊的预定义答案以响应某些关键字；它可以假装它是在开玩笑或喝醉，以通过它最奇怪的答案；
RNN 的 output 和 state 的区别
ziigea的博客
05-14 578
RNN 的 output 和 state 的区别问题记录简单RNNLSTM 问题记录 学习模型验证，要提取RNN的隐藏状态的时候遇到了一个难题，就是RNN的output 和 state 的区别。也就是说，model.predict()输出的是不是我想要的s呢 简单RNN 最简单的RNN单元，它每次接受一个当前输入 x_t 和前一步的隐层状态 s_{t-1}，然后产生一个新的隐层状态 s_t，也即：s_t = f(x_t, s_{t-1})，其中 f 代表某个函数，对应于 RNN 内部的运算过程。 这种情
tensorflow：rnn中的output和state
一新新的小白的博客
04-17 5162
原文： https://xdrush.github.io/2018/02/12/RNN%E5%8E%9F%E7%90%86%E8%AF%A6%E8%A7%A3%E4%BB%A5%E5%8F%8Atensorflow%E4%B8%AD%E7%9A%84RNN%E5%AE%9E%E7%8E%B0...
隐藏状态（Hidden State）
最新发布
m0_51200050的博客
06-27 1333
在递归神经网络中，隐藏状态hth_tht​是对输入序列xtx_txt​在时间步ttt的编码。htfht−1xtht​fht−1​xt​其中：hth_tht​：时间步ttt的隐藏状态。ht−1h_{t-1}ht−1​：前一个时间步的隐藏状态。xtx_txt​：时间步ttt的输入。fff：一个非线性函数，通常是通过神经网络层实现的。
tf.nn.dynamic_rnn的输出outputs和state含义
u010960155的博客
08-15 2万+
一、 tf.nn.dynamic_rnn的输出 tf.nn.dynamic_rnn的输入参数如下 tf.nn.dynamic_rnn(     cell,     inputs,     sequence_length=None,     initial_state=None,     dtype=None,     parallel_iterations=None,     swap_me...
RNN原理及输入输出
m0_68041978的博客
10-24 4820
循环神经网络（Recurrent Neural Neural Networks, RNN),是一种反馈网络。它可以有效处理序列特性的数据，能够挖掘数据中的时序信息以及语义信息。常用于语言识别、机器翻译、视频分析、生成图像描述的等。RNN主要用于时序类数据的处理，在文档分类、机器翻译、文本情感分析、文本预测等有着重要作用。
学会区分RNN的output和state
湛蓝的天空
12-19 849
写这篇文章的起因是，有人问调用 outputs, last_state = tf.nn.static_rnn(cell, inputs) 之后，last_state 和 outputs[-1] 相等吗？如果不想等，为什么会不等呢？ 其实这也是学习 RNN 的一大难点。我个人认为，学习 RNN 最难的地方就是弄明白它的输入和输出是什么。一个简单的回答是，对于一个 RNN 单元，它每次接受一个当前输...
对RNN中Output与State的区分
baidu_38971290的博客
08-17 596
对RNN中Output与State的区分 之所以写这篇文章，主要是在之前实现Seq2Seq模型时发现了一些问题，在这方面有着一些混淆，主要是对LSTM的理解不够 基础RNN的结构，每一个RNN单元实现的功能是 (插不来图，请自找。。。。) St=f(St−1,xt) S_t = f(S_{t-1},x_t)St​=f(St−1​,xt​) 那么OtO_tOt​是干嘛的呢？ 实际上OtO_tOt​...
TensorFlow中RNN网络的实现和关键参数选择
王尧的技术博客
05-06 3153
主旨TensorFlow提供了方便的API用于快速搭建和实现RNN网络。但是在实际工作中，这些API的关键参数选择令人迷惑，在没有时间详细阅读Tensorflow引用论文和源代码的条件下，仅仅靠网络上找到的样例代码决定某些参数的选择是危险且低效的。为了解决这个问题，同时不陷入过于复杂的论文和TensorFlow源代码分析，本文通过受控实验的方式，设计出一个虽然简单但是能反映出RNN基本规律的训练和测
深度学习（三）：详解循环神经网络RNN，含公式推导
ChihkAnchor的博客
04-29 1万+
循环神经网络简介 循环神经网络（recurrent neural network, RNN）源自1982年由Saratha Sathasivam提出的霍普菲尔德网络。霍普菲尔德网络因为实现困难，在提出时并且没有被合适地应用。该网络结构也于1986年后被全连接神经网络以及一些传统的机器学习算法所取代。然而： 传统的机器学习算法非常依赖于人工提取的特征，使得基于传统机器学习的图像识别、语音识别以及...
计算能量消耗：神经网络（Neural Network）分析——CNN、RNN、Transformers 模型的计算能量消耗量化评估
程序员光剑
08-04 1331
2021年AI技术的高速发展已经给人们生活带来了无限可能。但是伴随着技术的进步，同时也引起了环境问题和健康问题。其中，能源消耗问题更是难以回避。为了让AI技术能够更好的发挥作用，如何降低其能源消耗是一个重要课题。为此，作者从三个方面对神经网络（Neural Network）进行了分析——CNN、RNN、Transformers。通过研究不同模型的计算能量消耗，作者对计算能源消耗进行了量化评估。并且分析了人类与机器学习模型之间的差异，提出了针对性的解决方案。
Pytorch中RNN输出的h_n和output是什么
日积月累，天道酬勤
07-16 3290
Pytorch LSTM参数分析。
rnn按时间展开_循环神经网络(RNN)笔记——训练RNN
weixin_39858298的博客
12-19 604
以下内容参考、引用部分书籍、帖子的内容，若侵犯版权，请告知本人删帖。训练RNN的关键是将其按时序展开，然使用常用的反向传播即可，这种策略被称为时序反向传播(backpropagation through time，BPTT)，如图1所示。图1 时序反向传播和常用的反向传播一样，先对展开的网络做前向传播(如图1中的虚线箭头所示)。然后通过成本函数 评估输出序列， 和 是输出的第一个和最后一个时间节点...
关于python中的[:, -1, :] [:, :, -1] [-1, :, :]
Chauncey_Wang的博客
11-03 1983
其实是个比较简单的知识点，但是因为经常忘记，在此记录一下 以[:, -1, :]为例 冒号代表该维度的全部元素 -1代表该维度的最后一个元素 如 output = np.array([i for i in range(8)]).reshape(2, 2, 2) print(output) 输出的是 [[[0 1] [2 3]] [[4 5] [6 7]]] 而经过[:, -1, :]处理后 print(output[:, -1, :]) 变成 [[2 3] [6
使用RNN实现回归（16）
CSS360的博客
03-20 3071
（1）简介 关于RNN网络模型的介绍，请看https://blog.csdn.net/CSS360/article/details/88587801 （2）代码 import torch from torch import nn import numpy as np import matplotlib.pyplot as plt # torch.manual_seed(1) ...
RNN 循环神经网络 回归
ch206265的博客
06-28 2024
RNN 循环神经网络 回归 地平线上的背影关注 RNN网络较少运用于回归任务，但是并不代表其不可运用于回归任务。本文通过简单回归任务的RNN进一步加深对RNN的理解 1. 准备数据和超参数 import torch from torch import nn import numpy as np import matplotlib.pyplot as plt # torch.manual_seed(1) # reproducible # Hyper Parameters TIME_STEP
深度学习之RNN(循环神经网络)
热门推荐
笨拙的石头的博客
05-28 24万+
一 RNN概述     前面我们叙述了BP算法, CNN算法, 那么为什么还会有RNN呢?? 什么是RNN, 它到底有什么不同之处? RNN的主要应用领域有哪些呢?这些都是要讨论的问题.     1) BP算法,CNN之后, 为什么还有RNN?     细想BP算法,CNN(卷积神经网络)我们会发现, 他们的输出都是只考虑前一个输入的影响而不考虑其它时刻输入的影响, 比如简单的猫,狗,手写数...
解读tensorflow之rnn
slamer的专栏
09-02 9万+
from: http://lan2720.github.io/2016/07/16/%E8%A7%A3%E8%AF%BBtensorflow%E4%B9%8Brnn/ 这两天想搞清楚用tensorflow来实现rnn/lstm如何做，但是google了半天，发现tf在rnn方面的实现代码或者教程都太少了，仅有的几个教程讲的又过于简单。没办法，只能亲自动手一步步研究官方给出的代码了。 本文研
def forward(self, x, state=None, flow=None, mode='bilinear'): # pylint: disable=unused-argument, arguments-differ # Check size assert len(x.size()) == 5, 'Input tensor must be BxTxCxHxW.' b, timesteps, c, h, w = x.size() assert c == self.input_size, f'feature sizes must match, got input {c} for layer with size {self.input_size}' # recurrent layers rnn_output = [] rnn_state = torch.zeros(b, self.hidden_size, h, w, device=x.device) if state is None else state for t in range(timesteps): x_t = x[:, t] if flow is not None: rnn_state = warp_features(rnn_state, flow[:, t], mode=mode) # propagate rnn state rnn_state = self.gru_cell(x_t, rnn_state) rnn_output.append(rnn_state) # reshape rnn output to batch tensor return torch.stack(rnn_output, dim=1)这段代码的计算过程
06-10
然后，函数将 x_t 和 rnn_state 作为 GRU 循环神经网络的输入，计算得到 rnn_state。将 rnn_state 添加到 rnn_output 列表中。 最后，函数将 rnn_output 列表中的张量沿着时间步维度进行堆叠，得到输出张量。输出...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值