speechbrain.nnet.RNN 模块
实现循环神经网络的库。
- Authors
阿德尔·穆门 2023
Mirco Ravanelli 2020
周珏洁 2020
钟建元 2020
洛伦·卢戈斯奇 2020
摘要
类：
此函数实现了带有注意力的RNN解码器模型。 |
|
此函数实现了一个基本的GRU。 |
|
这个类实现了一个基本的GRU单元，用于处理单个时间步的输入，而GRU()则接受整个序列作为输入。 |
|
此函数实现了一个基本的LSTM。 |
|
该类实现了一个基本的LSTM单元，用于处理单个时间步的输入，而LSTM()则接受整个序列作为输入。 |
|
此函数实现了轻量级GRU（Li-GRU）。 |
|
该类实现了轻量门控循环单元（Li-GRU）层。 |
|
这是Quasi-RNN的一个实现。 |
|
将单层准循环神经网络（QRNN）应用于输入序列。 |
|
此函数实现了一个普通的RNN。 |
|
该类实现了一个基本的RNN单元，用于处理单个时间步的输入，而RNN()则将整个序列作为输入。 |
|
该类实现了一个稳定的轻量级GRU（SLi-GRU）。 |
|
该类实现了一个稳定的轻门控循环单元（SLi-GRU）层。 |
函数：
返回打包的speechbrain格式张量。 |
|
从打包的序列中返回speechbrain格式的张量。 |
|
此函数用于初始化RNN权重。 |
参考
- speechbrain.nnet.RNN.pack_padded_sequence(inputs, lengths)[source]
返回打包的speechbrain格式的张量。
- Parameters:
inputs (torch.Tensor) – 要打包的序列。
lengths (torch.Tensor) – 每个序列的长度。
- Return type:
打包的序列。
- speechbrain.nnet.RNN.pad_packed_sequence(inputs)[source]
从打包的序列中返回speechbrain格式的张量。
- Parameters:
inputs (torch.nn.utils.rnn.PackedSequence) – 一组要转换为张量的输入序列。
- Returns:
outputs – 填充后的序列。
- Return type:
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此函数实现了一个普通的RNN。
它接受格式为 (batch, time, fea) 的输入张量。 在像 (batch, time, fea, channel) 这样的4d输入情况下，张量会被展平为 (batch, time, fea*channel)。
- Parameters:
hidden_size (int) – 输出神经元的数量（即输出的维度）。 值（即时间和频率核大小分别）。
input_shape (元组) – 示例输入的形状。或者，使用
input_size。input_size (int) – 输入的大小。或者，使用
input_shape。非线性 (str) – 非线性类型（tanh, relu）。
num_layers (int) – 在RNN架构中使用的层数。
bias (bool) – 如果为True，则采用加法偏置b。
dropout (float) – 这是dropout因子（必须在0和1之间）。
re_init (bool) – 如果为True，则对循环权重使用正交初始化。 对输入连接权重使用Xavier初始化。
双向 (bool) – 如果为True，则使用一个双向模型，该模型会从左到右和从右到左扫描序列。
Example
>>> 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])
- 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)。
- Parameters:
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初始化。
双向 (bool) – 如果为True，则使用一个双向模型，该模型会从左到右和从右到左扫描序列。
Example
>>> 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])
- 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)的输入张量。 在4d输入的情况下，如(batch, time, fea, channel)，张量会被展平为(batch, time, fea*channel)。
- Parameters:
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初始化。
双向 (bool) – 如果为True，则使用一个双向模型，该模型会从左到右和从右到左扫描序列。
Example
>>> 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])
- 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) 的输入张量。
- Parameters:
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初始化。
非线性 (str) – 非线性类型（tanh, relu）。
Example
>>> 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])
- 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)的输入张量。
- Parameters:
Example
>>> 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])
- 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)的输入张量。
- Parameters:
Example
>>> 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])
- 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模型。它接受格式为（批次，时间，特征）的enc_states张量。在4d输入的情况下，如（批次，时间，特征，通道），张量按以下方式展平：（批次，时间，特征*通道）。
- Parameters:
rnn_type (str) – 使用的循环神经网络类型（rnn, lstm, gru）。
attn_type (str) – 使用的注意力类型（位置，内容）。
hidden_size (int) – 神经元的数量。
attn_dim (int) – 注意力模块内部和输出神经元的数量。
num_layers (int) – 在RNN架构中使用的层数。
enc_dim (int) – 编码维度的大小。
input_size (int) – 相关输入维度的预期大小。
非线性 (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之间）。
Example
>>> 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]
前向传播过程的一步。
- Parameters:
inp (torch.Tensor) – 当前时间步的输入。
hs (torch.Tensor 或 tuple 的 torch.Tensor) – RNN的细胞状态。
c (torch.Tensor) – 前一个时间步的上下文向量。
enc_states (torch.Tensor) – 由编码器生成的张量，用于注意力机制。
enc_len (torch.LongTensor) – 编码器状态的实际长度。
- Returns:
dec_out (torch.Tensor) – 输出张量。
hs (torch.Tensor 或 torch.Tensor 的元组) – RNN 的新细胞状态。
c (torch.Tensor) – 当前时间步的上下文向量。
w (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 是基于批归一化 + relu 激活 + 循环丢弃的单门 GRU 模型。更多信息请参见：
“M. Ravanelli, P. Brakel, M. Omologo, Y. Bengio, 用于语音识别的轻量门控循环单元, 发表于 IEEE 计算智能新兴主题汇刊, 2018” (https://arxiv.org/abs/1803.10225)
如果在训练过程中遇到不稳定性，请改用稳定化的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)。
- Parameters:
hidden_size (int) – 输出神经元的数量（即输出的维度）。 值（即时间和频率核大小分别）。
input_shape (tuple) – 示例输入的形状。
非线性 (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初始化。
双向 (bool) – 如果为True，则使用一个双向模型，该模型会从左到右和从右到左扫描序列。
Example
>>> 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])
- 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）层。
- Parameters:
input_size (int) – 输入张量的特征维度。
hidden_size (int) – 输出神经元的数量。
num_layers (int) – 层数。
batch_size (int) – 输入张量的批量大小。
dropout (float) – 这是dropout因子（必须在0和1之间）。
非线性 (str) – 非线性类型（tanh, sin, leaky_relu, relu）。
normalization (str) – 归一化类型（batchnorm, layernorm）。 任何不同于batchnorm和layernorm的字符串都将导致层归一化。
bias (bool) – 如果为True，则采用加法偏置b。
双向 (bool) – 如果为True，则使用一个双向模型，该模型会同时从右到左和从左到右扫描序列。
- 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 是基于批归一化 + relu 激活 + 循环连接上的层归一化 + 循环 dropout 的单门 GRU 模型。
SLi-GRU 与普通的 Li-GRU 在循环权重上有所不同。事实上，Li-GRU 在循环权重上存在梯度爆炸问题，无法在中大型 ASR 数据集上进行训练。为了解决这个问题，我们在循环权重上使用了层归一化，这稳定了模型的训练，并使其能够在大规模 ASR 数据集上顺利训练。
该模型在CommonVoice/LibriSpeech数据集上击败了传统的LSTM/GRU模型（WER和效率）。
更多信息请参见： “Moumen, A., & Parcollet, T. (2023, 6月). 稳定和加速用于自动语音识别的轻量门控循环单元。 在ICASSP 2023-2023 IEEE国际声学、语音和信号处理会议(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)。
- Parameters:
hidden_size (int) – 输出神经元的数量（即输出的维度）。 值（即时间和频率核大小分别）。
input_shape (tuple) – 示例输入的形状。
非线性 (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初始化。
双向 (bool) – 如果为True，则使用一个双向模型，该模型会从左到右和从右到左扫描序列。
Example
>>> 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])
- 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）层。
- Parameters:
input_size (int) – 输入张量的特征维度。
hidden_size (int) – 输出神经元的数量。
num_layers (int) – 层数。
batch_size (int) – 输入张量的批量大小。
dropout (float) – 这是dropout因子（必须在0和1之间）。
非线性 (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。
双向 (bool) – 如果为True，则使用一个双向模型，该模型会同时从右到左和从左到右扫描序列。
- class speechbrain.nnet.RNN.QuasiRNNLayer(input_size, hidden_size, bidirectional, zoneout=0.0, output_gate=True)[source]
基础：
Module将单层准循环神经网络（QRNN）应用于输入序列。
- Parameters:
Example
>>> 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: torch.Tensor, hidden: Tensor | None) torch.Tensor[source]
返回每个时间步的隐藏状态。
- Parameters:
f (torch.Tensor)
x (torch.Tensor) – 输入张量
hidden (torch.Tensor) – 如果有的话，第一个隐藏状态。
- Return type:
每个步骤的隐藏状态。
- 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
- Parameters:
hidden_size (int) – 隐藏状态 h 中的特征数量。如果未指定，则使用输入大小。
input_shape (tuple) – 示例输入的形状。或者，使用
input_size。input_size (int) – 输入的大小。或者，使用
input_shape。num_layers (int) – 要生成的QRNN层数。
bias (bool) – 是否添加偏置项，仅支持True。
dropout (float) – 将输出置零的比率。
双向 (bool) – 如果为真，一组参数将向前遍历，另一组参数将从末尾向开始遍历。
**kwargs (dict) – 传递给QuasiRNN层的参数。
Example
>>> 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])