重要提示

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

NeMo ASR API

模型类

模块

class nemo.collections.asr.modules.ConvASREncoder(*args: Any, **kwargs: Any)

基类： NeuralModule, Exportable, AccessMixin

ASR 模型的卷积编码器。 使用此类可以实现 JasperNet 和 QuartzNet 模型。

基于以下论文

https://arxiv.org/pdf/1904.03288.pdf https://arxiv.org/pdf/1910.10261.pdf

input_example(max_batch=1, max_dim=8192)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

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

property output_types

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

update_max_sequence_length(seq_length: int, device)

查找分布式训练中所有节点上的全局最大音频长度，并更新 max_audio_length

class nemo.collections.asr.modules.ConvASRDecoder(*args: Any, **kwargs: Any)

基类： NeuralModule, Exportable, AdapterModuleMixin

用于基于 CTC 的模型（如 JasperNet 和 QuartzNet）的简单 ASR 解码器

基于以下论文

https://arxiv.org/pdf/1904.03288.pdf https://arxiv.org/pdf/1910.10261.pdf https://arxiv.org/pdf/2005.04290.pdf

add_adapter(name: str, cfg: omegaconf.DictConfig)

向此模块添加 Adapter 模块。

参数:

• name – 适配器的全局唯一名称。 将用于访问、启用和禁用适配器。

• cfg – 一个 DictConfig 或 Dataclass，其中至少包含 __target__ 以实例化新的 Adapter 模块。

input_example(max_batch=1, max_dim=256)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

定义这些以启用输入神经类型检查

property output_types

定义这些以启用输出神经类型检查

class nemo.collections.asr.modules.ConvASRDecoderClassification(*args: Any, **kwargs: Any)

基类： NeuralModule, Exportable

用于分类模型（如 JasperNet 和 QuartzNet）的简单 ASR 解码器

基于以下论文

https://arxiv.org/pdf/2005.04290.pdf

input_example(max_batch=1, max_dim=256)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

定义这些以启用输入神经类型检查

property output_types

定义这些以启用输出神经类型检查

class nemo.collections.asr.modules.SpeakerDecoder(*args: Any, **kwargs: Any)

基类： NeuralModule, Exportable

Speaker Decoder 创建最终的神经层，这些神经层从 Jasper Encoder 的输出映射到嵌入层，然后是基于说话人的 softmax 损失。

参数:

• feat_in (int) – 输入到此模块的通道数

• num_classes (int) – 数据集中唯一说话人的数量

• emb_sizes (list) – 中间嵌入层的形状（我们考虑来自这些层中第一个的说话人嵌入）。 默认为 [1024,1024]

• pool_mode (str) – 池化策略类型。 选项为“xvector”、“tap”、“attention”。 默认为“xvector（均值和方差）” tap（时间平均池化：仅均值）attention（基于注意力的池化）

• init_mode (str) – 描述神经网络参数的初始化方式。 选项为 [‘xavier_uniform’, ‘xavier_normal’, ‘kaiming_uniform’,’kaiming_normal’]。 默认为“xavier_uniform”。

input_example(max_batch=1, max_dim=256)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

定义这些以启用输入神经类型检查

property output_types

定义这些以启用输出神经类型检查

class nemo.collections.asr.modules.ConformerEncoder(*args: Any, **kwargs: Any)

基类： NeuralModule, StreamingEncoder, Exportable, AccessMixin

Conformer 的 ASR 模型的编码器。 基于这篇论文：“Conformer: Convolution-augmented Transformer for Speech Recognition”，作者 Anmol Gulati 等人。 https://arxiv.org/abs/2005.08100

参数:

• feat_in (int) – 特征通道的大小

• n_layers (int) – ConformerBlock 的层数

• d_model (int) – 模型的隐藏大小

• feat_out (int) – 输出特征的大小。 默认为 -1（表示 feat_out 为 d_model）

• subsampling (str) – 降采样方法，选项=[‘vggnet’, ‘striding’, ‘dw-striding’, ‘stacking’, ‘stacking_norm’]。 默认为 striding。

• subsampling_factor (int) – 降采样因子，应为 2 的幂。 默认为 4。

• subsampling_conv_chunking_factor (int) – （可选）强制分块输入（对于大型输入很有用）。 应为 2 的幂，1（自动分块，默认）或 -1（不分块）

• subsampling_conv_channels (int) – 降采样模块中卷积的大小。 默认为 -1，这将将其设置为 d_model。

• reduction (str, Optional) – 缩减方法，选项=[‘pooling’, ‘striding’]。 如果未传递任何值，则不执行任何缩减，并且模型以原始 4 倍降采样运行。

• reduction_position (int, Optional) – 应用缩减的层的索引。 如果为 -1，则在末尾应用缩减。

• reduction_factor (int) – 缩减因子，应为 1 或 2 的幂。 默认为 1。

• ff_expansion_factor (int) – 前馈层中的扩展因子。 默认为 4。

• self_attention_model (str) –

  注意力层和位置编码的类型

  “rel_pos”

  相对位置嵌入和 Transformer-XL

  “rel_pos_local_attn”

  相对位置嵌入和 Transformer-XL，具有使用重叠块的局部注意力。 注意力上下文由 att_context_size 参数确定。

  “abs_pos”

  绝对位置嵌入和 Transformer

  默认为 rel_pos。

• pos_emb_max_len (int) – 位置嵌入的最大长度。 默认为 5000

• n_heads (int) – 多头注意力层中的头数。 默认为 4。

• att_context_size (List[Union[List[int],int]]) – 指定每侧的上下文大小。 每个上下文大小都应为两个整数的列表，例如 [100,100]。 也可以传递上下文大小列表，例如 [[100,100],[100,50]]。 -1 表示无限上下文。 默认为 [-1,-1]

• att_context_probs (List[float]) – 当传递上下文大小列表时，每个 att_context_size 的概率列表。 如果未指定，则使用均匀分布。 默认为 None

• att_context_style (str) – “regular” 或 “chunked_limited”。 默认为 “regular”

• xscaling (bool) – 启用按 sqrt(d_model) 缩放多头注意力层的输入。 默认为 True。

• untie_biases (bool) – 是否不共享（解绑）Transformer-XL 各层之间的偏置权重。 默认为 True。

• conv_kernel_size (int) – 卷积模块中卷积的大小。 默认为 31。

• conv_norm_type (str) – 卷积模块中归一化的类型。 默认为 “batch_norm”。

• conv_context_size (list) – 它可以是“causal”或两个整数的列表，而 conv_context_size[0]+conv_context_size[1]+1==conv_kernel_size。 None 表示 [(conv_kernel_size-1)//2, (conv_kernel_size-1)//2]，而“causal”表示 [(conv_kernel_size-1), 0]。 默认为 None。

• conv_dual_mode (bool) – 指定当使用 dual_offline 模式时，卷积是否应为双重模式。 启用后，卷积核的左半部分将在流式传输情况下被屏蔽。 默认为 False

• use_bias (bool) – 在每个 ConformerLayer 的所有 Linear 和 Conv1d 层中使用偏置，以改善激活流并稳定大型模型的训练。 默认为 True。

• dropout (float) – 除注意力层外的所有层中使用的 dropout 率。 默认为 0.1。

• dropout_pre_encoder (float) – 编码器之前使用的 dropout 率。 默认为 0.1。

• dropout_emb (float) – 位置嵌入的 dropout 率。 默认为 0.1。

• dropout_att (float) – 注意力层的 dropout 率。 默认为 0.0。

• stochastic_depth_drop_prob (float) – 如果为非零值，则在训练期间随机丢弃层。 此值越高，层被丢弃的频率越高。 默认为 0.0。

• stochastic_depth_mode (str) – 可以是“linear”或“uniform”。 如果设置为“uniform”，则所有层都具有相同的丢弃概率。 如果设置为“linear”，则丢弃概率从第一层的 0 线性增长到最后一层的期望值。 默认为 “linear”。

• stochastic_depth_start_layer (int) – 随机深度的起始层。 在此之前的所有层永远不会被丢弃。 请注意，当起始层 > 1 时，如果模式为“linear”，则会相应地调整丢弃概率。 默认为 1。

• global_tokens (int) – 用于全局注意力的令牌数。 仅当 self_attention_model 为 “rel_pos_local_attn” 时才相关。 默认为 0。

• global_tokens_spacing (int) – 全局令牌之间的距离。 默认为 1。

• global_attn_separate (bool) – 用于全局令牌的 q、k、v 层是否应分开。 默认为 False。

• use_pytorch_sdpa (bool) – 使用 torch sdpa 而不是手动注意力。 默认为 False。

• use_pytorch_sdpa_backends (list[str]) – sdpa 中要使用的后端名称列表。 None 或空列表表示所有后端。 例如 [“MATH”]。 默认为 None

• sync_max_audio_length (bool) – 如果为 true，则执行 NCCL all_reduce 以在所有 GPU 上为位置编码缓冲区分配相同数量的内存。 禁用此设置可能有助于解决某些情况下的死锁，例如模型并行，或者通常在此模块未作为训练步骤的一部分在某些 GPU 上运行时。

change_attention_model(

self_attention_model: str | None = None,

att_context_size: List[int] | None = None,

update_config: bool = True,

device: torch.device | None = None,

)

更新 self_attention_model，这将更改位置编码和注意力层。

参数:

• self_attention_model (str) –

  注意力层和位置编码的类型

  “rel_pos”

  相对位置嵌入和 Transformer-XL

  “rel_pos_local_attn”

  相对位置嵌入和 Transformer-XL，具有使用重叠窗口的局部注意力。 注意力上下文由 att_context_size 参数确定。

  “abs_pos”

  绝对位置嵌入和 Transformer

  如果提供 None，则 self_attention_model 不会更改。 默认为 None。

• att_context_size (List[int]) – 2 个整数的列表，分别对应于左侧和右侧的注意力上下文大小，如果为 None，则保持原样。 默认为 None。

• update_config (bool) – 是否使用新的注意力模型更新配置。 默认为 True。

• device (torch.device) – 如果提供，新层将移至设备。 默认为 None。

change_subsampling_conv_chunking_factor(

subsampling_conv_chunking_factor: int,

)

更新 conv_chunking_factor (int)。 默认为 1（自动）。 如果在 conv 降采样层中遇到 OOM，请将其设置为 -1（禁用）或特定值（2 的幂）

参数:

subsampling_conv_chunking_factor (int)

property disabled_deployment_input_names

实现此方法以返回为导出禁用的输入名称集合

property disabled_deployment_output_names

实现此方法以返回为导出禁用的输出名称集合

input_example(max_batch=1, max_dim=256)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

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

property input_types_for_export

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

property output_types

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

property output_types_for_export

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

set_max_audio_length(max_audio_length)

设置最大输入长度。预先计算内部 seq_range 掩码。

setup_streaming_params(

chunk_size: int | None = None,

shift_size: int | None = None,

left_chunks: int | None = None,

att_context_size: list | None = None,

max_context: int = 10000,

)

此函数设置执行流式处理所需的值和参数。配置将存储在 self.streaming_cfg 中。流式配置是模拟流式推理所必需的。

参数:

• chunk_size (int) – 覆盖块大小

• shift_size (int) – 覆盖块的移位大小

• left_chunks (int) – 覆盖每个块可见的左侧块的数量

• max_context (int) – 如果左侧上下文设置为无限 (-1)，则用于 last_channel 层的缓存大小的值。默认为 -1（表示 feat_out 为 d_model）

class nemo.collections.asr.modules.SqueezeformerEncoder(*args: Any, **kwargs: Any)

基类： NeuralModule, Exportable, AccessMixin

Squeezeformer 的 ASR 模型编码器。基于这篇论文：“Squeezeformer: An Efficient Transformer for Automatic Speech Recognition”，作者 Sehoon Kim 等人。 https://arxiv.org/abs/2206.00888

参数:

• feat_in (int) – 特征通道的大小

• n_layers (int) – ConformerBlock 的层数

• d_model (int) – 模型的隐藏大小

• feat_out (int) – 输出特征的大小。 默认为 -1（表示 feat_out 为 d_model）

• subsampling (str) – 子采样方法，选项=[‘vggnet’, ‘striding’, ‘dw_striding’]，默认为 dw_striding。

• subsampling_factor (int) – 降采样因子，应为 2 的幂。 默认为 4。

• subsampling_conv_channels (int) – 降采样模块中卷积的大小。 默认为 -1，这将将其设置为 d_model。

• ff_expansion_factor (int) – 前馈层中的扩展因子。 默认为 4。

• self_attention_model (str) – 注意力层和位置编码的类型 ‘rel_pos’：相对位置嵌入和 Transformer-XL ‘abs_pos’：绝对位置嵌入和 Transformer，默认为 rel_pos。

• pos_emb_max_len (int) – 位置嵌入的最大长度，默认为 5000

• n_heads (int) – 多头注意力层中的头数。 默认为 4。

• xscaling (bool) – 启用按 sqrt(d_model) 缩放多头注意力层的输入。 默认为 True。

• untie_biases (bool) – 是否不共享（解绑）Transformer-XL 各层之间的偏置权重。 默认为 True。

• conv_kernel_size (int) – 卷积模块中卷积的大小。 默认为 31。

• conv_norm_type (str) – 卷积模块中归一化的类型。 默认为 “batch_norm”。

• dropout (float) – 除注意力层外的所有层中使用的 dropout 率。 默认为 0.1。

• dropout_emb (float) – 位置嵌入的 dropout 率。 默认为 0.1。

• dropout_att (float) – 注意力层的 dropout 率。 默认为 0.0。

• adaptive_scale (bool) – 是否通过仿射 scale 和 bias 层缩放每个组件的输入。或者使用固定 scale=1 和 bias=0。

• time_reduce_idx (int) – 可选的整数索引，表示将发生时间缩减操作的层。超出此点的所有操作将仅以降低的分辨率发生。

• time_recovery_idx (int) – 可选的整数索引，表示将发生时间恢复操作的层。超出此点的所有操作将以原始分辨率（主下采样后的分辨率）发生。如果未提供值，则假定为最后一层。

input_example(max_batch=1, max_dim=256)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

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

make_pad_mask(max_audio_length, seq_lens)

为填充创建掩码。

property output_types

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

set_max_audio_length(max_audio_length)

设置最大输入长度。预先计算内部 seq_range 掩码。

class nemo.collections.asr.modules.RNNEncoder(*args: Any, **kwargs: Any)

基类： NeuralModule, Exportable

基于 RNN 的 ASR 模型编码器。遵循以下论文中建议的架构：“移动设备的流式端到端语音识别”，作者 Yanzhang He 等人。 https://arxiv.org/pdf/1811.06621.pdf

参数:

• feat_in (int) – 特征通道的大小

• n_layers (int) – RNN 的层数

• d_model (int) – 模型的隐藏大小

• proj_size (int) – 每个 RNN 层之后的输出投影大小

• rnn_type (str) – RNN 层的类型，选项=[‘lstm, ‘gru’, ‘rnn’]

• bidirectional (float) – 指定 RNN 层是否应为双向。默认为 True。

• feat_out (int) – 输出特征的大小。 默认为 -1（表示 feat_out 为 d_model）

• subsampling (str) – 子采样方法，选项=[‘stacking, ‘vggnet’, ‘striding’]，默认为 stacking。

• subsampling_factor (int) – 子采样因子，默认为 4。

• subsampling_conv_channels (int) – vggnet 和 striding 的子采样模块中的卷积大小，默认为 -1，这将设置为 d_model。

• dropout (float) – 所有层之间使用的 dropout 率，默认为 0.2。

input_example()

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

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

property output_types

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

class nemo.collections.asr.modules.RNNTDecoder(*args: Any, **kwargs: Any)

基类：AbstractRNNTDecoder, Exportable, AdapterModuleMixin

循环神经网络转录器解码器/预测网络 (RNN-T 预测网络)。 RNN-T 解码器/预测网络，由有状态 LSTM 模型组成。

参数:

• prednet –

  一个类似字典的对象，包含以下键值对。

  pred_hidden

  int，指定预测网络的隐藏维度。

  pred_rnn_layers

  int，指定 rnn 层的数量。

  可选地，它还可以包含以下内容

  forget_gate_bias

  float，默认设置为 1.0，它构造一个初始化为 1.0 的遗忘门。参考文献：[循环网络架构的实证探索](http://proceedings.mlr.press/v37/jozefowicz15.pdf)

  t_max

  int 值，默认设置为 None。如果指定了 int，则根据训练期间预期的最大时间步数 t_max 执行 LSTM 网络的 Chrono 初始化。参考文献：[循环神经网络可以扭曲时间吗？](https://openreview.net/forum?id=SJcKhk-Ab)

  weights_init_scale

  初始化后权重的浮点比例。设置为小于 1 有时有助于减少运行之间的差异。

  hidden_hidden_bias_scale

  隐藏到隐藏偏差比例的浮点比例。对于默认行为，设置为 0.0。

  dropout

  float，默认设置为 0.0。在最终 LSTM RNN 层末尾应用可选的 dropout。

• vocab_size – int，指定预测网络的嵌入层的词汇表大小，不包括 RNNT 空白标记。

• normalization_mode – 可以是 None、‘batch’ 或 ‘layer’。默认情况下，设置为 None。定义应用于 RNN 层的归一化类型。

• random_state_sampling – bool，默认设置为 False。设置后，在训练期间提供正态分布采样的状态张量，而不是零张量。参考文献：[使用流式端到端模型识别长格式语音](https://arxiv.org/abs/1910.11455)

• blank_as_pad –

  bool，默认设置为 True。设置后，将向此预测网络的嵌入层添加一个标记，并将此标记视为填充标记。本质上，RNNT 填充标记将被视为填充标记，并且嵌入层将为此标记返回零张量。

  默认情况下设置它，因为它启用了批量波束搜索所需的各种批量优化。因此，不建议禁用此标志。

add_adapter(name: str, cfg: omegaconf.DictConfig)

向此模块添加 Adapter 模块。

参数:

• name – 适配器的全局唯一名称。 将用于访问、启用和禁用适配器。

• cfg – 一个 DictConfig 或 Dataclass，其中至少包含 __target__ 以实例化新的 Adapter 模块。

batch_concat_states(

batch_states: List[List[torch.Tensor]],

) → List[torch.Tensor]

将一批解码器状态连接到打包状态。

参数:

batch_states (list) – 批量解码器状态 B x ([L x (H)], [L x (H)])

返回:

解码器状态

(L x B x H, L x B x H)

返回类型:

(tuple)

batch_copy_states(

old_states: List[torch.Tensor],

new_states: List[torch.Tensor],

ids: List[int],

value: float | None = None,

) → List[torch.Tensor]

在特定索引处将状态从新状态复制到旧状态。

参数:

• old_states (list) – 打包的解码器状态 (L x B x H, L x B x H)

• new_states – 打包的解码器状态 (L x B x H, L x B x H)

• ids (list) – 要复制状态的索引列表。

• value (optional float) – 如果应复制值而不是状态切片，则应提供浮点数

返回:

批量解码器状态，在 ids 处进行部分复制（或特定值）。

(L x B x H, L x B x H)

batch_initialize_states(

decoder_states: List[List[torch.Tensor]],

) → List[torch.Tensor]

创建要传递到预测网络的堆叠解码器状态

参数:

decoder_states (list of list of list of torch.Tensor) –

解码器状态列表 [B, C, L, H]

• B：批量大小。

• C：例如，对于 LSTM，这是 2：隐藏状态和单元状态

• L：预测 RNN 中的层数。

• H：隐藏状态的维度。

返回:

批量解码器状态

[C x torch.Tensor[L x B x H]

返回类型:

batch_states (torch.Tensor 列表)

classmethod batch_replace_states_all(

src_states: Tuple[torch.Tensor, torch.Tensor],

dst_states: Tuple[torch.Tensor, torch.Tensor],

)

用 src_states 中的状态替换 dst_states 中的状态

classmethod batch_replace_states_mask(

src_states: Tuple[torch.Tensor, torch.Tensor],

dst_states: Tuple[torch.Tensor, torch.Tensor],

mask: torch.Tensor,

)

使用掩码用 src_states 中的状态替换 dst_states 中的状态

batch_score_hypothesis(

hypotheses: List[Hypothesis],

cache: Dict[Tuple[int], Any],

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

用于批量波束搜索算法。类似于 score_hypothesis 方法。

参数:

• hypothesis – 假设列表。请参阅 rnnt_utils.Hypothesis。

• cache – 包含缓存以避免重复计算的 Dict。

返回:

batch_dec_out：torch.Tensor [1, H] 的列表，表示假设中最后一个标记的预测网络输出。 batch_dec_states：RNN 状态列表的列表，每个形状为 [L, B, H]。表示为 B x List[states]。

返回类型:

返回一个元组 (batch_dec_out, batch_dec_states)，使得

batch_select_state(

batch_states: List[torch.Tensor],

idx: int,

) → List[List[torch.Tensor]]

从批量状态中获取给定 id 的解码器状态。

参数:

• batch_states (list) – 批量解码器状态 ([L x (B, H)], [L x (B, H)])

• idx (int) – 从批量状态中提取状态的索引

返回:

给定 id 的解码器状态

([L x (1, H)], [L x (1, H)])

返回类型:

(tuple)

batch_split_states(

batch_states: Tuple[torch.Tensor, torch.Tensor],

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

将状态拆分为状态列表。用于拆分最终状态，以便将解码算法的结果转换为 Hypothesis 类。

initialize_state(

y: torch.Tensor,

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

使用与输入 y 相同的 dtype 和设备初始化 LSTM 层的状态。 LSTM 接受 2 个张量的元组作为状态。

参数:

y – 一个 torch.Tensor，其设备将放置生成的状态。

返回:

2 个张量的元组，每个形状为 [L, B, H]，其中

L = RNN 层数

B = 批量大小

H = RNN 的隐藏大小。

input_example(max_batch=1, max_dim=1)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

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

mask_select_states(

states: Tuple[torch.Tensor, torch.Tensor],

mask: torch.Tensor,

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

通过掩码选择返回状态 :param states: 批量的状态 :param mask: 用于选择状态的布尔掩码；批量维度应与状态相同

返回:

按掩码过滤的状态

property output_types

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

predict(

y: torch.Tensor | None = None,

state: List[torch.Tensor] | None = None,

add_sos: bool = True,

batch_size: int | None = None,

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

有状态地预测（可能为空的）标记集的得分和状态。此方法考虑了各种情况： - 没有标记，没有状态 - 用于启动 RNN - 没有标记，提供状态 - 用于空白标记评分 - 给定标记，状态 - 用于得分 + 新状态

此处：B - 批量大小 U - 标签长度 H - RNN 的隐藏维度大小 L - RNN 层数

参数:

• y – 可选的 torch 张量，形状为 [B, U]，dtype 为 long，将传递给 Embedding。如果为 None，则创建形状为 [B, 1, H] 的零张量，该张量模拟 EmbeddiNg 上 pad-token 的输出。

• state – RNN 的可选状态列表。例如：对于 LSTM，状态列表长度为 2。每个状态必须是形状为 [L, B, H] 的张量。如果为 None，并且在训练模式下且设置了 random_state_sampling，则将采样上述形状的正态分布张量。否则，None 将传递给 RNN。

• add_sos – bool 标志，指示是否应将描述“信号开始”标记的零向量预先添加到上述“y”张量。设置后，输出大小为 (B, U + 1, H)。

• batch_size – 可选的 int，指定 y 张量的批量大小。如果 y 和 state 为 None，则可以推断出来。但是，如果两者都为 None，则 batch_size 不能为 None。

返回:

一个元组 (g, hid)，使得 -

如果 add_sos 为 False

g

(B, U, H)

hid

(h, c)，其中 h 是最终序列隐藏状态，c 是最终单元状态

h (张量)，形状 (L, B, H)

c (张量)，形状 (L, B, H)

如果 add_sos 为 True

g

(B, U + 1, H)

hid

(h, c)，其中 h 是最终序列隐藏状态，c 是最终单元状态

h (张量)，形状 (L, B, H)

c (张量)，形状 (L, B, H)

score_hypothesis(

hypothesis: Hypothesis,

cache: Dict[Tuple[int], Any],

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

类似于 predict() 方法，此方法在波束搜索期间对假设进行评分。 Hypothesis 是一个数据类，表示波束搜索中的一个假设。

参数:

• hypothesis – 请参阅 rnnt_utils.Hypothesis。

• cache – 包含缓存以避免重复计算的 Dict。

返回:

y 是形状为 [1, 1, H] 的 torch.Tensor，表示假设中最后一个标记的分数。 state 是 RNN 状态列表，每个形状为 [L, 1, H]。 lm_token 是假设的最终整数标记。

返回类型:

返回一个元组 (y, states, lm_token)，使得

class nemo.collections.asr.modules.StatelessTransducerDecoder(*args: Any, **kwargs: Any)

基类：AbstractRNNTDecoder, Exportable

无状态神经网络转录器解码器/预测网络。 RNN-T 解码器/预测无状态网络，它仅将历史标记的嵌入连接作为输出。

参数:

• prednet –

  一个类似字典的对象，包含以下键值对。 pred_hidden：int，指定预测网络的隐藏维度。

  dropout：float，默认设置为 0.0。在最终 LSTM RNN 层末尾应用可选的 dropout。

• vocab_size – int，指定预测网络的嵌入层的词汇表大小，不包括 RNNT 空白标记。

• context_size – int，指定此解码器使用的历史上下文的大小。

• normalization_mode – 可以是 None、‘layer’。默认情况下，设置为 None。定义应用于 RNN 层的归一化类型。

batch_concat_states(

batch_states: List[List[torch.Tensor]],

) → List[torch.Tensor]

将一批解码器状态连接到打包状态。

参数:

batch_states (list) – 批量解码器状态 B x ([(C)]

返回:

解码器状态

[(B x C)]

返回类型:

(tuple)

batch_copy_states(

old_states: List[torch.Tensor],

new_states: List[torch.Tensor],

ids: List[int],

value: float | None = None,

) → List[torch.Tensor]

在特定索引处将状态从新状态复制到旧状态。

参数:

• old_states – 打包的解码器状态，单元素列表，格式为 (B x C)

• new_states – 打包的解码器状态，单元素列表，格式为 (B x C)

• ids (list) – 要复制状态的索引列表。

• value (optional float) – 如果应复制值而不是状态切片，则应提供浮点数

返回:

批量解码器状态，在 ids 处（或特定值）进行部分复制。(B x C)

batch_initialize_states(

decoder_states: List[List[torch.Tensor]],

)

创建堆叠的解码器状态，以便传递到预测网络。

参数:

decoder_states (list of list of torch.Tensor) –

解码器状态列表 [B, 1, C]

• B：批量大小。

• C：隐藏状态的维度。

返回:

批量解码器状态 [[B x C]]

返回类型:

batch_states (torch.Tensor 列表)

classmethod batch_replace_states_all(

src_states: list[torch.Tensor],

dst_states: list[torch.Tensor],

)

用 src_states 中的状态替换 dst_states 中的状态

classmethod batch_replace_states_mask(

src_states: list[torch.Tensor],

dst_states: list[torch.Tensor],

mask: torch.Tensor,

)

使用掩码用 src_states 中的状态替换 dst_states 中的状态

batch_score_hypothesis(

hypotheses: List[Hypothesis],

cache: Dict[Tuple[int], Any],

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

用于批量波束搜索算法。类似于 score_hypothesis 方法。

参数:

• hypothesis – 假设列表。请参阅 rnnt_utils.Hypothesis。

• cache – 包含缓存以避免重复计算的 Dict。

返回:

batch_dec_out：torch.Tensor [1, H] 的列表，表示假设中最后一个标记的预测网络输出。 batch_dec_states：RNN 状态列表的列表，每个形状为 [L, B, H]。表示为 B x List[states]。

返回类型:

返回一个元组 (batch_dec_out, batch_dec_states)，使得

batch_select_state(

batch_states: List[torch.Tensor],

idx: int,

) → List[List[torch.Tensor]]

从批量状态中获取给定 id 的解码器状态。

参数:

• batch_states (list) – 批量解码器状态 [(B, C)]

• idx (int) – 从批量状态中提取状态的索引

返回:

给定 id 的解码器状态

[(C)]

返回类型:

(tuple)

batch_split_states(

batch_states: list[torch.Tensor],

) → list[list[torch.Tensor]]

将状态拆分为状态列表。用于拆分最终状态，以便将解码算法的结果转换为 Hypothesis 类。

initialize_state(

y: torch.Tensor,

) → List[torch.Tensor]

初始化 RNN 层的状态，dtype 和设备与输入 y 相同。

参数:

y – 一个 torch.Tensor，其设备将放置生成的状态。

返回:

torch.Tensor 列表，每个形状为 [L, B, H]，其中

L = RNN 层数 B = 批大小 H = RNN 的隐藏层大小。

input_example(max_batch=1, max_dim=1)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

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

mask_select_states(

states: List[torch.Tensor] | None,

mask: torch.Tensor,

) → List[torch.Tensor] | None

通过掩码选择返回状态 :param states: 批量的状态 :param mask: 用于选择状态的布尔掩码；批量维度应与状态相同

返回:

按掩码过滤的状态

property output_types

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

predict(

y: torch.Tensor | None = None,

state: torch.Tensor | None = None,

add_sos: bool = True,

batch_size: int | None = None,

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

有状态地预测 token 集的分数和状态。

此处：B - 批大小 U - 标签长度 C - 无状态解码器的上下文大小 D - 总嵌入大小

参数:

• y – 可选的 torch 张量，形状为 [B, U]，dtype 为 long，将传递给 Embedding 层。如果为 None，则创建形状为 [B, 1, D] 的零张量，模拟 Embedding 层上 pad-token 的输出。

• state – 可选的单元素列表，包含一个张量。该张量用于存储之前的上下文标签。该张量使用 long 类型，形状为 [B, C]。

• add_sos – 布尔标志，指示是否应将描述“信号开始”token 的零向量添加到上述 “y” 张量的前面。设置后，输出大小为 (B, U + 1, D)。

• batch_size – 可选的 int，指定 y 张量的批量大小。如果 y 和 state 为 None，则可以推断出来。但是，如果两者都为 None，则 batch_size 不能为 None。

返回:

一个元组 (g, state)，其中 -

如果 add_sos 为 False

g

(B, U, D)

state

[(B, C)] 存储历史上下文，包括 y 中的新词。

如果 add_sos 为 True

g

(B, U + 1, D)

state

[(B, C)] 存储历史上下文，包括 y 中的新词。

score_hypothesis(

hypothesis: Hypothesis,

cache: Dict[Tuple[int], Any],

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

类似于 predict() 方法，此方法在波束搜索期间对假设进行评分。 Hypothesis 是一个数据类，表示波束搜索中的一个假设。

参数:

• hypothesis – 请参阅 rnnt_utils.Hypothesis。

• cache – 包含缓存以避免重复计算的 Dict。

返回:

y 是形状为 [1, 1, H] 的 torch.Tensor，表示假设中最后一个标记的分数。 state 是 RNN 状态列表，每个形状为 [L, 1, H]。 lm_token 是假设的最终整数标记。

返回类型:

返回一个元组 (y, states, lm_token)，使得

class nemo.collections.asr.modules.RNNTJoint(*args: Any, **kwargs: Any)

基类：AbstractRNNTJoint, Exportable, AdapterModuleMixin

循环神经网络转录器连接网络 (RNN-T Joint Network)。RNN-T 连接网络，由前馈模型组成。

参数:

• jointnet –

  类似字典的对象，包含以下键值对。encoder_hidden：int，指定编码器网络的隐藏维度。pred_hidden：int，指定预测网络的隐藏维度。joint_hidden：int，指定连接网络的隐藏维度。activation：连接步骤中使用的激活函数。可以是 [‘relu’, ‘tanh’, ‘sigmoid’] 之一。

  可选地，它也可以包含以下内容：dropout：float，默认为 0.0。可选的 dropout 应用于连接网络的末尾。

• num_classes – int，指定连接网络必须预测的词汇表大小，不包括 RNNT 空白 token。

• vocabulary – 可选的字符串/token 列表，构成连接网络的词汇表。未使用，仅为了方便字符编码 RNNT 模型访问而保留。

• log_softmax – 可选的 bool，默认为 None。如果设置为 None，将根据提供的值计算 log_softmax()。

• preserve_memory –

  可选的 bool，默认为 False。如果模型因内存密集型连接步骤而崩溃，可以尝试使用此标志来清空 pytorch 中的张量缓存。

  警告：这将使前向-后向传递比正常情况慢得多。如果 GPU 根本没有足够的内存来计算连接，这也可能无法解决 OOM 问题。

• fuse_loss_wer –

  可选的 bool，默认为 False。

  融合连接前向、损失前向和 WER 前向步骤。这样做，它通过创建提供的输入批次的子批次来权衡速度以换取内存节省，并在子批次上执行连接前向、损失前向和 WER 前向（可选），然后整理结果，使其与整个批次的结果完全相等。

  当设置此标志时，在调用 forward 之前，必须使用 RNNTJoint.set_loss() 或 RNNTJoint.set_wer() 方法设置字段 loss 和 wer（任一）。

  此外，当设置此标志时，必须提供以下参数 fused_batch_size 作为非负整数。此值指的是子批次的大小。

  当设置该标志时，此方法的 forward() 的输入和输出签名会发生变化。输入 - 除了 encoder_outputs（强制参数）之外，还可以提供以下参数。

  • decoder_outputs（可选）。如果需要计算损失，则为必需项。

  • encoder_lengths（必需）

  • transcripts（可选）。WER 计算的必需项。

  • transcript_lengths（可选）。WER 计算的必需项。

  • compute_wer（bool，默认为 false）。是否为融合批次计算 WER。

  输出 - 而不是通常的 joint 对数概率张量，可以返回以下结果。

  • loss（可选）。如果 decoder_outputs、transcripts 和 transript_lengths 不为 None，则返回。

  • wer_numerator + wer_denominator（可选）。如果提供了 transcripts、transcripts_lengths，则返回

    并且设置了 compute_wer。

• fused_batch_size – 可选的 int，如果设置了 fuse_loss_wer 标志，则为必需项。确定子批次的大小。应为低于每个 GPU 实际批大小的任何值。

• masking_prob – 可选的 float，指示在海南 (Hybrid Autoregressive Inference Transducer) 模型中屏蔽解码器输出的概率，详见 https://arxiv.org/pdf/2410.02597 默认为 -1.0，这将运行标准的连接网络计算；如果 > 0，则使用指定的概率屏蔽解码器输出。

add_adapter(name: str, cfg: omegaconf.DictConfig)

向此模块添加 Adapter 模块。

参数:

• name – 适配器的全局唯一名称。 将用于访问、启用和禁用适配器。

• cfg – 一个 DictConfig 或 Dataclass，其中至少包含 __target__ 以实例化新的 Adapter 模块。

property disabled_deployment_input_names

实现此方法以返回为导出禁用的输入名称集合

input_example(max_batch=1, max_dim=8192)

为追踪等生成输入示例。 :returns: 输入示例的元组。

property input_types

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

joint_after_projection(

f: torch.Tensor,

g: torch.Tensor,

) → torch.Tensor

计算网络在投影后的连接步骤。

此处，B = 批大小 T = 声学模型时间步长 U = 目标序列长度 H1, H2 = 编码器/解码器的隐藏维度 H = 连接隐藏步骤的隐藏维度。V = 解码器的词汇表大小（不包括 RNNT 空白 token）。

注

此模型的实现与原始论文略有不同。原始论文提出了以下步骤：（enc, dec）-> 扩展 + 连接 + 求和 [B, T, U, H1+H2] -> 通过连接隐藏层前向传播 [B, T, U, H] – *1 *1 -> 通过连接最终层前向传播 [B, T, U, V + 1]。

我们改为将连接隐藏层拆分为 joint_hidden_enc 和 joint_hidden_dec，并按如下方式操作：enc -> 通过 joint_hidden_enc 前向传播 -> 扩展 [B, T, 1, H] – *1 dec -> 通过 joint_hidden_dec 前向传播 -> 扩展 [B, 1, U, H] – *2 (*1, *2) -> 求和 [B, T, U, H] -> 通过连接最终层前向传播 [B, T, U, V + 1]。

参数:

• f – 编码器模型的输出。形状为 [B, T, H1] 的 torch.Tensor

• g – 解码器模型的输出。形状为 [B, U, H2] 的 torch.Tensor

返回:

形状为 (B, T, U, V + 1) 的 Logits / log softmax 张量。

property output_types

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

project_encoder(

encoder_output: torch.Tensor,

) → torch.Tensor

将编码器输出投影到连接隐藏维度。

参数:

encoder_output – 形状为 [B, T, D] 的 torch.Tensor

返回:

形状为 [B, T, H] 的 torch.Tensor

project_prednet(

prednet_output: torch.Tensor,

) → torch.Tensor

将预测网络（解码器）输出投影到连接隐藏维度。

参数:

prednet_output – 形状为 [B, U, D] 的 torch.Tensor

返回:

形状为 [B, U, H] 的 torch.Tensor

class nemo.collections.asr.modules.SampledRNNTJoint(*args: Any, **kwargs: Any)

基类：RNNTJoint

采样循环神经网络转录器连接网络 (RNN-T Joint Network)。RNN-T 连接网络，由前馈模型组成，其中词汇表大小将被采样，而不是计算完整的词汇表连接。

参数:

• jointnet –

  类似字典的对象，包含以下键值对。encoder_hidden：int，指定编码器网络的隐藏维度。pred_hidden：int，指定预测网络的隐藏维度。joint_hidden：int，指定连接网络的隐藏维度。activation：连接步骤中使用的激活函数。可以是 [‘relu’, ‘tanh’, ‘sigmoid’] 之一。

  可选地，它也可以包含以下内容：dropout：float，默认为 0.0。可选的 dropout 应用于连接网络的末尾。

• num_classes – int，指定连接网络必须预测的词汇表大小，不包括 RNNT 空白 token。

• n_samples – int，指定要从词汇空间中采样的 token 数量，不包括 RNNT 空白 token。如果给定值大于整个词汇表大小，则将使用完整的词汇表。

• vocabulary – 可选的字符串/token 列表，构成连接网络的词汇表。未使用，仅为了方便字符编码 RNNT 模型访问而保留。

• log_softmax – 可选的 bool，默认为 None。如果设置为 None，将根据提供的值计算 log_softmax()。

• preserve_memory –

  可选的 bool，默认为 False。如果模型因内存密集型连接步骤而崩溃，可以尝试使用此标志来清空 pytorch 中的张量缓存。

  警告：这将使前向-后向传递比正常情况慢得多。如果 GPU 根本没有足够的内存来计算连接，这也可能无法解决 OOM 问题。

• fuse_loss_wer –

  可选的 bool，默认为 False。

  融合连接前向、损失前向和 WER 前向步骤。这样做，它通过创建提供的输入批次的子批次来权衡速度以换取内存节省，并在子批次上执行连接前向、损失前向和 WER 前向（可选），然后整理结果，使其与整个批次的结果完全相等。

  当设置此标志时，在调用 forward 之前，必须使用 RNNTJoint.set_loss() 或 RNNTJoint.set_wer() 方法设置字段 loss 和 wer（任一）。

  此外，当设置此标志时，必须提供以下参数 fused_batch_size 作为非负整数。此值指的是子批次的大小。

  当设置该标志时，此方法的 forward() 的输入和输出签名会发生变化。输入 - 除了 encoder_outputs（强制参数）之外，还可以提供以下参数。

  • decoder_outputs（可选）。如果需要计算损失，则为必需项。

  • encoder_lengths（必需）

  • transcripts（可选）。WER 计算的必需项。

  • transcript_lengths（可选）。WER 计算的必需项。

  • compute_wer（bool，默认为 false）。是否为融合批次计算 WER。

  输出 - 而不是通常的 joint 对数概率张量，可以返回以下结果。

  • loss（可选）。如果 decoder_outputs、transcripts 和 transript_lengths 不为 None，则返回。

  • wer_numerator + wer_denominator（可选）。如果提供了 transcripts、transcripts_lengths，则返回

    并且设置了 compute_wer。

• fused_batch_size – 可选的 int，如果设置了 fuse_loss_wer 标志，则为必需项。确定子批次的大小。应为低于每个 GPU 实际批大小的任何值。

sampled_joint(

f: torch.Tensor,

g: torch.Tensor,

transcript: torch.Tensor,

transcript_lengths: torch.Tensor,

) → torch.Tensor

计算网络的采样连接步骤。

参考：Memory-Efficient Training of RNN-Transducer with Sampled Softmax。

此处，B = 批大小 T = 声学模型时间步长 U = 目标序列长度 H1, H2 = 编码器/解码器的隐藏维度 H = 连接隐藏步骤的隐藏维度。V = 解码器的词汇表大小（不包括 RNNT 空白 token）。S = 词汇表的采样大小。

注

此连接模型的实现与原始论文略有不同。原始论文提出了以下步骤：（enc, dec）-> 扩展 + 连接 + 求和 [B, T, U, H1+H2] -> 通过连接隐藏层前向传播 [B, T, U, H] – *1 *1 -> 通过连接最终层前向传播 [B, T, U, V + 1]。

我们改为将连接隐藏层拆分为 joint_hidden_enc 和 joint_hidden_dec，并按如下方式操作：enc -> 通过 joint_hidden_enc 前向传播 -> 扩展 [B, T, 1, H] – *1 dec -> 通过 joint_hidden_dec 前向传播 -> 扩展 [B, 1, U, H] – *2 (*1, *2) -> 求和 [B, T, U, H] -> 采样词汇表 V_Pos（用于目标 token）和 V_Neg -> (V_Neg 不是均匀采样的，而是作为所有词汇表 token 的随机排列，然后消除所有 Intersection(V_Pos, V_Neg) 公共 token 以避免重复损失) -> 连接新词汇表 V_Sampled = Union(V_Pos, V_Neg) -> 部分通过连接最终层前向传播以创建 [B, T, U, V_Sampled]

参数:

• f – 编码器模型的输出。形状为 [B, T, H1] 的 torch.Tensor

• g – 解码器模型的输出。形状为 [B, U, H2] 的 torch.Tensor

• transcript – 批量转录本。形状为 [B, U] 的 torch.Tensor

• transcript_lengths – 批量转录本的长度。形状为 [B] 的 torch.Tensor

返回:

形状为 (B, T, U, V + 1) 的 Logits / log softmax 张量。

部件

class nemo.collections.asr.parts.submodules.jasper.JasperBlock(*args: Any, **kwargs: Any)

基类：Module, AdapterModuleMixin, AccessMixin

构建单个 “Jasper” 块。通过修改参数，还可以为 QuartzNet 和 Citrinet 等模型构建其他块。

• 对于 Jasper：separable 标志应为 False

• 对于 QuartzNet：separable 标志应为 True

• 对于 Citrinet：separable 标志和 se 标志应为 True

请注意，以上是一般区别，每个模型都有复杂的差异，这些差异扩展到多个此类块。

有关使用 JasperBlock 的模型之间差异的更多信息，请查看 ASR 示例目录中的 ASR 模型配置文件。

参数:

• inplanes – 输入通道数。

• planes – 输出通道数。

• repeat – 此块的重复子块数 (R)。

• kernel_size – 所有重复子块上的卷积核大小。

• kernel_size_factor – 浮点比例值，与核大小相乘，然后向下舍入到最接近的奇数整数以构成核大小。默认为 1.0。

• stride – 卷积层的步幅。

• dilation – 定义核的扩张因子的整数。请注意，当 dilation > 1 时，步幅必须等于 1。

• padding – 表示填充类型的字符串。当前仅支持 “same” 填充，它对称地用零填充输入张量。

• dropout – 浮点值，确定输出中归零的百分比。

• activation – 表示激活函数的字符串。有效的激活函数为：{“hardtanh”: nn.Hardtanh, “relu”: nn.ReLU, “selu”: nn.SELU, “swish”: Swish}。默认为 “relu”。

• residual – 布尔值，确定是否应添加残差分支。所有残差分支都使用逐点卷积核构建，该卷积核可能会或可能不会根据参数 residual_mode 执行步进卷积。

• groups – 分组卷积的组数。默认为 1。

• separable – 布尔标志，描述应构建时间通道深度可分离卷积还是应构建普通卷积。

• heads – 掩码卷积的 “头” 数。默认为 -1，这将禁用它。

• normalization – 表示执行的归一化类型的字符串。可以是 “batch”、“group”、“instance” 或 “layer” 之一，以计算 BatchNorm1D、GroupNorm1D、InstanceNorm 或 LayerNorm（它们是 GroupNorm1D 的特殊情况）。

• norm_groups – 用于 GroupNorm 的组数（如果 normalization == “group”）。

• residual_mode – 字符串参数，描述残差分支应简单地添加 (“add”) 还是应先步进，然后添加 (“stride_add”)。当在并行分支上执行步进以及利用残差添加时，这是必需的。

• residual_panes – 残差窗格数，用于 Jasper-DR 模型。请参阅论文。

• conv_mask – 布尔标志，确定是否利用掩码卷积。通常，应将其设置为 True。

• se – 布尔标志，确定是否应使用 Squeeze-and-Excitation 层。

• se_reduction_ratio – 整数值，确定 SE 中间步骤的隐藏维度应减少到什么程度。较大的值会减少参数数量，但也限制了 SE 层的有效性。

• se_context_window – 整数值，确定应使用多少时间步长来计算平均上下文窗口。默认为 -1，这意味着它使用全局上下文 - 这样所有时间步长都被平均。如果使用任何正整数，它将利用该大小的有限上下文窗口。

• se_interpolation_mode – 用于 SE 块的时间步长维度插值模式的字符串。仅当上下文窗口 > 1 时使用。可用于调整大小的模式包括：nearest、linear (仅限 3D)、bilinear、area。

• stride_last – 布尔标志，确定所有重复块是否应一次步进（当此标志为 False 时，步幅为 S^R），或者仅最后一个重复块应步进（当此标志为 True 时，步幅为 S）。

• future_context –

  Int 值，确定在计算 conv 核的输出时将使用多少 “right” / “future” 上下文帧。所有计算仅针对奇数核大小完成。

  默认情况下，这是 -1，它被重新计算为对称填充情况。

  当 future_context >= 0 时，将按如下方式计算非对称填充：（左侧上下文，右侧上下文）= [K - 1 - future_context, future_context]

  确定限制未来上下文的确切公式取决于模型的全局布局。因此，我们在下面提供了 “local” 和 “global” 指南。

  本地上下文限制（应始终强制执行）- 未来上下文应 <= 任何给定层的核大小的一半 - 未来上下文 > 核大小默认为对称核 - 层的未来上下文 = 未来帧数 * 每个帧的宽度（取决于步幅）

  全局上下文限制（应仔细考虑）- 未来上下文应以不断减少的模式布局。初始层应比后面的层更少地限制未来上下文，因为浅深度（和减小的步幅）意味着每个帧使用的未来上下文量较少。- 超过某个点，未来上下文对于给定的步幅级别应保持静态。这是可以全局规模提供给模型的未来上下文量的上限。- 未来上下文（大致）计算为 - (2 ^ 步幅) * (K // 2) 未来帧数。此结果值应绑定到音频未来秒数的某个全局最大值（以毫秒为单位）。

  注：在 K < future_context 的特殊情况下，假定核太小而无法限制其未来上下文，因此改用对称填充。

  注：只要保持 K > future_context 约束，对使用的未来上下文量就没有明确的限制。这可能会导致 future_context 大于实际核大小 K 的一半的情况！在这种情况下，conv 层在计算输出时使用的未来上下文多于其当前和过去上下文。虽然这样做是可能的，但不建议这样做，并且该层将发出警告以通知用户此类情况。建议在此类情况下仅使用对称填充。

  示例：假设我们有一个执行 8x 步幅的模型，并接收步幅为 0.01 秒的频谱图帧。假设我们希望将未来上下文上限为 80 毫秒。

  层 ID、核大小、步幅、未来上下文、全局上下文 0、K=5、S=1、FC=8、GC= 2 * (2^0) = 2 * 0.01 毫秒（特殊情况，K < FC，因此使用对称填充） 1、K=7、S=1、FC=3、GC= 3 * (2^0) = 3 * 0.01 毫秒（请注意，此处的对称填充使用 3 个 FC 帧！） 2、K=11、S=2、FC=4、GC= 4 * (2^1) = 8 * 0.01 毫秒（请注意，此处的对称填充使用 5 个 FC 帧！） 3、K=15、S=1、FC=4、GC= 4 * (2^1) = 8 * 0.01 毫秒（请注意，此处的对称填充使用 7 个 FC 帧！） 4、K=21、S=2、FC=2、GC= 2 * (2^2) = 8 * 0.01 毫秒（请注意，此处的对称填充使用 10 个 FC 帧！） 5、K=25、S=2、FC=1、GC= 1 * (2^3) = 8 * 0.01 毫秒（请注意，此处的对称填充使用 14 个 FC 帧！） 6、K=29、S=1、FC=1、GC= 1 * (2^3) = 8 * 0.01 毫秒 …

• quantize – 布尔标志，指示是否量化卷积块。

• layer_idx (int, optional) – 可以指定以允许层输出捕获以进行 InterCTC 损失。默认为 -1。

forward(

input_: Tuple[List[torch.Tensor], torch.Tensor | None],

) → Tuple[List[torch.Tensor], torch.Tensor | None]

模块的前向传递。

参数:

input – 输入是两个值的元组 - 预处理的音频信号以及音频信号的长度。音频信号被填充为形状 [B, D, T]，长度是长度为 B 的 torch 向量。

返回:

通过 repeat 次子块处理输入后，块的输出，以及填充/步进后编码音频的长度。

混合类

class nemo.collections.asr.parts.mixins.mixins.ASRBPEMixin

基类：ABC

ASR BPE 混合类，通过配置设置 Tokenizer

此混合类添加了方法 _setup_tokenizer(…)，ASR 模型可以使用该方法，这些模型依赖于子词 tokenization。

setup_tokenizer 方法向类添加以下参数 -

• tokenizer_cfg：提供给 tokenizer 的已解析配置（带有 dir 和 type 参数）。

• tokenizer_dir：tokenizer 词汇表 + 附加元数据的目录路径。

• tokenizer_type：tokenizer 的类型。当前支持 bpe 和 wpe，以及 agg。

• vocab_path：词汇表文本文件的已解析路径。

除了这些变量之外，如果成功，该方法还将实例化并保留 tokenizer（TokenizerSpec 的子类），并将其分配给 self.tokenizer。

mixin 还支持聚合 tokenizer，它由普通的单语 tokenizer 组成。如果检测到单语 tokenizer 和聚合 tokenizer（或反之亦然）之间的转换，则将清理所有注册的工件。

save_tokenizers(directory: str)

将模型 tokenizer 保存到指定目录。

参数:

directory – 要将 tokenizer 保存到的目录。

class nemo.collections.asr.parts.mixins.mixins.ASRModuleMixin

基类：ASRAdapterModelMixin

ASRModuleMixin 是添加到 ASR 模型中的混合类，以便添加特定于 ASRModel 内部模块特定实例化的方法。

每个方法应首先检查模块是否存在于子类中，并在相应的模块存在时支持附加功能。

change_attention_model(

self_attention_model: str | None = None,

att_context_size: List[int] | None = None,

update_config: bool = True,

)

如果 encoder 中提供了函数，则更新 self_attention_model。

参数:

• self_attention_model (str) –

  注意力层和位置编码的类型

  “rel_pos”

  相对位置嵌入和 Transformer-XL

  “rel_pos_local_attn”

  相对位置嵌入和 Transformer-XL，具有使用重叠窗口的局部注意力。 注意力上下文由 att_context_size 参数确定。

  “abs_pos”

  绝对位置嵌入和 Transformer

  如果提供 None，则 self_attention_model 不会更改。默认为 None。

• att_context_size (List[int]) – 2 个整数的列表，对应于左右注意力上下文大小，如果为 None，则保持原样。默认为 None。

• update_config (bool) – 是否使用新的注意力模型更新配置。 默认为 True。

change_conv_asr_se_context_window(

context_window: int,

update_config: bool = True,

)

如果提供的模型包含 encoder 且该 encoder 是 ConvASREncoder 的实例，则更新 SqueezeExcitation 模块的上下文窗口。

参数:

• context_window –

  一个整数，表示用于计算上下文的输入时间帧的数量。每个时间帧对应于 STFT 特征的单个窗口步幅。

  假设 window_stride = 0.01 秒，那么上下文窗口为 128 表示使用 128 * 0.01 秒的上下文来计算 Squeeze 步骤。

• update_config – 是否使用新的上下文窗口更新配置。

change_subsampling_conv_chunking_factor(

subsampling_conv_chunking_factor: int,

update_config: bool = True,

)

如果编码器中存在该函数，则更新 conv_chunking_factor (int)。默认值为 1 (自动)。如果 conv 子采样层中出现 OOM 错误，则将其设置为 -1 (禁用) 或特定值 (2 的幂)

参数:

conv_chunking_factor (int)

conformer_stream_step(

processed_signal: torch.Tensor,

processed_signal_length: torch.Tensor | None = None,

cache_last_channel: torch.Tensor | None = None,

cache_last_time: torch.Tensor | None = None,

cache_last_channel_len: torch.Tensor | None = None,

keep_all_outputs: bool = True,

previous_hypotheses: List[Hypothesis] | None = None,

previous_pred_out: torch.Tensor | None = None,

drop_extra_pre_encoded: int | None = None,

return_transcription: bool = True,

return_log_probs: bool = False,

)

它模拟了用于流式传输的带缓存的前向步骤。它支持编码器支持流式传输的 ASR 模型，例如 Conformer。: param processed_signal: 输入音频信号 : param processed_signal_length: 音频的长度 : param cache_last_channel: 最后一个通道层（如 MHA）的缓存张量 : param cache_last_channel_len: cache_last_channel 的长度 : param cache_last_time: 最后一个时间层（如卷积）的缓存张量 : param keep_all_outputs: 如果设置为 True，则不会删除 encoder.streaming_cfg.valid_out_len 指定的额外输出 : param previous_hypotheses: 来自 RNNT 模型上一步的假设 : param previous_pred_out: 来自 CTC 模型上一步的预测输出 : param drop_extra_pre_encoded: 从下采样模块之后的输出开始删除的步数。如果在输入的左侧添加了额外的填充，则可以使用此参数。 : param return_transcription: 是否解码并返回转录文本。对于 Transducer 模型，无法禁用此选项。 : param return_log_probs: 是否返回对数概率，仅对 ctc 模型有效

返回:

解码器的贪婪预测 all_hyp_or_transcribed_texts: Transducer 模型的解码器假设和 CTC 模型的转录文本 cache_last_channel_next: 更新后的最后一个通道层张量缓存，用于下一个流式传输步骤 cache_last_time_next: 更新后的最后一个时间层张量缓存，用于下一个流式传输步骤 cache_last_channel_next_len: 更新后的 cache_last_channel 长度 best_hyp: Transducer 模型的最佳假设 log_probs: 当前流式传输块的 logits 张量，仅当 return_log_probs=True 时返回 encoded_len: 输出 log_probs + 历史块 log_probs 的长度，仅当 return_log_probs=True 时返回

返回类型:

greedy_predictions

transcribe_simulate_cache_aware_streaming(

paths2audio_files: List[str],

batch_size: int = 4,

logprobs: bool = False,

return_hypotheses: bool = False,

online_normalization: bool = False,

)

参数:

• paths2audio_files – 音频文件路径的（列表）。

• batch_size – (int) 推理期间使用的批处理大小。越大吞吐性能越好，但会使用更多内存。

• logprobs – (bool) 传递 True 以获取对数概率而不是转录文本。

• return_hypotheses – (bool) 返回假设或文本。使用假设可以进行一些后处理，例如获取时间戳或重新评分

• online_normalization – (bool) 对每个块运行规范化。

返回:

与 paths2audio_files 顺序相同的转录文本列表（如果 logprobs 为 True，则为原始对数概率）

class nemo.collections.asr.parts.mixins.transcription.TranscriptionMixin

基类：ABC

用于可转录模型的抽象类。

创建模板函数 transcribe()，该函数提供一个接口来执行音频张量或文件路径的转录。

子类必须实现以下抽象类

• _transcribe_input_manifest_processing():

  处理提供的输入参数（仅限文件路径），并返回数据加载器的配置字典。数据加载器通常应在 NeMo 清单上运行。

• _setup_transcribe_dataloader():

  设置用于转录的数据加载器。接收来自 _transcribe_input_manifest_processing() 的输出。

• _transcribe_forward():

  实现模型的自定义前向传递，以返回由 _transcribe_output_processing() 处理的输出。

• _transcribe_output_processing():

  实现模型输出的后处理，以将结果返回给用户。结果可以是对象列表、对象列表的列表、对象元组、对象列表的元组或对象列表的字典。

transcribe(

audio: str | List[str] | numpy.ndarray | torch.utils.data.DataLoader,

batch_size: int = 4,

return_hypotheses: bool = False,

num_workers: int = 0,

channel_selector: int | Iterable[int] | str | None = None,

augmentor: omegaconf.DictConfig | None = None,

verbose: bool = True,

timestamps: bool | None = None,

override_config: TranscribeConfig | None = None,

**config_kwargs,

) → List[Any] | List[List[Any]] | Tuple[Any] | Tuple[List[Any]] | Dict[str, List[Any]]

定义用于转录音频的执行策略的模板函数。

参数:

• audio – 音频文件路径的（单个或列表）或 np.ndarray 音频数组。也可以是提供可供模型使用的值的数据加载器对象。每个文件的建议长度在 5 到 25 秒之间。但是，如果有足够的 GPU 内存可用，则可以传递几个小时长的文件。

• batch_size – (int) 推理期间使用的批处理大小。越大吞吐性能越好，但会使用更多内存。

• return_hypotheses – (bool) 返回假设或文本。使用假设可以进行一些后处理，例如获取时间戳或重新评分

• num_workers – (int) DataLoader 的工作进程数

• channel_selector (int | Iterable[int] | str) – 从多通道音频中选择单个通道或通道子集。如果设置为 ‘average’，则执行跨通道平均。如果设置为 None，则禁用。默认为 None。使用从零开始的索引。

• augmentor – (DictConfig): 如果应用了 augmentor，则在转录期间增强音频样本。

• verbose – (bool) 是否显示 tqdm 进度条

• timestamps – Optional(Bool): 如果设置为 True，则时间戳将作为假设对象的一部分返回 (output.timestep[‘segment’]/output.timestep[‘word’])。有关更多详细信息，请参阅 Hypothesis 类。默认为 None，并将保留通过使用 self.change_decoding_strategy() 设置的先前状态。

• override_config – (Optional[TranscribeConfig]) 覆盖用户预定义的转录配置。注意：如果传递了 override_config，则函数中的所有其他参数都将被忽略。您应该将此参数称为 model.transcribe(audio, override_config=TranscribeConfig(…))。

• **config_kwargs – (Optional[Dict]) 用于覆盖默认 TranscribeConfig 的其他参数。注意：如果传递了 override_config，则这些参数将被忽略。

返回:

输出由 TranscriptionMixin._transcribe_output_processing() 的子类实现定义。它可以是

• List[str/Hypothesis]

• List[List[str/Hypothesis]]

• Tuple[str/Hypothesis]

• Tuple[List[str/Hypothesis]]

• Dict[str, List[str/Hypothesis]]

transcribe_generator(

audio,

override_config: TranscribeConfig | None,

)

函数 transcribe 的生成器版本。

class nemo.collections.asr.parts.mixins.transcription.TranscribeConfig(

batch_size: int = 4,

return_hypotheses: bool = False,

num_workers: int | None = None,

channel_selector: int | Iterable[int] | str = None,

augmentor: omegaconf.DictConfig | None = None,

timestamps: bool | None = None,

verbose: bool = True,

partial_hypothesis: List[Any] | None = None,

_internal: nemo.collections.asr.parts.mixins.transcription.InternalTranscribeConfig | None = None,

)

基类：object

class nemo.collections.asr.parts.mixins.interctc_mixin.InterCTCMixin

基类：object

添加了用于计算来自 https://arxiv.org/abs/2102.03216 的 interCTC 损失的实用程序。

要使用，请确保编码器访问 AccessMixin 中的 interctc['capture_layers'] 属性，并为我们要从中获取损失的所有层注册 interctc/layer_output_X 和 interctc/layer_length_X。此外，指定以下配置参数以设置损失

interctc:
    # can use different values
    loss_weights: [0.3]
    apply_at_layers: [8]

然后调用

• self.setup_interctc(ctc_decoder_name, ctc_loss_name, ctc_wer_name) 在 init 方法中

• self.add_interctc_losses 在计算常规损失后。

• self.finalize_interctc_metrics(metrics, outputs, prefix="val_") 在 multi_validation_epoch_end 方法中。

• self.finalize_interctc_metrics(metrics, outputs, prefix="test_") 在 multi_test_epoch_end 方法中。

add_interctc_losses(

loss_value: torch.Tensor,

transcript: torch.Tensor,

transcript_len: torch.Tensor,

compute_wer: bool,

compute_loss: bool = True,

log_wer_num_denom: bool = False,

log_prefix: str = '',

) → Tuple[torch.Tensor | None, Dict]

如果需要，则添加 interCTC 损失。

还将在返回的字典中注册 loss/wer 指标。

参数:

• loss_value (torch.Tensor) – 常规损失张量（将 interCTC 损失添加到其中）。

• transcript (torch.Tensor) – 当前话语的转录文本。

• transcript_len (torch.Tensor) – 当前话语的转录文本长度。

• compute_wer (bool) – 是否计算当前话语的 WER。通常对于验证/测试应为 True，仅当应记录当前批次 WER 时，对于训练才应为 True。

• compute_loss (bool) – 是否计算当前话语的损失。在训练中应始终为 True，在验证中几乎始终为 True，除非所有其他损失也被禁用。默认为 True。

• log_wer_num_denom (bool) – 如果为 True，则还将在返回的指标字典中记录 WER num/denom。对于验证/测试，应始终为 True，以允许正确的指标聚合。对于训练，应始终为 False。默认为 False。

• log_prefix (str) – 添加到所有日志值的前缀。对于训练应为 ""，对于验证应为 "val_"。默认为“”。

返回:

新的损失张量和包含记录指标的字典的元组。

返回类型:

tuple[Optional[torch.Tensor], Dict]

finalize_interctc_metrics(

metrics: Dict,

outputs: List[Dict],

prefix: str,

)

最终确定 InterCTC WER 和损失指标以进行日志记录。

应在 multi_validation_epoch_end （使用 prefix="val_"）或 multi_test_epoch_end （使用 prefix="test_"）内部调用。

请注意，metrics 字典将被就地更新。

get_captured_interctc_tensors() → List[Tuple[torch.Tensor, torch.Tensor]]

返回来自编码器的捕获张量列表：(output, length) 元组。

还将把 ctc_decoder 应用于输出。

get_interctc_param(param_name)

直接从 self._interctc_params 获取参数，或使用相应的名称调用 getattr。

is_interctc_enabled() → bool

返回是否启用了 interCTC 损失。

set_interctc_enabled(enabled: bool)

可用于手动启用/禁用 InterCTC。

set_interctc_param(param_name, param_value)

将参数设置为 self._interctc_params 字典。

如果尝试设置解码器、损失或 wer，则会引发错误，因为这些应始终来自主类。

setup_interctc(decoder_name, loss_name, wer_name)

设置所有 interctc 特定的参数并检查配置一致性。

调用者必须指定属性名称以执行 CTC 特定的 WER、解码器和损失计算。将在类状态中使用 getattr 查找它们。

我们获取名称并在稍后查找对象的原因是，这些对象可能会在不重新调用此类设置的情况下发生更改。因此，我们始终希望查找最新的对象，而不是在此处“缓存”它。

数据集

字符编码数据集

class nemo.collections.asr.data.audio_to_text.AudioToCharDataset(*args: Any, **kwargs: Any)

基类：_AudioTextDataset

数据集，通过 JSON 文件加载张量，JSON 文件包含音频文件、转录文本和持续时间（以秒为单位）的路径。每新行是一个不同的样本。以下是示例：{“audio_filepath”: “/path/to/audio.wav”, “text_filepath”: “/path/to/audio.txt”, “duration”: 23.147} … {“audio_filepath”: “/path/to/audio.wav”, “text”: “转录文本”, “offset”: 301.75, “duration”: 0.82, “utt”: “utterance_id”, “ctm_utt”: “en_4156”, “side”: “A”}

参数:

• manifest_filepath – 如上所述的清单 JSON 文件的路径。可以是逗号分隔的路径。

• labels – 包含要映射到的所有可能字符的字符串

• sample_rate (int) – 重新采样加载的音频到的采样率

• int_values (bool) – 如果为 true，则将样本加载为 32 位整数。默认为 False。

• augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor) – 用于增强加载的音频的 AudioAugmentor 对象

• max_duration – 如果音频超过此长度，则不包含在数据集中

• min_duration – 如果音频小于此长度，则不包含在数据集中

• max_utts – 限制话语数量

• blank_index – 空白字符索引，默认值 = -1

• unk_index – 未知字符索引，默认值 = -1

• normalize – 是否规范化转录文本（默认值）：True

• bos_id – 如果不为 None，则附加序列符号开头的 ID

• eos_id – 如果不为 None，则附加序列符号结尾的 ID

• return_sample_id (bool) – 是否将 sample_id 作为每个样本的一部分返回

• channel_selector (int | Iterable[int] | str) – 从多通道音频中选择单个通道或通道子集。如果设置为 ‘average’，则执行跨通道平均。如果设置为 None，则禁用。默认为 None。使用从零开始的索引。

• manifest_parse_func – 用于解析清单条目的可选函数。默认为 None。

property output_types: Dict[str, NeuralType] | None

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

class nemo.collections.asr.data.audio_to_text.TarredAudioToCharDataset(*args: Any, **kwargs: Any)

基类：decorator

与 AudioToCharDataset 类似的数据集，但它加载 tar 格式的音频文件。

接受单个逗号分隔的 JSON 清单文件（样式与 AudioToCharDataset 相同），以及包含 wav 文件的 tarball 的路径。清单的每一行应包含一个音频文件的信息，至少包括 tarball 中音频文件的转录文本和名称。

audio_tar_filepaths 参数的有效格式包括：(1) 可以进行大括号扩展的单个字符串，例如“path/to/audio.tar”或“path/to/audio_{1..100}.tar.gz”，或 (2) 不会进行大括号扩展的文件路径列表，例如 [‘audio_1.tar’, ‘audio_2.tar’, …]。

有关接受的数据和输入格式的更多信息，请参阅 WebDataset 文档。

如果使用多个 worker，shard 的数量应能被 world_size 整除，以确保在 worker 之间均匀分配。如果不能整除，日志将给出警告，但训练将继续进行。此外，如果使用多进程，应用过滤后，每个 shard 必须具有相同数量的条目。我们目前不检查这一点，但如果 shard 不均匀，您的程序可能会挂起！

请注意，一些参数与 AudioToCharDataset 不同；例如，shuffle (bool) 已被 shuffle_n (int) 替换。

此外，请注意，此 DataLayer 的 len() 被假定为过滤后 manifest 的长度。不正确的 manifest 长度可能会导致后续一些 DataLoader 问题。

参数:

• audio_tar_filepaths – 音频 tarball 文件路径列表，或字符串（可以是 brace-expandable）。

• manifest_filepath (str) – manifest 的路径。

• labels (list) – ASR 模型可以输出的字符列表。对于 Jasper，这是 28 个字符的集合 {a-z ‘}。对于使用 ctc 的模型，CTC 空白符号将在稍后自动添加。

• sample_rate (int) – 重新采样加载的音频到的采样率

• int_values (bool) – 如果为 true，则将样本加载为 32 位整数。默认为 False。

• augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor) – 用于增强加载的音频的 AudioAugmentor 对象

• shuffle_n (int) – 预先查看并加载以进行混洗的样本数量。有关更多详细信息，请参阅 WebDataset 文档。默认为 0。

• min_duration (float) – 数据集参数。所有持续时间小于 min_duration 的训练文件都将被删除。注意：持续时间从 manifest JSON 中读取。默认为 0.1。

• max_duration (float) – 数据集参数。所有持续时间超过 max_duration 的训练文件都将被删除。注意：持续时间从 manifest JSON 中读取。默认为 None。

• blank_index (int) – 空白字符索引，默认为 -1。

• unk_index (int) – 未知字符索引，默认为 -1。

• normalize (bool) – 数据集参数。是否使用自动文本清理。强烈建议手动清理文本以获得最佳结果。默认为 True。

• trim (bool) – 是否使用 librosa.effects.trim() 从音频信号的开头和结尾修剪静音。默认为 False。

• bos_id (id) – 数据集参数。用于 seq2seq 模型的字符串开头符号 id。默认为 None。

• eos_id (id) – 数据集参数。用于 seq2seq 模型的字符串结尾符号 id。默认为 None。

• pad_id (id) – 在批处理中整理样本时用于填充的 token。如果为 None，则使用 0 进行填充。默认为 None。

• shard_strategy (str) –

  在 ddp 期间选择的 Tarred 数据集 shard 分布策略，以 str 值表示。

  • scatter: WebDataset 应用的默认 shard 策略，其中每个节点获得一组唯一的 shard，这些 shard 是永久预先分配的，并且在运行时永远不会更改。

  • replicate: 可选的 shard 策略，其中每个节点获得 tarred 数据集中可用的所有 shard 集合，这些 shard 是永久预先分配的，并且在运行时永远不会更改。复制的好处是它允许每个节点独立于其他节点从整个数据集采样数据点，并减少对 shuffle_n 值的依赖。

    警告

    复制策略允许每个节点采样整个可用 tar 文件集，因此多个节点可能采样相同的 tar 文件，甚至采样相同的数据点！因此，不能保证在一个 epoch 期间数据集中的所有样本都至少被采样一次。另一方面，分散策略在特定情况下（当 shard 数量不能被 world_size 整除时），将不会采样整个数据集。由于这些原因，不建议将 tarred 数据集用作验证或测试数据集。

• global_rank (int) – Worker 排名，用于分区 shard。默认为 0。

• world_size (int) – 进程总数，用于分区 shard。默认为 0。

• return_sample_id (bool) – 是否将 sample_id 作为每个样本的一部分返回

• manifest_parse_func – 用于解析清单条目的可选函数。默认为 None。

混合 ASR-TTS 模型的文本到文本数据集

class nemo.collections.asr.data.text_to_text.TextToTextDataset(*args: Any, **kwargs: Any)

基类： TextToTextDatasetBase, Dataset

用于混合 ASR-TTS 模型的文本到文本 Map-style 数据集

collate_fn(

batch: List[TextToTextItem | tuple],

) → TextToTextBatch | TextOrAudioToTextBatch | tuple

用于 dataloader 的整理函数。可以接受文本到文本项和音频到文本项的混合批次（ASR 的典型情况）

class nemo.collections.asr.data.text_to_text.TextToTextIterableDataset(*args: Any, **kwargs: Any)

基类： TextToTextDatasetBase, IterableDataset

用于混合 ASR-TTS 模型的文本到文本 Iterable Dataset。应仅加载和存储当前进程所需的部分

collate_fn(

batch: List[TextToTextItem | tuple],

) → TextToTextBatch | TextOrAudioToTextBatch | tuple

用于 dataloader 的整理函数。可以接受文本到文本项和音频到文本项的混合批次（ASR 的典型情况）

Subword 编码数据集

class nemo.collections.asr.data.audio_to_text.AudioToBPEDataset(*args: Any, **kwargs: Any)

基类：_AudioTextDataset

数据集，通过 JSON 文件加载张量，JSON 文件包含音频文件、转录文本和持续时间（以秒为单位）的路径。每新行是一个不同的样本。以下是示例：{“audio_filepath”: “/path/to/audio.wav”, “text_filepath”: “/path/to/audio.txt”, “duration”: 23.147} … {“audio_filepath”: “/path/to/audio.wav”, “text”: “转录文本”, “offset”: 301.75, “duration”: 0.82, “utt”: “utterance_id”, “ctm_utt”: “en_4156”, “side”: “A”}

实际上，用于字符编码和字节对编码的数据集和 manifest 完全相同。唯一的区别在于数据集如何对 manifest 中的文本进行标记化。

参数:

• manifest_filepath – 如上所述的清单 JSON 文件的路径。可以是逗号分隔的路径。

• tokenizer – Tokenizer 包装器的子类，可在 common 集合 nemo.collections.common.tokenizers.TokenizerSpec 中找到。ASR 模型支持所有可用 tokenizer 的子集。

• sample_rate (int) – 重新采样加载的音频到的采样率

• int_values (bool) – 如果为 true，则将样本加载为 32 位整数。默认为 False。

• augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor) – 用于增强加载的音频的 AudioAugmentor 对象

• max_duration – 如果音频超过此长度，则不包含在数据集中

• min_duration – 如果音频小于此长度，则不包含在数据集中

• max_utts – 限制话语数量

• trim – 是否修剪静音段

• use_start_end_token – 布尔值，指示是否分别在语音的开头和结尾添加 [BOS] 和 [EOS] token。

• return_sample_id (bool) – 是否将 sample_id 作为每个样本的一部分返回

• channel_selector (int | Iterable[int] | str) – 从多通道音频中选择单个通道或通道子集。如果设置为 ‘average’，则执行跨通道平均。如果设置为 None，则禁用。默认为 None。使用从零开始的索引。

• manifest_parse_func – 用于解析清单条目的可选函数。默认为 None。

property output_types: Dict[str, NeuralType] | None

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

class nemo.collections.asr.data.audio_to_text.TarredAudioToBPEDataset(*args: Any, **kwargs: Any)

基类：decorator

与 AudioToBPEDataset 类似的数据集，但加载 tarred 音频文件。

接受单个逗号分隔的 JSON manifest 文件（样式与 AudioToBPEDataset 相同），以及包含 wav 文件的 tarball 的路径。manifest 的每一行应包含一个音频文件的信息，至少包括音频文件在 tarball 中的转录和名称。

audio_tar_filepaths 参数的有效格式包括：(1) 可以进行大括号扩展的单个字符串，例如“path/to/audio.tar”或“path/to/audio_{1..100}.tar.gz”，或 (2) 不会进行大括号扩展的文件路径列表，例如 [‘audio_1.tar’, ‘audio_2.tar’, …]。

有关接受的数据和输入格式的更多信息，请参阅 WebDataset 文档。

如果使用多个 worker，shard 的数量应能被 world_size 整除，以确保在 worker 之间均匀分配。如果不能整除，日志将给出警告，但训练将继续进行。此外，如果使用多进程，应用过滤后，每个 shard 必须具有相同数量的条目。我们目前不检查这一点，但如果 shard 不均匀，您的程序可能会挂起！

请注意，一些参数与 AudioToBPEDataset 不同；例如，shuffle (bool) 已被 shuffle_n (int) 替换。

此外，请注意，此 DataLayer 的 len() 被假定为过滤后 manifest 的长度。不正确的 manifest 长度可能会导致后续一些 DataLoader 问题。

参数:

• audio_tar_filepaths – 音频 tarball 文件路径列表，或字符串（可以是 brace-expandable）。

• manifest_filepath (str) – manifest 的路径。

• tokenizer (TokenizerSpec) – Word Piece Encoding tokenizer (BERT) 或 Sentence Piece Encoding tokenizer (BPE)。对于使用 ctc 的模型，CTC 空白符号将在稍后自动添加。

• sample_rate (int) – 重新采样加载的音频到的采样率

• int_values (bool) – 如果为 true，则将样本加载为 32 位整数。默认为 False。

• augmentor (nemo.collections.asr.parts.perturb.AudioAugmentor) – 用于增强加载的音频的 AudioAugmentor 对象

• shuffle_n (int) – 预先查看并加载以进行混洗的样本数量。有关更多详细信息，请参阅 WebDataset 文档。默认为 0。

• min_duration (float) – 数据集参数。所有持续时间小于 min_duration 的训练文件都将被删除。注意：持续时间从 manifest JSON 中读取。默认为 0.1。

• max_duration (float) – 数据集参数。所有持续时间超过 max_duration 的训练文件都将被删除。注意：持续时间从 manifest JSON 中读取。默认为 None。

• trim (bool) – 是否使用 librosa.effects.trim() 从音频信号的开头和结尾修剪静音。默认为 False。

• use_start_end_token – 布尔值，指示是否分别在语音的开头和结尾添加 [BOS] 和 [EOS] token。

• pad_id (id) – 在批处理中整理样本时用于填充的 token。如果为 None，则使用 0 进行填充。默认为 None。

• shard_strategy (str) –

  在 ddp 期间选择的 Tarred 数据集 shard 分布策略，以 str 值表示。

  • scatter: WebDataset 应用的默认 shard 策略，其中每个节点获得一组唯一的 shard，这些 shard 是永久预先分配的，并且在运行时永远不会更改。

  • replicate: 可选的 shard 策略，其中每个节点获得 tarred 数据集中可用的所有 shard 集合，这些 shard 是永久预先分配的，并且在运行时永远不会更改。复制的好处是它允许每个节点独立于其他节点从整个数据集采样数据点，并减少对 shuffle_n 值的依赖。

    警告

    复制策略允许每个节点采样整个可用 tar 文件集，因此多个节点可能采样相同的 tar 文件，甚至采样相同的数据点！因此，不能保证在一个 epoch 期间数据集中的所有样本都至少被采样一次。另一方面，分散策略在特定情况下（当 shard 数量不能被 world_size 整除时），将不会采样整个数据集。由于这些原因，不建议将 tarred 数据集用作验证或测试数据集。

• global_rank (int) – Worker 排名，用于分区 shard。默认为 0。

• world_size (int) – 进程总数，用于分区 shard。默认为 0。

• return_sample_id (bool) – 是否将 sample_id 作为每个样本的一部分返回

• manifest_parse_func – 用于解析清单条目的可选函数。默认为 None。

音频预处理器

class nemo.collections.asr.modules.AudioToMelSpectrogramPreprocessor(*args: Any, **kwargs: Any)

基类： AudioPreprocessor, Exportable

将 wav 转换为 mel 频谱图的特征提取器模块。

参数:

• sample_rate (int) – 输入音频数据的采样率。默认为 16000

• window_size (float) – FFT 窗口大小，以秒为单位。默认为 0.02

• window_stride (float) – FFT 窗口步长，以秒为单位。默认为 0.01

• n_window_size (int) – FFT 窗口大小，以样本为单位。默认为 None。使用 window_size 或 n_window_size 之一。

• n_window_stride (int) – FFT 窗口步长，以样本为单位。默认为 None。使用 window_stride 或 n_window_stride 之一。

• window (str) – FFT 的窗口函数。可以是 [‘hann’, ‘hamming’, ‘blackman’, ‘bartlett’] 之一。默认为 “hann”

• normalize (str) – 可以是 [‘per_feature’, ‘all_features’] 之一；所有其他选项禁用特征归一化。“all_features” 将整个频谱图归一化为均值为 0，标准差为 1。“pre_features” 而是按通道/频率进行归一化。默认为 “per_feature”

• n_fft (int) – FT 窗口的长度。如果为 None，则使用大于 n_window_size 的最小 2 的幂。默认为 None

• preemph (float) – 要添加到音频的预加重量。可以通过传递 None 来禁用。默认为 0.97

• features (int) – 要输出的 mel 频谱图频率 bin 的数量。默认为 64

• lowfreq (int) – mel 基的下限，单位为 Hz。默认为 0

• highfreq (int) – mel 基的下限，单位为 Hz。默认为 None

• log (bool) – 对数特征。默认为 True

• log_zero_guard_type (str) – 需要避免对零取对数。有两个选项：“add” 或 “clamp”。默认为 “add”。

• log_zero_guard_value (float, or str) – Add 或 clamp 需要添加或 clamp 的数字。log_zero_guard_value 可以是浮点数或 “tiny” 或 “eps”。如果传递 “tiny” 或 “eps”，则使用 torch.finfo。默认为 2**-24。

• dither (float) – 白噪声抖动量。默认为 1e-5

• pad_to (int) – 确保时间维度的输出大小是 pad_to 的倍数。默认为 16

• frame_splicing (int) – 默认为 1

• exact_pad (bool) – 如果为 True，则将 stft center 设置为 False 并添加填充，以便 num_frames = audio_length // hop_length。默认为 False。

• pad_value (float) – 较短的 mel 使用此值进行填充。默认为 0

• mag_power (float) – 线性频谱图在与 mel 基相乘之前所升到的幂。对于功率谱，默认为 2

• rng – 随机数生成器

• nb_augmentation_prob (float) – 窄带增强应用于批次中样本的概率。默认为 0.0

• nb_max_freq (int) – 窄带增强将屏蔽所有频率的频率上限。默认为 4000

• use_torchaudio – 是否使用 torchaudio 实现。

• mel_norm – 用于 mel 滤波器组权重的归一化。默认为 ‘slaney’（面积归一化）

• stft_exact_pad – 已弃用的参数，保留以与旧检查点兼容。

• stft_conv – 已弃用的参数，保留以与旧检查点兼容。

input_example(

max_batch: int = 8,

max_dim: int = 32000,

min_length: int = 200,

)

如果随机输入不起作用，请覆盖此方法 :returns: 有效输入数据的元组样本。

property input_types

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

property output_types

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

processed_signal

0: AxisType(BatchTag) 1: AxisType(MelSpectrogramSignalTag) 2: AxisType(ProcessedTimeTag)

processed_length

0: AxisType(BatchTag)

classmethod restore_from(restore_path: str)

从 .nemo 文件恢复模型实例（权重和配置）

参数:

• restore_path – .nemo 文件的路径，模型应从中实例化

• override_config_path – yaml 配置文件的路径，该文件将覆盖内部配置文件或表示模型配置的 OmegaConf / DictConfig 对象。

• map_location – 可选的 torch.device()，用于将实例化的模型映射到设备。默认情况下 (None)，如果可用，它将选择 GPU，否则回退到 CPU。

• strict – 传递给 load_state_dict。默认为 True

• return_config – 如果设置为 true，将仅返回已恢复模型的底层配置作为 OmegaConf DictConfig 对象，而不实例化模型。

• trainer – 可选的 Trainer 对象，传递给模型构造函数。

• save_restore_connector – 可选的 SaveRestoreConnector 对象，它定义 restore_from() 方法的实现。

save_to(save_path: str)

用于保存包含检查点、配置和任何其他工件的 tar 文件的标准化方法。通过 nemo.core.connectors.save_restore_connector.SaveRestoreConnector.save_to() 实现。

参数:

save_path – str，文件应保存到的路径。

class nemo.collections.asr.modules.AudioToMFCCPreprocessor(*args: Any, **kwargs: Any)

基类： AudioPreprocessor

将 wav 转换为 MFCC 的预处理器。使用 torchaudio.transforms.MFCC。

参数:

• sample_rate – 音频的采样率。默认为 16000。

• window_size – FFT 窗口大小，以秒为单位。用于计算 mel 频谱图的 win_length 参数。默认为 0.02

• window_stride – FFT 窗口步长，以秒为单位。用于计算 mel 频谱图的 hop_length 参数。默认为 0.01

• n_window_size – FFT 窗口大小，以样本为单位。默认为 None。使用 window_size 或 n_window_size 之一。

• n_window_stride – FFT 窗口步长，以样本为单位。默认为 None。使用 window_stride 或 n_window_stride 之一。

• window – FFT 的窗口函数。可以是 [‘hann’, ‘hamming’, ‘blackman’, ‘bartlett’, ‘none’, ‘null’] 之一。默认为 ‘hann’

• n_fft – FT 窗口的长度。如果为 None，则使用大于 n_window_size 的最小 2 的幂。默认为 None

• lowfreq (int) – mel 基的下限，单位为 Hz。默认为 0

• highfreq (int) – mel 基的下限，单位为 Hz。默认为 None

• n_mels – mel 滤波器组的数量。默认为 64

• n_mfcc – 要保留的系数数量。默认为 64

• dct_type – 要使用的离散余弦变换的类型

• norm – 要使用的 norm 类型

• log – 是否使用对数 mel 频谱图而不是 db 标度。默认为 True。

property input_types

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

property output_types

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

classmethod restore_from(restore_path: str)

从 .nemo 文件恢复模型实例（权重和配置）

参数:

• restore_path – .nemo 文件的路径，模型应从中实例化

• override_config_path – yaml 配置文件的路径，该文件将覆盖内部配置文件或表示模型配置的 OmegaConf / DictConfig 对象。

• map_location – 可选的 torch.device()，用于将实例化的模型映射到设备。默认情况下 (None)，如果可用，它将选择 GPU，否则回退到 CPU。

• strict – 传递给 load_state_dict。默认为 True

• return_config – 如果设置为 true，将仅返回已恢复模型的底层配置作为 OmegaConf DictConfig 对象，而不实例化模型。

• trainer – 可选的 Trainer 对象，传递给模型构造函数。

• save_restore_connector – 可选的 SaveRestoreConnector 对象，它定义 restore_from() 方法的实现。

save_to(save_path: str)

用于保存包含检查点、配置和任何其他工件的 tar 文件的标准化方法。通过 nemo.core.connectors.save_restore_connector.SaveRestoreConnector.save_to() 实现。

参数:

save_path – str，文件应保存到的路径。

音频增强器

class nemo.collections.asr.modules.SpectrogramAugmentation(*args: Any, **kwargs: Any)

基类： NeuralModule

以两种方式之一执行时间和频率 cuts。SpecAugment 将垂直和水平部分归零，如 SpecAugment (https://arxiv.org/abs/1904.08779) 中所述。与 SpecAugment 一起使用的参数是 freq_masks、time_masks、freq_width 和 time_width。SpecCutout 将矩形归零，如 Cutout (https://arxiv.org/abs/1708.04552) 中所述。与 Cutout 一起使用的参数是 rect_masks、rect_freq 和 rect_time。

参数:

• freq_masks (int) – 应剪切多少个频率段。默认为 0。

• time_masks (int) – 应剪切多少个时间段。默认为 0。

• freq_width (int) – 一个段中要剪切的最大频率数。默认为 10。

• time_width (int) – 一个段中要剪切的最大时间步数。默认为 10。

• rect_masks (int) – 应剪切多少个矩形掩码。默认为 0。

• rect_freq (int) – 沿频率维度剪切矩形的最大尺寸。默认为 5。

• rect_time (int) – 沿时间维度剪切矩形的最大尺寸。默认为 25。

• use_numba_spec_augment – 使用 numba 代码进行 Spectrogram 增强

• use_vectorized_spec_augment – 使用向量化代码进行 Spectrogram 增强

property input_types

返回模块输入类型的定义

property output_types

返回模块输出类型的定义

class nemo.collections.asr.modules.CropOrPadSpectrogramAugmentation(*args: Any, **kwargs: Any)

基类： NeuralModule

将传入的频谱图填充或裁剪为特定形状。

参数:

audio_length (int) – 所需的最终时间步数。信号将在时间上填充或裁剪到此大小。

property input_types

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

property output_types

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

classmethod restore_from(restore_path: str)

从 .nemo 文件恢复模型实例（权重和配置）

参数:

• restore_path – .nemo 文件的路径，模型应从中实例化

• override_config_path – yaml 配置文件的路径，该文件将覆盖内部配置文件或表示模型配置的 OmegaConf / DictConfig 对象。

• map_location – 可选的 torch.device()，用于将实例化的模型映射到设备。默认情况下 (None)，如果可用，它将选择 GPU，否则回退到 CPU。

• strict – 传递给 load_state_dict。默认为 True

• return_config – 如果设置为 true，将仅返回已恢复模型的底层配置作为 OmegaConf DictConfig 对象，而不实例化模型。

• trainer – 可选的 Trainer 对象，传递给模型构造函数。

• save_restore_connector – 可选的 SaveRestoreConnector 对象，它定义 restore_from() 方法的实现。

save_to(save_path: str)

用于保存包含检查点、配置和任何其他工件的 tar 文件的标准化方法。通过 nemo.core.connectors.save_restore_connector.SaveRestoreConnector.save_to() 实现。

参数:

save_path – str，文件应保存到的路径。

class nemo.collections.asr.parts.preprocessing.perturb.SpeedPerturbation(

sr,

resample_type,

min_speed_rate=0.9,

max_speed_rate=1.1,

num_rates=5,

rng=None,

)

基类： Perturbation

通过将数据重采样到不同的采样率来执行速度增强，这不会保留音调。

注意：对于在线增强，这是一个非常缓慢的操作。如果空间允许，最好预先计算并保存文件以增强数据集。

参数:

• sr – 原始采样率。

• resample_type – 将执行的重采样操作的类型。为了获得更好的速度，请使用 resampy 的快速重采样方法，使用 resample_type='kaiser_fast'。为了获得高质量的重采样，请设置 resample_type='kaiser_best'。要使用 scipy.signal.resample，请设置 resample_type='fft' 或 resample_type='scipy'

• min_speed_rate – 最小采样率修改器。

• max_speed_rate – 最大采样率修改器。

• num_rates – 允许的离散速率数。可以是正整数或负整数。如果提供大于 0 的正整数，则速度范围将离散为 num_rates 个值。如果提供负整数或 0，则将在速度的整个范围内均匀采样。注意：如果提供了正整数，并且结果离散的速率范围包含值 ‘1.0’，则速率为 1.0 的那些样本将根本不会增强，而只是跳过。这是为了避免不必要的增强并增加计算时间。在这种情况下，有效增强机会 = prob * (num_rates - 1 / num_rates) * 100`% chance，其中 `prob 是样本被增强的全局概率。

• rng – 随机种子。默认为 None

class nemo.collections.asr.parts.preprocessing.perturb.TimeStretchPerturbation(

min_speed_rate=0.9,

max_speed_rate=1.1,

num_rates=5,

n_fft=512,

rng=None,

)

基类： Perturbation

通过固定速率拉伸音频序列的时间，同时保留音调，基于 [1, 2]。

注意：这是一个简化的实现，主要用于参考和教学目的。它没有尝试处理瞬态，并且很可能产生可听见的 artifacts。

参考 [1] [Ellis, D. P. W. “A phase vocoder in Matlab.” Columbia University, 2002.] (http://www.ee.columbia.edu/~dpwe/resources/matlab/pvoc/) [2] [librosa.effects.time_stretch] (https://librosa.github.io/librosa/generated/librosa.effects.time_stretch.html)

参数:

• min_speed_rate – 最小采样率修改器。

• max_speed_rate – 最大采样率修改器。

• num_rates – 允许的离散速率数。可以是正整数或负整数。如果提供大于 0 的正整数，则速度范围将离散为 num_rates 个值。如果提供负整数或 0，则将在速度的整个范围内均匀采样。注意：如果提供了正整数，并且结果离散的速率范围包含值 ‘1.0’，则速率为 1.0 的那些样本将根本不会增强，而只是跳过。这是为了避免不必要的增强并增加计算时间。在这种情况下，有效增强机会 = prob * (num_rates - 1 / num_rates) * 100`% chance，其中 `prob 是样本被增强的全局概率。

• n_fft – 要计算的 fft 滤波器数量。

• rng – 随机种子。默认为 None

class nemo.collections.asr.parts.preprocessing.perturb.GainPerturbation(min_gain_dbfs=-10, max_gain_dbfs=10, rng=None)

基类： Perturbation

对音频应用随机增益。

参数:

• min_gain_dbfs (float) – 最小增益水平，单位为 dB

• max_gain_dbfs (float) – 最大增益水平，单位为 dB

• rng (int) – 随机种子。默认为 None

class nemo.collections.asr.parts.preprocessing.perturb.ImpulsePerturbation(

manifest_path=None,

audio_tar_filepaths=None,

shuffle_n=128,

normalize_impulse=False,

shift_impulse=False,

rng=None,

)

基类： Perturbation

使用房间脉冲响应对音频进行卷积。

参数:

• manifest_path (list) – RIR 的清单文件

• audio_tar_filepaths (list) – Tar 文件，如果 RIR 音频文件被打包成 tar 文件

• shuffle_n (int) – 用于打乱来自 tar 文件的缓冲文件的 Shuffle 参数

• normalize_impulse (bool) – 将脉冲响应归一化为零均值和幅度 1

• shift_impulse (bool) – 偏移脉冲响应以调整开始时的延迟

• rng (int) – 随机种子。默认为 None

class nemo.collections.asr.parts.preprocessing.perturb.ShiftPerturbation(min_shift_ms=-5.0, max_shift_ms=5.0, rng=None)

基类： Perturbation

通过在 min_shift_ms 和 max_shift_ms 之间随机偏移音频的时间来扰动音频。音频的最终长度保持不变，通过用零填充音频。

参数:

• min_shift_ms (float) – 音频将被偏移的最小时间，单位为毫秒

• max_shift_ms (float) – 音频将被偏移的最大时间，单位为毫秒

• rng (int) – 随机种子。默认为 None

class nemo.collections.asr.parts.preprocessing.perturb.NoisePerturbation(

manifest_path=None,

min_snr_db=10,

max_snr_db=50,

max_gain_db=300.0,

rng=None,

audio_tar_filepaths=None,

shuffle_n=100,

orig_sr=16000,

)

基类： Perturbation

向输入音频添加噪声的扰动。

参数:

• manifest_path (str) – 包含噪声文件路径的清单文件

• min_snr_db (float) – 添加噪声后音频的最小 SNR

• max_snr_db (float) – 添加噪声后音频的最大 SNR

• max_gain_db (float) – 可以应用于噪声样本的最大增益

• audio_tar_filepaths (list) – Tar 文件，如果噪声音频文件被打包成 tar 文件

• shuffle_n (int) – 用于打乱来自 tar 文件的缓冲文件的 Shuffle 参数

• orig_sr (int) – 噪声文件的原始采样率

• rng (int) – 随机种子。默认为 None

perturb(data, ref_mic=0)

参数:

• data (AudioSegment) – 音频数据

• ref_mic (int) – 用于缩放多通道音频的参考麦克风索引

perturb_with_foreground_noise(

data,

noise,

data_rms=None,

max_noise_dur=2,

max_additions=1,

ref_mic=0,

)

参数:

• data (AudioSegment) – 音频数据

• noise (AudioSegment) – 噪声数据

• data_rms (Union[float, List[float]) – 数据输入的 rms_db

• max_noise_dur – (float): 最大噪声持续时间

• max_additions (int) – 添加噪声的次数

• ref_mic (int) – 用于缩放多通道音频的参考麦克风索引

perturb_with_input_noise(

data,

noise,

data_rms=None,

ref_mic=0,

)

参数:

• data (AudioSegment) – 音频数据

• noise (AudioSegment) – 噪声数据

• data_rms (Union[float, List[float]) – 数据输入的 rms_db

• ref_mic (int) – 用于缩放多通道音频的参考麦克风索引

class nemo.collections.asr.parts.preprocessing.perturb.WhiteNoisePerturbation(min_level=-90, max_level=-46, rng=None)

基类： Perturbation

向训练数据集中的音频文件添加白噪声的扰动。

参数:

• min_level (int) – 添加白噪声的最小级别，单位为 dB

• max_level (int) – 添加白噪声的最大级别，单位为 dB

• rng (int) – 随机种子。默认为 None

class nemo.collections.asr.parts.preprocessing.perturb.RirAndNoisePerturbation(

rir_manifest_path=None,

rir_prob=0.5,

noise_manifest_paths=None,

noise_prob=1.0,

min_snr_db=0,

max_snr_db=50,

rir_tar_filepaths=None,

rir_shuffle_n=100,

noise_tar_filepaths=None,

apply_noise_rir=False,

orig_sample_rate=None,

max_additions=5,

max_duration=2.0,

bg_noise_manifest_paths=None,

bg_noise_prob=1.0,

bg_min_snr_db=10,

bg_max_snr_db=50,

bg_noise_tar_filepaths=None,

bg_orig_sample_rate=None,

rng=None,

)

基类： Perturbation

RIR 增强与附加的前景和背景噪声。在此实现中，音频数据首先通过与房间脉冲响应进行卷积来增强，然后以不同的 SNR 添加前景噪声和背景噪声。RIR、前景和背景噪声应通过清单文件或作为打包的音频文件（更快）提供。

基于噪声的原始采样率的不同噪声音频文件集。这在训练混合采样率模型时很有用。例如，当以 16 kHz 的目标采样率训练具有 8 kHz 和 16 kHz 音频的混合模型时，人们希望使用 8 kHz 噪声而不是 16 kHz 噪声来增强 8 kHz 数据。

参数:

• rir_manifest_path – RIR 的清单文件

• rir_tar_filepaths – Tar 文件，如果 RIR 音频文件被打包成 tar 文件

• rir_prob – 应用 RIR 的概率

• noise_manifest_paths – 前景噪声清单文件路径

• min_snr_db – 前景噪声的最小 SNR

• max_snr_db – 背景噪声的最大 SNR

• noise_tar_filepaths – Tar 文件，如果噪声文件被打包成 tar 文件

• apply_noise_rir – 是否将前景噪声与随机 RIR 进行卷积

• orig_sample_rate – 前景噪声音频的原始采样率

• max_additions – 前景噪声添加到话语中的最大次数

• max_duration – 前景噪声的最大持续时间

• bg_noise_manifest_paths – 背景噪声清单文件路径

• bg_min_snr_db – 背景噪声的最小 SNR

• bg_max_snr_db – 背景噪声的最大 SNR

• bg_noise_tar_filepaths – Tar 文件，如果噪声文件被打包成 tar 文件

• bg_orig_sample_rate – 背景噪声音频的原始采样率

• rng – 随机种子。默认为 None

class nemo.collections.asr.parts.preprocessing.perturb.TranscodePerturbation(codecs=None, rng=None)

基类： Perturbation

音频编解码器增强。此实现使用 sox 对音频进行低速率音频编解码器转码，因此用户需要确保安装的 sox 版本支持此处使用的编解码器（G711 和 amr-nb）。

参数:

• codecs (List[str]) – 要转码到的编解码器列表。默认为 None。

• rng (int) – 随机种子。默认为 None。

杂项类

CTC 解码

class nemo.collections.asr.parts.submodules.ctc_decoding.CTCDecoding(decoding_cfg, vocabulary)

基类：AbstractCTCDecoding

用于对基于字符的模型的 logprobs 执行 CTC 自回归/非自回归解码。

参数:

• decoding_cfg –

  一个类似字典的对象，包含以下键值对。

  strategy

  str 值，表示可能发生的解码类型。可能的值为

  • greedy（用于贪婪解码）。

  • beam（用于基于 DeepSpeed KenLM 的解码）。

  compute_timestamps

  一个布尔标志，用于确定是否计算字符/子词或基于单词的时间戳，将输出 log-probabilities 映射到离散的时间戳间隔。时间戳将在返回的 Hypothesis.timestep 中以字典形式提供。

  ctc_timestamp_type

  一个 str 值，表示应计算的时间戳类型。可以采用以下值 - “char” 表示字符/子词时间戳，“word” 表示单词级别时间戳，“all”（默认）表示字符级别和单词级别时间戳。

  word_seperator

  表示单词之间分隔符的 Str token。

  segment_seperators

  包含表示段之间分隔符的 token 的列表。

  segment_gap_threshold

  形成段所需的两个单词之间间隙的阈值（以帧为单位）。

  preserve_alignments

  布尔标志，用于保留解码期间生成的 logprobs 的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 logprobs 中包含非空值。在此，logprobs 是 torch.Tensors。

  confidence_cfg

  一个类似字典的对象，其中包含与置信度分数相关的以下键值对。为了获得具有置信度分数的假设，请使用 ctc_decoder_predictions_tensor 函数，并将 preserve_frame_confidence 标志设置为 True。

  preserve_frame_confidence

  布尔标志，用于保留解码期间生成的每帧置信度分数的历史记录。当设置为 true 时，Hypothesis 将在其 frame_confidence 中包含非空值。在此，frame_confidence 是浮点数列表。

  preserve_token_confidence

  布尔标志，用于保留贪婪解码期间生成的每 token 置信度分数的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 token_confidence 中包含非空值。在此，token_confidence 是浮点数列表。

  列表的长度对应于识别的 token 的数量。

  preserve_word_confidence

  布尔标志，用于保留贪婪解码期间生成的每单词置信度分数的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 word_confidence 中包含非空值。在此，word_confidence 是浮点数列表。

  列表的长度对应于识别的单词的数量。

  exclude_blank

  布尔标志，指示空白 token 置信度分数将从 token_confidence 中排除。

  aggregation

  用于将每 token 置信度折叠为每单词置信度的聚合类型。有效选项为 mean、min、max、prod。

  tdt_include_duration: 布尔标志，指示将计算持续时间置信度分数，并且

  附加到常规帧置信度，使 TDT 帧置信度元素成为一对：（prediction_confidence，duration_confidence）。

  method_cfg

  一个类似字典的对象，其中包含方法名称和用于计算每帧置信度分数的设置。

  name

  方法名称 (str)。支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type

  要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha

  logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm

  熵值到区间 [0,1] 的映射。支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

  batch_dim_index

  ctc_decoder_predictions_tensor 方法的 targets 和 predictions 参数的批次维度索引。可以是 0 或 1。

  配置可能还包含以下子字典

  “greedy”

  preserve_alignments：与上面相同，覆盖上面的值。compute_timestamps：与上面相同，覆盖上面的值。preserve_frame_confidence：与上面相同，覆盖上面的值。confidence_method_cfg：与上面相同，覆盖 confidence_cfg.method_cfg。

  “beam”

  beam_size

  int，定义束搜索的束大小。必须 >= 1。如果 beam_size == 1，将执行缓存的贪婪搜索。与上面的贪婪搜索相比，这可能会有稍微不同的结果。

  return_best_hypothesis

  可选布尔值，指示在束搜索结束后是仅返回最佳假设还是返回所有假设。默认情况下设置此标志。

  beam_alpha

  float，语言模型对 token 最终分数的强度。final_score = acoustic_score + beam_alpha * lm_score + beam_beta * seq_length。

  beam_beta

  float，序列长度惩罚对 token 最终分数的强度。final_score = acoustic_score + beam_alpha * lm_score + beam_beta * seq_length。

  kenlm_path

  str，KenLM ARPA 或 .binary 文件的路径（取决于选择的策略）。如果路径无效（在路径中找不到文件），将在计算束搜索时引发延迟错误，以便用户可以更新/更改解码策略以指向正确的文件。

• blank_id – RNNT 空白 token 的 ID。

decode_ids_to_tokens(

tokens: List[int],

) → List[str]

由子类实现，以便将 token ID 列表解码为 token 列表。token 列表是每个 token ID 的字符串表示形式。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 token 列表。

decode_tokens_to_str(tokens: List[int]) → str

由子类实现，以便将 token 列表解码为字符串。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的字符串。

class nemo.collections.asr.parts.submodules.ctc_decoding.CTCBPEDecoding(

decoding_cfg,

tokenizer: TokenizerSpec,

)

基类：AbstractCTCDecoding

用于对基于子词的模型的 logprobs 执行 CTC 自回归/非自回归解码。

参数:

• decoding_cfg –

  一个类似字典的对象，包含以下键值对。

  strategy

  str 值，表示可能发生的解码类型。可能的值为

  • greedy（用于贪婪解码）。

  • beam（用于基于 DeepSpeed KenLM 的解码）。

  compute_timestamps

  一个布尔标志，用于确定是否计算字符/子词或基于单词的时间戳，将输出 log-probabilities 映射到离散的时间戳间隔。时间戳将在返回的 Hypothesis.timestep 中以字典形式提供。

  ctc_timestamp_type

  一个 str 值，表示应计算的时间戳类型。可以采用以下值 - “char” 表示字符/子词时间戳，“word” 表示单词级别时间戳，“all”（默认）表示字符级别和单词级别时间戳。

  word_seperator

  表示单词之间分隔符的 Str token。

  preserve_alignments

  布尔标志，用于保留解码期间生成的 logprobs 的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 logprobs 中包含非空值。在此，logprobs 是 torch.Tensors。

  confidence_cfg

  一个类似字典的对象，其中包含与置信度分数相关的以下键值对。为了获得具有置信度分数的假设，请使用 ctc_decoder_predictions_tensor 函数，并将 preserve_frame_confidence 标志设置为 True。

  preserve_frame_confidence

  布尔标志，用于保留解码期间生成的每帧置信度分数的历史记录。当设置为 true 时，Hypothesis 将在其 frame_confidence 中包含非空值。在此，frame_confidence 是浮点数列表。

  preserve_token_confidence

  布尔标志，用于保留贪婪解码期间生成的每 token 置信度分数的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 token_confidence 中包含非空值。在此，token_confidence 是浮点数列表。

  列表的长度对应于识别的 token 的数量。

  preserve_word_confidence

  布尔标志，用于保留贪婪解码期间生成的每单词置信度分数的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 word_confidence 中包含非空值。在此，word_confidence 是浮点数列表。

  列表的长度对应于识别的单词的数量。

  exclude_blank

  布尔标志，指示空白 token 置信度分数将从 token_confidence 中排除。

  aggregation

  用于将每 token 置信度折叠为每单词置信度的聚合类型。有效选项为 mean、min、max、prod。

  tdt_include_duration: 布尔标志，指示将计算持续时间置信度分数，并且

  附加到常规帧置信度，使 TDT 帧置信度元素成为一对：（prediction_confidence，duration_confidence）。

  method_cfg

  一个类似字典的对象，其中包含方法名称和用于计算每帧置信度分数的设置。

  name

  方法名称 (str)。支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type

  要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha

  logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm

  熵值到区间 [0,1] 的映射。支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

  batch_dim_index

  ctc_decoder_predictions_tensor 方法的 targets 和 predictions 参数的批次维度索引。可以是 0 或 1。

  配置可能还包含以下子字典

  “greedy”

  preserve_alignments：与上面相同，覆盖上面的值。compute_timestamps：与上面相同，覆盖上面的值。preserve_frame_confidence：与上面相同，覆盖上面的值。confidence_method_cfg：与上面相同，覆盖 confidence_cfg.method_cfg。

  “beam”

  beam_size

  int，定义束搜索的束大小。必须 >= 1。如果 beam_size == 1，将执行缓存的贪婪搜索。与上面的贪婪搜索相比，这可能会有稍微不同的结果。

  return_best_hypothesis

  可选布尔值，指示在束搜索结束后是仅返回最佳假设还是返回所有假设。默认情况下设置此标志。

  beam_alpha

  float，语言模型对 token 最终分数的强度。final_score = acoustic_score + beam_alpha * lm_score + beam_beta * seq_length。

  beam_beta

  float，序列长度惩罚对 token 最终分数的强度。final_score = acoustic_score + beam_alpha * lm_score + beam_beta * seq_length。

  kenlm_path

  str，KenLM ARPA 或 .binary 文件的路径（取决于选择的策略）。如果路径无效（在路径中找不到文件），将在计算束搜索时引发延迟错误，以便用户可以更新/更改解码策略以指向正确的文件。

• tokenizer – NeMo tokenizer 对象，它继承自 TokenizerSpec。

decode_ids_to_tokens(

tokens: List[int],

) → List[str]

由子类实现，以便将 token ID 列表解码为 token 列表。token 列表是每个 token ID 的字符串表示形式。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 token 列表。

decode_tokens_to_str(tokens: List[int]) → str

由子类实现，以便将 token 列表解码为字符串。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的字符串。

class nemo.collections.asr.parts.submodules.ctc_greedy_decoding.GreedyCTCInfer(

blank_id: int,

preserve_alignments: bool = False,

compute_timestamps: bool = False,

preserve_frame_confidence: bool = False,

confidence_method_cfg: omegaconf.DictConfig | None = None,

)

基类：Typing, ConfidenceMethodMixin

一个贪婪 CTC 解码器。

为样本级别和批次级别贪婪解码提供通用抽象。

参数:

• blank_index – 空白 token 的整数索引。可以是 0 或 len(vocabulary)。

• preserve_alignments – 布尔标志，用于保留解码期间生成的 logprobs 的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 logprobs 中包含非空值。在此，logprobs 是 torch.Tensors。

• compute_timestamps – 一个布尔标志，用于确定是否计算字符/子词或基于单词的时间戳，将输出 log-probabilities 映射到离散的时间戳间隔。时间戳将在返回的 Hypothesis.timestep 中以字典形式提供。

• preserve_frame_confidence – 布尔标志，用于保留解码期间生成的每帧置信度分数的历史记录。当设置为 true 时，Hypothesis 将在其 frame_confidence 中包含非空值。在此，frame_confidence 是浮点数列表。

• confidence_method_cfg –

  一个类似字典的对象，其中包含方法名称和用于计算每帧置信度分数的设置。

  name: 方法名称 (str)。

  支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type: 要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。

  支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha: logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。

  当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm: 熵值到区间 [0,1] 的映射。

  支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

forward(

decoder_output: torch.Tensor,

decoder_lengths: torch.Tensor | None,

)

返回给定编码器隐藏嵌入输入批次的假设列表。输出 token 是自回归生成的。

参数:

• decoder_output – 大小为 (batch, timesteps, features) 或 (batch, timesteps) 的张量（每个 timestep 都是一个标签）。

• decoder_lengths – 表示每个序列输出序列长度的整数列表。

返回:

包含批次句子数（Hypotheses）的打包列表。

property input_types

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

property output_types

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

class nemo.collections.asr.parts.submodules.ctc_beam_decoding.BeamCTCInfer(

blank_id: int,

beam_size: int,

search_type: str = 'default',

return_best_hypothesis: bool = True,

preserve_alignments: bool = False,

compute_timestamps: bool = False,

beam_alpha: float = 1.0,

beam_beta: float = 0.0,

kenlm_path: str | None = None,

flashlight_cfg: FlashlightConfig | None = None,

pyctcdecode_cfg: PyCTCDecodeConfig | None = None,

)

基类：AbstractBeamCTCInfer

一个贪婪 CTC 解码器。

为样本级别和批次级别贪婪解码提供通用抽象。

参数:

• blank_index – 空白 token 的整数索引。可以是 0 或 len(vocabulary)。

• preserve_alignments – 布尔标志，用于保留解码期间生成的 logprobs 的历史记录（样本/批次）。当设置为 true 时，Hypothesis 将在其 logprobs 中包含非空值。在此，logprobs 是 torch.Tensors。

• compute_timestamps – 一个布尔标志，用于确定是否计算字符/子词或基于单词的时间戳，将输出 log-probabilities 映射到离散的时间戳间隔。时间戳将在返回的 Hypothesis.timestep 中以字典形式提供。

default_beam_search(

x: torch.Tensor,

out_len: torch.Tensor,

) → List[Hypothesis | NBestHypotheses]

开放 Seq2Seq 束搜索算法 (DeepSpeed)

参数:

• x – 形状为 [B, T, V+1] 的张量，其中 B 是批次大小，T 是最大序列长度，V 是词汇表大小。该张量包含对数概率。

• out_len – 形状为 [B] 的张量，包含批次中每个序列的长度。

返回:

NBestHypotheses 对象列表，批次中的每个序列对应一个对象。

flashlight_beam_search(

x: torch.Tensor,

out_len: torch.Tensor,

) → List[Hypothesis | NBestHypotheses]

Flashlight 束搜索算法。应支持字符和子词模型。

参数:

• x – 形状为 [B, T, V+1] 的张量，其中 B 是批次大小，T 是最大序列长度，V 是词汇表大小。该张量包含对数概率。

• out_len – 形状为 [B] 的张量，包含批次中每个序列的长度。

返回:

NBestHypotheses 对象列表，批次中的每个序列对应一个对象。

forward(

decoder_output: torch.Tensor,

decoder_lengths: torch.Tensor,

) → Tuple[List[Hypothesis | NBestHypotheses]]

返回给定编码器隐藏嵌入输入批次的假设列表。输出 token 是自回归生成的。

参数:

• decoder_output – 大小为 (batch, timesteps, features) 的张量。

• decoder_lengths – 表示每个序列输出序列长度的整数列表。

返回:

包含批次句子数（Hypotheses）的打包列表。

set_decoding_type(decoding_type: str)

设置框架的解码类型。可以支持字符或子词模型。

参数:

decoding_type – 与解码类型对应的 Str。仅支持“char”和“subword”。

RNNT 解码

class nemo.collections.asr.parts.submodules.rnnt_decoding.RNNTDecoding(decoding_cfg, decoder, joint, vocabulary)

基类：AbstractRNNTDecoding

用于给定编码器状态，对 Decoder+Joint 网络执行 RNN-T 自回归解码。

参数:

• decoding_cfg –

  一个类似字典的对象，包含以下键值对。

  strategy

  str 值，表示可能发生的解码类型。可能的值为

  • greedy, greedy_batch (用于贪心解码)。

  • beam, tsd, alsd (用于集束搜索解码)。

  compute_hypothesis_token_set: 一个布尔标志，用于确定是否计算解码后的

  tokens 列表以及解码后的字符串。 默认值为 False，以避免在不需要时进行双重解码。

  preserve_alignments: 布尔标志，用于保留在

  解码（sample / batched）期间生成的 logprobs 历史记录。 如果设置为 true，则 Hypothesis 将包含 logprobs 的非空值。 在这里，alignments 是 List of List of Tuple(Tensor (长度为 V + 1), Tensor(标量，argmax 后的标签))。

  为了获得此假设，请使用 rnnt_decoder_predictions_tensor 函数，并将 return_hypotheses 标志设置为 True。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示来自词汇表的一个或多个目标。 U 是当前时间步 Ti 的目标 tokens 数量。

  confidence_cfg：一个类似字典的对象，其中包含与置信度相关的以下键值对

  分数。 为了获得具有置信度分数的假设，请使用 rnnt_decoder_predictions_tensor 函数，并将 preserve_frame_confidence 标志设置为 True。

  preserve_frame_confidence: 布尔标志，用于保留在

  解码（sample / batched）期间生成的每帧置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 frame_confidence 的非空值。 在这里，alignments 是 List of List of floats。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示一个或多个置信度分数。 U 是当前时间步 Ti 的目标 tokens 数量。

  preserve_token_confidence: 布尔标志，用于保留在贪心解码（sample / batched）期间生成的每 token 置信度分数的历史记录。

  解码（sample / batched）期间生成的每 token 置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 token_confidence 的非空值。 在这里，token_confidence 是 List of floats。

  列表的长度对应于识别的 token 的数量。

  preserve_word_confidence: 布尔标志，用于保留在

  贪心解码（sample / batched）期间生成的每词置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 word_confidence 的非空值。 在这里，word_confidence 是 List of floats。

  列表的长度对应于识别的单词的数量。

  exclude_blank: 布尔标志，指示要排除 blank token 置信度分数

  从 token_confidence 中排除。

  aggregation: 用于将每 token 置信度折叠为每词置信度的聚合类型。

  有效选项为 mean、min、max、prod。

  tdt_include_duration: 布尔标志，指示将计算持续时间置信度分数，并且

  附加到常规帧置信度，使 TDT 帧置信度元素成为一对：（prediction_confidence，duration_confidence）。

  method_cfg: 一个类似字典的对象，其中包含用于计算每帧

  置信度分数的方法名称和设置。

  name

  方法名称 (str)。支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type

  要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha

  logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm

  熵值到区间 [0,1] 的映射。支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

  配置可能还包含以下子字典

  “greedy”

  max_symbols: int，描述在贪心解码期间每个

  时间步要解码的最大目标 tokens 数量。 设置为较大的值可以解码更长的句子，但会增加执行时间。

  preserve_frame_confidence: 与上述相同，覆盖上述值。

  confidence_method_cfg: 与上述相同，覆盖 confidence_cfg.method_cfg。

  “beam”

  beam_size: int，定义集束搜索的集束大小。 必须 >= 1。

  如果 beam_size == 1，将执行缓存的贪心搜索。 与上面的贪心搜索相比，这可能会产生略有不同的结果。

  score_norm: 可选的布尔值，指示是否标准化假设中返回的集束分数。

  默认设置为 True。

  return_best_hypothesis: 可选的布尔值，指示是仅返回最佳假设还是返回所有

  集束搜索结束后得到的假设。 默认情况下，此标志已设置。

  tsd_max_sym_exp: 可选的 int，确定声学模型每个时间步的目标 tokens 的对称扩展数量

  。 较大的值将允许解码更长的句子，但会增加执行时间成本。

  alsd_max_target_len: 可选的 int 或 float，确定潜在的最大目标序列

  长度。 如果提供整数，则可以解码该特定最大长度的序列。 如果提供浮点数，则可以解码长度为 int(alsd_max_target_len * seq_len) 的序列，其中 seq_len 是声学模型输出的长度 (T)。

  注意

  如果提供浮点数，则可以大于 1！ 默认情况下，使用 2.0 的浮点数，以便目标序列最多可以是声学模型输出长度 T 的两倍。

  maes_num_steps: 要采取的自适应步骤数。 根据论文，通常 2 步就足够了，

  并且可以减少到 1 以提高解码速度，但会牺牲一些准确性。 int > 0。

  maes_prefix_alpha: 前缀搜索中的最大前缀长度。 必须是整数，建议保持为 1，以减少后续昂贵的集束搜索成本。 int >= 0。

  maes_expansion_beta: 除了集束大小之外，允许的最大前缀扩展数。

  实际上，假设的数量 = beam_size + maes_expansion_beta。 必须是 int >= 0，并且会影响推理速度，因为较大的值将在下一步执行大型集束搜索。

  maes_expansion_gamma: 用于在计算

  扩展时，在按值剪枝步骤中使用的浮点剪枝阈值。 默认值 (2.3) 是从论文中选择的。 它执行比较 (max_log_prob - gamma <= log_prob[v])，其中 v 是 Vocab 集合中的所有词汇表索引，max_log_prob 是要预测的“最”可能的 token。 因此，Gamma 提供了除“最可能”候选者之外，可以作为潜在扩展候选者的额外 tokens 的余量。 较低的值将减少扩展的数量（通过增加按值剪枝，从而提高速度但损害准确性）。 较高的值将增加扩展的数量（通过减少按值剪枝，从而降低速度，但可能提高准确性）。 这是一个超参数，需要在验证集上进行实验性调整。

  softmax_temperature: 在计算 log_softmax 之前，缩放 Joint 的 logits。

• decoder – Decoder/Prediction 网络模块。

• joint – Joint 网络模块。

• vocabulary – 词汇表（不包括 RNNT blank token），将用于解码。

decode_ids_to_langs(

tokens: List[int],

) → List[str]

将 token id 列表解码为语言 ID (LID) 列表。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 LIDS 列表。

decode_ids_to_tokens(

tokens: List[int],

) → List[str]

由子类实现，以便将 token ID 列表解码为 token 列表。token 列表是每个 token ID 的字符串表示形式。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 token 列表。

decode_tokens_to_lang(tokens: List[int]) → str

计算给定 tokens 的最可能的语言 ID (LID) 字符串。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 LID 字符串。

decode_tokens_to_str(tokens: List[int]) → str

由子类实现，以便将 token 列表解码为字符串。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的字符串。

class nemo.collections.asr.parts.submodules.rnnt_decoding.RNNTBPEDecoding(

decoding_cfg,

decoder,

joint,

tokenizer: TokenizerSpec,

)

基类：AbstractRNNTDecoding

用于给定编码器状态，对 Decoder+Joint 网络执行 RNN-T 自回归解码。

参数:

• decoding_cfg –

  一个类似字典的对象，包含以下键值对。

  strategy

  str 值，表示可能发生的解码类型。可能的值为

  • greedy, greedy_batch (用于贪心解码)。

  • beam, tsd, alsd (用于集束搜索解码)。

  compute_hypothesis_token_set: 一个布尔标志，用于确定是否计算解码后的

  tokens 列表以及解码后的字符串。 默认值为 False，以避免在不需要时进行双重解码。

  preserve_alignments: 布尔标志，用于保留在

  解码（sample / batched）期间生成的。 如果设置为 true，则 Hypothesis 将包含 alignments 的非空值。 在这里，alignments 是 List of List of Tuple(Tensor (长度为 V + 1), Tensor(标量，argmax 后的标签))。

  为了获得此假设，请使用 rnnt_decoder_predictions_tensor 函数，并将 return_hypotheses 标志设置为 True。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示来自词汇表的一个或多个目标。 U 是当前时间步 Ti 的目标 tokens 数量。

  compute_timestamps: 一个布尔标志，用于确定是否计算字符/子词或

  单词级时间戳，将输出 log-probabilities 映射到离散的时间戳间隔。 时间戳将在返回的 Hypothesis.timestep 中以字典形式提供。

  compute_langs: 一个布尔标志，允许计算每个 token 的语言 ID (LID) 信息，

  单词和整个样本（最可能的语言 ID）。 LIDS 将在返回的 Hypothesis 对象中以字典形式提供

  rnnt_timestamp_type: 一个字符串值，表示应计算的时间戳类型。

  可以采用以下值 - “char” 表示字符/子词时间戳，“word” 表示单词级时间戳，“all”（默认）表示字符级和单词级时间戳。

  word_seperator: 字符串 token，表示单词之间的分隔符。

  segment_seperators: 包含 tokens 的列表，表示段落之间的分隔符。

  segment_gap_threshold: 阈值（以帧为单位），限制形成

  段落所需的两个单词之间的间隔。

  preserve_frame_confidence: 布尔标志，用于保留在

  解码（sample / batched）期间生成的。 如果设置为 true，则 Hypothesis 将包含 frame_confidence 的非空值。 在这里，alignments 是 List of List of ints。

  confidence_cfg：一个类似字典的对象，其中包含与置信度相关的以下键值对

  分数。 为了获得具有置信度分数的假设，请使用 rnnt_decoder_predictions_tensor 函数，并将 preserve_frame_confidence 标志设置为 True。

  preserve_frame_confidence: 布尔标志，用于保留在

  解码（sample / batched）期间生成的每帧置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 frame_confidence 的非空值。 在这里，alignments 是 List of List of floats。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示一个或多个置信度分数。 U 是当前时间步 Ti 的目标 tokens 数量。

  preserve_token_confidence: 布尔标志，用于保留在贪心解码（sample / batched）期间生成的每 token 置信度分数的历史记录。

  解码（sample / batched）期间生成的每 token 置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 token_confidence 的非空值。 在这里，token_confidence 是 List of floats。

  列表的长度对应于识别的 token 的数量。

  preserve_word_confidence: 布尔标志，用于保留在

  贪心解码（sample / batched）期间生成的每词置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 word_confidence 的非空值。 在这里，word_confidence 是 List of floats。

  列表的长度对应于识别的单词的数量。

  exclude_blank: 布尔标志，指示要排除 blank token 置信度分数

  从 token_confidence 中排除。

  aggregation: 用于将每 token 置信度折叠为每词置信度的聚合类型。

  有效选项为 mean、min、max、prod。

  tdt_include_duration: 布尔标志，指示将计算持续时间置信度分数，并且

  附加到常规帧置信度，使 TDT 帧置信度元素成为一对：（prediction_confidence，duration_confidence）。

  method_cfg: 一个类似字典的对象，其中包含用于计算每帧

  置信度分数的方法名称和设置。

  name

  方法名称 (str)。支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type: 要使用的熵类型 (str)。

  如果 confidence_method_cfg.name 设置为 entropy，则使用。 支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha: logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。

  当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm: 熵值到区间 [0,1] 的映射。

  支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

  配置可能还包含以下子字典

  “greedy”

  max_symbols: int，描述在贪心解码期间每个

  时间步要解码的最大目标 tokens 数量。 设置为较大的值可以解码更长的句子，但会增加执行时间。

  preserve_frame_confidence: 与上述相同，覆盖上述值。

  confidence_method_cfg: 与上述相同，覆盖 confidence_cfg.method_cfg。

  “beam”

  beam_size: int，定义集束搜索的集束大小。 必须 >= 1。

  如果 beam_size == 1，将执行缓存的贪心搜索。 与上面的贪心搜索相比，这可能会产生略有不同的结果。

  score_norm: 可选的布尔值，指示是否标准化假设中返回的集束分数。

  默认设置为 True。

  return_best_hypothesis: 可选的布尔值，指示是仅返回最佳假设还是返回所有

  集束搜索结束后得到的假设。

  tsd_max_sym_exp: 可选的 int，确定声学模型每个时间步的目标 tokens 的对称扩展数量

  。 较大的值将允许解码更长的句子，但会增加执行时间成本。

  alsd_max_target_len: 可选的 int 或 float，确定潜在的最大目标序列

  长度。如果提供整数，则可以解码该特定最大长度的序列。 如果提供浮点数，则可以解码长度为 int(alsd_max_target_len * seq_len) 的序列，其中 seq_len 是声学模型输出的长度 (T)。

  注意

  如果提供浮点数，则可以大于 1！ 默认情况下，使用 2.0 的浮点数，以便目标序列最多可以是声学模型输出长度 T 的两倍。

  maes_num_steps: 要采取的自适应步骤数。 根据论文，通常 2 步就足够了，

  并且可以减少到 1 以提高解码速度，但会牺牲一些准确性。 int > 0。

  maes_prefix_alpha: 前缀搜索中的最大前缀长度。 必须是整数，建议

  保持为 1，以减少后续昂贵的集束搜索成本。 int >= 0。

  maes_expansion_beta: 除了集束大小之外，允许的最大前缀扩展数。

  实际上，假设的数量 = beam_size + maes_expansion_beta。 必须是 int >= 0，并且会影响推理速度，因为较大的值将在下一步执行大型集束搜索。

  maes_expansion_gamma: 用于在计算

  扩展时，在按值剪枝步骤中使用的浮点剪枝阈值。 默认值 (2.3) 是从论文中选择的。 它执行比较 (max_log_prob - gamma <= log_prob[v])，其中 v 是 Vocab 集合中的所有词汇表索引，max_log_prob 是要预测的“最”可能的 token。 因此，Gamma 提供了除“最可能”候选者之外，可以作为潜在扩展候选者的额外 tokens 的余量。 较低的值将减少扩展的数量（通过增加按值剪枝，从而提高速度但损害准确性）。 较高的值将增加扩展的数量（通过减少按值剪枝，从而降低速度，但可能提高准确性）。 这是一个超参数，需要在验证集上进行实验性调整。

  softmax_temperature: 在计算 log_softmax 之前，缩放 Joint 的 logits。

• decoder – Decoder/Prediction 网络模块。

• joint – Joint 网络模块。

• tokenizer – 将用于解码的 tokenizer。

decode_hypothesis(

hypotheses_list: List[Hypothesis],

) → List[Hypothesis | NBestHypotheses]

将假设列表解码为字符串列表。 覆盖 super() 方法，并可选择添加语言信息

参数:

hypotheses_list – Hypothesis 列表。

返回:

字符串列表。

decode_ids_to_langs(

tokens: List[int],

) → List[str]

将 token id 列表解码为语言 ID (LID) 列表。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 LIDS 列表。

decode_ids_to_tokens(

tokens: List[int],

) → List[str]

由子类实现，以便将 token ID 列表解码为 token 列表。token 列表是每个 token ID 的字符串表示形式。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 token 列表。

decode_tokens_to_lang(

tokens: List[int],

) → str

计算给定 tokens 的最可能的语言 ID (LID) 字符串。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的 LID 字符串。

decode_tokens_to_str(tokens: List[int]) → str

由子类实现，以便将 token 列表解码为字符串。

参数:

tokens – 表示 token ID 的整数列表。

返回:

解码后的字符串。

class nemo.collections.asr.parts.submodules.rnnt_greedy_decoding.GreedyRNNTInfer(

decoder_model: AbstractRNNTDecoder,

joint_model: AbstractRNNTJoint,

blank_index: int,

max_symbols_per_step: int | None = None,

preserve_alignments: bool = False,

preserve_frame_confidence: bool = False,

confidence_method_cfg: omegaconf.DictConfig | None = None,

)

基类：_GreedyRNNTInfer

一个贪心 transducer 解码器。

序列级贪心解码，以自回归方式执行。

参数:

• decoder_model – rnnt_utils.AbstractRNNTDecoder 实现。

• joint_model – rnnt_utils.AbstractRNNTJoint 实现。

• blank_index – 空白 token 的整数索引。可以是 0 或 len(vocabulary)。

• max_symbols_per_step – 可选的 int。 每个时间步可以添加到序列的最大符号数； 如果设置为 None，则没有限制。

• preserve_alignments –

  布尔标志，用于保留在贪心解码（sample / batched）期间生成的 alignments 历史记录。 如果设置为 true，则 Hypothesis 将包含 alignments 的非空值。 在这里，alignments 是 List of List of Tuple(Tensor (长度为 V + 1), Tensor(标量，argmax 后的标签))。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示来自词汇表的一个或多个目标。 U 是当前时间步 Ti 的目标 tokens 数量。

• preserve_frame_confidence –

  布尔标志，用于保留在贪心解码（sample / batched）期间生成的每帧置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 frame_confidence 的非空值。 在这里，frame_confidence 是 List of List of floats。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示一个或多个置信度分数。 U 是当前时间步 Ti 的目标 tokens 数量。

• confidence_method_cfg –

  一个类似字典的对象，其中包含方法名称和用于计算每帧置信度分数的设置。

  name: 方法名称 (str)。

  支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type: 要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。

  支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha: logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。

  当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm: 熵值到区间 [0,1] 的映射。

  支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

forward(

encoder_output: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: List[Hypothesis] | None = None,

)

返回给定编码器隐藏嵌入的输入批次的假设列表。 输出 token 以自回归方式生成。

参数:

• encoder_output – 大小为 (batch, features, timesteps) 的 tensor。

• encoded_lengths – 表示每个序列输出序列长度的 int 列表。

返回:

包含批次句子数（Hypotheses）的打包列表。

class nemo.collections.asr.parts.submodules.rnnt_greedy_decoding.GreedyBatchedRNNTInfer(

decoder_model: AbstractRNNTDecoder,

joint_model: AbstractRNNTJoint,

blank_index: int,

max_symbols_per_step: int | None = None,

preserve_alignments: bool = False,

preserve_frame_confidence: bool = False,

confidence_method_cfg: omegaconf.DictConfig | None = None,

loop_labels: bool = True,

use_cuda_graph_decoder: bool = True,

)

基类：_GreedyRNNTInfer, WithOptionalCudaGraphs

一个批处理级别的贪心 transducer 解码器。

批处理级别贪心解码，以自回归方式执行。

参数:

• decoder_model – rnnt_utils.AbstractRNNTDecoder 实现。

• joint_model – rnnt_utils.AbstractRNNTJoint 实现。

• blank_index – 空白 token 的整数索引。可以是 0 或 len(vocabulary)。

• max_symbols_per_step – 可选的 int。 每个时间步可以添加到序列的最大符号数； 如果设置为 None，则没有限制。

• preserve_alignments –

  布尔标志，用于保留在贪心解码（sample / batched）期间生成的 alignments 历史记录。 如果设置为 true，则 Hypothesis 将包含 alignments 的非空值。 在这里，alignments 是 List of List of Tuple(Tensor (长度为 V + 1), Tensor(标量，argmax 后的标签))。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示来自词汇表的一个或多个目标。 U 是当前时间步 Ti 的目标 tokens 数量。

• preserve_frame_confidence –

  布尔标志，用于保留在贪心解码（sample / batched）期间生成的每帧置信度分数的历史记录。 如果设置为 true，则 Hypothesis 将包含 frame_confidence 的非空值。 在这里，frame_confidence 是 List of List of floats。

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示一个或多个置信度分数。 U 是当前时间步 Ti 的目标 tokens 数量。

• confidence_method_cfg –

  一个类似字典的对象，其中包含方法名称和用于计算每帧置信度分数的设置。

  name: 方法名称 (str)。

  支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type: 要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。

  支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha: logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。

  当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm: 熵值到区间 [0,1] 的映射。

  支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

• loop_labels – 在解码算法之间切换。 两种算法产生等效的结果。 loop_labels=True（默认）算法速度更快（尤其是对于大批量），但会使用更多的内存（与编码器使用的内存量相比，开销可忽略不计）。 loop_labels=False 是传统解码算法的实现，该算法迭代帧（编码器输出向量），并在内部循环中，逐个解码当前帧的标签，当找到 <blank> 时停止。 loop_labels=True 迭代标签，在每个步骤中找到下一个非 blank 标签（在内部循环中多次评估 Joint）； 它使用最少可能的预测网络调用量（具有最大可能的批处理大小），这使其特别适用于扩展预测网络。

• use_cuda_graph_decoder – 是否应为解码启用 CUDA graphs（目前仅推荐用于推理）

disable_cuda_graphs()

禁用 CUDA graphs（例如，用于训练中的解码）

forward(

encoder_output: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: List[Hypothesis] | None = None,

)

返回给定编码器隐藏嵌入的输入批次的假设列表。 输出 token 以自回归方式生成。

参数:

• encoder_output – 大小为 (batch, features, timesteps) 的 tensor。

• encoded_lengths – 表示每个序列输出序列长度的 int 列表。

返回:

包含批次句子数（Hypotheses）的打包列表。

maybe_enable_cuda_graphs()

启用 CUDA graphs（如果允许）

class nemo.collections.asr.parts.submodules.rnnt_beam_decoding.BeamRNNTInfer(

decoder_model: AbstractRNNTDecoder,

joint_model: AbstractRNNTJoint,

beam_size: int,

search_type: str = 'default',

score_norm: bool = True,

return_best_hypothesis: bool = True,

tsd_max_sym_exp_per_step: int | None = 50,

alsd_max_target_len: int | float = 1.0,

nsc_max_timesteps_expansion: int = 1,

nsc_prefix_alpha: int = 1,

maes_num_steps: int = 2,

maes_prefix_alpha: int = 1,

maes_expansion_gamma: float = 2.3,

maes_expansion_beta: int = 2,

language_model: Dict[str, Any] | None = None,

softmax_temperature: float = 1.0,

preserve_alignments: bool = False,

ngram_lm_model: str | None = None,

ngram_lm_alpha: float = 0.0,

hat_subtract_ilm: bool = False,

hat_ilm_weight: float = 0.0,

)

基类：Typing

从 ESPNet 实现移植的集束搜索实现 - espnet/espnet

序列级集束解码或批处理集束解码，根据选择的搜索类型以自回归方式执行。

参数:

• decoder_model – rnnt_utils.AbstractRNNTDecoder 实现。

• joint_model – rnnt_utils.AbstractRNNTJoint 实现。

• beam_size –

  集束搜索的集束数量。 必须是正整数 >= 1。 如果集束大小为 1，则默认为有状态贪心搜索。 由于实现差异，此贪心搜索可能会产生与 GreedyRNNTInfer 获得的贪心结果略有不同的结果。

  为了获得准确的贪心结果，请使用 GreedyRNNTInfer 或 GreedyBatchedRNNTInfer。

• search_type (# 以下参数特定于所选的) –

  字符串，表示要执行的集束搜索类型。 必须是 [‘beam’, ‘tsd’, ‘alsd’] 之一。 目前不支持 ‘nsc’。

  使用的算法

  beam - 基本的集束搜索策略。 较大的集束通常会带来更好的解码效果，

  但是搜索所需的时间也会稳步增长。

  tsd - 时间同步解码。 请参阅论文

  [用于 RNN Transducer 的对齐长度同步解码] (https://ieeexplore.ieee.org/document/9053040)，了解有关已实现算法的详细信息。

  时间同步解码 (TSD) 执行时间按因子 T * max_symmetric_expansions 增长。 对于较长的序列，T 较大，因此集束可能需要很长时间才能获得良好的结果。 这也需要更大的内存来执行。

  alsd - 对齐长度同步解码。 请参阅论文

  [用于 RNN Transducer 的对齐长度同步解码] (https://ieeexplore.ieee.org/document/9053040)，了解有关已实现算法的详细信息。

  对齐长度同步解码 (ALSD) 执行时间比 TSD 快，增长因子为 T + U_max，其中 U_max 是执行期间预期的最大目标长度。

  通常，T + U_max < T * max_symmetric_expansions。 但是，ALSD 集束是非唯一的，因此需要使用更大的集束大小才能达到与 TSD 相同的（或接近相同的）解码准确度。

  对于给定的解码准确度，可以通过 ALSD 比 TSD 获得更快的解码速度。

  maes = 修改后的自适应扩展搜索。 请参阅论文

  [通过自适应扩展搜索加速 RNN Transducer 推理] (https://ieeexplore.ieee.org/document/9250505)

  修改后的自适应同步解码 (mAES) 执行时间是自适应的，与每个时间步所需的扩展（对于 tokens）数量有关。 扩展的数量通常可以限制为 1 或 2，在大多数情况下，2 就足够了。

  这种集束搜索技术可能会获得更好的 WER，但会牺牲一些评估时间。

• score_norm – 布尔值，指示是否标准化 log 概率的分数。

• return_best_hypothesis – 布尔值，决定是返回单个假设（N 个中最好的一个），还是返回所有 N 个假设（按最佳分数排序）。 容器类根据此标志而变化 - 当设置为 True（默认值）时，返回单个 Hypothesis。 当设置为 False 时，返回 NBestHypotheses 容器，其中包含 Hypothesis 列表。

• search_type

• tsd_max_sym_exp_per_step – 用于 search_type=tsd。 梁搜索期间每个时间步允许的最大对称扩展数。 应使用较大的值来尝试解码较长的序列，但这反过来会增加执行时间和内存使用量。

• alsd_max_target_len – 用于 search_type=alsd。 集束搜索期间预期的最大目标序列长度。 较大的值允许解码更长的序列，但会牺牲执行时间和内存。

• stabilized. (# 以下两个标志是占位符，在 nsc 实现稳定之前未使用)

• nsc_max_timesteps_expansion – 未使用的 int。

• nsc_prefix_alpha – 未使用的 int。

• flags (# mAES)

• maes_num_steps – 要采取的自适应步骤数。 根据论文，通常 2 步就足够了。 int > 1。

• maes_prefix_alpha – 前缀搜索中的最大前缀长度。 必须是整数，建议保持为 1，以减少后续昂贵的集束搜索成本。 int >= 0。

• maes_expansion_beta – 除了集束大小之外，允许的最大前缀扩展数。 实际上，假设的数量 = beam_size + maes_expansion_beta。 必须是 int >= 0，并且会影响推理速度，因为较大的值将在下一步执行大型集束搜索。

• maes_expansion_gamma – 用于在计算扩展时，在按值剪枝步骤中使用的浮点剪枝阈值。 默认值 (2.3) 是从论文中选择的。 它执行比较 (max_log_prob - gamma <= log_prob[v])，其中 v 是 Vocab 集合中的所有词汇表索引，max_log_prob 是要预测的“最”可能的 token。 因此，Gamma 提供了除“最可能”候选者之外，可以作为潜在扩展候选者的额外 tokens 的余量。 较低的值将减少扩展的数量（通过增加按值剪枝，从而提高速度但损害准确性）。 较高的值将增加扩展的数量（通过减少按值剪枝，从而降低速度，但可能提高准确性）。 这是一个超参数，需要在验证集上进行实验性调整。

• softmax_temperature – 在计算 log_softmax 之前，缩放 Joint 的 logits。

• preserve_alignments –

  布尔标志，用于保留在集束解码（sample）期间生成的 alignments 历史记录。 如果设置为 true，则 Hypothesis 将包含 alignments 的非空值。 在这里，alignments 是 List of List of Tensor (长度为 V + 1)

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示来自词汇表的一个或多个目标。 U 是当前时间步 Ti 的目标 tokens 数量。

  注意：preserve_alignments 对于基本集束搜索以外的任何 search_type 都是无效的参数。

• ngram_lm_model – str N-gram LM 的路径

• ngram_lm_alpha – float N-gram LM 的 Alpha 权重

• tokens_type – str 分词类型 [‘subword’, ‘char’]

align_length_sync_decoding(

h: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: Hypothesis | None = None,

) → List[Hypothesis]

对齐长度同步波束搜索实现。基于 https://ieeexplore.ieee.org/document/9053040

参数:

h – 编码后的语音特征 (1, T_max, D_enc)

返回:

N-best 解码结果

返回类型:

nbest_hyps

compute_ngram_score(

current_lm_state: kenlm.State,

label: int,

) → Tuple[float, kenlm.State]

KenLM ngram 语言模型的得分计算。

default_beam_search(

h: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: Hypothesis | None = None,

) → List[Hypothesis]

波束搜索实现。

参数:

x – 编码后的语音特征 (1, T_max, D_enc)

返回:

N-best 解码结果

返回类型:

nbest_hyps

greedy_search(

h: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: Hypothesis | None = None,

) → List[Hypothesis]

用于 transducer 的贪婪搜索实现。当波束大小 = 1 时的通用情况。与 GreedyRNNTInfer 和 GreedyBatchRNNTInfer 相比，结果可能因实现细节而略有不同。

参数:

h – 编码后的语音特征 (1, T_max, D_enc)

返回:

1-best 解码结果

返回类型:

hyp

property input_types

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

modified_adaptive_expansion_search(

h: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: Hypothesis | None = None,

) → List[Hypothesis]

基于/修改自 https://ieeexplore.ieee.org/document/9250505

参数:

h – 编码后的语音特征 (1, T_max, D_enc)

返回:

N-best 解码结果

返回类型:

nbest_hyps

property output_types

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

prefix_search(

hypotheses: List[Hypothesis],

enc_out: torch.Tensor,

prefix_alpha: int,

) → List[Hypothesis]

用于 NSC 和 mAES 策略的前缀搜索。基于 https://arxiv.org/pdf/1211.3711.pdf

recombine_hypotheses(

hypotheses: List[Hypothesis],

) → List[Hypothesis]

重组具有等效输出序列的假设。

参数:

hypotheses (list) – 假设列表

返回:

重组后的假设列表

返回类型:

final (list)

resolve_joint_output(

enc_out: torch.Tensor,

dec_out: torch.Tensor,

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

解析 RNNT 和 HAT joint 模型的输出类型

set_decoding_type(decoding_type: str)

设置解码类型。请查看 scripts/asr_language_modeling/ 中的 train_kenlm.py 以了解为什么我们需要 :param decoding_type: 解码类型

sort_nbest(

hyps: List[Hypothesis],

) → List[Hypothesis]

按分数或给定序列长度的分数对假设进行排序。

参数:

hyps – 假设列表

返回:

排序后的假设列表

返回类型:

hyps

time_sync_decoding(

h: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: Hypothesis | None = None,

) → List[Hypothesis]

时间同步波束搜索实现。基于 https://ieeexplore.ieee.org/document/9053040

参数:

h – 编码后的语音特征 (1, T_max, D_enc)

返回:

N-best 解码结果

返回类型:

nbest_hyps

TDT 解码

class nemo.collections.asr.parts.submodules.rnnt_greedy_decoding.GreedyTDTInfer(

decoder_model: AbstractRNNTDecoder,

joint_model: AbstractRNNTJoint,

blank_index: int,

durations: list,

max_symbols_per_step: int | None = None,

preserve_alignments: bool = False,

preserve_frame_confidence: bool = False,

include_duration: bool = False,

include_duration_confidence: bool = False,

confidence_method_cfg: omegaconf.DictConfig | None = None,

)

基类：_GreedyRNNTInfer

贪婪 TDT 解码器。

序列级贪心解码，以自回归方式执行。

参数:

• decoder_model – rnnt_utils.AbstractRNNTDecoder 实现。

• joint_model – rnnt_utils.AbstractRNNTJoint 实现。

• blank_index – 空白符 token 的 int 索引。对于 TDT 模型，必须是 len(vocabulary)。

• durations – 包含 TDT 时长的列表。

• max_symbols_per_step – 可选的 int。 每个时间步可以添加到序列的最大符号数； 如果设置为 None，则没有限制。

• preserve_alignments – 布尔标志，用于保留贪婪解码（样本/批量）期间生成的对齐历史记录。当设置为 true 时，Hypothesis 将在其 alignments 中包含非空值。这里，alignments 是 Tuple(Tensor (长度为 V + 1 + num-big-blanks), Tensor(标量，argmax 后的标签)) 的列表的列表。列表的长度对应于声学长度 (T)。列表 (Ti) 中的每个值都是一个 torch.Tensor (U)，表示词汇表中的一个或多个目标。U 是当前时间步 Ti 的目标 token 数。

• preserve_frame_confidence – 布尔标志，用于保留贪婪解码（样本/批量）期间生成的每帧置信度分数历史记录。当设置为 true 时，Hypothesis 将在其 frame_confidence 中包含非空值。这里，frame_confidence 是浮点数列表的列表。列表的长度对应于声学长度 (T)。列表 (Ti) 中的每个值都是一个 torch.Tensor (U)，表示一个或多个置信度分数。U 是当前时间步 Ti 的目标 token 数。

• include_duration – 布尔标志，用于确定是否需要在 Hypothesis 对象中包含每个 token 的预测时长。默认为 False。

• include_duration_confidence – 布尔标志，指示要计算持续时间置信度分数并将其附加到常规帧置信度，使 TDT 帧置信度元素成为一对：(prediction_confidence, duration_confidence)。

• confidence_method_cfg –

  一个类似字典的对象，其中包含方法名称和用于计算每帧置信度分数的设置。

  name: 方法名称 (str)。

  支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type: 要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。

  支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha: logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。

  当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm: 熵值到区间 [0,1] 的映射。

  支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

forward(

encoder_output: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: List[Hypothesis] | None = None,

)

返回给定编码器隐藏嵌入的输入批次的假设列表。输出 token 是自回归生成的。 :param encoder_output: 大小为 (batch, features, timesteps) 的 tensor。 :param encoded_lengths: 表示每个序列长度的 int 列表

输出序列。

返回:

包含批次句子数（Hypotheses）的打包列表。

class nemo.collections.asr.parts.submodules.rnnt_greedy_decoding.GreedyBatchedTDTInfer(

decoder_model: AbstractRNNTDecoder,

joint_model: AbstractRNNTJoint,

blank_index: int,

durations: List[int],

max_symbols_per_step: int | None = None,

preserve_alignments: bool = False,

preserve_frame_confidence: bool = False,

include_duration: bool = False,

include_duration_confidence: bool = False,

confidence_method_cfg: omegaconf.DictConfig | None = None,

use_cuda_graph_decoder: bool = True,

)

基类：_GreedyRNNTInfer, WithOptionalCudaGraphs

批量级别贪婪 TDT 解码器。批量级别贪婪解码，自回归执行。 :param decoder_model: rnnt_utils.AbstractRNNTDecoder 实现。 :param joint_model: rnnt_utils.AbstractRNNTJoint 实现。 :param blank_index: 空白符 token 的 int 索引。对于 TDT 模型，必须是 len(vocabulary)。 :param durations: 包含时长的列表。 :param max_symbols_per_step: 可选的 int。可以在单个时间步添加到序列的最大符号数；如果设置为 None，则没有限制。

到序列的单个时间步；如果设置为 None，则没有限制。

参数:

• preserve_alignments – 布尔标志，用于保留贪婪解码（样本/批量）期间生成的对齐历史记录。当设置为 true 时，Hypothesis 将在其 alignments 中包含非空值。这里，alignments 是 Tuple(Tensor (长度为 V + 1 + num-big-blanks), Tensor(标量，argmax 后的标签)) 的列表的列表。列表的长度对应于声学长度 (T)。列表 (Ti) 中的每个值都是一个 torch.Tensor (U)，表示词汇表中的一个或多个目标。U 是当前时间步 Ti 的目标 token 数。

• preserve_frame_confidence – 布尔标志，用于保留贪婪解码（样本/批量）期间生成的每帧置信度分数历史记录。当设置为 true 时，Hypothesis 将在其 frame_confidence 中包含非空值。这里，frame_confidence 是浮点数列表的列表。列表的长度对应于声学长度 (T)。列表 (Ti) 中的每个值都是一个 torch.Tensor (U)，表示一个或多个置信度分数。U 是当前时间步 Ti 的目标 token 数。

• include_duration – 布尔标志，用于确定是否需要在 Hypothesis 对象中包含每个 token 的预测时长。默认为 False。

• include_duration_confidence – 布尔标志，指示要计算持续时间置信度分数并将其附加到常规帧置信度，使 TDT 帧置信度元素成为一对：(prediction_confidence, duration_confidence)。

• confidence_method_cfg –

  一个类似字典的对象，其中包含方法名称和用于计算每帧置信度分数的设置。

  name: 方法名称 (str)。

  支持的值

  • “max_prob” 用于将最大 token 概率用作置信度。

  • “entropy” 用于使用对数似然向量的归一化熵。

  entropy_type: 要使用的熵类型 (str)。如果 confidence_method_cfg.name 设置为 entropy，则使用。

  支持的值

  • “gibbs” 表示（标准）吉布斯熵。如果提供了 alpha (α)，

    则公式如下：H_α = -sum_i((p^α_i)*log(p^α_i))。请注意，对于此熵，alpha 应符合以下不等式：(log(V)+2-sqrt(log^2(V)+4))/(2*log(V)) <= α <= (1+log(V-1))/log(V-1)，其中 V 是模型词汇表大小。

  • “tsallis” 表示 Boltzmann 常数为 1 的 Tsallis 熵。

    Tsallis 熵公式如下：H_α = 1/(α-1)*(1-sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/Tsallis_entropy

  • “renyi” 表示 Rényi 熵。

    Rényi 熵公式如下：H_α = 1/(1-α)*log_2(sum_i(p^α_i))，其中 α 是一个参数。当 α == 1 时，它类似于吉布斯熵。更多信息：https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy

  alpha: logsoftmax 的功率缩放（熵的 α）。此处我们将其限制为 > 0。

  当 alpha 等于 1 时，缩放不应用于“max_prob”，并且任何熵类型都表现得像香农熵：H = -sum_i(p_i*log(p_i))

  entropy_norm: 熵值到区间 [0,1] 的映射。

  支持的值

  • “lin” 用于使用线性映射。

  • “exp” 用于使用具有线性偏移的指数映射。

• use_cuda_graph_decoder – 是否应为解码启用 CUDA graphs（目前仅推荐用于推理）

disable_cuda_graphs()

禁用 CUDA graphs（例如，用于训练中的解码）

forward(

encoder_output: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: List[Hypothesis] | None = None,

)

返回给定编码器隐藏嵌入的输入批次的假设列表。输出 token 是自回归生成的。 :param encoder_output: 大小为 (batch, features, timesteps) 的 tensor。 :param encoded_lengths: 表示每个序列长度的 int 列表

输出序列。

返回:

包含批次句子数（Hypotheses）的打包列表。

maybe_enable_cuda_graphs()

启用 CUDA graphs（如果允许）

class nemo.collections.asr.parts.submodules.tdt_beam_decoding.BeamTDTInfer(

decoder_model: AbstractRNNTDecoder,

joint_model: AbstractRNNTJoint,

durations: list,

beam_size: int,

search_type: str = 'default',

score_norm: bool = True,

return_best_hypothesis: bool = True,

maes_num_steps: int = 2,

maes_prefix_alpha: int = 1,

maes_expansion_gamma: float = 2.3,

maes_expansion_beta: int = 2,

softmax_temperature: float = 1.0,

preserve_alignments: bool = False,

ngram_lm_model: str | None = None,

ngram_lm_alpha: float = 0.3,

)

基类：Typing

用于 Token-andDuration Transducer (TDT) 模型的波束搜索实现。

序列级集束解码或批处理集束解码，根据选择的搜索类型以自回归方式执行。

参数:

• decoder_model – rnnt_utils.AbstractRNNTDecoder 实现。

• joint_model – rnnt_utils.AbstractRNNTJoint 实现。

• durations – 来自 TDT 模型的持续时间值列表。

• beam_size – 波束搜索的波束数量。必须是正整数 >= 1。如果波束大小为 1，则默认为有状态贪婪搜索。对于准确的贪婪结果，请使用 GreedyRNNTInfer 或 GreedyBatchedRNNTInfer。

• search_type (# 以下参数特定于所选的) –

  表示要执行的波束搜索类型的字符串。必须是 [‘beam’, ‘maes’] 之一。

  使用的算法

  default - 基本波束搜索策略。较大的波束通常会产生更好的解码，

  但是搜索所需的时间也会稳步增长。

  maes = 修改后的自适应扩展搜索。请参考论文

  [通过自适应扩展搜索加速 RNN Transducer 推理] (https://ieeexplore.ieee.org/document/9250505)

  修改后的自适应同步解码 (mAES) 执行时间是自适应的，与每个时间步所需的扩展（对于 tokens）数量有关。 扩展的数量通常可以限制为 1 或 2，在大多数情况下，2 就足够了。

  这种集束搜索技术可能会获得更好的 WER，但会牺牲一些评估时间。

• score_norm – 布尔值，指示是否标准化 log 概率的分数。

• return_best_hypothesis – 布尔值，决定是返回单个假设（N 个中最好的一个），还是返回所有 N 个假设（按最佳分数排序）。 容器类根据此标志而变化 - 当设置为 True（默认值）时，返回单个 Hypothesis。 当设置为 False 时，返回 NBestHypotheses 容器，其中包含 Hypothesis 列表。

• search_type

• flags (# mAES)

• maes_num_steps – 要采取的自适应步骤数。 根据论文，通常 2 步就足够了。 int > 1。

• maes_prefix_alpha – 前缀搜索中的最大前缀长度。 必须是整数，建议保持为 1，以减少后续昂贵的集束搜索成本。 int >= 0。

• maes_expansion_beta – 除了集束大小之外，允许的最大前缀扩展数。 实际上，假设的数量 = beam_size + maes_expansion_beta。 必须是 int >= 0，并且会影响推理速度，因为较大的值将在下一步执行大型集束搜索。

• maes_expansion_gamma – 用于在计算扩展时，在按值剪枝步骤中使用的浮点剪枝阈值。 默认值 (2.3) 是从论文中选择的。 它执行比较 (max_log_prob - gamma <= log_prob[v])，其中 v 是 Vocab 集合中的所有词汇表索引，max_log_prob 是要预测的“最”可能的 token。 因此，Gamma 提供了除“最可能”候选者之外，可以作为潜在扩展候选者的额外 tokens 的余量。 较低的值将减少扩展的数量（通过增加按值剪枝，从而提高速度但损害准确性）。 较高的值将增加扩展的数量（通过减少按值剪枝，从而降低速度，但可能提高准确性）。 这是一个超参数，需要在验证集上进行实验性调整。

• softmax_temperature – 在计算 log_softmax 之前，缩放 Joint 的 logits。

• preserve_alignments –

  布尔标志，用于保留在集束解码（sample）期间生成的 alignments 历史记录。 如果设置为 true，则 Hypothesis 将包含 alignments 的非空值。 在这里，alignments 是 List of List of Tensor (长度为 V + 1)

  列表的长度对应于声学长度 (T)。 列表中的每个值 (Ti) 都是一个 torch.Tensor (U)，表示来自词汇表的一个或多个目标。 U 是当前时间步 Ti 的目标 tokens 数量。

  注意：preserve_alignments 对于基本集束搜索以外的任何 search_type 都是无效的参数。

• ngram_lm_model – str N-gram LM 的路径。

• ngram_lm_alpha – float N-gram LM 的 alpha 权重。

compute_ngram_score(

current_lm_state: kenlm.State,

label: int,

) → Tuple[float, kenlm.State]

计算 KenLM Ngram 语言模型的得分。

参数:

• current_lm_state – KenLM 语言模型的当前状态。

• label – 下一个标签。

返回:

label 的得分。

返回类型:

lm_score

default_beam_search(

encoder_outputs: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: Hypothesis | None = None,

) → List[Hypothesis]

用于 TDT 模型的默认波束搜索实现。

参数:

• encoder_outputs – 编码器输出（batch, features, timesteps）。

• encoded_lengths – 编码器输出的长度。

• partial_hypotheses – 部分假设。

返回:

N-best 解码结果

返回类型:

nbest_hyps

property input_types

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

merge_duplicate_hypotheses(hypotheses)

合并具有相同 token 序列和长度的假设。组合假设的概率是所有重复项的概率之和。当预测两个连续的空白符 token 且它们的持续时间值加起来相同时，会发生重复的假设。

参数:

hypotheses – 假设列表。

返回:

不含重复项的假设列表。

返回类型:

hypotheses

modified_adaptive_expansion_search(

encoder_outputs: torch.Tensor,

encoded_lengths: torch.Tensor,

partial_hypotheses: Hypothesis | None = None,

) → List[Hypothesis]

用于 TDT 模型的修改后的自适应扩展搜索算法。基于/修改自 https://ieeexplore.ieee.org/document/9250505。支持 N-gram 语言模型浅融合。

参数:

• encoder_outputs – 编码器输出（batch, features, timesteps）。

• encoded_lengths – 编码器输出的长度。

• partial_hypotheses – 部分假设。

返回:

N-best 解码结果

返回类型:

nbest_hyps

property output_types

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

prefix_search(

hypotheses: List[Hypothesis],

encoder_output: torch.Tensor,

prefix_alpha: int,

) → List[Hypothesis]

执行前缀搜索并就地更新假设的分数。基于 https://arxiv.org/pdf/1211.3711.pdf。

参数:

• hypotheses – 按长度从最长到最短排序的假设列表。

• encoder_output – 编码器输出。

• prefix_alpha – 假设与前缀之间允许的最大长度差异。

返回:

具有更新分数的假设列表。

返回类型:

hypotheses

set_decoding_type(decoding_type: str)

设置解码类型。请查看 scripts/asr_language_modeling/ 中的 train_kenlm.py 以了解为什么我们需要 :param decoding_type: 解码类型

sort_nbest(

hyps: List[Hypothesis],

) → List[Hypothesis]

按分数或给定序列长度的分数对假设进行排序。

参数:

hyps – 假设列表

返回:

排序后的假设列表

返回类型:

hyps

假设

class nemo.collections.asr.parts.utils.rnnt_utils.Hypothesis(

score: float,

y_sequence: ~typing.List[int] | torch.Tensor,

text: str | None = None,

dec_out: ~typing.List[torch.Tensor] | None = None,

dec_state: ~typing.List[~typing.List[torch.Tensor]] | ~typing.List[torch.Tensor] | None = None,

timestamp: ~typing.List[int] | torch.Tensor = <factory>,

alignments: ~typing.List[int] | ~typing.List[~typing.List[int]] | None = None,

frame_confidence: ~typing.List[float] | ~typing.List[~typing.List[float]] | None = None,

token_confidence: ~typing.List[float] | None = None,

word_confidence: ~typing.List[float] | None = None,

length: int | torch.Tensor = 0,

y: ~typing.List[torch.tensor] | None = None,

lm_state: ~typing.Dict[str,

~typing.Any] | ~typing.List[~typing.Any] | None = None,

lm_scores: torch.Tensor | None = None,

ngram_lm_state: ~typing.Dict[str,

~typing.Any] | ~typing.List[~typing.Any] | None = None,

tokens: ~typing.List[int] | torch.Tensor | None = None,

last_token: torch.Tensor | None = None,

token_duration: ~typing.List[int] | None = None,

last_frame: int | None = None,

)

基类：object

用于波束搜索算法的 Hypothesis 类。

score: 从 AbstractRNNTDecoder 模块的 score_hypothesis 方法获得的浮点分数。

y_sequence: 指向某些词汇表的整数 ID 序列，或以相同方式运行的打包 torch.Tensor。后一种情况下的 dtype 必须是 torch.Long。

behaving in the same manner. dtype must be torch.Long in the latter case.

dec_state: LSTM-RNN 解码器状态的列表（或列表的列表）。可以为 None。

text: (可选) 通过 CTC / RNN-T 解码（删除 CTC/RNNT

blank token，并可选地合并 word-piece）后解码的字符串。应用作词错误率计算的解码字符串。

timestamp: (可选) 表示 token 出现在解码过程中的哪个索引的整数索引列表。应与非空白符 token 的数量长度相同。

process did the token appear. Should be of same length as the number of non-blank tokens.

alignments: (可选) 表示 CTC / RNNT token 对齐，作为沿时间轴 T（对于 CTC）或时间 x 目标 (TxU) 的整数 token。对于 CTC，表示为整数索引的单个列表。对于 RNNT，表示为整数索引的列表的悬空列表。外层列表表示时间维度 (T)，内层列表表示目标维度 (U)。有效索引集**包括** CTC / RNNT 空白符 token，以便表示对齐。

time T (for CTC) or Time x Target (TxU). For CTC, represented as a single list of integer indices. For RNNT, represented as a dangling list of list of integer indices. Outer list represents Time dimension (T), inner list represents Target dimension (U). The set of valid indices includes the CTC / RNNT blank token in order to represent alignments.

frame_confidence: (可选) 表示 CTC / RNNT 每帧置信度分数，作为 token 概率

沿时间轴 T（对于 CTC）或时间 x 目标 (TxU)。对于 CTC，表示为浮点数索引的单个列表。对于 RNNT，表示为浮点数索引的列表的悬空列表。外层列表表示时间维度 (T)，内层列表表示目标维度 (U)。

token_confidence: (可选) 表示 CTC / RNNT 每 token 置信度分数，作为 token 概率

沿目标轴 U。表示为浮点数索引的单个列表。

word_confidence: (可选) 表示 CTC / RNNT 每词置信度分数，作为 token 概率

沿目标轴 U。表示为浮点数索引的单个列表。

length: 表示序列的长度（原始长度，不含填充），否则

默认为 0。

y: (未使用) 表示假设列表的 torch.Tensor 列表。

lm_state: (未使用) 外部语言模型使用的字典状态缓存。

lm_scores: (未使用) 外部语言模型的分数。

ngram_lm_state: (可选) 外部 n-gram 语言模型的状态。

tokens: (可选) 解码 token 列表（可以是字符或 word-piece）。

last_token (可选): 在最后一步预测的 token 或 token 批次。

last_frame (可选): 假设更新的最后一个解码步骤的索引，包括空白符 token 预测。

class nemo.collections.asr.parts.utils.rnnt_utils.NBestHypotheses(

n_best_hypotheses: List[Hypothesis] | None,

)

基类：object

N-best 假设列表

Adapter 网络

class nemo.collections.asr.parts.submodules.adapters.multi_head_attention_adapter_module.MultiHeadAttentionAdapter(*args: Any, **kwargs: Any)

Bases: MultiHeadAttention, AdapterModuleUtil

Transformer 的多头注意力层。

参数:

• n_head (int) – 头数

• n_feat (int) – 特征大小

• dropout_rate (float) – dropout 率

• proj_dim – 用于在计算注意力之前进行投影的可选整数值。如果为 None，则没有投影（等效于 proj_dim = n_feat）。如果 > 0，则在计算注意力之前将 n_feat 投影到 proj_dim。如果 <0，则将等于 n_head，以便每个头部的投影维度为 1。

forward(

query,

key,

value,

mask,

pos_emb=None,

cache=None,

)

计算“缩放点积注意力”。 :param query: (batch, time1, size) :type query: torch.Tensor :param key: (batch, time2, size) :type key: torch.Tensor :param value: (batch, time2, size) :type value: torch.Tensor :param mask: (batch, time1, time2) :type mask: torch.Tensor :param cache: (batch, time_cache, size) :type cache: torch.Tensor

返回:

由 query 点积 key 注意力加权的转换后的 value (batch, time1, d_model) cache (torch.Tensor) : (batch, time_cache_next, size)

返回类型:

output (torch.Tensor)

get_default_strategy_config() → dataclass

返回默认的 adapter 模块策略。

---

class nemo.collections.asr.parts.submodules.adapters.multi_head_attention_adapter_module.RelPositionMultiHeadAttentionAdapter(*args: Any, **kwargs: Any)

Bases: RelPositionMultiHeadAttention, AdapterModuleUtil

Transformer-XL 的多头注意力层，支持相对位置编码。论文： https://arxiv.org/abs/1901.02860

参数:

• n_head (int) – 头数

• n_feat (int) – 特征大小

• dropout_rate (float) – dropout 率

• proj_dim (int, optional) – 用于在计算注意力之前进行投影的可选整数值。如果为 None，则没有投影（等效于 proj_dim = n_feat）。如果 > 0，则在计算注意力之前将 n_feat 投影到 proj_dim。如果 <0，则将等于 n_head，以便每个头部的投影维度为 1。

• adapter_strategy – 默认情况下，MHAResidualAddAdapterStrategyConfig。adapter 组合函数对象。

forward(

query,

key,

value,

mask,

pos_emb,

cache=None,

)

计算带有相对位置编码的“缩放点积注意力”。 :param query: (batch, time1, size) :type query: torch.Tensor :param key: (batch, time2, size) :type key: torch.Tensor :param value: (batch, time2, size) :type value: torch.Tensor :param mask: (batch, time1, time2) :type mask: torch.Tensor :param pos_emb: (batch, time1, size) :type pos_emb: torch.Tensor :param cache: (batch, time_cache, size) :type cache: torch.Tensor

返回:

由 query 点积 key 注意力 cache_next 加权的转换后的 value (batch, time1, d_model) (torch.Tensor) : (batch, time_cache_next, size)

返回类型:

output (torch.Tensor)

get_default_strategy_config() → dataclass

返回默认的 adapter 模块策略。

---

class nemo.collections.asr.parts.submodules.adapters.multi_head_attention_adapter_module.PositionalEncodingAdapter(*args: Any, **kwargs: Any)

Bases: PositionalEncoding, AdapterModuleUtil

绝对位置编码 adapter。

注

绝对位置嵌入值被添加到输入张量，不带残差连接！ 因此，如果您只需要位置嵌入，输入就会被更改，请丢弃返回的 x！

参数:

• d_model (int) – x 的输入维度。

• max_len (int) – 最大序列长度。

• xscale (float) – 输入缩放因子。默认为 1.0。

• adapter_strategy (AbstractAdapterStrategy) – 默认情况下为 ReturnResultAdapterStrategyConfig。一个适配器组合函数对象。 注意：由于这是位置编码，它不会添加残差！

get_default_strategy_config() → dataclass

返回默认的 adapter 模块策略。

---

class nemo.collections.asr.parts.submodules.adapters.multi_head_attention_adapter_module.RelPositionalEncodingAdapter(*args: Any, **kwargs: Any)

基类： RelPositionalEncoding, AdapterModuleUtil

TransformerXL 层的相对位置编码。 参见：附录 B，https://arxiv.org/abs/1901.02860

注

相对位置嵌入值 不 被添加到输入张量！ 因此，如果您只需要位置嵌入，输入应该被更新更改，请丢弃返回的 x！

参数:

• d_model (int) – 嵌入维度

• max_len (int) – 最大输入长度

• xscale (bool) – 是否按 sqrt(d_model) 缩放输入

• adapter_strategy – 默认情况下为 ReturnResultAdapterStrategyConfig。 一个适配器组合函数对象。

get_default_strategy_config() → dataclass

返回默认的 adapter 模块策略。

适配器策略

class nemo.collections.asr.parts.submodules.adapters.multi_head_attention_adapter_module.MHAResidualAddAdapterStrategy(

stochastic_depth: float = 0.0,

l2_lambda: float = 0.0,

)

基类： ResidualAddAdapterStrategy

MHA 适配器的适配器模块与其输入的残差加法的实现。

forward(

input: dict,

adapter: torch.nn.Module,

*,

module: AdapterModuleMixin,

)

一个基本策略，包括在底层适配器进行前向传递后，对输入进行残差连接。 额外的工作是打包和解包输入和输出的字典。

注意： `value` 张量作为残差连接被添加到 attention 适配器的输出中。

参数:

• input –

  适配器模块的多个输入参数的字典。

  query、key、value：模块的原始输出张量，或

  前一个适配器的输出（如果启用了多个适配器）。

  mask：注意力掩码。

  pos_emb：相对编码的可选位置嵌入。

• adapter – 当前需要执行前向传递的适配器模块。

• module – 调用模块，完整形式。 它是一个实现了 `AdapterModuleMixin` 的模块，因此该策略可以通过 `module.adapter_layer` 访问此模块中的所有其他适配器。

返回:

结果张量，在一个活动的适配器完成其前向传递之后。

compute_output(

input: torch.Tensor,

adapter: torch.nn.Module,

*,

module: AdapterModuleMixin,

) → torch.Tensor

计算单个适配器对某些输入的输出。

参数:

• input – 模块的原始输出张量，或前一个适配器的输出（如果启用了多个适配器）。

• adapter – 当前需要执行前向传递的适配器模块。

• module – 调用模块，完整形式。 它是一个实现了 `AdapterModuleMixin` 的模块，因此该策略可以通过 `module.adapter_layer` 访问此模块中的所有其他适配器。

返回:

结果张量，在一个活动的适配器完成其前向传递之后。