speechbrain.lobes.models.resepformer 模块

资源高效Sepformer的库。

Authors

Cem Subakan 2022

摘要

类：

`MemLSTM`	SkiM 的 Mem-LSTM --
`ResourceEfficientSeparationPipeline`	用于RE-SepFormer和SkiM的资源高效分离管道
`ResourceEfficientSeparator`	资源高效源分离器这是实现RE-SepFormer的类
`SBRNNBlock`	带有输出层的RNNBlock。
`SBTransformerBlock_wnormandskip`	SpeechBrain实现的transformer编码器的封装。
`SegLSTM`	SkiM的分段LSTM

参考

class speechbrain.lobes.models.resepformer.MemLSTM(hidden_size, dropout=0.0, bidirectional=False, mem_type='hc', norm_type='cln')[source]

基础：Module

SkiM的Mem-LSTM –

注意：这是从ESPNet工具包中的SkiM实现中提取的，并进行了修改以兼容SpeechBrain。

Parameters:

hidden_size (int) – 隐藏状态的维度。
dropout (float) – dropout比例。默认值为0。
双向 (bool) – LSTM层是否为双向的。默认值为 False。
mem_type (str) – ‘hc’, ‘h’, ‘c’, 或 ‘id’ 这控制了SegLSTM的隐藏（或单元）状态是否会被MemLSTM处理。在‘id’模式下，隐藏状态和单元状态将完全相同地返回。
norm_type (str) – ‘gln’, ‘cln’ 这选择了归一化的类型 cln 用于因果实现

Example

>>> x = (torch.randn(1, 5, 64), torch.randn(1, 5, 64))
>>> block = MemLSTM(64)
>>> x = block(x, 5)
>>> x[0].shape
torch.Size([1, 5, 64])

forward(hc, S)[source]

记忆RNN的前向函数

Parameters:

hc (tuple) –
(h, c), 来自SegLSTM的隐藏状态和细胞状态的元组 h和c的形状: (d, B*S, H)

其中d是方向的数量
B是批量大小 S是块的数量 H是潜在维度
S (int) – S 是块的数量

Returns:

ret_val – 内存RNN的输出

Return type:

torch.Tensor

class speechbrain.lobes.models.resepformer.SegLSTM(input_size, hidden_size, dropout=0.0, bidirectional=False, norm_type='cLN')[source]

基础：Module

SkiM的Segment-LSTM

注意：这是从ESPNet工具包中的SkiM实现中提取的，并进行了修改以兼容SpeechBrain。

Parameters:

input_size (int,) – 输入特征的维度。输入应具有形状 (batch, seq_len, input_size)。
hidden_size (int,) – 隐藏状态的维度。
dropout (float,) – dropout比例。默认值为0。
双向 (bool,) – LSTM层是否为双向。默认值为False。
norm_type (str) – 其中之一是 gln, cln。这选择了归一化的类型 cln 用于因果实现。

Example

>>> x = torch.randn(3, 20, 64)
>>> hc = None
>>> seglstm = SegLSTM(64, 64)
>>> y = seglstm(x, hc)
>>> y[0].shape
torch.Size([3, 20, 64])

forward(input, hc)[source]

Segment LSTM的前向函数

Parameters:

input (torch.Tensor) –
形状 [B*S, T, H] 其中 B 是批量大小

S 是块的数量 T 是块的大小 H 是潜在维度
hc (tuple) –
来自SegLSTM的隐藏状态和单元状态的元组 h和c的形状：(d, B*S, H)

其中d是方向的数量
B是批量大小 S是块的数量 H是潜在维度

Returns:

output (torch.Tensor) – Segment LSTM 的输出
(h, c) (tuple) – 与 hc 输入相同

class speechbrain.lobes.models.resepformer.SBRNNBlock(input_size, hidden_channels, num_layers, outsize, rnn_type='LSTM', dropout=0, bidirectional=True)[source]

基础：Module

带有输出层的RNNBlock。

Parameters:

input_size (int) – 输入特征的维度。
hidden_channels (int) – RNN潜在层的维度。
num_layers (int) – RNN层的数量。
outsize (int) – 线性层输出时的维度数量
rnn_type (str) – RNN单元的类型。
dropout (float) – 丢弃率
双向 (bool) – 如果为True，则为双向。

Example

>>> x = torch.randn(10, 100, 64)
>>> rnn = SBRNNBlock(64, 100, 1, 128, bidirectional=True)
>>> x = rnn(x)
>>> x.shape
torch.Size([10, 100, 128])

forward(x)[source]

返回转换后的输出。

Parameters:

x (torch.Tensor) –

[B, L, N] 其中，B = 批量大小，

N = 滤波器数量 L = 时间点

Returns:

out – 转换后的输出。

Return type:

torch.Tensor

class speechbrain.lobes.models.resepformer.SBTransformerBlock_wnormandskip(num_layers, d_model, nhead, d_ffn=2048, input_shape=None, kdim=None, vdim=None, dropout=0.1, activation='relu', use_positional_encoding=False, norm_before=False, attention_type='regularMHA', causal=False, use_norm=True, use_skip=True, norm_type='gln')[source]

基础：Module

SpeechBrain实现的transformer编码器的封装。

Parameters:

num_layers (int) – 层数。
d_model (int) – 表示的维度。
nhead (int) – 注意力头的数量。
d_ffn (int) – 位置前馈的维度。
input_shape (tuple) – 输入的形状。
kdim (int) – 键的维度（可选）。
vdim (int) – 值的维度（可选）。
dropout (float) – 丢弃率。
activation (str) – 激活函数。
use_positional_encoding (bool) – 如果为真，我们使用位置编码。
norm_before (bool) – 在转换之前使用归一化。
attention_type (str) – 注意力的类型，默认为“regularMHA”
因果 (布尔) – 是否屏蔽未来信息，默认为 False
use_norm (bool) – 是否在块中包含规范。
use_skip (bool) – 是否在块中添加跳跃连接。
norm_type (str) – 其中之一为“cln”、“gln”

Example

>>> x = torch.randn(10, 100, 64)
>>> block = SBTransformerBlock_wnormandskip(1, 64, 8)
>>> x = block(x)
>>> x.shape
torch.Size([10, 100, 64])

forward(x)[source]

返回转换后的输出。

Parameters:

x (torch.Tensor) –

张量形状 [B, L, N], 其中, B = 批量大小,

L = 时间点 N = 滤波器数量

Returns:

out – 转换后的输出。

Return type:

torch.Tensor

class speechbrain.lobes.models.resepformer.ResourceEfficientSeparationPipeline(input_size, hidden_size, output_size, dropout=0.0, num_blocks=2, segment_size=20, bidirectional=True, mem_type='av', norm_type='gln', seg_model=None, mem_model=None)[source]

基础：Module

用于RE-SepFormer和SkiM的资源高效分离管道

注意：此实现是对ESPNET实现的SkiM的泛化

Parameters:

input_size (int) – 输入特征的维度。输入形状应为 (batch, length, input_size)
hidden_size (int) – 隐藏状态的维度。
output_size (int) – 输出大小的维度。
dropout (float) – 丢弃率。默认值为0。
num_blocks (int) – 基本SkiM块的数量
segment_size (int) – 用于分割长特征的段大小
双向 (bool) – RNN层是否是双向的。
mem_type (str) – ‘hc’, ‘h’, ‘c’, ‘id’ 或 None. 这控制了SegLSTM的隐藏（或单元）状态是否会被MemLSTM处理。在‘id’模式下，隐藏状态和单元状态将完全相同地返回。当mem_type为None时，MemLSTM将被移除。
norm_type (str) – 其中之一是 gln 或 cln cln 用于因果实现。
seg_model (class) – 处理段内元素的模型
mem_model (class) – 确保段之间连续性的内存模型

Example

>>> x = torch.randn(10, 100, 64)
>>> seg_mdl = SBTransformerBlock_wnormandskip(1, 64, 8)
>>> mem_mdl = SBTransformerBlock_wnormandskip(1, 64, 8)
>>> resepf_pipeline = ResourceEfficientSeparationPipeline(64, 64, 128, seg_model=seg_mdl, mem_model=mem_mdl)
>>> out = resepf_pipeline.forward(x)
>>> out.shape
torch.Size([10, 100, 128])

forward(input)[source]

ResourceEfficientSeparationPipeline的前向函数

这接受一个大小为 [B, (S*K), D] 的张量

Parameters:

input (torch.Tensor) –

张量形状 [B, (S*K), D], 其中, B = 批量大小,

S = 块数 K = 块大小 D = 特征数量

Returns:

output – 分离后的张量。

Return type:

torch.Tensor

class speechbrain.lobes.models.resepformer.ResourceEfficientSeparator(input_dim: int, causal: bool = True, num_spk: int = 2, nonlinear: str = 'relu', layer: int = 3, unit: int = 512, segment_size: int = 20, dropout: float = 0.0, mem_type: str = 'hc', seg_model=None, mem_model=None)[source]

基础：Module

资源高效源分离器这是实现RE-SepFormer的类

Parameters:

input_dim (int) – 输入特征维度
causal (bool) – 系统是否是因果的。
num_spk (int) – 目标说话者的数量。
非线性 (类) – 用于掩码估计的非线性函数，从‘relu’, ‘tanh’, ‘sigmoid’中选择
层数 (int) – 块的数量。对于RE-SepFormer，默认值为2。
unit (int) – 隐藏状态的维度。
segment_size (int) – 用于分割长特征的块大小
dropout (float) – dropout比例。默认值为0。
mem_type (str) – ‘hc’, ‘h’, ‘c’, ‘id’, ‘av’ 或 None。这控制是否将使用内存表示来确保段之间的连续性。在‘av’模式下，摘要状态是通过简单地平均每个段的时间维度来计算的。在‘id’模式下，隐藏状态和单元状态将完全相同地返回。当mem_type为None时，内存模型将被移除。
seg_model (class) – 处理段内元素的模型
mem_model (class) – 确保段之间连续性的内存模型

Example

>>> x = torch.randn(10, 64, 100)
>>> seg_mdl = SBTransformerBlock_wnormandskip(1, 64, 8)
>>> mem_mdl = SBTransformerBlock_wnormandskip(1, 64, 8)
>>> resepformer = ResourceEfficientSeparator(64, num_spk=3, mem_type='av', seg_model=seg_mdl, mem_model=mem_mdl)
>>> out = resepformer.forward(x)
>>> out.shape
torch.Size([3, 10, 64, 100])

forward(inpt: Tensor)[source]

前进

Parameters:: inpt (torch.Tensor) – 编码特征 [B, T, N]
Returns:: mask_tensor
Return type:: torch.Tensor