重要提示

您正在查看 NeMo 2.0 文档。此版本引入了 API 的重大更改和一个新的库 NeMo Run。我们目前正在将 NeMo 1.0 中的所有功能移植到 2.0。有关先前版本或 2.0 中尚不可用的功能的文档，请参阅 NeMo 24.07 文档。

NeMo 音频 API#

模型类#

基类#

class nemo.collections.audio.models.AudioToAudioModel(*args: Any, **kwargs: Any)#

基类：ModelPT, ABC

音频到音频模型的基础类。

参数:

cfg – 具有配置参数的 DictConfig 对象。
trainer – 用于训练的 Trainer 对象。

configure_callbacks()#: 创建一个回调以将音频/频谱图添加到 tensorboard 和 wandb 中。

classmethod list_available_models() → List[PretrainedModelInfo]#

此方法返回一个预训练模型列表，这些模型可以直接从 NVIDIA 的 NGC 云实例化。

返回:: 可用预训练模型的列表。

static match_batch_length( input: torch.Tensor, batch_length: int, ) → torch.Tensor#

裁剪或填充输出以匹配批次长度。

参数:

input – 形状为 (B, C, T) 的张量
batch_length – 整数

返回:

形状为 (B, C, T) 的张量，其中 T 匹配批次长度。

multi_test_epoch_end( outputs, dataloader_idx: int = 0, )#

添加对多个测试数据集的支持。应由子类重写，以便为每个数据加载器获得适当的日志。

参数:

outputs – 与 LightningModule.on_validation_epoch_end() 为单个数据加载器提供的输出相同。
dataloader_idx – 表示数据加载器索引的整数。

返回:

值的字典，可选择包含子字典 log，以便日志中的值将以数据加载器前缀开头。

multi_validation_epoch_end( outputs, dataloader_idx: int = 0, )#

添加对多个验证数据集的支持。应由子类重写，以便为每个数据加载器获得适当的日志。

参数:

outputs – 与 LightningModule.on_validation_epoch_end() 为单个数据加载器提供的输出相同。
dataloader_idx – 表示数据加载器索引的整数。

返回:

值的字典，可选择包含子字典 log，以便日志中的值将以数据加载器前缀开头。

on_after_backward()#: 将任何为 NAN 或 INF 的梯度归零

获取音频文件路径，并返回处理后音频的路径列表。

参数:

paths2audio_files – 要处理的音频文件路径
output_dir – 用于保存处理后文件的目录
batch_size – (int) 推理期间使用的批次大小。
num_workers – 数据加载器的工作人员数量
input_channel_selector (int | Iterable[int] | str) – 从多声道音频中选择单个声道或声道子集。如果设置为 ‘average’，则执行跨声道的平均。如果设置为 None，则禁用。默认为 None。
input_dir – 可选，包含输入文件的目录。如果提供，输出目录将镜像输入目录结构。

返回:

处理后音频信号的路径。

setup_optimization_flags()#

子类必须显式调用的实用程序方法，以便支持可选的优化标志。此方法是在 DDP 训练发生之前访问 self.cfg 的唯一有效位置。

子类可以选择不支持此方法，因此此处的所有变量都必须通过 hasattr() 进行检查

处理模型#

class nemo.collections.audio.models.EncMaskDecAudioToAudioModel(*args: Any, **kwargs: Any)#

基类：AudioToAudioModel

用于编码器-掩码-解码器音频处理模型的类。

该模型由以下模块组成

encoder：将输入多声道音频信号转换为编码表示（分析变换）
mask_estimator：估计信号处理器使用的掩码
mask_processor：基于掩码的信号处理器，组合编码输入和估计的掩码
decoder：将处理器输出转换为时域（合成变换）

forward(input_signal, input_length=None)#

模型的前向传递。

参数:

input_signal – 表示一批原始音频信号的张量，形状为 [B, T] 或 [B, T, C]。T 在这里表示时间步长，1 秒音频表示为 self.sample_rate 个浮点值。
input_signal_length – 长度为 B 的向量，包含音频序列的各个长度。

返回:

时域中的输出信号 output 和输出信号的长度 output_length。

property input_types: Dict[str, NeuralType]#: 定义这些以启用输入神经类型检查

classmethod list_available_models() → PretrainedModelInfo | None#

此方法返回一个预训练模型列表，这些模型可以直接从 NVIDIA 的 NGC 云实例化。

返回:: 可用预训练模型的列表。

property output_types: Dict[str, NeuralType]#: 定义这些以启用输出神经类型检查

class nemo.collections.audio.models.FlowMatchingAudioToAudioModel(*args: Any, **kwargs: Any)#

基类：AudioToAudioModel

此模型使用流匹配过程来生成增强信号的编码表示。

该模型由以下模块组成

encoder：将输入多声道音频信号转换为编码表示（分析变换）
estimator：神经模型，估计扩散过程的分数
flow：定义流和向量场的常微分方程 (ODE)。
sampler：用于推理过程的采样器，估计目标信号的系数
decoder：将采样器输出转换为时域（合成变换）
ssl_pretrain_masking：如果已定义，则在训练过程中执行 ssl 预训练掩码以进行自我重建

property input_types: Dict[str, NeuralType]#: 定义这些以启用输入神经类型检查

property output_types: Dict[str, NeuralType]#: 定义这些以启用输出神经类型检查

class nemo.collections.audio.models.PredictiveAudioToAudioModel(*args: Any, **kwargs: Any)#

基类：AudioToAudioModel

此模型旨在通过应用神经模型直接估计编码域中的系数。

forward(input_signal, input_length=None)#

模型的前向传递。

参数:

input_signal – 时域信号
input_length – 批次中每个示例的有效长度

返回:

时域中的输出信号 output 和输出信号的长度 output_length。

property input_types: Dict[str, NeuralType]#: 定义这些以启用输入神经类型检查

property output_types: Dict[str, NeuralType]#: 定义这些以启用输出神经类型检查

class nemo.collections.audio.models.ScoreBasedGenerativeAudioToAudioModel(*args: Any, **kwargs: Any)#

基类：AudioToAudioModel

此模型使用基于分数的扩散过程来生成增强信号的编码表示。

该模型由以下模块组成

encoder：将输入多声道音频信号转换为编码表示（分析变换）
estimator：神经模型，估计扩散过程的分数
sde：定义前向和反向扩散过程的随机微分方程 (SDE)
sampler：用于反向扩散过程的采样器，估计目标信号的系数
decoder：将采样器输出转换为时域（合成变换）

property input_types: Dict[str, NeuralType]#: 定义这些以启用输入神经类型检查

property output_types: Dict[str, NeuralType]#: 定义这些以启用输出神经类型检查

class nemo.collections.audio.models.SchroedingerBridgeAudioToAudioModel(*args: Any, **kwargs: Any)#

基类：AudioToAudioModel

此模型使用薛定谔桥过程来生成增强信号的编码表示。

该模型由以下模块组成

encoder：将输入音频信号转换为编码表示（分析变换）
estimator：神经模型，估计 SB 过程的系数
noise_schedule：定义干净信号和噪声信号之间的路径
sampler：用于反向过程的采样器，估计目标信号的系数
decoder：将采样器输出转换为时域（合成变换）

参考文献

用于生成语音增强的薛定谔桥，https://arxiv.org/abs/2407.16074

property input_types: Dict[str, NeuralType]#: 定义这些以启用输入神经类型检查

property output_types: Dict[str, NeuralType]#: 定义这些以启用输出神经类型检查

模块#

特征#

class nemo.collections.audio.modules.features.SpectrogramToMultichannelFeatures(*args: Any, **kwargs: Any)#

基类：NeuralModule

将复值多声道频谱图转换为多声道特征。

参数:

num_subbands – 输入信号中预期的子带数量
num_input_channels – 可选，提供输入信号的声道数。用于推断输出声道数。
mag_reduction – 跨声道的缩减。默认 None，将计算每个声道的幅度。
mag_power – 可选，对幅度应用幂次。
use_ipd – 使用声道间相位差 (IPD)。
mag_normalization – 幅度特征的归一化
ipd_normalization – IPD 特征的归一化
eps – 小的正则化常数。

forward( input: torch.Tensor, input_length: torch.Tensor, ) → torch.Tensor#

将 C 声道频谱图的输入批次转换为具有维度 num_feat 的时频特征批次。输出声道数可能与输入相同，也可能减少到 1，例如，如果对幅度求平均值并且不附加单独的 IPD。

参数:

input – C 声道的频谱图，具有 F 个子带和 N 个时间帧，(B, C, F, N)
input_length – 沿时间维度的有效条目的长度，形状 (B,)

返回:

具有 num_feat 特征的 num_feat_channels 声道，形状 (B, num_feat_channels, num_feat, N)

classmethod get_mean_std_time_channel( input: torch.Tensor, input_length: torch.Tensor | None = None, eps: float = 1e-10, ) → torch.Tensor#

计算跨时间和声道维度的均值和标准差。

参数:

input – 形状为 (B, C, F, T) 的张量
input_length – 形状为 (B,) 的张量

返回:

input 的均值和标准差，跨时间和声道维度计算，每个形状为 (B, 1, F, 1)。

static get_mean_time_channel( input: torch.Tensor, input_length: torch.Tensor | None = None, ) → torch.Tensor#

计算跨时间和声道维度的均值。

参数:

input – 形状为 (B, C, F, T) 的张量
input_length – 形状为 (B,) 的张量

返回:

input 的均值，跨时间和声道维度计算，形状为 (B, 1, F, 1)

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

normalize_mean( input: torch.Tensor, input_length: torch.Tensor, ) → torch.Tensor#

输入张量的均值归一化。

参数:

input – 输入张量
input_length – 每个样本的有效长度

返回:

均值归一化后的输入。

normalize_mean_var( input: torch.Tensor, input_length: torch.Tensor, ) → torch.Tensor#

输入张量的均值和方差归一化。

参数:

input – 输入张量
input_length – 每个样本的有效长度

返回:

均值和方差归一化后的输入。

property num_channels: int#: 配置的通道数

property num_features: int#: 配置的特征数

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

掩码#

class nemo.collections.audio.modules.masking.MaskEstimatorRNN(*args: Any, **kwargs: Any)#

基类：NeuralModule

使用堆叠的 RNN 和投影，从输入频谱图中估计 num_outputs 个掩码。

该模块的结构如下

输入 –> 空间特征 –> 输入投影 –>: –> 堆叠的 RNN –> 每个输出的输出投影 –> sigmoid

参考

用于远场多说话人语音识别的多麦克风神经语音分离 (https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=8462081)

参数:

num_outputs – 要估计的输出掩码的数量
num_subbands – 输入频谱图的子带数量
num_features – 输入投影后的特征数量
num_layers – RNN 层数
num_hidden_features – RNN 层中的隐藏特征数量
num_input_channels – 输入通道数
dropout – 如果非零，则在除最后一层之外的每个 RNN 层的输出上引入 dropout，dropout 概率等于 dropout。默认值：0
bidirectional – 如果为 True，则使用双向 RNN。
rnn_type – RNN 的类型，可以是 lstm 或 gru。默认值：lstm
mag_reduction – 幅度特征的通道方向缩减
use_ipd – 使用通道间相位差 (IPD) 特征

forward( input: torch.Tensor, input_length: torch.Tensor, ) → Tuple[torch.Tensor, torch.Tensor]#

从输入频谱图中估计 num_outputs 个掩码。

参数:

input – C 通道输入，形状 (B, C, F, N)
input_length – 沿时间维度的有效条目的长度，形状 (B,)

返回:

在张量中返回 num_outputs 个掩码，形状 (B, num_outputs, F, N)，以及形状为 (B,) 的输出长度

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

class nemo.collections.audio.modules.masking.MaskEstimatorFlexChannels(*args: Any, **kwargs: Any)#

基类：NeuralModule

使用堆叠的通道方向和时序层，从输入频谱图中估计 num_outputs 个掩码。

该模型使用交错的通道块和时序块，并且可以处理任意数量的输入通道。默认通道块是 transform-average-concatenate 层。默认时序块是 Conformer 编码器。从多通道信号到单通道信号的缩减在 channel_reduction_position 块之后执行。之后仅使用时序块。在块序列之后，使用附加的输出时序层和非线性计算输出掩码。

参考文献

Yoshioka 等人，VarArray：与阵列几何无关的连续语音分离，2022
Jukić 等人，用于噪声鲁棒前端的灵活多通道语音增强，2023

参数:

num_outputs – 输出掩码的数量。
num_subbands – 输入频谱图上的子带数量。
num_blocks – 模型中的块数量。
channel_reduction_position – 在此块之后，信号将在通道上缩减。
channel_reduction_type – 通道方向缩减：“average” 或 “attention”
channel_block_type – 用于通道处理的块：“transform_average_concatenate” 或 “transform_attend_concatenate”
temporal_block_type – 用于时序处理的块：“conformer_encoder”
temporal_block_num_layers – 时序块的层数
temporal_block_num_heads – 时序块的头数
temporal_block_dimension – 模型的隐藏大小
temporal_block_self_attention_model – 时序块的自注意力模型
temporal_block_att_context_size – 时序块的注意力上下文大小
mag_reduction – 幅度特征的通道方向缩减
mag_power – 应用于幅度特征的功率
use_ipd – 使用通道间相位差 (IPD) 特征
mag_normalization – 使用均值 (“mean”) 或均值和方差 (“mean_var”) 进行归一化
ipd_normalization – 使用均值 (“mean”) 或均值和方差 (“mean_var”) 进行归一化

forward( input: torch.Tensor, input_length: torch.Tensor, ) → Tuple[torch.Tensor, torch.Tensor]#: 从输入频谱图中估计 num_outputs 个掩码。

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

class nemo.collections.audio.modules.masking.MaskEstimatorGSS(*args: Any, **kwargs: Any)#

基类：NeuralModule

使用复角中心高斯混合模型 (cACGMM) [1] 的引导源分离来估计掩码。

此模块对应于 [2] 中图 2 中的 GSS。

符号大致遵循 [1]，其中 gamma 表示时频掩码，alpha 表示混合权重，BM 表示形状矩阵。此外，提供的源活动表示为 activity。

参数:

num_iterations – EM 算法的迭代次数
eps – 用于正则化的小值
dtype – 内部计算的数据类型（默认 torch.cdouble）

参考文献

[1] Ito 等人，《基于掩码的麦克风阵列信号处理中方向统计的复角中心高斯混合模型》，2016 年 [2] Boeddeker 等人，《CHiME-5 晚餐聚会场景的前端处理》，2018 年

forward( input: torch.Tensor, activity: torch.Tensor, ) → torch.Tensor#

应用 GSS 来估计每个输出源的时频掩码。

参数:

input – 批量 C 通道输入信号，形状 (B, num_inputs, F, T)
activity – 每个输出源的批量逐帧活动，形状 (B, num_outputs, T)

返回:

模型组件的掩码，形状 (B, num_outputs, F, T)

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

normalize( x: torch.Tensor, dim: int = 1, ) → torch.Tensor#

对输入进行归一化，使其在 dim 上具有单位 L2 范数。默认情况下，跨输入通道进行归一化。

参数:

x – C 通道输入信号，形状 (B, C, F, T)
dim – 归一化的维度，默认为 -3 以跨通道进行归一化

返回:

归一化后的信号，形状 (B, C, F, T)

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

update_masks( alpha: torch.Tensor, activity: torch.Tensor, log_pdf: torch.Tensor, ) → torch.Tensor#

更新 cACGMM 的掩码。

参数:

alpha – 组件权重，形状 (B, num_outputs, F)
activity – 组件的时序活动，形状 (B, num_outputs, T)
log_pdf – PDF 的对数，形状 (B, num_outputs, F, T)

返回:

模型组件的掩码，形状 (B, num_outputs, F, T)

update_pdf( z: torch.Tensor, gamma: torch.Tensor, zH_invBM_z: torch.Tensor, ) → Tuple[torch.Tensor, torch.Tensor]#

更新 cACGMM 的 PDF。

参数:

z – 方向统计量，形状 (B, num_inputs, F, T)
gamma – 掩码，形状 (B, num_outputs, F, T)
zH_invBM_z – 由形状矩阵加权的能量，形状 (B, num_outputs, F, T)

返回:

PDF 的对数，形状 (B, num_outputs, F, T)，能量项，形状 (B, num_outputs, F, T)

update_weights(gamma: torch.Tensor) → torch.Tensor#

更新混合模型中各个组件的权重。

参数:: gamma – 掩码，形状 (B, num_outputs, F, T)
返回:: 组件权重，形状 (B, num_outputs, F)

class nemo.collections.audio.modules.masking.MaskReferenceChannel(*args: Any, **kwargs: Any)#

基类：NeuralModule

一个简单的掩码处理器，它将掩码应用于输入信号的 ref_channel。

参数:

ref_channel – 参考通道的索引。
mask_min_db – 在应用掩码之前，将掩码阈值设置为最小值，默认为 -200dB
mask_max_db – 在应用掩码之前，将掩码阈值设置为最大值，默认为 0dB

forward( input: torch.Tensor, input_length: torch.Tensor, mask: torch.Tensor, ) → Tuple[torch.Tensor, torch.Tensor]#

将掩码应用于输入信号的 ref_channel。这可以用于生成多通道输出。如果 mask 具有 M 个通道，则输出也将具有 M 个通道。

参数:

input – 输入信号复值频谱图，形状 (B, C, F, N)
input_length – 沿时间维度的有效条目的长度，形状 (B,)
mask – M 个输出的掩码，形状 (B, M, F, N)

返回:

M 通道输出复值频谱图，形状 (B, M, F, N)

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

class nemo.collections.audio.modules.masking.MaskBasedBeamformer(*args: Any, **kwargs: Any)#

基类：NeuralModule

使用掩码估计信号统计量的多通道处理器。

参数:

filter_type – 表示滤波器类型的字符串。默认为 mvdr
filter_beta – 参数化多通道维纳滤波器的参数
filter_rank – 参数化多通道维纳滤波器的秩
filter_postfilter – 可选，滤波器的后处理
ref_channel – 可选，参考通道。如果为 None，将自动估计
ref_hard – 如果为 true，则为硬（one-hot）参考。如果为 false，则为软参考
ref_hard_use_grad – 如果为 true，则在使用硬参考时使用直通梯度
ref_subband_weighting – 如果为 true，则在估计参考通道时使用子带加权
num_subbands – 可选，用于确定参考估计的参数大小
mask_min_db – 在应用掩码之前，将掩码阈值设置为最小值，默认为 -200dB
mask_max_db – 在应用掩码之前，将掩码阈值设置为最大值，默认为 0dB
diag_reg – 可选，多通道滤波器的对角正则化
eps – 用于避免除以零的小正则化常数

forward( input: torch.Tensor, mask: torch.Tensor, mask_undesired: torch.Tensor | None = None, input_length: torch.Tensor | None = None, ) → torch.Tensor#

将基于掩码的波束形成器应用于输入频谱图。这可以用于生成多通道输出。如果 mask 具有多个通道，则为每个掩码创建一个多通道滤波器，并且输出是沿通道维度连接的各个输出。输出总数为 num_masks * M，其中 M 是滤波器输出端的通道数。

参数:

input – 输入信号复值频谱图，形状 (B, C, F, N)
mask – M 个输出信号的掩码，形状 (B, num_masks, F, N)
input_length – 沿时间维度的有效条目的长度，形状 (B,)

返回:

多通道输出信号复值频谱图，形状 (B, num_masks * M, F, N)

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

class nemo.collections.audio.modules.masking.MaskBasedDereverbWPE(*args: Any, **kwargs: Any)#

基类：NeuralModule

基于加权预测误差的滤波器估计，进行多通道线性预测去混响。

可以提供可选的掩码来估计信号功率。如果未提供时频掩码，则该算法对应于传统的 WPE 算法。

参数:

filter_length – 每个通道卷积滤波器的长度，以帧为单位。
prediction_delay – 多通道线性预测的输入信号延迟，以帧为单位。
num_iterations – 重加权迭代次数
mask_min_db – 在应用掩码之前，将掩码阈值设置为最小值，默认为 -200dB
mask_max_db – 在应用掩码之前，将掩码阈值设置为最小值，默认为 0dB
diag_reg – WPE 的对角正则化
eps – 小正则化常数
dtype – 内部计算的数据类型

参考文献

Kinoshita 等人，《用于在线 WPE 去混响的基于神经网络的频谱估计》，2017 年
Yoshioka 和 Nakatani，《盲 MIMO 脉冲响应缩短的多通道线性预测方法的推广》，2012 年

forward( input: torch.Tensor, input_length: torch.Tensor | None = None, mask: torch.Tensor | None = None, ) → torch.Tensor#

给定输入信号 input，应用 WPE 去混响算法。

参数:

input – C 通道复值频谱图，形状 (B, C, F, T)
input_length – 批量中每个信号的可选长度，形状 (B,)
mask – 可选掩码，形状 (B, 1, F, N) 或 (B, C, F, T)

返回:

处理后的张量，通道数与输入相同，形状 (B, C, F, T)。

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

投影#

class nemo.collections.audio.modules.projections.MixtureConsistencyProjection(*args: Any, **kwargs: Any)#

基类：NeuralModule

确保估计的源与输入混合信号一致。请注意，输入混合信号假定为单声道信号。

参数:

weighting – 一致性约束的可选加权模式。如果为 None，则使用均匀加权。如果为 power，则使用估计源的功率作为权重。
eps – 用于正则化的小正值

参考: Wisdom et al, Differentiable consistency constraints for improved deep speech enhancement, 2018

forward( mixture: torch.Tensor, estimate: torch.Tensor, ) → torch.Tensor#

在估计源上强制执行混合一致性。 :param mixture: 单声道混合信号，形状 (B, 1, F, N) :param estimate: M 个估计源，形状 (B, M, F, N)

返回:: 与混合信号一致的源估计，形状 (B, M, F, N)

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

SSL 预训练#

class nemo.collections.audio.modules.ssl_pretrain_masking.SSLPretrainWithMaskedPatch(*args: Any, **kwargs: Any)#

基类：NeuralModule

将频谱图的固定大小时间补丁置零。批次中的所有样本都保证具有相同数量的掩码时间步长。请注意，当我们在不平衡数据集上进行预训练时，这可能会有问题。

例如，假设一个批次包含两个长度分别为 87 和 276 的频谱图。使用 mask_fraction=0.7 和 patch_size=10，我们将获得 mask_patches=7。然后，两个数据都将具有 7 个 10 帧掩码的补丁。

参数:

patch_size (int) – 一个补丁最多包含多少时间步长。默认为 10。
mask_fraction (float) – 每个样本中要掩码多少比例（补丁数量向上取整）。范围从 0.0 到 1.0。默认为 0.7。

forward(input_spec, length)#

在 input_spec 上应用补丁掩码。

在训练阶段，掩码是随机生成的，大约 self.mask_fraction 的时间帧被掩码掉。

在验证阶段，掩码模式是固定的，以确保检查点的一致评估并防止过拟合。请注意，相同的掩码模式应用于所有数据，而与其长度无关。平均而言，大约 self.mask_fraction 的时间帧将被掩码掉。

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

变换#

class nemo.collections.audio.modules.transforms.AudioToSpectrogram(*args: Any, **kwargs: Any)#

基类：NeuralModule

将一批输入多通道信号转换为一批基于 STFT 的频谱图。

参数:

fft_length – FFT 的长度
hop_length – 滑动窗口的跳跃/位移长度
power – 幅度频谱图的指数。默认 None 将返回复数值频谱图
magnitude_power – 将频谱图的幅度变换为 x^magnitude_power。
scale – 频谱图的正比例缩放。

forward( input: torch.Tensor, input_length: torch.Tensor | None = None, ) → Tuple[torch.Tensor, torch.Tensor]#

将一批 C 通道输入信号转换为一批复数值频谱图。

参数:

input – 具有 C 通道的时域输入信号，形状 (B, C, T)
input_length – 沿时间维度的有效条目的长度，形状 (B,)

返回:

输出频谱图，具有 F 个子带和 N 个时间帧，形状 (B, C, F, N) 和输出长度，形状 (B,)。

get_output_length( input_length: torch.Tensor, ) → torch.Tensor#

获取输出的有效帧长度。

参数:: input_length – 有效样本数，形状 (B,)
返回:: 有效帧数，形状 (B,)

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

stft(x: torch.Tensor)#

应用 STFT，如 torchaudio.transforms.Spectrogram(power=None)

参数:: x_spec – 输入时域信号，形状 (…, T)
返回:: 时域信号 x_spec = STFT(x)，形状 (…, F, N)。

class nemo.collections.audio.modules.transforms.SpectrogramToAudio(*args: Any, **kwargs: Any)#

基类：NeuralModule

将一批输入多通道频谱图转换为一批时域多通道信号。

参数:

fft_length – FFT 的长度
hop_length – 滑动窗口的跳跃/位移长度
magnitude_power – 将频谱图的幅度变换为 x^(1/magnitude_power)。
scale – 频谱图将在逆变换之前以 1/scale 缩放。

forward( input: torch.Tensor, input_length: torch.Tensor | None = None, ) → torch.Tensor#

将输入复数值频谱图转换为时域信号。支持多通道 IO。

参数:

input – C 通道的输入频谱图，形状 (B, C, F, N)
input_length – 沿时间维度的有效条目的长度，形状 (B,)

返回:

具有 T 个时域样本和 C 个通道的时域信号，(B, C, T) 和输出长度，形状 (B,)。

get_output_length( input_length: torch.Tensor, ) → torch.Tensor#

获取输出的有效样本长度。

参数:: input_length – 有效帧数，形状 (B,)
返回:: 有效样本数，形状 (B,)

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

istft(x_spec: torch.Tensor)#

应用 iSTFT，如 torchaudio.transforms.InverseSpectrogram

参数:: x_spec – 输入复数值频谱图，形状 (…, F, N)
返回:: 时域信号 x = iSTFT(x_spec)，形状 (…, T)。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

部件#

子模块：扩散#

class nemo.collections.audio.parts.submodules.diffusion.StochasticDifferentialEquation(*args: Any, **kwargs: Any)#

基类： NeuralModule， ABC

随机微分方程的基类。

abstract coefficients(

state: torch.Tensor,

time: torch.Tensor,

**kwargs,

) → Tuple[torch.Tensor, torch.Tensor]#

参数:

state – 形状为 (B, C, D, T) 的张量
time – 形状为 (B,) 的张量

返回:

包含漂移系数和扩散系数的元组。

abstract copy()#: 创建此 SDE 的副本。

discretize(

*,

state: torch.Tensor,

time: torch.Tensor,

state_length: torch.Tensor | None = None,

**kwargs,

) → Tuple[torch.Tensor, torch.Tensor]#

假设我们有以下 SDE

dx = drift(x, t) * dt + diffusion(x, t) * dwt

其中 wt 是标准维纳过程。

我们假设以下离散化

new_state = current_state + total_drift + total_diffusion * z_norm

其中 z_norm 是从均值为零且单位方差的正态分布中采样的。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
time – 过程的当前时间，形状 (B,)
state_length – 批次中每个示例的有效时间步长长度，形状 (B,)
**kwargs – 其他参数

返回:

漂移和扩散。

property dt: float#: 此 SDE 的时间步长。这表示使用 self.num_steps 时，0 和 self.time_max 之间的步长大小。

generate_time( size: int, device: torch.device, ) → torch.Tensor#

在有效范围内生成随机时间步长。

时间步长在 self.time_min 和 self.time_max 之间生成。

参数:

size – 样本数
device – 要使用的设备

返回:

形状为 (size,) 的浮点数张量

prior_sampling( prior_mean: torch.Tensor, ) → torch.Tensor#

从先验分布 p_T 生成一个样本。

参数:: prior_mean – 先验分布的均值
返回:: 来自先验分布的样本。

property time_delta: float#: 此 SDE 的时间范围。

class nemo.collections.audio.parts.submodules.diffusion.OrnsteinUhlenbeckVarianceExplodingSDE(*args: Any, **kwargs: Any)#

基类： StochasticDifferentialEquation

此类实现了具有方差爆炸噪声调度的 Ornstein-Uhlenbeck SDE。

SDE 由下式给出

dx = theta * (y - x) dt + g(t) dw

其中 theta 是刚度参数，g(t) 是扩散系数

g(t) = std_min * (std_max/std_min)^t * sqrt(2 * log(std_max/std_min))

参考文献

Richter et al., Speech Enhancement and Dereverberation with Diffusion-based Generative Models, Tr. ASLP 2023

coefficients( state: torch.Tensor, time: torch.Tensor, prior_mean: torch.Tensor, state_length: torch.Tensor | None = None, ) → Tuple[torch.Tensor, torch.Tensor]#

计算此 SDE 的漂移系数和扩散系数。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
time – 过程的当前时间，形状 (B,)
prior_mean – 先验分布的均值
state_length – 批次中每个示例的有效时间步长长度

返回:

漂移系数和扩散系数。

copy()#: 创建此 SDE 的副本。

perturb_kernel_mean( state: torch.Tensor, prior_mean: torch.Tensor, time: torch.Tensor, ) → torch.Tensor#

返回此 SDE 的扰动核的均值。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
prior_mean – 先验分布的均值
time – 过程的当前时间，形状 (B,)

返回:

形状为 (B, C, D, T) 的张量

perturb_kernel_params( state: torch.Tensor, prior_mean: torch.Tensor, time: torch.Tensor, ) → torch.Tensor#

返回此 SDE 的扰动核的均值和标准差。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
prior_mean – 先验分布的均值
time – 过程的当前时间，形状 (B,)

perturb_kernel_std( time: torch.Tensor, ) → torch.Tensor#

返回此 SDE 的扰动核的标准差。

请注意，标准差取决于时间和噪声调度，噪声调度使用 self.stiffness、self.std_min 和 self.std_max 进行参数化。

参数:: time – 过程的当前时间，形状 (B,)
返回:: 形状为 (B,) 的张量

prior_sampling( prior_mean: torch.Tensor, ) → torch.Tensor#

从先验分布 p_T 生成一个样本。

参数:: prior_mean – 先验分布的均值

class nemo.collections.audio.parts.submodules.diffusion.ReverseStochasticDifferentialEquation(*args: Any, **kwargs: Any)#

基类： StochasticDifferentialEquation

coefficients(

state: torch.Tensor,

time: torch.Tensor,

score_condition: torch.Tensor | None = None,

state_length: torch.Tensor | None = None,

**kwargs,

) → Tuple[torch.Tensor, torch.Tensor]#

计算反向 SDE 的漂移系数和扩散系数。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
time – 过程的当前时间，形状 (B,)

copy()#: 创建此 SDE 的副本。

discretize(

*,

state: torch.Tensor,

time: torch.Tensor,

score_condition: torch.Tensor | None = None,

state_length: torch.Tensor | None = None,

**kwargs,

) → Tuple[torch.Tensor, torch.Tensor]#

离散化反向 SDE。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
time – 过程的当前时间，形状 (B,)
score_condition – 分数估计器的条件
state_length – 批次中每个示例的有效时间步长长度
**kwargs – 前向 SDE 离散化的其他参数

prior_sampling( shape: torch.Size, device: torch.device, ) → torch.Tensor#: 先验采样对于反向 SDE 不是必需的。

class nemo.collections.audio.parts.submodules.diffusion.PredictorCorrectorSampler(*args: Any, **kwargs: Any)#

基类：NeuralModule

反向 SDE 的预测-校正采样器。

参数:

sde – 前向 SDE
score_estimator – 神经分数估计器
predictor – 反向过程的预测器
corrector – 反向过程的校正器
num_steps – 反向过程的时间步数
num_corrector_steps – 校正器步骤数
time_max – 最大时间
time_min – 最小时间
snr – 退火朗之万动力学的 SNR
output_type – 输出类型（最终状态为 ‘state’，最终状态的均值为 ‘mean’）

参考文献

Song et al., Score-based generative modeling through stochastic differential equations, 2021

class nemo.collections.audio.parts.submodules.diffusion.Predictor(*args: Any, **kwargs: Any)#

基类： Module， ABC

反向过程的预测器。

参数:

sde – 前向 SDE
score_estimator – 神经分数估计器

abstract forward(

*,

state: torch.Tensor,

time: torch.Tensor,

score_condition: torch.Tensor | None = None,

state_length: torch.Tensor | None = None,

**kwargs,

)#

预测反向过程的下一个状态。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
time – 过程的当前时间，形状 (B,)
score_condition – 分数估计器的条件
state_length – 批次中每个示例的有效时间步长长度

返回:

新状态和均值。

class nemo.collections.audio.parts.submodules.diffusion.ReverseDiffusionPredictor(*args: Any, **kwargs: Any)#

基类： Predictor

使用反向扩散过程预测反向过程的下一个状态。

参数:

sde – 前向 SDE
score_estimator – 神经分数估计器

forward(

*,

state,

time,

score_condition=None,

state_length=None,

**kwargs,

)#

使用反向扩散过程预测反向过程的下一个状态。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
time – 过程的当前时间，形状 (B,)
score_condition – 分数估计器的条件
state_length – 批次中每个示例的有效时间步长长度

返回:

扩散过程的新状态和均值。

class nemo.collections.audio.parts.submodules.diffusion.Corrector(*args: Any, **kwargs: Any)#

基类： NeuralModule， ABC

反向过程的校正器。

参数:

sde – 前向 SDE
score_estimator – 神经分数估计器
snr – 退火朗之万动力学的 SNR
num_steps – 校正器的步数

class nemo.collections.audio.parts.submodules.diffusion.AnnealedLangevinDynamics(*args: Any, **kwargs: Any)#

基类： Corrector

反向过程的退火朗之万动力学。

参考文献

Song et al., Score-based generative modeling through stochastic differential equations, 2021

forward( state, time, score_condition=None, state_length=None, )#

使用退火朗之万动力学校正状态。

参数:

state – 过程的当前状态，形状 (B, C, D, T)
time – 过程的当前时间，形状 (B,)
score_condition – 分数估计器的条件
state_length – 批次中每个示例的有效时间步长长度

返回:

扩散过程的新状态和均值。

参考文献

算法 4，见 http://arxiv.org/abs/2011.13456

子模块：Flow#

class nemo.collections.audio.parts.submodules.flow.ConditionalFlow(time_min: float = 1e-08, time_max: float = 1.0)#

基类: ABC

不同条件流匹配 (CFM) 类的抽象类

时间范围是 [time_min, time_max (应为 1)]

每个路径都“条件化”于路径的端点，端点只是我们的配对数据样本，子类需要实现 mean、std 和 vector_field

flow( *, time: torch.Tensor, x_start: torch.Tensor, x_end: torch.Tensor, point: torch.Tensor, ) → torch.Tensor#: 计算条件流 phi_t( point | x_start, x_end)。这是一个仿射流。

generate_time( batch_size: int, rng: torch.random.Generator | None = None, ) → torch.Tensor#: 从 U[self.time_min, self.time_max] 中随机采样一个批次大小的时间步。支持外部随机数生成器以获得更好的可重复性

abstract mean( *, time: torch.Tensor, x_start: torch.Tensor, x_end: torch.Tensor, ) → torch.Tensor#: 返回时间 t 时 p_t(x | x_start, x_end) 的均值

sample( *, time: torch.Tensor, x_start: torch.Tensor, x_end: torch.Tensor, ) → torch.Tensor#: 在时间 t 时从 p_t(x | x_start, x_end) 生成一个样本。请注意，此实现假设所有路径边际均为正态分布。

abstract std( *, time: torch.Tensor, x_start: torch.Tensor, x_end: torch.Tensor, ) → torch.Tensor#: 返回时间 t 时 p_t(x | x_start, x_end) 的标准差

abstract vector_field( *, time: torch.Tensor, x_start: torch.Tensor, x_end: torch.Tensor, point: torch.Tensor, ) → torch.Tensor#: 计算条件向量场 v_t( point | x_start, x_end)

class nemo.collections.audio.parts.submodules.flow.OptimalTransportFlow( time_min: float = 1e-08, time_max: float = 1.0, sigma_start: float = 1.0, sigma_end: float = 0.0001, )#

基类: ConditionalFlow

来自 [Lipman et al, 2023] 的 OT-CFM 模型

每个条件路径都满足以下条件：p_0 = N(x_start, sigma_start) p_1 = N(x_end, sigma_end),

mean(x, t) = (time_max - t) * x_start + t * x_end: (x_start 和 x_end 之间的线性插值)

std(x, t) = (time_max - t) * sigma_start + t * sigma_end

每个条件路径都是从 p_0(x_start, x_end) 到 p_1(x_start, x_end) 的最优传输映射。边际路径不保证是从 p_0 到 p_1 的最优传输映射

要获得来自 [Lipman et al, 2023] 的 OT-CFM 模型，只需为 x_start 传递零。要获得 I-CFM 模型，请设置 sigma_min=sigma_max。要获得修正流模型，请设置 sigma_min=sigma_max=0

参数:

time_min – 过程中使用的最小时间值
time_max – 过程中使用的最大时间值
sigma_start – 初始分布的标准差
sigma_end – 目标分布的标准差

mean( *, x_start: torch.Tensor, x_end: torch.Tensor, time: torch.Tensor, ) → torch.Tensor#: 返回时间 t 时 p_t(x | x_start, x_end) 的均值

std( *, x_start: torch.Tensor, x_end: torch.Tensor, time: torch.Tensor, ) → torch.Tensor#: 返回时间 t 时 p_t(x | x_start, x_end) 的标准差

vector_field( *, x_start: torch.Tensor, x_end: torch.Tensor, time: torch.Tensor, point: torch.Tensor, eps: float = 1e-06, ) → torch.Tensor#: 计算条件向量场 v_t( point | x_start, x_end)

class nemo.collections.audio.parts.submodules.flow.ConditionalFlowMatchingSampler( estimator: torch.nn.Module, num_steps: int = 5, time_min: float = 1e-08, time_max: float = 1.0, )#

基类: ABC

用于解决 CFM 中 ODE 的不同采样器的抽象类

参数:

estimator – 基于神经网络的条件向量场估计器
num_steps – 过程中迭代多少时间步
time_min – 过程中使用的最小时间值
time_max – 过程中使用的最大时间值

class nemo.collections.audio.parts.submodules.flow.ConditionalFlowMatchingEulerSampler( estimator: torch.nn.Module, num_steps: int = 5, time_min: float = 1e-08, time_max: float = 1.0, )#

基类: ConditionalFlowMatchingSampler

用于在均匀时间网格上求解 CFM 中 ODE 的欧拉采样器

子模块：Multichannel#

class nemo.collections.audio.parts.submodules.multichannel.ChannelAugment(*args: Any, **kwargs: Any)#

基类：NeuralModule

随机排列并选择通道子集。

参数:

permute_channels (bool) – 应用通道的随机排列。
num_channels_min (int) – 要选择的最小通道数。
num_channels_max (int) – 要选择的最大通道数。
rng – 可选，随机生成器。
seed – 可选，生成器的种子。

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

class nemo.collections.audio.parts.submodules.multichannel.TransformAverageConcatenate(*args: Any, **kwargs: Any)#

基类：NeuralModule

跨通道应用变换-平均-连接。我们使用的是来自 [2] 的版本。

参数:

in_features – 输入特征的数量
out_features – 输出特征的数量

参考文献

[1] Luo et al, End-to-end Microphone Permutation and Number Invariant Multi-channel Speech Separation, 2019 [2] Yoshioka et al, VarArray: Array-Geometry-Agnostic Continuous Speech Separation, 2022

forward( input: torch.Tensor, ) → torch.Tensor#

参数:: input – 形状 (B, M, in_features, T)
返回:: 输出张量，形状 (B, M, out_features, T)

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

class nemo.collections.audio.parts.submodules.multichannel.TransformAttendConcatenate(*args: Any, **kwargs: Any)#

基类：NeuralModule

跨通道应用变换-注意力-连接。输出是变换后的通道和跨通道 MHA 的连接。

参数:

in_features – 输入特征的数量
out_features – 输出特征的数量
n_head – MHA 模块的头数
dropout_rate – MHA 模块的 dropout 率

参考文献

Jukić 等人，用于噪声鲁棒前端的灵活多通道语音增强，2023

forward( input: torch.Tensor, ) → torch.Tensor#

参数:: input – 形状 (B, M, in_features, T)
返回:: 输出张量，形状 (B, M, out_features, T)

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

class nemo.collections.audio.parts.submodules.multichannel.ChannelAveragePool(*args: Any, **kwargs: Any)#

基类：NeuralModule

跨通道应用平均池化。

forward(input: torch.Tensor) → torch.Tensor#

参数:: input – 形状 (B, M, F, T)
返回:: 输出张量，形状 (B, F, T)

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

class nemo.collections.audio.parts.submodules.multichannel.ChannelAttentionPool(*args: Any, **kwargs: Any)#

基类：NeuralModule

使用注意力池化来聚合跨通道的信息。首先跨通道应用 MHA，然后应用平均。

参数:

in_features – 输入特征的数量
out_features – 输出特征的数量
n_head – MHA 模块的头数
dropout_rate – MHA 模块的 dropout 率

参考文献

Wang et al, Neural speech separation using sparially distributed microphones, 2020
Jukić 等人，用于噪声鲁棒前端的灵活多通道语音增强，2023

forward(input: torch.Tensor) → torch.Tensor#

参数:: input – 形状 (B, M, F, T)
返回:: 输出张量，形状 (B, F, T)

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

class nemo.collections.audio.parts.submodules.multichannel.ParametricMultichannelWienerFilter(*args: Any, **kwargs: Any)#

基类：NeuralModule

参数化多通道维纳滤波器，可在降噪和语音失真之间进行可调节的权衡。它支持基于估计的输出 SNR 自动选择参考通道。

参数:

beta – 参数化滤波器的参数，降噪和语音失真之间的权衡 (0: MVDR, 1: MWF)。
rank – 语音协方差矩阵的秩假设。
postfilter – 可选的后置滤波器。如果为 None，则不应用后置滤波器。
ref_channel – 可选的参考通道。如果为 None，将自动估计。
ref_hard – 如果为 true，则估计硬 (one-hot) 参考。如果为 false，则估计软参考。
ref_hard_use_grad – 如果为 true，则在使用硬参考时使用直通梯度
ref_subband_weighting – 如果为 true，则在估计参考通道时使用子带加权
num_subbands – 可选，用于确定参考估计的参数大小
diag_reg – 可选，多通道滤波器的对角正则化
eps – 用于避免除以零的小正则化常数

参考文献

Souden et al, On Optimal Frequency-Domain Multichannel Linear Filtering for Noise Reduction, 2010

apply_ban( input: torch.Tensor, filter: torch.Tensor, psd_n: torch.Tensor, ) → torch.Tensor#

应用盲分析归一化后置滤波器。请注意，此归一化已针对 [1] 中的 GEV 波束形成器导出。更具体地说，BAN 后置滤波器旨在缩放 GEV 以满足无失真约束，并且最终的解析表达式是使用关于传递函数范数的假设导出的。但是，这在某些情况下可能仍然有用。

参数:

input – 具有 M 个输出通道的批次 (B, M, F, T)
filter – C 输入、M 输出滤波器的批次，形状 (B, F, C, M)
psd_n – 噪声 PSD 的批次，形状 (B, F, C, C)

返回:

滤波后的输入，形状 (B, M, F, T)

参考文献

Warsitz and Haeb-Umbach, Blind Acoustic Beamforming Based on Generalized Eigenvalue Decomposition, 2007

apply_diag_reg( psd: torch.Tensor, ) → torch.Tensor#

在 psd 上应用对角正则化。

参数:: psd – 张量，形状 (…, C, C)
返回:: 张量，与输入形状相同。

apply_filter( input: torch.Tensor, filter: torch.Tensor, ) → torch.Tensor#

在输入上应用 MIMO 滤波器。

参数:

input – 具有 C 个输入通道的批次，形状 (B, C, F, T)
filter – C 输入、M 输出滤波器的批次，形状 (B, F, C, M)

返回:

M 通道滤波器输出，形状 (B, M, F, T)

forward( input: torch.Tensor, mask_s: torch.Tensor, mask_n: torch.Tensor, ) → torch.Tensor#

返回处理后的信号。如果选择了 ref_channel，则输出具有一个通道 (M=1)，如果 ref_channel 为 None，则输出具有与输入相同数量的通道 (M=C)。

参数:

input – 输入信号，复数张量，形状 (B, C, F, T)
mask_s – 期望信号的掩码，形状 (B, F, T)
mask_n – 不期望噪声的掩码，形状 (B, F, T)

返回:

处理后的信号，形状 (B, M, F, T)

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

static trace( x: torch.Tensor, keepdim: bool = False, ) → torch.Tensor#

计算输入张量最后两个维度上的矩阵切片的迹。

参数:: x – 张量，形状 (…, C, C)
返回:: 每个 (C, C) 矩阵的迹。形状 (…)

class nemo.collections.audio.parts.submodules.multichannel.ReferenceChannelEstimatorSNR(*args: Any, **kwargs: Any)#

基类：NeuralModule

通过选择最大化输出 SNR 的参考来估计参考通道。它返回 one-hot 编码向量或软参考。

当使用硬参考时，直通估计器用于梯度。

参数:

hard – 如果为 true，则使用 ref 通道的硬估计。如果为 false，则使用跨通道的软估计。
hard_use_grad – 为梯度使用直通估计器。
subband_weighting – 如果为 true，则在跨子带 SNR 添加时使用子带加权。如果为 false，则使用跨子带的平均值。

参考文献

Boeddeker et al, Front-End Processing for the CHiME-5 Dinner Party Scenario, 2018

forward( W: torch.Tensor, psd_s: torch.Tensor, psd_n: torch.Tensor, ) → torch.Tensor#

参数:

W – 多通道输入多通道输出滤波器，形状 (B, F, C, M)，其中 C 是输入通道数，M 是输出通道数
psd_s – 信号的协方差，形状 (B, F, C, C)
psd_n – 噪声的协方差，形状 (B, F, C, C)

返回:

One-hot 或软参考通道，形状 (B, M)

property input_types#: 返回模块输入类型的定义

property output_types#: 返回模块输出类型的定义

class nemo.collections.audio.parts.submodules.multichannel.WPEFilter(*args: Any, **kwargs: Any)#

基类：NeuralModule

加权预测误差滤波器。给定输入信号和期望的期望信号功率，此类估计多输入多输出预测滤波器并返回滤波后的信号。目前，统计量的估计和处理以批处理模式执行。

参数:

filter_length – 每个通道的预测滤波器长度（帧数）
prediction_delay – 预测延迟（帧数）
diag_reg – 相关矩阵 Q 的对角正则化，应用为 diag_reg * trace(Q) + eps
eps – 用于正则化的小正数常数

参考文献

Yoshioka and Nakatani, Generalization of Multi-Channel Linear Prediction
Methods for Blind MIMO Impulse Response Shortening, 2012
Jukić et al, Group sparsity for MIMO speech dereverberation, 2015

apply_filter( filter: torch.Tensor, input: torch.Tensor | None = None, tilde_input: torch.Tensor | None = None, ) → torch.Tensor#

在输入 input 上应用预测滤波器 filter，如

output(b,f) = tilde{input(b,f)} * filter(b,f)

如果可用，直接使用卷积矩阵 tilde_input。

参数:

input – 输入信号，形状 (B, C, F, N)
tilde_input – 输入信号的卷积矩阵，形状 (B, C, F, N, filter_length)
filter – 预测滤波器，形状 (B, C, F, C, filter_length)

返回:

通过在输入信号上应用预测滤波器获得的多通道信号，与输入形状相同 (B, C, F, N)

classmethod convtensor( x: torch.Tensor, filter_length: int, delay: int = 0, n_steps: int | None = None, ) → torch.Tensor#

为批处理中的每个示例创建一个等效于 convmtx_mc 的张量。输入信号张量 x 的形状为 (B, C, F, N)。Convtensor 返回输入信号 x 的视图。

注意：我们避免重塑输出以将通道和滤波器抽头折叠到单个维度，例如 (B, F, N, -1)。这样，输出是输入的视图，而额外的重塑将导致连续数组和更多内存使用。

参数:

x – 输入张量，形状 (B, C, F, N)
filter_length – 滤波器的长度，决定卷积张量的形状
delay – 在构造卷积张量之前添加到输入信号 x 的延迟
n_steps – 可选的，要保留在输出中的时间步数。默认为输入张量中的时间步数。

返回:

返回一个卷积张量，形状为 (B, C, F, n_steps, filter_length)

estimate_correlations( input: torch.Tensor, weight: torch.Tensor, tilde_input: torch.Tensor, input_length: torch.Tensor | None = None, ) → Tuple[torch.Tensor]#

参数:

input – 输入信号，形状 (B, C, F, N)
weight – 时频权重，形状 (B, F, N)
tilde_input – 多通道卷积张量，形状 (B, C, F, N, filter_length)
input_length – 每个输入样本的长度，形状 (B)

返回:

返回每个批次的互相关矩阵的元组。

设 X 表示单个子带中的输入信号，tilde{X} 表示相应的多通道互相关矩阵，w 表示权重向量。

第一个输出是: Q = tilde{X}^H * diag(w) * tilde{X} (1)

对于每个 (b, f)。在 (1) 中计算的矩阵的形状为 (C * filter_length, C * filter_length)。输出以形状为 (B, F, C, filter_length, C, filter_length) 的张量返回。

第二个输出是: R = tilde{X}^H * diag(w) * X (2)

对于每个 (b, f)。在 (2) 中计算的矩阵的形状为 (C * filter_length, C)。输出以形状为 (B, F, C, filter_length, C) 的张量返回。最后一个维度对应于输出通道。

estimate_filter( Q: torch.Tensor, R: torch.Tensor, ) → torch.Tensor#

估计 MIMO 预测滤波器为: G(b,f) = Q(b,f) R(b,f)

对于批次 (b, f) 中每个示例的每个子带。

参数:

Q – 形状 (B, F, C, filter_length, C, filter_length)
R – 形状 (B, F, C, filter_length, C)

返回:

复值预测滤波器，形状 (B, C, F, C, filter_length)

forward( input: torch.Tensor, power: torch.Tensor, input_length: torch.Tensor | None = None, ) → torch.Tensor#

给定输入和期望信号的预测功率，估计 WPE 滤波器并返回处理后的信号。

参数:

input – 输入信号，形状 (B, C, F, N)
power – 期望信号的预测功率，形状 (B, C, F, N)
input_length – 可选，input 中有效帧的长度。默认为 None

返回:

处理后的信号和输出长度的元组。(processed_signal, output_length)。处理后的信号具有与输入信号 (B, C, F, N) 相同的形状，输出长度与输入长度相同。

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

classmethod permute_convtensor(x: torch.Tensor) → torch.Tensor#

重塑和置换列，以将 convtensor 的结果转换为等于 convmtx_mc。这用于验证目的，使用滤波器不是必需的。

参数:: x – self.convtensor 的输出，形状 (B, C, F, N, filter_length)
返回:: 输出的形状为 (B, F, N, C*filter_length)，对应于 convmtx_mc 的布局。

子模块: NCSN++#

class nemo.collections.audio.parts.submodules.ncsnpp.SpectrogramNoiseConditionalScoreNetworkPlusPlus(

*args: Any,

**kwargs: Any,

)#

基类：NeuralModule

该模型通过堆叠实部和虚部来处理复值输入。堆叠的张量使用 NCSN++ 进行处理，并且输出被投影以生成输出通道的实部和虚部。

参数:

in_channels – 输入复值通道的数量
out_channels – 输出复值通道的数量

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

class nemo.collections.audio.parts.submodules.ncsnpp.NoiseConditionalScoreNetworkPlusPlus(*args: Any, **kwargs: Any)#

基类：NeuralModule

噪声条件评分网络 (NCSN++) 架构的实现。

参考文献

Song et al., Score-Based Generative Modeling through Stochastic Differential Equations, NeurIPS 2021
Brock et al., Large scale GAN training for high fidelity natural image synthesis, ICLR 2018

forward( *, input: torch.Tensor, input_length: torch.Tensor | None, condition: torch.Tensor | None = None, )#

模型的前向传递。

参数:

input – 输入张量，形状 (B, C, D, T)
input_length – 批次中每个示例的有效时间步长，形状 (B,)
condition – 模型的标量条件（时间），将使用 self.time_embedding 嵌入

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

pad_input( input: torch.Tensor, ) → torch.Tensor#: 填充输入张量以匹配 T 和 D 上的所需维度。

class nemo.collections.audio.parts.submodules.ncsnpp.GaussianFourierProjection(*args: Any, **kwargs: Any)#

基类：NeuralModule

输入标量的高斯傅里叶嵌入。

输入标量通常是时间和噪声水平。

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

class nemo.collections.audio.parts.submodules.ncsnpp.ResnetBlockBigGANPlusPlus(*args: Any, **kwargs: Any)#

基类：Module

BigGAN 模型的 ResNet 块的实现。

参考文献

Song et al., Score-Based Generative Modeling through Stochastic Differential Equations, NeurIPS 2021
Brock et al., Large scale GAN training for high fidelity natural image synthesis, ICLR 2018

forward( x: torch.Tensor, diffusion_time_embedding: torch.Tensor | None = None, )#

模型的前向传递。

参数:

x – 输入张量
diffusion_time_embedding – 扩散时间步长的嵌入

返回:

输出张量

init_weights_()#: 权重初始化

子模块: Schrödinger Bridge#

class nemo.collections.audio.parts.submodules.schroedinger_bridge.SBNoiseSchedule(*args: Any, **kwargs: Any)#

基类： NeuralModule， ABC

薛定谔桥的噪声计划

参数:

time_min – 过程的最小时间
time_max – 过程的最大时间
num_steps – 过程的步数
eps – 小的正则化项

参考文献

用于生成语音增强的薛定谔桥，https://arxiv.org/abs/2407.16074

abstract alpha(time: torch.Tensor) → torch.Tensor#

返回 SB 噪声计划的 alpha。

alpha_t = exp( int_0^s f(s) ds )

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示每个时间的 alpha。

alpha_bar_from_alpha( alpha: torch.Tensor, )#

返回 SB 的 alpha_bar。

alpha_bar = alpha_t / alpha_t_max

参数:: alpha – 具有 alpha 值的张量
返回:: 与 alpha 大小相同的张量，表示 alpha_bar 和 alpha_t_max。

property alpha_t_max#: 返回 t_max 时的 alpha_t。

abstract copy()#: 返回噪声计划的副本。

property dt: float#: 过程的时间步长。

abstract f(time: torch.Tensor) → torch.Tensor#

漂移缩放 f(t)。

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示漂移缩放。

abstract g(time: torch.Tensor) → torch.Tensor#

扩散缩放 g(t)。

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示扩散缩放。

generate_time( size: int, device: torch.device, ) → torch.Tensor#: 在有效范围内生成随机时间步长。

get_alphas( time: torch.Tensor, )#

返回 SB 的 alpha、alpha_bar 和 alpha_t_max。

参数:: time – 具有时间步长的张量
返回:: 包含 alpha、alpha_bar 和 alpha_t_max 的张量元组。

get_sigmas( time: torch.Tensor, )#

返回 SB 的 sigma、sigma_bar 和 sigma_t_max。

参数:: time – 具有时间步长的张量
返回:: 包含 sigma、sigma_bar 和 sigma_t_max 的张量元组。

abstract sigma(time: torch.Tensor) → torch.Tensor#

返回 SB 的 sigma_t。

sigma_t^2 = int_0^s g^2(s) / alpha_s^2 ds

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示每个时间的 sigma。

sigma_bar_from_sigma( sigma: torch.Tensor, )#

返回 SB 的 sigma_bar_t。

sigma_bar_t^2 = sigma_t_max^2 - sigma_t^2

参数:: sigma – 具有 sigma 值的张量
返回:: 与 sigma 大小相同的张量，表示 sigma_bar 和 sigma_t_max。

property sigma_t_max#: 返回 t_max 时的 sigma_t。

property time_delta: float#: 过程的时间范围。

class nemo.collections.audio.parts.submodules.schroedinger_bridge.SBNoiseScheduleVE(*args: Any, **kwargs: Any)#

基类：SBNoiseSchedule

薛定谔桥的方差爆炸噪声计划。

参数:

k – 定义指数扩散系数的基数
c – 扩散系数的缩放
time_min – 过程的最小时间
time_max – 过程的最大时间
num_steps – 过程的步数
eps – 小的正则化项

参考文献

用于生成语音增强的薛定谔桥，https://arxiv.org/abs/2407.16074

alpha(time: torch.Tensor) → torch.Tensor#

返回 SB 噪声计划的 alpha。

alpha_t = exp( int_0^s f(s) ds )

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示每个时间的 alpha。

copy()#: 返回噪声计划的副本。

f(time: torch.Tensor) → torch.Tensor#

漂移缩放 f(t)。

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示漂移缩放。

g(time: torch.Tensor) → torch.Tensor#

扩散缩放 g(t)。

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示扩散缩放。

sigma(time: torch.Tensor) → torch.Tensor#

返回 SB 的 sigma_t。

sigma_t^2 = int_0^s g^2(s) / alpha_s^2 ds

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示每个时间的 sigma。

class nemo.collections.audio.parts.submodules.schroedinger_bridge.SBNoiseScheduleVP(*args: Any, **kwargs: Any)#

基类：SBNoiseSchedule

薛定谔桥的方差保持噪声计划。

参数:

beta_0 – 定义扩散系数的下限
beta_1 – 定义扩散系数的上限
c – 扩散系数的缩放
time_min – 过程的最小时间
time_max – 过程的最大时间
num_steps – 过程的步数
eps – 小的正则化项

alpha(time: torch.Tensor) → torch.Tensor#

返回 SB 噪声计划的 alpha。

alpha_t = exp( int_0^s f(s) ds )

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示每个时间的 alpha。

copy()#: 返回噪声计划的副本。

f(time: torch.Tensor) → torch.Tensor#

漂移缩放 f(t)。

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示漂移缩放。

g(time: torch.Tensor) → torch.Tensor#

扩散缩放 g(t)。

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示扩散缩放。

sigma(time: torch.Tensor) → torch.Tensor#

返回 SB 的 sigma_t。

sigma_t^2 = int_0^s g^2(s) / alpha_s^2 ds

参数:: time – 具有时间步长的张量
返回:: 与时间大小相同的张量，表示每个时间的 sigma。

class nemo.collections.audio.parts.submodules.schroedinger_bridge.SBSampler(*args: Any, **kwargs: Any)#

基类：NeuralModule

薛定谔桥采样器。

参数:

noise_schedule – 桥的噪声计划
estimator – 神经估计器
estimator_output – 定义估计器的输出，例如 data_prediction
estimator_time – 用于调节估计器的时间，例如“current”或“previous”。默认为“previous”。
process – 定义过程，例如 sde 或 ode
time_max – 过程的最大时间
time_min – 过程的最小时间
num_steps – 过程的步数
eps – 防止除以零的小正则化项

参考文献

Schrödinger Bridge for Generative Speech Enhancement, https://arxiv.org/abs/2407.16074 Schrodinger Bridges Beat Diffusion Models on Text-to-Speech Synthesis, https://arxiv.org/abs/2312.03491

子模块: TransformerUNet#

class nemo.collections.audio.parts.submodules.transformerunet.LearnedSinusoidalPosEmb(*args: Any, **kwargs: Any)#

基类：Module

正弦波嵌入，用于编码时间条件信息

forward(t: torch.Tensor) → torch.Tensor#

参数:: t – 输入时间张量，形状 (B)
返回:: 编码的时间条件嵌入，形状 (B, D)
返回类型:: fouriered

class nemo.collections.audio.parts.submodules.transformerunet.ConvPositionEmbed(*args: Any, **kwargs: Any)#

基类：Module

卷积嵌入，用于编码每个帧的时间信息

forward(x, mask=None)#

参数:: x – 输入张量，形状 (B, T, D)
返回:: 具有相同形状 (B, T, D) 的输出张量
返回类型:: out

class nemo.collections.audio.parts.submodules.transformerunet.RMSNorm(*args: Any, **kwargs: Any)#

基类：Module

均方根层归一化

参考文献

Zhang et al., Root Mean Square Layer Normalization, 2019

class nemo.collections.audio.parts.submodules.transformerunet.AdaptiveRMSNorm(*args: Any, **kwargs: Any)#

基类：Module

自适应均方根层归一化，给定条件嵌入。这使模型能够在归一化期间考虑条件输入。

class nemo.collections.audio.parts.submodules.transformerunet.GEGLU(*args: Any, **kwargs: Any)#

基类：Module

GeGLU 激活函数的实现

class nemo.collections.audio.parts.submodules.transformerunet.TransformerUNet(*args: Any, **kwargs: Any)#

基类：NeuralModule

在 VoiceBox 和 AudioBox 中使用的具有 U-Net 结构的 Transformer 编码器模型的实现

参考文献

Le et al., Voicebox: Text-Guided Multilingual Universal Speech Generation at Scale, 2023 Vyas et al., Audiobox: Unified Audio Generation with Natural Language Prompts, 2023

forward( x, key_padding_mask: torch.Tensor | None = None, adaptive_rmsnorm_cond=None, )#

模型的前向传递。

参数:

input – 输入张量，形状 (B, C, D, T)
key_padding_mask – 掩码张量，指示填充部分，形状 (B, T)
adaptive_rmsnorm_cond – 模型的条件输入，形状 (B, D)

get_alibi_bias(batch_size: int, seq_len: int)#: 返回给定批次大小和序列长度的 alibi_bias

init_alibi(max_positions: int, heads: int)#

初始化 Alibi 偏置参数

参考文献

Press et al., Train Short, Test Long: Attention with Linear Biases Enables Input Length Extrapolation, 2021

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

class nemo.collections.audio.parts.submodules.transformerunet.SpectrogramTransformerUNet(*args: Any, **kwargs: Any)#

基类：NeuralModule

该模型通过堆叠实部和虚部来处理复数值输入。堆叠张量使用 TransformerUNet 进行处理，输出被投影以生成输出通道的实部和虚部。

卷积位置嵌入应用于输入序列

forward( input, input_length=None, condition=None, )#

模型的前向传递。

参数:

input – 输入张量，形状 (B, C, D, T)
input_length – 批次中每个示例的有效时间步长，形状 (B,)
condition – 模型的标量条件（时间），将使用 self.time_embedding 嵌入

property input_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

property output_types: Dict[str, NeuralType]#: 返回模块输入端口的定义。

Losses#

class nemo.collections.audio.losses.MAELoss(*args: Any, **kwargs: Any)#

Bases: Loss, Typing

计算跨通道加权平均的平均绝对误差 (MAE) 损失。

参数:

weight – 每个输出通道损失的权重，用于平均跨通道的损失。默认为 None (平均)。
reduction – 批次缩减。默认为批次的 mean (平均)。
ndim – 输入信号的维度数量

forward( estimate: torch.Tensor, target: torch.Tensor, input_length: torch.Tensor | None = None, mask: torch.Tensor | None = None, ) → torch.Tensor#

对于多通道信号的输入批次，计算每个通道的估计值和目标值之间的 MAE，执行跨通道的平均（权重可选），并应用跨批次的缩减。

参数:

estimate – 目标信号的估计值
target – 目标信号
input_length – 批次中每个样本的长度
mask – 每个信号的掩码

返回:

标量损失。

property input_types#: MAELoss 的输入类型定义。

property output_types#: MAELoss 的输出类型定义。 loss

NeuralType(None)

class nemo.collections.audio.losses.MSELoss(*args: Any, **kwargs: Any)#

Bases: Loss, Typing

计算跨通道加权平均的 MSE 损失。

参数:

weight – 每个输出通道损失的权重，用于平均跨通道的损失。默认为 None (平均)。
reduction – 批次缩减。默认为批次的 mean (平均)。
ndim – 输入信号的维度数量

forward( estimate: torch.Tensor, target: torch.Tensor, input_length: torch.Tensor | None = None, mask: torch.Tensor | None = None, ) → torch.Tensor#

对于多通道信号的输入批次，计算每个通道的估计值和目标值之间的 SDR，执行跨通道的平均（权重可选），并应用跨批次的缩减。

参数:

estimate – 目标信号的估计值
target – 目标信号
input_length – 批次中每个样本的长度
mask – 每个信号的掩码

返回:

标量损失。

property input_types#: SDRLoss 的输入类型定义。

property output_types#: SDRLoss 的输出类型定义。 loss

NeuralType(None)

class nemo.collections.audio.losses.SDRLoss(*args: Any, **kwargs: Any)#

Bases: Loss, Typing

计算跨通道加权平均的信号失真比 (SDR) 损失。

参数:

weight – 每个输出通道 SDR 的权重，用于平均跨通道的损失。默认为 None (平均)。
reduction – 批次缩减。默认为批次的 mean (平均)。
scale_invariant – 如果为 True，则使用尺度不变 SDR。默认为 False。
remove_mean – 在计算损失之前去除均值。默认为 True。
sdr_max – 损失的软阈值化到 SDR_max。
eps – 用于正则化的小值。

forward( estimate: torch.Tensor, target: torch.Tensor, input_length: torch.Tensor | None = None, mask: torch.Tensor | None = None, ) → torch.Tensor#

对于多通道信号的输入批次，计算每个通道的估计值和目标值之间的 SDR，执行跨通道的平均（权重可选），并应用跨批次的缩减。

参数:

estimate – 信号批次，形状 (B, C, T)
target – 信号批次，形状 (B, C, T)
input_length – 长度批次，形状 (B,)
mask – 每个通道的时间掩码批次，形状 (B, C, T)

返回:

标量损失。

property input_types#: SDRLoss 的输入类型定义。

property output_types#: SDRLoss 的输出类型定义。 loss

NeuralType(None)

Datasets#

NeMo Format#

class nemo.collections.audio.data.audio_to_audio.BaseAudioDataset(*args: Any, **kwargs: Any)#

Bases: Dataset

音频数据集的基类，为其他音频数据集提供通用功能。

参数:

collection – 从清单文件准备的音频示例集合。
audio_processor – 用于处理集合中的每个示例。一个具有 process 方法的可调用对象。有关参考，请查看 ASRAudioProcessor。

num_channels(signal_key) → int#

返回此字典准备的项目中特定信号的通道数。

更具体地说，这将从数据集中的第一个项目获取张量，检查它是否是一维或二维张量，并根据第一个轴的大小 (shape[0]) 返回通道数。

注意：这假设所有示例都具有相同数量的通道。

参数:: signal_key – 字符串，用于从 __getitem__ 输出的字典中选择信号
返回:: 所选信号的通道数。

abstract property output_types: Dict[str, NeuralType] | None#: 返回模块输入端口的定义。

class nemo.collections.audio.data.audio_to_audio.AudioToTargetDataset(*args: Any, **kwargs: Any)#

Bases: BaseAudioDataset

用于音频到音频任务的数据集，其中目标是使用输入信号来恢复相应的目标信号。

清单文件中的每一行都应具有以下格式: ``` {

‘input_key’: ‘path/to/input.wav’, ‘target_key’: ‘path/to/path_to_target.wav’, ‘duration’: duration_of_input,
此外，可以为清单中的每个键提供多个音频文件，例如，: ``` {

‘input_key’: ‘path/to/input.wav’, ‘target_key’: [‘path/to/path_to_target_ch0.wav’, ‘path/to/path_to_target_ch1.wav’], ‘duration’: duration_of_input,

可以在构造函数中配置输入和目标信号的键 (input_key 和 target_key)。

参数:

manifest_filepath – 以上述格式的清单文件路径。
sample_rate – 加载音频信号的采样率。
input_key – 指向清单中输入音频文件的键
target_key – 指向清单中目标音频文件的键
audio_duration – __getitem__ 返回的每个项目的可选持续时间。如果为 None，将加载完整音频。如果设置，将从目标音频和输入音频同步加载随机子段，即具有相同的开始和结束点。
random_offset – 如果为 True，则从文件加载子段时，偏移量将随机化。
max_duration – 如果音频超过此长度，则不包括在数据集中。
min_duration – 如果音频小于此长度，则不包括在数据集中。
max_utts – 限制 utterance 的数量。
input_channel_selector – 可选，从每个输入音频文件中选择通道子集。如果为 None，将加载所有通道。
target_channel_selector – 可选，从每个输入音频文件中选择通道子集。如果为 None，将加载所有通道。
normalization_signal – 使用确保归一化信号在 [-1, 1] 范围内的比例来归一化音频信号。所有音频信号都按相同的因子缩放。支持的值为 None (无归一化)、‘input_signal’、‘target_signal’。

property output_types: Dict[str, NeuralType] | None#

返回模块输入端口的定义。

返回:

``` {

‘input_signal’: 批处理的单通道或多通道格式, ‘input_length’: 每个输入信号的批处理原始长度 ‘target_signal’: 批处理的单通道或多通道格式, ‘target_length’: 每个目标信号的批处理原始长度

返回类型:

以下形式的有序字典

class nemo.collections.audio.data.audio_to_audio.AudioToTargetWithReferenceDataset(*args: Any, **kwargs: Any)#

Bases: BaseAudioDataset

用于音频到音频任务的数据集，其中目标是使用输入信号来恢复相应的目标信号，并且可以使用额外的参考信号。

例如，当参考信号可从以下来源获得时，可以使用此方法 - 目标信号的注册 utterance - 来自回放的回声参考 - 来自与目标信号相关的另一个传感器的参考

清单文件中的每一行都应具有以下格式: ``` {

‘input_key’: ‘path/to/input.wav’, ‘target_key’: ‘path/to/path_to_target.wav’, ‘reference_key’: ‘path/to/path_to_reference.wav’, ‘duration’: duration_of_input,

可以在构造函数中配置输入、目标和参考信号的键。

参数:

manifest_filepath – 以上述格式的清单文件路径。
sample_rate – 加载音频信号的采样率。
input_key – 指向清单中输入音频文件的键
target_key – 指向清单中目标音频文件的键
reference_key – 指向清单中参考音频文件的键
audio_duration – __getitem__ 返回的每个项目的可选持续时间。如果为 None，将加载完整音频。如果设置，将从目标音频和输入音频同步加载随机子段，即具有相同的开始和结束点。
random_offset – 如果为 True，则从文件加载子段时，偏移量将随机化。
max_duration – 如果音频超过此长度，则不包括在数据集中。
min_duration – 如果音频小于此长度，则不包括在数据集中。
max_utts – 限制 utterance 的数量。
input_channel_selector – 可选，从每个输入音频文件中选择通道子集。如果为 None，将加载所有通道。
target_channel_selector – 可选，从每个输入音频文件中选择通道子集。如果为 None，将加载所有通道。
reference_channel_selector – 可选，从每个输入音频文件中选择通道子集。如果为 None，将加载所有通道。
reference_is_synchronized – 如果为 True，则假定参考信号与输入信号同步，因此将加载与输入和目标相同的子段。如果为 False，则将独立于输入和目标加载参考信号。
reference_duration – 可选，可用于设置参考 utterance 的固定持续时间。如果为 None，将加载完整的音频文件。
normalization_signal – 使用确保归一化信号在 [-1, 1] 范围内的比例来归一化音频信号。所有音频信号都按相同的因子缩放。支持的值为 None (无归一化)、‘input_signal’、‘target_signal’、‘reference_signal’。

property output_types: Dict[str, NeuralType] | None#

返回模块输入端口的定义。

返回:

``` {

‘input_signal’: 批处理的单通道或多通道格式, ‘input_length’: 每个输入信号的批处理原始长度 ‘target_signal’: 批处理的单通道或多通道格式, ‘target_length’: 每个目标信号的批处理原始长度 ‘reference_signal’: 单通道或多通道格式, ‘reference_length’: 每个参考信号的原始长度

返回类型:

以下形式的有序字典

class nemo.collections.audio.data.audio_to_audio.AudioToTargetWithEmbeddingDataset(*args: Any, **kwargs: Any)#

Bases: BaseAudioDataset

用于音频到音频任务的数据集，其中目标是使用输入信号来恢复相应的目标信号以及额外的嵌入信号。假定嵌入是向量形式。

清单文件中的每一行都应具有以下格式: ``` {

input_key: ‘path/to/input.wav’, target_key: ‘path/to/path_to_target.wav’, embedding_key: ‘path/to/path_to_reference.npy’, ‘duration’: duration_of_input,

可以在构造函数中配置输入、目标和嵌入信号的键。

参数:

manifest_filepath – 以上述格式的清单文件路径。
sample_rate – 加载音频信号的采样率。
input_key – 指向清单中输入音频文件的键
target_key – 指向清单中目标音频文件的键
embedding_key – 指向清单中嵌入文件的键
audio_duration – __getitem__ 返回的每个项目的可选持续时间。如果为 None，将加载完整音频。如果设置，将从目标音频和输入音频同步加载随机子段，即具有相同的开始和结束点。
random_offset – 如果为 True，则从文件加载子段时，偏移量将随机化。
max_duration – 如果音频超过此长度，则不包括在数据集中。
min_duration – 如果音频小于此长度，则不包括在数据集中。
max_utts – 限制 utterance 的数量。
input_channel_selector – 可选，从每个输入音频文件中选择通道子集。如果为 None，将加载所有通道。
target_channel_selector – 可选，从每个输入音频文件中选择通道子集。如果为 None，将加载所有通道。
normalization_signal – 使用确保归一化信号在 [-1, 1] 范围内的比例来归一化音频信号。所有音频信号都按相同的因子缩放。支持的值为 None (无归一化)、‘input_signal’、‘target_signal’。

property output_types: Dict[str, NeuralType] | None#

返回模块输入端口的定义。

返回:

``` {

‘input_signal’: 批处理的单通道或多通道格式, ‘input_length’: 每个输入信号的批处理原始长度 ‘target_signal’: 批处理的单通道或多通道格式, ‘target_length’: 每个目标信号的批处理原始长度 ‘embedding_vector’: 批处理的嵌入向量格式, ‘embedding_length’: 每个嵌入向量的批处理原始长度

返回类型:

以下形式的有序字典

Lhotse Format#

class nemo.collections.audio.data.audio_to_audio_lhotse.LhotseAudioToTargetDataset(*args: Any, **kwargs: Any)#

Bases: Dataset

用于音频到音频任务的数据集，其中目标是使用输入信号来恢复相应的目标信号。

Note

这是 nemo.collections.asr.data.audio_to_audio.AudioToTargetDataset 的 Lhotse 变体。