python

关注公众号 jb51net

关闭
首页 > 脚本专栏 > python > Pytorch RNN输入和输出的形状总结

Pytorch中关于RNN输入和输出的形状总结

作者:会唱歌的猪233

这篇文章主要介绍了Pytorch中关于RNN输入和输出的形状总结,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教

Pytorch对RNN输入和输出的形状总结

个人对于RNN的一些总结。

RNN的输入和输出

RNN的经典图如下所示


各个参数的含义

Pytorch中的使用

Pytorch中RNN函数如下

RNN的主要参数如下

nn.RNN(input_size, hidden_size, num_layers=1, bias=True)

参数解释

output=输出O, 隐藏状态St,其中输出O=[time_step, batch_size, hidden_size],St为t时刻的隐藏层状态

理解RNN中的batch_size和seq_len

深度学习中采用mini-batch的方法进行迭代优化,在CNN中batch的思想较容易理解,一次输入batch个图片,进行迭代。但是RNN中引入了seq_len(time_step), 理解较为困难,下面是我自己的一些理解。

首先假如我有五句话,作为训练的语料。

sentences = ["i like dog", "i love coffee", "i hate milk", "i like music", "i hate you"]

那么在输入RNN之前要先进行embedding,比如one-hot encoding,容易得到这里的embedding-dim为9.

那么输入的sentences可以表示为如下方式

t=0t=1t=2
batch1ilikedog
batch2ilovecoffee
batch3ihatemilk
batch4ilikemusic
batch5ihateyou

那么在RNN的训练中。

那么对应的时间t来说,RNN需要对先后输入的batch_size个字符进行前向计算迭代,得到输出。

Pytorch双向RNN隐藏层和输出层结果拆分

1 RNN隐藏层和输出层结果的形状

从Pytorch官方文档可以得到,对于批量化输入的RNN来讲,其隐藏层的shape为(num_directions*num_layers, batch_size, hidden_size)。

其输出的shape为(seq_len, batch_size, D*hidden_size)。

2 双向RNN情况下,隐藏层和输出层结果拆分

当采用双向RNN时,其输出的结果包含正向和反向两个方向输出的结果。

2.1 输出层结果拆分

其中对于输出output来讲,从官方文档我们可以得到,其拆分正向和反向两个方向结果的方法为:

output.shape = (seq_len, batch_size, num_directions*hidden_size)

output.view(seq_len, batch, num_directions, hidden_size)

其中,对于(num_directions)方向维度,正向和反向的维度值分别为​​0​​​和​​1​。

2.2 隐藏层结果拆分

而对于隐藏层,包括初始值h_0以及最终输出h_n,也都包含两个方向的隐藏状态,但是其拆分方式跟输出层不一样。

方法如下:

h_0, h_n.shape = (num_directions*num_layers, batch_size, hidden_size)

h_0, h_n.view(num_layers, num_directions, batch_size, hidden_size)

可以从简单单层双向RNN的输出结果来验证,此时RNN的输出结果与最后一层的隐藏层结果是一样的。

import torch
import torch.nn as nn
if __name__ == "__main__":
    # input_size: 3, hidden_size: 5, num_layers: 3
    BiRNN_Net = nn.RNN(3, 5, 3, bidirectional=True, batch_first=True)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    # batch_size: 1, seq_len: 1, input_size: 3
    inputs = torch.zeros(1, 1, 3, device=device)
    # state: (num_directions*num_layers, batch_size, hidden_size)
    state = torch.randn(6, 1, 5, device=device)
    BiRNN_Net.to(device)
    output, hidden = BiRNN_Net(inputs, state)
    output_re = output.reshape((1, 1, 2, 5))
    hidden_re = hidden.reshape((3, 2, 1, 5))
    print(output)
    print(output_re)
    print(hidden)
    print(hidden_re)

输出结果可以看出,隐藏层的结果是优先num_layers网络层数这一个维度来构成的。

tensor([[[ 0.3939, -0.9160,  0.5054,  0.2949, -0.5225,  0.0533,  0.4197,
          -0.7200, -0.1262, -0.7975]]], device='cuda:0',
       grad_fn=<CudnnRnnBackward0>)
tensor([[[[ 0.3939, -0.9160,  0.5054,  0.2949, -0.5225],
          [ 0.0533,  0.4197, -0.7200, -0.1262, -0.7975]]]], device='cuda:0',
       grad_fn=<ReshapeAliasBackward0>)
tensor([[[-0.2606,  0.5410, -0.2663,  0.6418, -0.2902]],
        [[ 0.1367,  0.7222, -0.3051, -0.6410, -0.3062]],
        [[ 0.2433,  0.3287, -0.4809, -0.1782, -0.5582]],
        [[ 0.4824, -0.8529,  0.7604,  0.8508, -0.1902]],
        [[ 0.3939, -0.9160,  0.5054,  0.2949, -0.5225]],
        [[ 0.0533,  0.4197, -0.7200, -0.1262, -0.7975]]], device='cuda:0',
       grad_fn=<CudnnRnnBackward0>)
tensor([[[[-0.2606,  0.5410, -0.2663,  0.6418, -0.2902]],
         [[ 0.1367,  0.7222, -0.3051, -0.6410, -0.3062]]],
        [[[ 0.2433,  0.3287, -0.4809, -0.1782, -0.5582]],
         [[ 0.4824, -0.8529,  0.7604,  0.8508, -0.1902]]],
        [[[ 0.3939, -0.9160,  0.5054,  0.2949, -0.5225]],
         [[ 0.0533,  0.4197, -0.7200, -0.1262, -0.7975]]]], device='cuda:0',
       grad_fn=<ReshapeAliasBackward0>)

总结

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文