speechbrain.nnet.RNN 模块

实现循环神经网络的库。

作者

Adel Moumen 2023
Mirco Ravanelli 2020
Ju-Chieh Chou 2020
Jianyuan Zhong 2020
Loren Lugosch 2020

总结

类

`AttentionalRNNDecoder`	此函数实现了带注意力的 RNN 解码器模型。
`GRU`	此函数实现了基本的 GRU。
`GRUCell`	此类实现了用于一个输入时间步的基本 GRU 单元，而 GRU() 则接受整个序列作为输入。
`LSTM`	此函数实现了基本的 LSTM。
`LSTMCell`	此类实现了用于一个输入时间步的基本 LSTM 单元，而 LSTM() 则接受整个序列作为输入。
`LiGRU`	此函数实现了轻量 GRU (Li-GRU)。
`LiGRU_Layer`	此类实现了轻量门控循环单元 (Li-GRU) 层。
`QuasiRNN`	这是 Quasi-RNN 的一个实现。
`QuasiRNNLayer`	将单层准循环神经网络 (QRNN) 应用于输入序列。
`RNN`	此函数实现了 vanilla RNN。
`RNNCell`	此类实现了用于一个输入时间步的基本 RNN 单元，而 RNN() 则接受整个序列作为输入。
`SLiGRU`	此类实现了稳定轻量 GRU (SLi-GRU)。
`SLiGRU_Layer`	此类实现了稳定轻量门控循环单元 (SLi-GRU) 层。

函数

`pack_padded_sequence`	返回打包的 SpeechBrain 格式张量。
`pad_packed_sequence`	从打包序列返回 SpeechBrain 格式张量。
`rnn_init`	此函数用于初始化 RNN 权重。

参考

speechbrain.nnet.RNN.pack_padded_sequence(inputs, lengths)[source]

返回打包的 SpeechBrain 格式张量。

参数:

inputs (torch.Tensor) – 要打包的序列。
lengths (torch.Tensor) – 每个序列的长度。

返回类型:

打包后的序列。

speechbrain.nnet.RNN.pad_packed_sequence(inputs)[source]

从打包序列返回 SpeechBrain 格式张量。

参数:: inputs (torch.nn.utils.rnn.PackedSequence) – 要转换为张量的输入序列集合。
返回:: outputs – 填充后的序列。
返回类型:: torch.Tensor

class speechbrain.nnet.RNN.RNN(hidden_size, input_shape=None, input_size=None, nonlinearity='relu', num_layers=1, bias=True, dropout=0.0, re_init=True, bidirectional=False)[source]

基类： Module

此函数实现了 vanilla RNN。

它接受格式为 (batch, time, fea) 的输入张量。如果是 (batch, time, fea, channel) 这样的 4D 输入，张量会被展平为 (batch, time, fea*channel)。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。值（即时间和频率核大小）。
input_shape (tuple) – 输入示例的形状。或者，使用 input_size。
input_size (int) – 输入的大小。或者，使用 input_shape。
nonlinearity (str) – 非线性类型 (tanh, relu)。
num_layers (int) – 在 RNN 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。
bidirectional (bool) – 如果为 True，则使用双向模型，该模型从右向左和从左向右扫描序列。

示例

>>> inp_tensor = torch.rand([4, 10, 20])
>>> net = RNN(hidden_size=5, input_shape=inp_tensor.shape)
>>> out_tensor, _ = net(inp_tensor)
>>>
torch.Size([4, 10, 5])

forward(x, hx=None, lengths=None)[source]

返回 vanilla RNN 的输出。

参数:

x (torch.Tensor) – 输入张量。
hx (torch.Tensor) – 初始隐藏状态。
lengths (torch.Tensor) – 输入信号的相对长度。

返回:

output (torch.Tensor) – vanilla RNN 的输出。
hn (torch.Tensor) – 隐藏状态。

class speechbrain.nnet.RNN.LSTM(hidden_size, input_shape=None, input_size=None, num_layers=1, bias=True, dropout=0.0, re_init=True, bidirectional=False)[source]

基类： Module

此函数实现了基本的 LSTM。

它接受格式为 (batch, time, fea) 的输入张量。如果是 (batch, time, fea, channel) 这样的 4D 输入，张量会被展平为 (batch, time, fea*channel)。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。值（即时间和频率核大小）。
input_shape (tuple) – 输入示例的形状。或者，使用 input_size。
input_size (int) – 输入的大小。或者，使用 input_shape。
num_layers (int) – 在 RNN 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。
bidirectional (bool) – 如果为 True，则使用双向模型，该模型从右向左和从左向右扫描序列。

示例

>>> inp_tensor = torch.rand([4, 10, 20])
>>> net = LSTM(hidden_size=5, input_shape=inp_tensor.shape)
>>> out_tensor = net(inp_tensor)
>>>
torch.Size([4, 10, 5])

forward(x, hx=None, lengths=None)[source]

返回 LSTM 的输出。

参数:

x (torch.Tensor) – 输入张量。
hx (torch.Tensor) – 初始隐藏状态。
lengths (torch.Tensor) – 输入信号的相对长度。

返回:

output (torch.Tensor) – LSTM 的输出。
hn (torch.Tensor) – 隐藏状态。

class speechbrain.nnet.RNN.GRU(hidden_size, input_shape=None, input_size=None, num_layers=1, bias=True, dropout=0.0, re_init=True, bidirectional=False)[source]

基类： Module

此函数实现了基本的 GRU。

它接受格式为 (batch, time, fea) 的输入张量。如果是 (batch, time, fea, channel) 这样的 4D 输入，张量会被展平为 (batch, time, fea*channel)。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。值（即时间和频率核大小）。
input_shape (tuple) – 输入示例的形状。或者，使用 input_size。
input_size (int) – 输入的大小。或者，使用 input_shape。
num_layers (int) – 在 RNN 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。
bidirectional (bool) – 如果为 True，则使用双向模型，该模型从右向左和从左向右扫描序列。

示例

>>> inp_tensor = torch.rand([4, 10, 20])
>>> net = GRU(hidden_size=5, input_shape=inp_tensor.shape)
>>> out_tensor, _ = net(inp_tensor)
>>>
torch.Size([4, 10, 5])

forward(x, hx=None, lengths=None)[source]

返回 GRU 的输出。

参数:

x (torch.Tensor) – 输入张量。
hx (torch.Tensor) – 初始隐藏状态。
lengths (torch.Tensor) – 输入信号的相对长度。

返回:

output (torch.Tensor) – GRU 的输出。
hn (torch.Tensor) – 隐藏状态。

class speechbrain.nnet.RNN.RNNCell(hidden_size, input_shape=None, input_size=None, num_layers=1, bias=True, dropout=0.0, re_init=True, nonlinearity='tanh')[source]

基类： Module

此类实现了用于一个输入时间步的基本 RNN 单元，而 RNN() 则接受整个序列作为输入。

它专为自回归解码器（例如，注意力解码器）设计，一次接受一个输入。使用 torch.nn.RNNCell() 代替 torch.nn.RNN() 以减少 VRAM 消耗。

它接受格式为 (batch, fea) 的输入张量。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。
input_shape (tuple) – 输入示例的形状。或者，使用 input_size。
input_size (int) – 输入的大小。或者，使用 input_shape。
num_layers (int) – 在 RNN 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。
nonlinearity (str) – 非线性类型 (tanh, relu)。

示例

>>> inp_tensor = torch.rand([4, 20])
>>> net = RNNCell(hidden_size=5, input_shape=inp_tensor.shape)
>>> out_tensor, _ = net(inp_tensor)
>>> out_tensor.shape
torch.Size([4, 5])

forward(x, hx=None)[source]

返回 RNNCell 的输出。

参数:

x (torch.Tensor) – RNNCell 的输入。
hx (torch.Tensor) – RNNCell 的隐藏状态。

返回:

h (torch.Tensor) – RNNCell 的输出。
hidden (torch.Tensor) – 隐藏状态。

class speechbrain.nnet.RNN.GRUCell(hidden_size, input_shape=None, input_size=None, num_layers=1, bias=True, dropout=0.0, re_init=True)[source]

基类： Module

此类实现了用于一个输入时间步的基本 GRU 单元，而 GRU() 则接受整个序列作为输入。

它专为自回归解码器（例如，注意力解码器）设计，一次接受一个输入。使用 torch.nn.GRUCell() 代替 torch.nn.GRU() 以减少 VRAM 消耗。它接受格式为 (batch, fea) 的输入张量。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。
input_shape (tuple) – 输入示例的形状。或者，使用 input_size。
input_size (int) – 输入的大小。或者，使用 input_shape。
num_layers (int) – 在 GRU 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。

示例

>>> inp_tensor = torch.rand([4, 20])
>>> net = GRUCell(hidden_size=5, input_shape=inp_tensor.shape)
>>> out_tensor, _ = net(inp_tensor)
>>> out_tensor.shape
torch.Size([4, 5])

forward(x, hx=None)[source]

返回 GRUCell 的输出。

参数:

x (torch.Tensor) – GRUCell 的输入。
hx (torch.Tensor) – GRUCell 的隐藏状态。

返回:

h (torch.Tensor) – GRUCell 的输出
hidden (torch.Tensor) – 隐藏状态。

class speechbrain.nnet.RNN.LSTMCell(hidden_size, input_shape=None, input_size=None, num_layers=1, bias=True, dropout=0.0, re_init=True)[source]

基类： Module

此类实现了用于一个输入时间步的基本 LSTM 单元，而 LSTM() 则接受整个序列作为输入。

它专为自回归解码器（例如注意力解码器）设计，每次接收一个输入。使用 torch.nn.LSTMCell() 而非 torch.nn.LSTM() 以减少 VRAM 消耗。它接受格式为 (batch, fea) 的输入张量。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。
input_shape (tuple) – 输入示例的形状。或者，使用 input_size。
input_size (int) – 输入的大小。或者，使用 input_shape。
num_layers (int) – LSTM 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。

示例

>>> inp_tensor = torch.rand([4, 20])
>>> net = LSTMCell(hidden_size=5, input_shape=inp_tensor.shape)
>>> out_tensor, _ = net(inp_tensor)
>>> out_tensor.shape
torch.Size([4, 5])

forward(x, hx=None)[source]

返回 LSTMCell 的输出。

参数:

x (torch.Tensor) – LSTMCell 的输入。
hx (torch.Tensor) – LSTMCell 的隐藏状态。

返回:

h (torch.Tensor) – 输出
(隐藏状态, 单元状态) 的元组

class speechbrain.nnet.RNN.AttentionalRNNDecoder(rnn_type, attn_type, hidden_size, attn_dim, num_layers, enc_dim, input_size, nonlinearity='relu', re_init=True, normalization='batchnorm', scaling=1.0, channels=None, kernel_size=None, bias=True, dropout=0.0)[source]

基类： Module

此函数实现了带注意力的 RNN 解码器模型。

此函数实现了不同的 RNN 模型。它接受格式为 (batch, time, fea) 的 enc_states 张量作为输入。对于像 (batch, time, fea, channel) 这样的 4d 输入，张量会被展平为 (batch, time, fea*channel)。

参数:

rnn_type (str) – 使用的循环神经网络类型 (rnn, lstm, gru)。
attn_type (str) – 使用的注意力类型 (location, content)。
hidden_size (int) – 神经元数量。
attn_dim (int) – 注意力模块内部和输出神经元的数量。
num_layers (int) – 在 RNN 架构中使用的层数。
enc_dim (int) – 编码维度的大小。
input_size (int) – 相关输入维度的预期大小。
nonlinearity (str) – 非线性类型 (tanh, relu)。此选项仅对 rnn 和 ligru 模型有效。对于 lstm 和 gru，使用 tanh。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。输入连接权重使用 Xavier 初始化。
normalization (str) – ligru 模型的归一化类型 (batchnorm, layernorm)。任何不同于 batchnorm 和 layernorm 的字符串都将导致不进行归一化。
scaling (float) – 用于使注意力分布更尖锐或更平滑的缩放因子。
channels (int) – 基于位置注意力的通道数量。
kernel_size (int) – 基于位置注意力的核大小。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。

示例

>>> batch_size = 4
>>> enc_states = torch.rand([batch_size, 10, 20])
>>> wav_len = torch.ones([batch_size])
>>> inp_tensor = torch.rand([batch_size, 5, 6])
>>> net = AttentionalRNNDecoder(
...     rnn_type="lstm",
...     attn_type="content",
...     hidden_size=7,
...     attn_dim=5,
...     num_layers=1,
...     enc_dim=20,
...     input_size=6,
... )
>>> out_tensor, attn = net(inp_tensor, enc_states, wav_len)
>>> out_tensor.shape
torch.Size([4, 5, 7])

forward_step(inp, hs, c, enc_states, enc_len)[source]

前向传播过程的一个步骤。

参数:

inp (torch.Tensor) – 当前时间步的输入。
hs (torch.Tensor 或 tuple of torch.Tensor) – RNN 的单元状态。
c (torch.Tensor) – 上一个时间步的上下文向量。
enc_states (torch.Tensor) – 由编码器生成的需要被注意力的张量。
enc_len (torch.LongTensor) – 编码器状态的实际长度。

返回:

dec_out (torch.Tensor) – 输出张量。
hs (torch.Tensor 或 tuple of torch.Tensor) – RNN 的新单元状态。
c (torch.Tensor) – 当前时间步的上下文向量。
w (torch.Tensor) – 注意力权重。

forward(inp_tensor, enc_states, wav_len)[source]

此方法实现了注意力 RNN 解码器的前向传播。

参数:

inp_tensor (torch.Tensor) – RNN 解码器每个时间步的输入张量。
enc_states (torch.Tensor) – 需要被解码器注意的张量。
wav_len (torch.Tensor) – 此变量存储波形的相对长度。

返回:

outputs (torch.Tensor) – RNN 解码器的输出。
attn (torch.Tensor) – 每个时间步的注意力权重。

class speechbrain.nnet.RNN.LiGRU(hidden_size, input_shape, nonlinearity='relu', normalization='batchnorm', num_layers=1, bias=True, dropout=0.0, re_init=True, bidirectional=False)[source]

基类： Module

此函数实现了轻量 GRU (Li-GRU)。

Li-GRU 是一种单门 GRU 模型，基于批量归一化 + relu 激活 + 循环 dropout。更多信息请参见

“M. Ravanelli, P. Brakel, M. Omologo, Y. Bengio, Light Gated Recurrent Units for Speech Recognition, in IEEE Transactions on Emerging Topics in Computational Intelligence, 2018” (https://arxiv.org/abs/1803.10225)

如果在训练过程中遇到不稳定性，请改用 Stabilised Li-GRU (SLi-GRU)。参见

speechbrain.nnet.RNN.SLiGRU

为了提高模型速度，建议在使用前立即使用 torch 即时编译器 (jit)，或者您可以使用 https://github.com/Adel-Moumen/fast_ligru 提供的自定义实现 (CUDA+PyTorch)。

您可以使用以下命令编译：compiled_model = torch.jit.script(model)

它接受格式为 (batch, time, fea) 的输入张量。如果是 (batch, time, fea, channel) 这样的 4D 输入，张量会被展平为 (batch, time, fea*channel)。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。值（即时间和频率核大小）。
input_shape (tuple) – 示例输入的形状。
nonlinearity (str) – 非线性类型 (tanh, relu)。
normalization (str) – ligru 模型的归一化类型 (batchnorm, layernorm)。任何不同于 batchnorm 和 layernorm 的字符串都将导致不进行归一化。
num_layers (int) – 在 RNN 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。
bidirectional (bool) – 如果为 True，则使用双向模型，该模型从右向左和从左向右扫描序列。

示例

>>> inp_tensor = torch.rand([4, 10, 20])
>>> net = LiGRU(input_shape=inp_tensor.shape, hidden_size=5)
>>> out_tensor, _ = net(inp_tensor)
>>>
torch.Size([4, 10, 5])

forward(x, hx: Tensor | None = None)[source]

返回 Li-GRU 的输出。

参数:

x (torch.Tensor) – 输入张量。
hx (torch.Tensor) – 初始隐藏状态。

返回:

output (torch.Tensor) – LiGRU 的输出
hh (torch.Tensor) – 隐藏状态

class speechbrain.nnet.RNN.LiGRU_Layer(input_size, hidden_size, num_layers, batch_size, dropout=0.0, nonlinearity='relu', normalization='batchnorm', bias=True, bidirectional=False)[source]

基类： Module

此类实现了轻量门控循环单元 (Li-GRU) 层。

参数:

input_size (int) – 输入张量的特征维度。
hidden_size (int) – 输出神经元数量。
num_layers (int) – 层数。
batch_size (int) – 输入张量的批量大小。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
nonlinearity (str) – 非线性类型 (tanh, sin, leaky_relu, relu)。
normalization (str) – 归一化类型 (batchnorm, layernorm)。任何不同于 batchnorm 和 layernorm 的字符串都将导致层归一化。
bias (bool) – 如果为 True，则采用加性偏差 b。
bidirectional (bool) – 如果为 True，则使用双向模型，该模型从右向左和从左向右扫描序列。

forward(x: Tensor, hx: Tensor | None = None) → Tensor[source]

返回 liGRU 层的输出。

参数:

x (torch.Tensor) – 输入张量。
hx (torch.Tensor) – 隐藏状态。

返回:

h – liGRU 的输出。

返回类型:

torch.Tensor

class speechbrain.nnet.RNN.SLiGRU(hidden_size, input_shape, nonlinearity='relu', ff_normalization='batchnorm', recurrent_elementwise_affine=False, num_layers=1, bias=True, dropout=0.0, re_init=True, bidirectional=False)[source]

基类： Module

此类实现了稳定轻量 GRU (SLi-GRU)。

SLi-GRU 是一种单门 GRU 模型，基于批量归一化 + relu 激活 + 循环连接上的层归一化 + 循环 dropout。

SLi-GRU 与普通 Li-GRU 在循环权重上有所不同。事实上，Li-GRU 在循环权重上存在梯度爆炸问题，无法在中大型 ASR 数据集上进行训练。为了解决这个问题，我们在循环权重上使用了层归一化，这稳定了模型的训练，并允许在大型 ASR 数据集上进行训练而没有任何问题。

此模型在 CommonVoice/LibriSpeech 数据集上（WER 和效率）优于传统的 LSTM/GRU 模型。

更多信息请参见：“Moumen, A., & Parcollet, T. (2023, June). Stabilising and accelerating light gated recurrent units for automatic speech recognition. In ICASSP 2023-2023 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) (pp. 1-5). IEEE.” (https://arxiv.org/abs/2302.10144)

为了提高模型速度，建议在使用前立即使用 torch 即时编译器 (jit)，或者您可以使用 https://github.com/Adel-Moumen/fast_ligru 提供的自定义实现 (CUDA+PyTorch)。

您可以使用以下命令编译：compiled_model = torch.jit.script(model)

它接受格式为 (batch, time, fea) 的输入张量。如果是 (batch, time, fea, channel) 这样的 4D 输入，张量会被展平为 (batch, time, fea*channel)。

参数:

hidden_size (int) – 输出神经元的数量（即输出的维度）。值（即时间和频率核大小）。
input_shape (tuple) – 示例输入的形状。
nonlinearity (str) – 非线性类型 (tanh, relu)。
ff_normalization (str) – ligru 模型的全连接归一化类型 (batchnorm, layernorm)。任何不同于 batchnorm 和 layernorm 的字符串都将导致不进行归一化。
recurrent_elementwise_affine (bool) – 一个布尔值，设置为 True 时启用可学习的仿射参数。
num_layers (int) – 在 RNN 架构中使用的层数。
bias (bool) – 如果为 True，则采用加性偏差 b。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
re_init (bool) – 如果为 True，则对循环权重使用正交初始化。对输入连接权重使用 Xavier 初始化。
bidirectional (bool) – 如果为 True，则使用双向模型，该模型从右向左和从左向右扫描序列。

示例

>>> inp_tensor = torch.rand([4, 10, 20])
>>> net = SLiGRU(input_shape=inp_tensor.shape, hidden_size=5)
>>> out_tensor, _ = net(inp_tensor)
>>>
torch.Size([4, 10, 5])

forward(x, hx: Tensor | None = None)[source]

返回 SLi-GRU 的输出。

参数:

x (torch.Tensor) – 输入张量。
hx (torch.Tensor) – 初始隐藏状态。

返回:

output (torch.Tensor) – SLiGRU 的输出
hh (torch.Tensor) – 隐藏状态

class speechbrain.nnet.RNN.SLiGRU_Layer(input_size, hidden_size, num_layers, batch_size, dropout=0.0, nonlinearity='relu', ff_normalization='batchnorm', recurrent_elementwise_affine=False, bias=True, bidirectional=False)[source]

基类： Module

此类实现了稳定轻量门控循环单元 (SLi-GRU) 层。

参数:

input_size (int) – 输入张量的特征维度。
hidden_size (int) – 输出神经元数量。
num_layers (int) – 层数。
batch_size (int) – 输入张量的批量大小。
dropout (float) – dropout 因子（必须在 0 到 1 之间）。
nonlinearity (str) – 非线性类型 (tanh, sin, leaky_relu, relu)。
ff_normalization (str) – 归一化类型 (batchnorm, layernorm)。任何不同于 batchnorm 和 layernorm 的字符串都将导致层归一化。请注意，这仅适用于前馈仿射变换。SLi-GRU（与 Li-GRU 不同）无条件地在循环层中应用层归一化，这不受此参数的影响。
recurrent_elementwise_affine (bool) – 一个布尔值，设置为 True 时启用可学习的仿射参数。
bias (bool) – 如果为 True，则采用加性偏差 b。
bidirectional (bool) – 如果为 True，则使用双向模型，该模型从右向左和从左向右扫描序列。

forward(x: Tensor, hx: Tensor | None = None) → Tensor[source]

返回 liGRU 层的输出。

参数:

x (torch.Tensor) – 输入张量。
hx (torch.Tensor) – 隐藏状态。

返回:

h – liGRU 的输出。

返回类型:

torch.Tensor

class speechbrain.nnet.RNN.QuasiRNNLayer(input_size, hidden_size, bidirectional, zoneout=0.0, output_gate=True)[source]

基类： Module

将单层准循环神经网络 (QRNN) 应用于输入序列。

参数:

input_size (int) – 输入 x 中预期特征的数量。
hidden_size (int) – 隐藏状态 h 中的特征数量。如果未指定，则使用输入大小。
bidirectional (bool) – 是否在向前和向后两个方向应用 RNN。
zoneout (float) – 是否对隐藏状态更新应用 zoneout（即未能更新隐藏状态中的元素）。默认值：0。
output_gate (bool) – 如果为 True，则执行 QRNN-fo（对输出应用输出门）。如果为 False，则执行 QRNN-f。默认值：True。

示例

>>> import torch
>>> model = QuasiRNNLayer(60, 256, bidirectional=True)
>>> a = torch.rand([10, 120, 60])
>>> b = model(a)
>>> b[0].shape
torch.Size([10, 120, 512])

forgetMult(f: Tensor, x: Tensor, hidden: Tensor | None) → Tensor[source]

返回每个时间步的隐藏状态。

参数:

f (torch.Tensor)
x (torch.Tensor) – 输入张量
hidden (torch.Tensor) – 如果有的话，第一个隐藏状态。

返回类型:

每个步骤的隐藏状态。

split_gate_inputs(y: Tensor) → tuple[Tensor, Tensor, Tensor | None][source]: 分割输入门。

forward(x: Tensor, hidden: Tensor | None = None) → tuple[Tensor, Tensor][source]

返回 QRNN 层的输出。

参数:

x (torch.Tensor) – 用于线性变换的输入。
hidden (torch.Tensor) – 如果有的话，初始隐藏状态。

返回:

h (torch.Tensor)
c (torch.Tensor)

class speechbrain.nnet.RNN.QuasiRNN(hidden_size, input_shape=None, input_size=None, num_layers=1, bias=True, dropout=0, bidirectional=False, **kwargs)[source]

基类： Module

这是 Quasi-RNN 的一个实现。

https://arxiv.org/pdf/1611.01576.pdf

部分代码改编自：https://github.com/salesforce/pytorch-qrnn

参数:

hidden_size (int) – 隐藏状态 h 中的特征数量。如果未指定，则使用输入大小。
input_shape (tuple) – 输入示例的形状。或者，使用 input_size。
input_size (int) – 输入的大小。或者，使用 input_shape。
num_layers (int) – 生成的 QRNN 层数。
bias (bool) – 是否添加偏置项，仅支持 True。
dropout (float) – 输出归零的概率。
bidirectional (bool) – 如果为 True，则一组参数向前遍历，另一组参数从末尾向起始遍历。
**kwargs (dict) – 传递给 QuasiRNN 层的参数。

示例

>>> a = torch.rand([8, 120, 40])
>>> model = QuasiRNN(
...     256, num_layers=4, input_shape=a.shape, bidirectional=True
... )
>>> b, _ = model(a)
>>> b.shape
torch.Size([8, 120, 512])

forward(x, hidden=None)[source]: 将 QuasiRNN 应用于输入张量 x。

speechbrain.nnet.RNN.rnn_init(module)[source]

此函数用于初始化 RNN 权重。循环连接：正交初始化。

参数:: module (torch.nn.Module) – 循环神经网络模块。

示例

>>> inp_tensor = torch.rand([4, 10, 20])
>>> net = RNN(hidden_size=5, input_shape=inp_tensor.shape)
>>> out_tensor = net(inp_tensor)
>>> rnn_init(net)