目录
目录

torchaudio.models

models 子包包含用于解决常见音频任务的模型定义。

Conformer

class torchaudio.models.Conformer(input_dim: int, num_heads: int, ffn_dim: int, num_layers: int, depthwise_conv_kernel_size: int, dropout: float = 0.0, use_group_norm: bool = False, convolution_first: bool = False)[source]

实现了在论文 Conformer: Convolution-augmented Transformer for Speech Recognition [1]中提出的 Conformer 架构。

Parameters

  • input_dim (int) – 输入维度。

  • num_heads (int) – 每个 Conformer 层中的注意力头数量。

  • ffn_dim (int) – 前馈网络的隐藏层维度。

  • num_layers (int) – 要实例化的 Conformer 层数。

  • depthwise_conv_kernel_size (int) – 每个 Conformer 层深度卷积层的核大小。

  • dropout (float, optional) – dropout 概率。（默认值：0.0）

  • use_group_norm (bool, optional) – 在卷积模块中使用 GroupNorm 而不是 BatchNorm1d（默认值：False）

  • convolution_first (bool, optional) – 在注意力模块之前应用卷积模块。（默认值：False）

示例

>>> conformer = Conformer(
>>>     input_dim=80,
>>>     num_heads=4,
>>>     ffn_dim=128,
>>>     num_layers=4,
>>>     depthwise_conv_kernel_size=31,
>>> )
>>> lengths = torch.randint(1, 400, (10,))  # (batch,)
>>> input = torch.rand(10, int(lengths.max()), input_dim)  # (batch, num_frames, input_dim)
>>> output = conformer(input, lengths)
forward(input: torch.Tensor, lengths: torch.Tensor) → Tuple[torch.Tensor, torch.Tensor][source]
Parameters

  • input (torch.Tensor) – 形状为 (B, T, input_dim)。

  • lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 input 中第 i 个批次元素的有效帧数。

Returns

(torch.Tensor, torch.Tensor)
torch.Tensor

输出帧，形状为 (B, T, input_dim)

torch.Tensor

输出长度，形状为 (B,)，其中第 i 个元素表示输出帧中第 i 个批次元素的有效帧数。

ConvTasNet

class torchaudio.models.ConvTasNet(num_sources: int = 2, enc_kernel_size: int = 16, enc_num_feats: int = 512, msk_kernel_size: int = 3, msk_num_feats: int = 128, msk_num_hidden_feats: int = 512, msk_num_layers: int = 8, msk_num_stacks: int = 3, msk_activate: str = 'sigmoid')[source]

Conv-TasNet：一个全卷积时域音频分离网络 Conv-TasNet：超越理想时频幅度掩蔽的语音分离 [2]。

Parameters

  • num_sources (int, optional) – 要分割的源的数量。

  • enc_kernel_size (int, optional) – 编码器/解码器的卷积核大小，<L>。

  • enc_num_feats (int, optional) – 传递给掩码生成器的特征维度，<N>。

  • msk_kernel_size (int, optional) – 掩码生成器的卷积核大小，<P>。

  • msk_num_feats (int, optional) – 掩码生成器中卷积块的输入/输出特征维度，<B, Sc>。

  • msk_num_hidden_feats (int, optional) – 掩码生成器中卷积块的内部特征维度，<H>。

  • msk_num_layers (int, optional) – 掩码生成器中一个卷积块的层数，<X>。

  • msk_num_stacks (int, optional) – 掩码生成器的卷积块数量，<R>。

  • msk_activate (str, optional) – 掩码输出的激活函数（默认值：sigmoid）。

注意

此实现对应于论文中的“非因果”设置。

forward(input: torch.Tensor) → torch.Tensor[source]

执行源分离。生成音频源波形。

Parameters

input (torch.Tensor) – 形状为 [batch, channel==1, frames] 的 3D 张量

Returns

形状为 [batch, channel==num_sources, frames] 的三维张量

Return type

张量

DeepSpeech

class torchaudio.models.DeepSpeech(n_feature: int, n_hidden: int = 2048, n_class: int = 40, dropout: float = 0.0)[source]

来自《Deep Speech：扩展端到端语音识别》的 DeepSpeech 模型架构 [3]。

Parameters

  • n_feature – 输入特征的数量

  • n_hidden – 内部隐藏单元大小。

  • n_class – 输出类别的数量

forward(x: torch.Tensor) → torch.Tensor[source]
Parameters

x (torch.Tensor) – 维度为 (batch, channel, time, feature) 的张量。

Returns

维度为 (batch, time, class) 的预测张量。

Return type

张量

Emformer

class torchaudio.models.Emformer(input_dim: int, num_heads: int, ffn_dim: int, num_layers: int, segment_length: int, dropout: float = 0.0, activation: str = 'relu', left_context_length: int = 0, right_context_length: int = 0, max_memory_size: int = 0, weight_init_scale_strategy: Optional[str] = 'depthwise', tanh_on_mem: bool = False, negative_inf: float = - 100000000.0)[source]

实现了在论文 Emformer: Efficient Memory Transformer Based Acoustic Model for Low Latency Streaming Speech Recognition 中介绍的 Emformer 架构 [4]。

Parameters

  • input_dim (int) – 输入维度。

  • num_heads (int) – 每个 Emformer 层中的注意力头数量。

  • ffn_dim (int) – 每个 Emformer 层前馈网络的隐藏层维度。

  • num_layers (int) – 要实例化的 Emformer 层数。

  • segment_length (int) – 每个输入片段的长度。

  • dropout (float, optional) – dropout 概率。（默认值：0.0）

  • activation (str, optional) – 每个 Emformer 层的前馈网络中使用的激活函数。必须是（“relu”, “gelu”, “silu”）之一。（默认值：“relu”）

  • left_context_length (int, optional) – 左侧上下文长度。（默认值：0）

  • right_context_length (int, optional) – 右侧上下文的长度。（默认值：0）

  • max_memory_size (int, optional) – 要使用的内存元素的最大数量。（默认值：0）

  • weight_init_scale_strategy (str 或 None, 可选) – 每层权重初始化缩放策略。必须是以下之一（“depthwise”，“constant”，None）。（默认值：“depthwise”）

  • tanh_on_mem (bool, optional) – 如果为 True，则对记忆元素应用 tanh。（默认值：False）

  • negative_inf (float, optional) – 在注意力权重中用于表示负无穷大的值。（默认值：-1e8）

示例

>>> emformer = Emformer(512, 8, 2048, 20, 4, right_context_length=1)
>>> input = torch.rand(128, 400, 512)  # batch, num_frames, feature_dim
>>> lengths = torch.randint(1, 200, (128,))  # batch
>>> output, lengths = emformer(input, lengths)
>>> input = torch.rand(128, 5, 512)
>>> lengths = torch.ones(128) * 5
>>> output, lengths, states = emformer.infer(input, lengths, None)
forward(input: torch.Tensor, lengths: torch.Tensor) → Tuple[torch.Tensor, torch.Tensor]

用于训练和非流式推理的前向传播。

B：批次大小； T：批次中最大输入帧数； D：每帧的特征维度。

Parameters

  • input (torch.Tensor) – 使用右侧上下文帧进行右填充的语句帧，形状为 (B, T + right_context_length, D)。

  • lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 input 中第 i 个批次元素的有效语音帧数。

Returns

Tensor

输出帧，形状为 (B, T, D)。

Tensor

输出长度，形状为 (B,)，其中第 i 个元素表示输出帧中第 i 个批次元素的有效帧数。

Return type

(张量，张量)

infer(input: torch.Tensor, lengths: torch.Tensor, states: Optional[List[List[torch.Tensor]]] = None) → Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]

流式推理的前向传播。

B：批次大小； D：每帧的特征维度。

Parameters

  • input (torch.Tensor) – 使用右侧上下文帧进行右填充的语句帧，形状为 (B, segment_length + right_context_length, D)。

  • lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 input 中第 i 个批次元素的有效帧数。

  • states (List[List[torch.Tensor]] or None, optional) – 表示在前一次调用 infer 中生成的内部状态的张量列表的列表。（默认值：None）

Returns

Tensor

输出帧，形状为 (B, segment_length, D)。

Tensor

输出长度，形状为 (B,)，其中第 i 个元素表示输出帧中第 i 个批次元素的有效帧数。

List[List[Tensor]]

输出状态；表示在当前调用 infer 中生成的内部状态的张量列表的列表。

Return type

(张量，张量，列表[列表[张量]])

RNN-T

模型

RNNT

class torchaudio.models.RNNT[source]

循环神经网络转换器（RNN-T）模型。

注意

要构建模型，请使用其中一个工厂函数。

Parameters
forward(sources: torch.Tensor, source_lengths: torch.Tensor, targets: torch.Tensor, target_lengths: torch.Tensor, predictor_state: Optional[List[List[torch.Tensor]]] = None) → Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[List[torch.Tensor]]][source]

训练的前向传播。

B：批次大小； T：批次中源序列的最大长度； U：批次中目标序列的最大长度； D：每个源序列元素的特征维度。

Parameters

  • sources (torch.Tensor) – 右侧填充了右上下文的源帧序列，形状为 (B, T, D)。

  • source_lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 sources 中第 i 个批次元素的有效帧数。

  • targets (torch.Tensor) – 目标序列，形状为 (B, U)，且每个元素映射到一个目标符号。

  • target_lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 targets 中第 i 个批次元素的有效帧数。

  • predictor_state (List[List[torch.Tensor]] or None, optional) – 表示在前一次调用 forward 时生成的预测网络内部状态的张量列表的列表。（默认值：None）

Returns

torch.Tensor

联合网络输出，形状为 (B, max output source length, max output target length, output_dim (number of target symbols))。

torch.Tensor

输出源长度，形状为 (B,)，其中第 i 个元素表示联合网络输出中第 i 个批次元素沿维度 1 的有效元素数量。

torch.Tensor

输出目标长度，形状为 (B,)，其中第 i 个元素表示联合网络输出中第 i 个批次元素沿维度 2 的有效元素数量。

List[List[torch.Tensor]]

输出状态；张量列表的列表，表示在当前调用 forward 中生成的预测网络内部状态。

Return type

(torch.Tensor, torch.Tensor, torch.Tensor, List[List[torch.Tensor]])

transcribe_streaming(sources: torch.Tensor, source_lengths: torch.Tensor, state: Optional[List[List[torch.Tensor]]]) → Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]][source]

以流式模式将转录网络应用于源数据。

B：批次大小； T：批次中源序列片段的最大长度； D：每个源序列帧的特征维度。

Parameters

  • sources (torch.Tensor) – 使用右侧上下文右填充的源帧序列片段，形状为 (B, T + right context length, D)。

  • source_lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 sources 中第 i 个批次元素的有效帧数。

  • state (List[List[torch.Tensor]] or None) – 表示在前一次调用 transcribe_streaming 中生成的转录网络内部状态的张量列表的列表。

Returns

torch.Tensor

输出帧序列，形状为 (B, T // time_reduction_stride, output_dim)。

torch.Tensor

输出长度，形状为 (B,)，其中第 i 个元素表示输出中第 i 个批次元素的有效元素数量。

List[List[torch.Tensor]]

输出状态；张量列表的列表，表示在当前调用 transcribe_streaming 中生成的转录网络内部状态。

Return type

(torch.Tensor, torch.Tensor, List[List[torch.Tensor]])

transcribe(sources: torch.Tensor, source_lengths: torch.Tensor) → Tuple[torch.Tensor, torch.Tensor][source]

在非流式模式下将转录网络应用于源数据。

B：批次大小； T：批次中源序列的最大长度； D：每个源序列帧的特征维度。

Parameters

  • sources (torch.Tensor) – 右侧填充了右上下文的源帧序列，形状为 (B, T + right context length, D)。

  • source_lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 sources 中第 i 个批次元素的有效帧数。

Returns

torch.Tensor

输出帧序列，形状为 (B, T // time_reduction_stride, output_dim)。

torch.Tensor

输出长度，形状为 (B,)，其中第 i 个元素表示输出帧序列中第 i 个批次元素的有效元素数量。

Return type

(torch.Tensor, torch.Tensor)

predict(targets: torch.Tensor, target_lengths: torch.Tensor, state: Optional[List[List[torch.Tensor]]]) → Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]][source]

将预测网络应用于目标。

B：批次大小； U：批次中目标序列的最大长度； D：每个目标序列帧的特征维度。

Parameters

  • targets (torch.Tensor) – 目标序列，形状为 (B, U)，且每个元素映射到一个目标符号，即范围在 [0, num_symbols) 内。

  • target_lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 targets 中第 i 个批次元素的有效帧数。

  • state (List[List[torch.Tensor]] or None) – 张量列表的列表，表示在前一次调用 predict 时生成的内部状态。

Returns

torch.Tensor

输出帧序列，形状为 (B, U, output_dim)。

torch.Tensor

输出长度，形状为 (B,)，其中第 i 个元素表示输出中第 i 个批次元素的有效元素数量。

List[List[torch.Tensor]]

输出状态；表示在 predict 的当前调用中生成的内部状态的张量列表的列表。

Return type

(torch.Tensor, torch.Tensor, List[List[torch.Tensor]])

join(source_encodings: torch.Tensor, source_lengths: torch.Tensor, target_encodings: torch.Tensor, target_lengths: torch.Tensor) → Tuple[torch.Tensor, torch.Tensor, torch.Tensor][source]

将联合网络应用于源编码和目标编码。

B：批次大小； T：批次中源序列的最大长度； U：批次中目标序列的最大长度； D：每个源和目标序列编码的维度。

Parameters

  • source_encodings (torch.Tensor) – 源编码序列，形状为 (B, T, D)。

  • source_lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 source_encodings 中第 i 个批次元素的有效序列长度。

  • target_encodings (torch.Tensor) – 目标编码序列，形状为 (B, U, D)。

  • target_lengths (torch.Tensor) – 形状为 (B,)，其中第 i 个元素表示 target_encodings 中第 i 个批次元素的有效序列长度。

Returns

torch.Tensor

联合网络输出，形状为 (B, T, U, output_dim)。

torch.Tensor

输出源长度，形状为 (B,)，其中第 i 个元素表示联合网络输出中第 i 个批次元素沿维度 1 的有效元素数量。

torch.Tensor

输出目标长度，形状为 (B,)，其中第 i 个元素表示联合网络输出中第 i 个批次元素沿维度 2 的有效元素数量。

Return type

(torch.Tensor, torch.Tensor, torch.Tensor)

工厂函数

emformer_rnnt_model

torchaudio.models.emformer_rnnt_model(*, input_dim: int, encoding_dim: int, num_symbols: int, segment_length: int, right_context_length: int, time_reduction_input_dim: int, time_reduction_stride: int, transformer_num_heads: int, transformer_ffn_dim: int, transformer_num_layers: int, transformer_dropout: float, transformer_activation: str, transformer_left_context_length: int, transformer_max_memory_size: int, transformer_weight_init_scale_strategy: str, transformer_tanh_on_mem: bool, symbol_embedding_dim: int, num_lstm_layers: int, lstm_layer_norm: bool, lstm_layer_norm_epsilon: float, lstm_dropout: float) → torchaudio.models.rnnt.RNNT[source]

构建基于 Emformer 的循环神经网络转换器（RNN-T）模型。

注意

对于非流式推理，期望在输入序列右侧拼接 right_context_length 帧后调用 transcribe。

对于流式推理，期望对包含 segment_length 帧的输入块调用 transcribe_streaming，这些块与右侧拼接的 right_context_length 帧相连。

Parameters

  • input_dim (int) – 传递给转录网络的输入序列帧的维度。

  • encoding_dim (int) – 传递给联合网络的由转录网络和预测网络生成的编码的维度。

  • num_symbols (int) – 目标 token 集合的基数。

  • segment_length (int) – 以帧数表示的输入片段长度。

  • right_context_length (int) – 以帧数表示的右侧上下文长度。

  • time_reduction_input_dim (int) – 在应用时间缩减块之前，将输入序列中的每个元素缩放到的维度。

  • time_reduction_stride (int) – 用于缩短输入序列长度的因子。

  • transformer_num_heads (int) – 每个 Emformer 层中的注意力头数量。

  • transformer_ffn_dim (int) – 每个 Emformer 层前馈网络的隐藏层维度。

  • transformer_num_layers (int) – 要实例化的 Emformer 层数。

  • transformer_left_context_length (int) – Emformer 考虑的左侧上下文长度。

  • transformer_dropout (float) – Emformer 丢弃概率。

  • transformer_activation (str) – 每个 Emformer 层的前馈网络中使用的激活函数。必须是（"relu", "gelu", "silu"）之一。

  • transformer_max_memory_size (int) – 要使用的最大内存元素数量。

  • transformer_weight_init_scale_strategy (str) – 每层权重初始化缩放策略。必须是以下之一（“depthwise”，“constant”，None）。

  • transformer_tanh_on_mem (布尔值) – 如果 True，则对内存元素应用 tanh。

  • symbol_embedding_dim (int) – 每个目标 token 嵌入的维度。

  • num_lstm_layers (int) – 要实例化的 LSTM 层数。

  • lstm_layer_norm (bool) – 如果 True，则为 LSTM 层启用层归一化。

  • lstm_layer_norm_epsilon (float) – 在 LSTM 层归一化层中使用的 epsilon 值。

  • lstm_dropout (float) – LSTM 丢弃概率。

Returns

Emformer RNN-T 模型。

Return type

RNNT

emformer_rnnt_base

torchaudio.models.emformer_rnnt_base(num_symbols: int) → torchaudio.models.rnnt.RNNT[source]

构建 Emformer RNN-T 模型的基础版本。

Parameters

num_symbols (int) – 目标标记词典的大小。

Returns

Emformer RNN-T 模型。

Return type

RNNT

解码器

RNNTBeamSearch

class torchaudio.models.RNNTBeamSearch(model: torchaudio.models.rnnt.RNNT, blank: int, temperature: float = 1.0, hypo_sort_key: Optional[Callable[[Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float]], float]] = None, step_max_tokens: int = 100)[source]

用于 RNN-T 模型的束搜索解码器。

Parameters

  • model (RNNT) – 要使用的 RNN-T 模型。

  • blank (int) – 词汇表中空白标记的索引。

  • temperature (float, optional) – 应用于联合网络输出的温度值。 较大的值会产生更均匀的样本。（默认值：1.0）

  • hypo_sort_key (Callable[[Hypothesis], float] or None, optional) – 用于计算给定假设分数的可调用对象，以便对假设进行排序。如果为 None，则默认为返回按标记序列长度归一化的假设分数的可调用对象。（默认值：None）

  • step_max_tokens (int, optional) – 每个输入时间步生成的最大令牌数。（默认值：100）

Tutorials using RNNTBeamSearch:
forward(input: torch.Tensor, length: torch.Tensor, beam_width: int) → List[Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float]][source]

对给定的输入序列执行束搜索。

T：帧数； D：每帧的特征维度。

Parameters

  • input (torch.Tensor) – 输入帧序列，形状为 (T, D) 或 (1, T, D)。

  • length (torch.Tensor) – 输入序列中有效帧的数量，形状为 () 或 (1,)。

  • beam_width (int) – 搜索过程中使用的束宽。

Returns

beam search 找到的前beam_width个假设。

Return type

List[Hypothesis]

infer(input: torch.Tensor, length: torch.Tensor, beam_width: int, state: Optional[List[List[torch.Tensor]]] = None, hypothesis: Optional[Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float]] = None) → Tuple[List[Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float]], List[List[torch.Tensor]]][source]

以流式模式对给定的输入序列执行束搜索。

T：帧数； D：每帧的特征维度。

Parameters

  • input (torch.Tensor) – 输入帧序列，形状为 (T, D) 或 (1, T, D)。

  • length (torch.Tensor) – 输入序列中有效帧的数量，形状为 () 或 (1,)。

  • beam_width (int) – 搜索过程中使用的束宽。

  • state (List[List[torch.Tensor]] or None, optional) – 表示在前一次调用中生成的转录网络内部状态的张量列表的列表。 （默认值：None）

  • hypothesis (Hypothesis 或 None) – 来自前一次调用的假设，用于播种搜索。（默认值：None）

Returns

List[Hypothesis]

beam search 找到的前beam_width个假设。

List[List[torch.Tensor]]

表示转录网络内部状态的张量列表的列表，该状态在当前调用中生成。

Return type

(List[Hypothesis], List[List[torch.Tensor]])

假设

torchaudio.models.Hypothesis

由 RNN-T 束搜索解码器生成的假设，表示为 (tokens, prediction network output, prediction network state, score) 元组。

Tuple[List[int], torch.Tensor, List[List[torch.Tensor]], float] 的别名

Tacotron2

class torchaudio.models.Tacotron2(mask_padding: bool = False, n_mels: int = 80, n_symbol: int = 148, n_frames_per_step: int = 1, symbol_embedding_dim: int = 512, encoder_embedding_dim: int = 512, encoder_n_convolution: int = 3, encoder_kernel_size: int = 5, decoder_rnn_dim: int = 1024, decoder_max_step: int = 2000, decoder_dropout: float = 0.1, decoder_early_stopping: bool = True, attention_rnn_dim: int = 1024, attention_hidden_dim: int = 128, attention_location_n_filter: int = 32, attention_location_kernel_size: int = 31, attention_dropout: float = 0.1, prenet_dim: int = 256, postnet_n_convolution: int = 5, postnet_kernel_size: int = 5, postnet_embedding_dim: int = 512, gate_threshold: float = 0.5)[source]

基于来自 Nvidia的实现构建的 Tacotron2 模型。

原始实现在论文《通过条件化 WaveNet 于 Mel 频谱预测实现自然 TTS 合成》中提出 [5]。

Parameters

  • mask_padding (bool, optional) – 使用掩码填充（默认值：False）。

  • n_mels (int, optional) – Mel 分箱的数量（默认值：80）。

  • n_symbol (int, optional) – 输入文本的符号数量（默认值：148）。

  • n_frames_per_step (int, optional) – 每步处理的帧数，仅支持 1（默认值：1）。

  • symbol_embedding_dim (int, optional) – 输入嵌入维度（默认值：512）。

  • encoder_n_convolution (int, optional) – 编码器卷积的数量（默认值：3）。

  • encoder_kernel_size (int, optional) – 编码器核大小（默认值：5）。

  • encoder_embedding_dim (int, optional) – 编码器嵌入维度（默认值：512）。

  • decoder_rnn_dim (int, optional) – 解码器 LSTM 中的单元数量（默认值：1024）。

  • decoder_max_step (int, optional) – 输出梅尔频谱图的最大数量（默认值：2000）。

  • decoder_dropout (float, optional) – 解码器 LSTM 的 Dropout 概率（默认值：0.1）。

  • decoder_early_stopping (bool, optional) – 在所有样本完成后继续解码（默认值：True）。

  • attention_rnn_dim (int, optional) – 注意力 LSTM 中的单元数量（默认值：1024）。

  • attention_hidden_dim (int, optional) – 注意力隐藏表示的维度（默认值：128）。

  • attention_location_n_filter (int, optional) – 注意力模型的过滤器数量（默认值：32）。

  • attention_location_kernel_size (int, optional) – 注意力模型的核大小（默认值：31）。

  • attention_dropout (float, optional) – 注意力 LSTM 的 Dropout 概率（默认值：0.1）。

  • prenet_dim (int, optional) – prenet 层中 ReLU 单元的数量（默认值：256）。

  • postnet_n_convolution (int, optional) – 后网络卷积层数量（默认值：5）。

  • postnet_kernel_size (int, optional) – Postnet 核大小（默认值：5）。

  • postnet_embedding_dim (int, optional) – Postnet 嵌入维度（默认值：512）。

  • gate_threshold (float, optional) – 停止标记的概率阈值（默认值：0.5）。

Tutorials using Tacotron2:
forward(tokens: torch.Tensor, token_lengths: torch.Tensor, mel_specgram: torch.Tensor, mel_specgram_lengths: torch.Tensor) → Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor][source]

将输入通过 Tacotron2 模型。这处于教师强制模式，通常用于训练。

输入 tokens 应使用零填充至最大长度 token_lengths。 输入 mel_specgram 应使用零填充至最大长度 mel_specgram_lengths。

Parameters

  • tokens (Tensor) – 输入到 Tacotron2 的 token，形状为 (n_batch, max of token_lengths)。

  • token_lengths (Tensor) – tokens 中每个样本的有效长度，形状为 (n_batch, )。

  • mel_specgram (Tensor) – 目标梅尔频谱图，形状为 (n_batch, n_mels, max of mel_specgram_lengths)。

  • mel_specgram_lengths (Tensor) – 每个梅尔频谱图的长度，形状为 (n_batch, )。

Returns

Tensor

Postnet 之前的梅尔频谱图，形状为 (n_batch, n_mels, max of mel_specgram_lengths)。

Tensor

经过 Postnet 处理后的梅尔频谱图，形状为 (n_batch, n_mels, max of mel_specgram_lengths)。

Tensor

每个时间步停止 token 的输出，形状为 (n_batch, max of mel_specgram_lengths)。

Tensor

来自解码器的注意力权重序列，形状为 (n_batch, max of mel_specgram_lengths, max of token_lengths)。

Return type

[张量，张量，张量，张量]

infer(tokens: torch.Tensor, lengths: Optional[torch.Tensor] = None) → Tuple[torch.Tensor, torch.Tensor, torch.Tensor][source]

使用 Tacotron2 进行推理。输入是一批编码后的句子 (tokens) 及其对应的长度 (lengths)。输出是生成的梅尔频谱图、其对应的长度以及来自解码器的注意力权重。

输入 tokens 应使用零填充至最大长度 lengths。

Parameters

  • tokens (Tensor) – 输入到 Tacotron2 的 token，形状为 (n_batch, max of lengths)。

  • lengths (Tensor 或 None, 可选) – tokens 中每个样本的有效长度，形状为 (n_batch, )。 如果为 None，则假设所有标记均有效。默认值：None

Returns

Tensor

预测的梅尔频谱图，形状为 (n_batch, n_mels, max of mel_specgram_lengths)。

Tensor

预测的 mel 频谱图的长度，形状为 (n_batch, )。

Tensor

来自解码器的注意力权重序列，形状为 (n_batch, max of mel_specgram_lengths, max of lengths)。

Return type

(张量，张量，张量)

Wav2Letter

class torchaudio.models.Wav2Letter(num_classes: int = 40, input_type: str = 'waveform', num_features: int = 1)[source]

来自 Wav2Letter：一种基于端到端卷积神经网络的语音识别系统 [6] 的 Wav2Letter 模型架构。

\(\text{padding} = \frac{\text{ceil}(\text{kernel} - \text{stride})}{2}\)

Parameters

  • num_classes (int, optional) – 要分类的类别数量。（默认值：40）

  • input_type (str, optional) – Wav2Letter 可以使用以下输入：waveform、power_spectrum或 mfcc（默认值：waveform）。

  • num_features (int, optional) – 网络将接收的输入特征数量（默认值：1）。

forward(x: torch.Tensor) → torch.Tensor[source]
Parameters

x (torch.Tensor) – 维度为 (batch_size, num_features, input_length) 的张量。

Returns

维度为 (batch_size, number_of_classes, input_length) 的预测张量。

Return type

张量

Wav2Vec2.0 / HuBERT

模型

Wav2Vec2Model

class torchaudio.models.Wav2Vec2Model(feature_extractor: torch.nn.Module, encoder: torch.nn.Module, aux: Optional[torch.nn.Module] = None)[source]

在 wav2vec 2.0 [7] 中使用的编码器模型。

注意

要构建模型，请使用其中一个工厂函数。

Parameters

  • feature_extractor (torch.nn.Module) – 从原始音频 Tensor 中提取特征向量的特征提取器。

  • encoder (torch.nn.Module) – 编码器，将音频特征转换为标签上的概率分布序列（以负对数似然表示）。

  • aux (torch.nn.Module 或 None, 可选) – 辅助模块。如果提供，编码器的输出将传递给此模块。

Tutorials using Wav2Vec2Model:
extract_features(waveforms: torch.Tensor, lengths: Optional[torch.Tensor] = None, num_layers: Optional[int] = None) → Tuple[List[torch.Tensor], Optional[torch.Tensor]][source]

从原始波形中提取特征向量

此操作返回编码器中 Transformer 块中间层的输出列表。

Parameters

  • waveforms (Tensor) – 形状为 (batch, frames) 的音频张量。

  • lengths (Tensor 或 None, 可选) – 指示批次中每个音频的有效长度。 形状：(batch, )。 当 waveforms 包含不同持续时间的音频时， 通过提供 lengths 参数，模型将计算 相应的有效输出长度，并在 transformer 注意力层应用适当的掩码。 如果为 None，则假设整个音频波形 长度均为有效。

  • num_layers (int 或 None, 可选) – 如果提供，则限制要经过的中间层数量。 提供 1 将在经过一个中间层后停止计算。如果不提供，则返回所有中间层的输出。

Returns

List of Tensors

来自请求层的特征。 每个张量的形状为：(batch, time frame, feature dimension)

Tensor or None

如果提供了 lengths 个参数，则返回一个形状为 (batch, ) 的张量。 它表示每个特征张量在时间轴上的有效长度。

Return type

(List[Tensor], Optional[Tensor])

forward(waveforms: torch.Tensor, lengths: Optional[torch.Tensor] = None) → Tuple[torch.Tensor, Optional[torch.Tensor]][source]

计算标签上的概率分布序列。

Parameters

  • waveforms (Tensor) – 形状为 (batch, frames) 的音频张量。

  • lengths (Tensor 或 None, optional) – 指示批次中每个音频的有效长度。 形状：(batch, )。 当 waveforms 包含不同持续时间的音频时， 通过提供 lengths 参数，模型将计算 相应的有效输出长度，并在 Transformer 注意力层应用适当的掩码。 如果为 None，则假设 waveforms 中的音频 均具有有效长度。默认值：None。

Returns

Tensor

标签上的概率分布序列（以 logit 形式）。 形状：(batch, frames, num labels)。

Tensor or None

如果提供了 lengths 个参数，则返回形状为 (batch, ) 的张量。 它表示输出张量在时间轴上的有效长度。

Return type

(张量，可选[张量])

HuBERTPretrainModel

class torchaudio.models.HuBERTPretrainModel(wav2vec2: torchaudio.models.wav2vec2.model.Wav2Vec2Model, mask_generator: torch.nn.modules.module.Module, logit_generator: torch.nn.modules.module.Module, feature_grad_mult: Optional[float])[source]

用于从头训练的 HuBERT 预训练模型。

注意

To build the model, please use one of the factory functions in

[hubert_pretrain_base, hubert_pretrain_large, hubert_pretrain_xlarge].

Parameters

  • feature_extractor (torch.nn.Module) – 从原始音频 Tensor 中提取特征向量的特征提取器。

  • encoder (torch.nn.Module) – 编码器，将音频特征转换为标签上的概率分布序列（以负对数似然表示）。

  • mask_generator (torch.nn.Module) – 掩码生成器，用于在训练期间为掩码预测生成掩码。

  • logit_generator (torch.nn.Module) – 预测掩码和非掩码输入 logits 的 Logit 生成器。

  • feature_grad_mult (float 或 None) – 用于缩放卷积特征提取层梯度的因子。 如果为 None，则特征提取层的梯度不受影响。 该缩放因子不会影响前向传播。

forward(waveforms: torch.Tensor, labels: torch.Tensor, audio_lengths: Optional[torch.Tensor] = None) → Tuple[torch.Tensor, Optional[torch.Tensor]][source]

计算标签上的概率分布序列。

Parameters

  • waveforms (Tensor) – 维度为 [batch, frames] 的音频张量。

  • labels (Tensor) – 预训练的标签。一个维度为 [batch, frames] 的张量。

  • audio_lengths (Tensor 或 None, 可选) – 指示批次中每个音频的有效长度。 形状：[batch, ]。 当 waveforms 包含不同持续时间的音频时， 通过提供 lengths 参数，模型将计算 相应的有效输出长度，并在 Transformer 注意力层应用适当的掩码。 如果为 None，则假设 waveforms 中的所有音频 均具有有效长度。默认值：None。

Returns

Tensor

概率分布（logit）的掩码序列。 形状：(masked_frames, num labels)。

Tensor

未掩码的概率分布序列（以 logit 形式）。 形状：(unmasked_frames, num labels)。

Tensor

用于额外惩罚损失的均值特征。 形状: (1,)。

Return type

(张量，张量，张量)

工厂函数

wav2vec2_model

torchaudio.models.wav2vec2_model(extractor_mode: str, extractor_conv_layer_config: Optional[List[Tuple[int, int, int]]], extractor_conv_bias: bool, encoder_embed_dim: int, encoder_projection_dropout: float, encoder_pos_conv_kernel: int, encoder_pos_conv_groups: int, encoder_num_layers: int, encoder_num_heads: int, encoder_attention_dropout: float, encoder_ff_interm_features: int, encoder_ff_interm_dropout: float, encoder_dropout: float, encoder_layer_norm_first: bool, encoder_layer_drop: float, aux_num_out: Optional[int]) → torchaudio.models.Wav2Vec2Model[source]

构建自定义 Wav2Vec2Model

注意

下面的“特征提取器”对应于原始 fairseq 实现中的 ConvFeatureExtractionModel。 在 wav2vec 2.0 [7] 论文中，这被称为“（卷积）特征编码器”。

下面的“编码器”对应于 TransformerEncoder， 在论文中这被称为“Transformer”。

Parameters

  • extractor_mode (str) –

    特征提取器的工作模式。 有效值为 "group_norm" 或 "layer_norm"。 如果为 "group_norm"，则在第一个卷积块中应用单次归一化。否则，所有卷积块都将具有层归一化。

    此选项对应于 extractor_mode 来自 fairseq。

  • extractor_conv_layer_config (python:integer 元组列表 或 None) –

    特征提取器中卷积层的配置。 卷积配置列表， 即 [(output_channel, kernel_size, stride), ...]

    如果提供了 None，则使用以下默认值。

    [
  (512, 10, 5),
  (512, 3, 2),
  (512, 3, 2),
  (512, 3, 2),
  (512, 3, 2),
  (512, 2, 2),
  (512, 2, 2),
]

    此选项对应于 conv_feature_layers 来自 fairseq。

  • extractor_conv_bias (布尔值) –

    是否在每个卷积运算中包含偏置项。

    此选项对应于 conv_bias 来自 fairseq。

  • encoder_embed_dim (int) –

    编码器中嵌入的维度。

    此选项对应于 encoder_embed_dim 来自 fairseq。

  • encoder_projection_dropout (float) –

    输入特征投影到 encoder_embed_dim 后应用的丢弃概率。

    此选项对应于 dropout_input 来自 fairseq。

  • encoder_pos_conv_kernel (int) –

    卷积位置编码的核大小。

    此选项对应于 conv_pos 来自 fairseq。

  • encoder_pos_conv_groups (int) –

    卷积位置嵌入的组数。

    此选项对应于 conv_pos_groups 来自 fairseq。

  • encoder_num_layers (int) –

    Transformer 块中自注意力层的数量。

    此选项对应于 encoder_layers 来自 fairseq。

  • encoder_num_heads (int) –

    自注意力层中的头数。

    此选项对应于 encoder_attention_heads 来自 fairseq。

  • encoder_attention_dropout (float) –

    在自注意力层中，softmax 之后应用的 dropout 概率。

    此选项对应于 attention_dropout 来自 fairseq。

  • encoder_ff_interm_features (int) –

    前馈层中隐藏特征的维度。

    此选项对应于 encoder_ffn_embed_dim 来自 fairseq。

  • encoder_ff_interm_dropout (float) –

    在全前向层中应用的丢弃概率。

    此选项对应于 activation_dropout 来自 fairseq。

  • encoder_dropout (float) –

    在全前向层末尾应用的 Dropout 概率。

    此选项对应于 dropout 来自 fairseq。

  • encoder_layer_norm_first (布尔值) –

    控制 Transformer 层和每个编码器层中 LayerNorm 的顺序。 如果为 True，在 Transformer 层中，LayerNorm 在特征输入到编码器层之前应用；在编码器层中，两个 LayerNorm 分别应用于自注意力机制之前和之后。 如果为 False，在 Transformer 层中，LayerNorm 在特征输入到编码器层之后应用；在编码器层中，两个 LayerNorm 均应用于自注意力机制之后，分别位于前馈网络之前和之后。

    此选项对应于 layer_norm_first 来自 fairseq。

  • encoder_layer_drop (float) –

    训练期间丢弃每个编码器层的概率。

    此选项对应于 layerdrop 来自 fairseq。

  • aux_num_out (int 或 None) – 如果提供，将在编码器顶部附加一个额外的线性层，可用于微调。

Returns

生成的模型。

Return type

Wav2Vec2Model

wav2vec2_base

torchaudio.models.wav2vec2_base(encoder_projection_dropout: float = 0.1, encoder_attention_dropout: float = 0.1, encoder_ff_interm_dropout: float = 0.1, encoder_dropout: float = 0.1, encoder_layer_drop: float = 0.1, aux_num_out: Optional[int] = None) → torchaudio.models.Wav2Vec2Model[source]

使用“base”架构从 wav2vec 2.0 [7] 构建 Wav2Vec2Model

Parameters
Returns

生成的模型。

Return type

Wav2Vec2Model

wav2vec2_large

torchaudio.models.wav2vec2_large(encoder_projection_dropout: float = 0.1, encoder_attention_dropout: float = 0.1, encoder_ff_interm_dropout: float = 0.1, encoder_dropout: float = 0.1, encoder_layer_drop: float = 0.1, aux_num_out: Optional[int] = None) → torchaudio.models.Wav2Vec2Model[source]

使用“large”架构从 wav2vec 2.0 [7] 构建 Wav2Vec2Model

Parameters
Returns

生成的模型。

Return type

Wav2Vec2Model

wav2vec2_large_lv60k

torchaudio.models.wav2vec2_large_lv60k(encoder_projection_dropout: float = 0.1, encoder_attention_dropout: float = 0.0, encoder_ff_interm_dropout: float = 0.1, encoder_dropout: float = 0.0, encoder_layer_drop: float = 0.1, aux_num_out: Optional[int] = None) → torchaudio.models.Wav2Vec2Model[source]

使用来自 wav2vec 2.0 [7] 的“large lv-60k”架构构建 Wav2Vec2Model

Parameters
Returns

生成的模型。

Return type

Wav2Vec2Model

hubert_base

torchaudio.models.hubert_base(encoder_projection_dropout: float = 0.1, encoder_attention_dropout: float = 0.1, encoder_ff_interm_dropout: float = 0.0, encoder_dropout: float = 0.1, encoder_layer_drop: float = 0.05, aux_num_out: Optional[int] = None) → torchaudio.models.Wav2Vec2Model[source]

使用“base”架构从 HuBERT [8] 构建 HuBERT 模型

Parameters
Returns

生成的模型。

Return type

Wav2Vec2Model

hubert_large

torchaudio.models.hubert_large(encoder_projection_dropout: float = 0.0, encoder_attention_dropout: float = 0.0, encoder_ff_interm_dropout: float = 0.0, encoder_dropout: float = 0.0, encoder_layer_drop: float = 0.0, aux_num_out: Optional[int] = None) → torchaudio.models.Wav2Vec2Model[source]

使用“large”架构从 HuBERT [8] 构建 HuBERT 模型

Parameters
Returns

生成的模型。

Return type

Wav2Vec2Model

hubert_xlarge

torchaudio.models.hubert_xlarge(encoder_projection_dropout: float = 0.0, encoder_attention_dropout: float = 0.0, encoder_ff_interm_dropout: float = 0.0, encoder_dropout: float = 0.0, encoder_layer_drop: float = 0.0, aux_num_out: Optional[int] = None) → torchaudio.models.Wav2Vec2Model[source]

使用“超大”架构从 HuBERT 构建 HuBERT 模型 [8]

Parameters
Returns

生成的模型。

Return type

Wav2Vec2Model

hubert_pretrain_model

torchaudio.models.hubert_pretrain_model(extractor_mode: str, extractor_conv_layer_config: Optional[List[Tuple[int, int, int]]], extractor_conv_bias: bool, encoder_embed_dim: int, encoder_projection_dropout: float, encoder_pos_conv_kernel: int, encoder_pos_conv_groups: int, encoder_num_layers: int, encoder_num_heads: int, encoder_attention_dropout: float, encoder_ff_interm_features: int, encoder_ff_interm_dropout: float, encoder_dropout: float, encoder_layer_norm_first: bool, encoder_layer_drop: float, mask_prob: float, mask_selection: str, mask_other: float, mask_length: int, no_mask_overlap: bool, mask_min_space: int, mask_channel_prob: float, mask_channel_selection: str, mask_channel_other: float, mask_channel_length: int, no_mask_channel_overlap: bool, mask_channel_min_space: int, skip_masked: bool, skip_nomask: bool, num_classes: int, final_dim: int) → torchaudio.models.HuBERTPretrainModel[source]

从头开始构建自定义的 HuBERTPretrainModel 进行训练

注意

下面的“特征提取器”对应于原始 fairseq 实现中的 ConvFeatureExtractionModel。 在 wav2vec 2.0 [7] 论文中，这被称为“（卷积）特征编码器”。

下面的“编码器”对应于 TransformerEncoder， 在论文中这被称为“Transformer”。

Parameters

  • extractor_mode (str) –

    特征提取器的工作模式。 有效值为 "group_norm" 或 "layer_norm"。 如果为 "group_norm"，则在第一个卷积块中应用单次归一化。否则，所有卷积块都将具有层归一化。

    此选项对应于 extractor_mode 来自 fairseq。

  • extractor_conv_layer_config (python:integer 元组列表 或 None) –

    特征提取器中卷积层的配置。 卷积配置列表， 即 [(output_channel, kernel_size, stride), ...]

    如果提供了 None，则使用以下默认值。

    [
  (512, 10, 5),
  (512, 3, 2),
  (512, 3, 2),
  (512, 3, 2),
  (512, 3, 2),
  (512, 2, 2),
  (512, 2, 2),
]

    此选项对应于 conv_feature_layers 来自 fairseq。

  • extractor_conv_bias (布尔值) –

    是否在每个卷积运算中包含偏置项。

    此选项对应于 conv_bias 来自 fairseq。

  • encoder_embed_dim (int) –

    编码器中嵌入的维度。

    此选项对应于 encoder_embed_dim 来自 fairseq。

  • encoder_projection_dropout (float) –

    输入特征投影到 encoder_embed_dim 后应用的丢弃概率。

    此选项对应于 dropout_input 来自 fairseq。

  • encoder_pos_conv_kernel (int) –

    卷积位置编码的核大小。

    此选项对应于 conv_pos 来自 fairseq。

  • encoder_pos_conv_groups (int) –

    卷积位置嵌入的组数。

    此选项对应于 conv_pos_groups 来自 fairseq。

  • encoder_num_layers (int) –

    Transformer 块中自注意力层的数量。

    此选项对应于 encoder_layers 来自 fairseq。

  • encoder_num_heads (int) –

    自注意力层中的头数。

    此选项对应于 encoder_attention_heads 来自 fairseq。

  • encoder_attention_dropout (float) –

    在自注意力层中，softmax 之后应用的 dropout 概率。

    此选项对应于 attention_dropout 来自 fairseq。

  • encoder_ff_interm_features (int) –

    前馈层中隐藏特征的维度。

    此选项对应于 encoder_ffn_embed_dim 来自 fairseq。

  • encoder_ff_interm_dropout (float) –

    在全前向层中应用的丢弃概率。

    此选项对应于 activation_dropout 来自 fairseq。

  • encoder_dropout (float) –

    在全前向层末尾应用的 Dropout 概率。

    此选项对应于 dropout 来自 fairseq。

  • encoder_layer_norm_first (布尔值) –

    控制 Transformer 层和每个编码器层中 LayerNorm 的顺序。 如果为 True，在 Transformer 层中，LayerNorm 在特征输入到编码器层之前应用；在编码器层中，两个 LayerNorm 分别应用于自注意力机制之前和之后。 如果为 False，在 Transformer 层中，LayerNorm 在特征输入到编码器层之后应用；在编码器层中，两个 LayerNorm 均应用于自注意力机制之后，分别位于前馈网络之前和之后。

    此选项对应于 layer_norm_first 来自 fairseq。

  • encoder_layer_drop (float) –

    训练期间丢弃每个编码器层的概率。

    此选项对应于 layerdrop 来自 fairseq。

  • mask_prob (float) –

    每个标记被选为要掩码的跨度起点的概率。该值将乘以时间步数除以掩码跨度的长度，以大约掩码此百分比的所有元素。但由于存在重叠，实际数量会更小（除非 no_overlap 为 True）。

    此选项对应于 mask_prob 来自 fairseq。

  • mask_selection (str) –

    如何选择掩码长度。选项：[static, uniform, normal, poisson]。

    此选项对应于 mask_selection 来自 fairseq。

  • mask_other (float) –

    次要掩码参数（用于更复杂的分布）。

    此选项对应于 mask_other 来自 fairseq。

  • mask_length (int) –

    掩码的长度。

    此选项对应于 mask_length 来自 fairseq。

  • no_mask_overlap (布尔值) –

    是否允许掩码重叠。

    此选项对应于 no_mask_overlap 来自 fairseq。

  • mask_min_space (int) –

    跨度之间的最小间距（如果未启用重叠）。

    此选项对应于 mask_min_space 来自 fairseq。

  • mask_channel_prob –

    (float): 将特征替换为 0 的概率。

    此选项对应于 mask_channel_prob 来自 fairseq。

  • mask_channel_selection (str) –

    如何选择通道掩码的长度。选项：[static, uniform, normal, poisson]。

    此选项对应于 mask_channel_selection 来自 fairseq。

  • mask_channel_other (浮点数) –

    用于通道掩码的次要掩码参数（用于更复杂的分布）。

    此选项对应于 mask_channel_other 来自 fairseq。

  • mask_channel_length (int) –

    通道掩码中跨度之间的最小间距（如果未启用重叠）。

    此选项对应于 mask_channel_length 来自 fairseq。

  • no_mask_channel_overlap (布尔值) –

    是否允许通道掩码重叠。

    此选项对应于 no_mask_channel_overlap 来自 fairseq。

  • mask_channel_min_space (int) –

    通道掩码中跨度之间的最小间距（如果未启用重叠）。

    此选项对应于 mask_channel_min_space 来自 fairseq。

  • skip_masked (bool) –

    如果为 True，则跳过对掩码帧的损失计算。

    此选项对应于 skip_masked 来自 fairseq。

  • skip_nomask (bool) –

    如果为 True，则跳过对未掩码帧的损失计算。

    此选项对应于 skip_nomask 来自 fairseq。

  • num_classes (int) – 标签中的类别数量。

  • final_dim (int) –

    将项目的最终表示和目标投影到 final_dim。

    此选项对应于 final_dim 来自 fairseq。

  • feature_grad_mult (float 或 None) –

    用于缩放卷积特征提取层梯度的因子。 该缩放因子不会影响前向传播过程。

    此选项对应于 feature_grad_mult 来自 fairseq。

Returns

生成的模型。

Return type

HuBERTPretrainModel

hubert_pretrain_base

torchaudio.models.hubert_pretrain_base(encoder_projection_dropout: float = 0.1, encoder_attention_dropout: float = 0.1, encoder_ff_interm_dropout: float = 0.0, encoder_dropout: float = 0.1, encoder_layer_drop: float = 0.05, mask_prob: float = 0.8, mask_channel_prob: float = 0.0, mask_channel_length: int = 10, feature_grad_mult: Optional[float] = 0.1, num_classes: int = 100) → torchaudio.models.HuBERTPretrainModel[source]

使用“base”架构从 HuBERT [8] 构建 HuBERTPretrainModel 模型

Parameters
Returns

生成的模型。

Return type

HuBERTPretrainModel

hubert_pretrain_large

torchaudio.models.hubert_pretrain_large(encoder_projection_dropout: float = 0.0, encoder_attention_dropout: float = 0.0, encoder_ff_interm_dropout: float = 0.0, encoder_dropout: float = 0.0, encoder_layer_drop: float = 0.0, mask_prob: float = 0.8, mask_channel_prob: float = 0.0, mask_channel_length: int = 10, feature_grad_mult: Optional[float] = None) → torchaudio.models.HuBERTPretrainModel[source]

构建 HuBERTPretrainModel 模型，使用“large”架构进行预训练，源自 HuBERT [8]

Parameters
Returns

生成的模型。

Return type

HuBERTPretrainModel

hubert_pretrain_xlarge

torchaudio.models.hubert_pretrain_xlarge(encoder_projection_dropout: float = 0.0, encoder_attention_dropout: float = 0.0, encoder_ff_interm_dropout: float = 0.0, encoder_dropout: float = 0.0, encoder_layer_drop: float = 0.0, mask_prob: float = 0.8, mask_channel_prob: float = 0.0, mask_channel_length: int = 10, feature_grad_mult: Optional[float] = None) → torchaudio.models.HuBERTPretrainModel[source]

构建 HuBERTPretrainModel 模型，用于使用“超大”架构进行预训练，源自 HuBERT [8]

Parameters
Returns

生成的模型。

Return type

HuBERTPretrainModel

实用函数

import_huggingface_model

torchaudio.models.wav2vec2.utils.import_huggingface_model(original: torch.nn.Module) → torchaudio.models.Wav2Vec2Model[source]

从 Hugging Face 的 Transformers 对应的模型对象构建 Wav2Vec2Model。

Parameters

原始 (torch.nn.Module) – Wav2Vec2ForCTC 类的一个实例，来自 transformers。

Returns

已导入模型。

Return type

Wav2Vec2Model

Example
>>> from torchaudio.models.wav2vec2.utils import import_huggingface_model
>>>
>>> original = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = import_huggingface_model(original)
>>>
>>> waveforms, _ = torchaudio.load("audio.wav")
>>> logits, _ = model(waveforms)

import_fairseq_model

torchaudio.models.wav2vec2.utils.import_fairseq_model(original: torch.nn.Module) → torchaudio.models.Wav2Vec2Model[source]

从 fairseq 的对应模型对象构建 Wav2Vec2Model。

Parameters

original (torch.nn.Module) – fairseq 的 Wav2Vec2.0 或 HuBERT 模型的一个实例。 fairseq.models.wav2vec.wav2vec2_asr.Wav2VecEncoder、 fairseq.models.wav2vec.wav2vec2.Wav2Vec2Model 或 fairseq.models.hubert.hubert_asr.HubertEncoder 中的一个。

Returns

已导入模型。

Return type

Wav2Vec2Model

Example - Loading pretrain-only model
>>> from torchaudio.models.wav2vec2.utils import import_fairseq_model
>>>
>>> # Load model using fairseq
>>> model_file = 'wav2vec_small.pt'
>>> model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([model_file])
>>> original = model[0]
>>> imported = import_fairseq_model(original)
>>>
>>> # Perform feature extraction
>>> waveform, _ = torchaudio.load('audio.wav')
>>> features, _ = imported.extract_features(waveform)
>>>
>>> # Compare result with the original model from fairseq
>>> reference = original.feature_extractor(waveform).transpose(1, 2)
>>> torch.testing.assert_allclose(features, reference)
Example - Fine-tuned model
>>> from torchaudio.models.wav2vec2.utils import import_fairseq_model
>>>
>>> # Load model using fairseq
>>> model_file = 'wav2vec_small_960h.pt'
>>> model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([model_file])
>>> original = model[0]
>>> imported = import_fairseq_model(original.w2v_encoder)
>>>
>>> # Perform encoding
>>> waveform, _ = torchaudio.load('audio.wav')
>>> emission, _ = imported(waveform)
>>>
>>> # Compare result with the original model from fairseq
>>> mask = torch.zeros_like(waveform)
>>> reference = original(waveform, mask)['encoder_out'].transpose(0, 1)
>>> torch.testing.assert_allclose(emission, reference)

WaveRNN

class torchaudio.models.WaveRNN(upsample_scales: List[int], n_classes: int, hop_length: int, n_res_block: int = 10, n_rnn: int = 512, n_fc: int = 512, kernel_size: int = 5, n_freq: int = 128, n_hidden: int = 128, n_output: int = 128)[source]

基于 fatchord 实现的 WaveRNN 模型。

原始实现在 Efficient Neural Audio Synthesis 中引入 [9]。波形和频谱图的输入通道必须为 1。 upsample_scales 的乘积必须等于 hop_length。

Parameters

  • upsample_scales – 上采样比例列表。

  • n_classes – 输出类别的数量。

  • hop_length – 连续帧起始点之间的样本数。

  • n_res_block – 堆叠中 ResBlock 的数量。（默认值：10）

  • n_rnn – RNN 层的维度。（默认值：512）

  • n_fc – 全连接层的维度。（默认值：512）

  • kernel_size – 第一个 Conv1d 层中的卷积核大小数量。（默认值：5）

  • n_freq – 频谱图中的分箱数量。（默认值：128）

  • n_hidden – resblock 的隐藏层维度数量。（默认值：128）

  • n_output – melresnet 的输出维度数量。（默认值：128）

Example
>>> wavernn = WaveRNN(upsample_scales=[5,5,8], n_classes=512, hop_length=200)
>>> waveform, sample_rate = torchaudio.load(file)
>>> # waveform shape: (n_batch, n_channel, (n_time - kernel_size + 1) * hop_length)
>>> specgram = MelSpectrogram(sample_rate)(waveform)  # shape: (n_batch, n_channel, n_freq, n_time)
>>> output = wavernn(waveform, specgram)
>>> # output shape: (n_batch, n_channel, (n_time - kernel_size + 1) * hop_length, n_classes)
forward(waveform: torch.Tensor, specgram: torch.Tensor) → torch.Tensor[source]

将输入通过 WaveRNN 模型。

Parameters

  • waveform – WaveRNN 层的输入波形 (n_batch, 1, (n_time - kernel_size + 1) * hop_length)

  • specgram – 输入到 WaveRNN 层的频谱图 (n_batch, 1, n_freq, n_time)

Returns

形状 (n_batch, 1, (n_time - kernel_size + 1) * hop_length, n_classes)

Return type

张量

infer(specgram: torch.Tensor, lengths: Optional[torch.Tensor] = None) → Tuple[torch.Tensor, Optional[torch.Tensor]][source]

WaveRNN 的推理方法。

此函数目前仅支持多项式采样，该采样假设网络是使用交叉熵损失进行训练的。

Parameters

  • specgram (Tensor) – 一批频谱图。形状：(n_batch, n_freq, n_time)。

  • lengths (Tensor 或 None, 可选) – 指示批次中每个音频的有效长度。 形状：(batch, )。 当 specgram 包含不同持续时间的频谱图时， 通过提供 lengths 参数，模型将计算 相应的有效输出长度。 如果为 None，则假设 waveforms 中的所有音频 均具有有效长度。默认值：None。

Returns

Tensor

推断出的波形大小为 (n_batch, 1, n_time)。 1 代表单通道。

Tensor or None

如果提供了 lengths 个参数，则返回形状为 (batch, ) 的张量。 它表示输出张量在时间轴上的有效长度。

Return type

(张量，可选[张量])

参考文献

1

Anmol Gulati, James Qin, Chung-Cheng Chiu, Niki Parmar, Yu Zhang, Jiahui Yu, Wei Han, Shibo Wang, Zhengdong Zhang, Yonghui Wu, and Ruoming Pang. Conformer: convolution-augmented transformer for speech recognition. 2020. arXiv:2005.08100.

2

Yi Luo 和 Nima Mesgarani。Conv-tasnet：超越理想时频幅度掩码的语音分离。IEEE/ACM Transactions on Audio, Speech, and Language Processing，27(8):1256–1266，2019年8月。URL: http://dx.doi.org/10.1109/TASLP.2019.2915167，doi:10.1109/taslp.2019.2915167。

3

Awni Hannun, Carl Case, Jared Casper, Bryan Catanzaro, Greg Diamos, Erich Elsen, Ryan Prenger, Sanjeev Satheesh, Shubho Sengupta, Adam Coates, 和 Andrew Y. Ng。Deep speech: scaling up end-to-end speech recognition。2014。 arXiv:1412.5567。

4

石阳阳，王永强，吴春阳，叶清风，陈朱利安，张弗兰克，黎杜克，和塞尔茨勒迈克。Emformer：基于高效内存变换器的低延迟流式语音识别声学模型。发表于ICASSP 2021 - 2021 IEEE国际声学、语音与信号处理会议（ICASSP），第6783–6787页。2021年。

5

Jonathan Shen, Ruoming Pang, Ron J Weiss, Mike Schuster, Navdeep Jaitly, Zongheng Yang, Zhifeng Chen, Yu Zhang, Yuxuan Wang, Rj Skerrv-Ryan, and others. 通过将WaveNet条件化在梅尔频谱预测上实现自然的TTS合成。In 2018 IEEE国际声学、语音与信号处理会议（ICASSP）, 4779–4783. IEEE, 2018.

6

Ronan Collobert, Christian Puhrsch, 和 Gabriel Synnaeve。Wav2letter：一个端到端的基于卷积网络的语音识别系统。2016。 arXiv:1609.03193。

7(1,2,3,4,5,6)

Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, 和 Michael Auli. Wav2vec 2.0: 一个用于语音表示自监督学习的框架。2020. arXiv:2006.11477.

8(1,2,3,4,5,6)

魏宁 胡, 本杰明·博尔特, 姚宏·赫伯特·蔡, 库沙尔·拉克霍蒂亚, 鲁斯兰·萨拉胡丁诺夫, 和阿卜杜勒拉赫曼·穆罕默德。Hubert：通过隐藏单元的掩码预测进行自监督语音表征学习。2021。arXiv:2106.07447.

9

Nal Kalchbrenner, Erich Elsen, Karen Simonyan, Seb Noury, Norman Casagrande, Edward Lockhart, Florian Stimberg, Aaron van den Oord, Sander Dieleman, 和 Koray Kavukcuoglu. 高效的神经音频合成。2018. arXiv:1802.08435.

文档

访问 PyTorch 的全面开发人员文档

查看文档

教程

获取面向初学者和高级开发人员的深入教程

查看教程

资源

查找开发资源并解答您的问题

查看资源