torchaudio.models¶
models 子包包含用于解决常见音频任务的模型定义。
转换器¶
-
类 （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）[来源]
torchaudio.models.Conformer¶ 实现 Conformer 中引入的 Conformer 架构：用于语音识别的卷积增强转换器 [1]。
- 参数
input_dim （int） – 输入维度。
num_heads （int） – 每个 Conformer 层中的注意力头数。
ffn_dim （int） - 前馈网络的隐藏层维度。
num_layers （int） - 要实例化的 Conformer 层数。
depthwise_conv_kernel_size （int） - 每个 Conformer 层的深度卷积层的核大小。
dropout （float， optional） - 辍学概率。（默认值：0.0）
use_group_norm （bool， optional） – 使用而不是在卷积模块中使用。（默认：
GroupNormBatchNorm1dFalse)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(输入：Torch。张量，长度：torch。Tensor） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 T张量][来源]¶ - 参数
input （Torch.Tensor） – 形状为 （B， T， input_dim）。
长度（割torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效帧数。
input
- 返回
- （Torch。Tensor、torch 的 Tensor 和 Torch 的 T张量）
- torch.Tensor
输出帧， 形状为 （B， T， input_dim）
- torch.Tensor
输出长度，形状为 （B，） 和第 i 个元素表示 输出帧中第 i 个批处理元素的有效帧数。
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'）[来源]
torchaudio.models.ConvTasNet¶ Conv-TasNet：一个全卷积的时域音频分离网络 Conv-TasNet：超越理想的语音分离时频幅度掩码 [2]。
- 参数
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） - 掩码生成器中 conv 块的输入/输出特征维度，<B， Sc>。
msk_num_hidden_feats （int， optional） - 掩码生成器的conv块的内部特征维度<H>。
msk_num_layers （int， optional） – 遮罩生成器的一个 conv 块 <X> 中的层数。
msk_num_stacks （int， optional） - 掩码生成器的 conv 块数 <R>。
msk_activate （str， optional） – 掩码输出的激活函数 （默认值： ）。
sigmoid
注意
此实现对应于论文中的 “non-causal” 设置。
-
forward(输入：Torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ 执行源分离。生成音频源波形。
- 参数
input （Torch.Tensor） – 形状为 [batch， channel==1， frames] 的 3D Tensor
- 返回
形状为 [batch， channel==num_sources， frames] 的 3D 张量
- 返回类型
张肌
深度语音¶
-
类 （n_feature： int， n_hidden： int = 2048， n_class： int = 40， 辍学： 浮点数 = 0.0）[来源]
torchaudio.models.DeepSpeech¶ 来自 Deep Speech 的 DeepSpeech 模型架构：扩展端到端语音识别 [3]。
- 参数
n_feature – 输入特征的数量
n_hidden – 内部隐藏单元大小。
n_class – 输出类的数量
-
forward(x：Torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ - 参数
x （Torch。Tensor） - 维度的张量 （batch， channel， time， feature）.
- 返回
维度 （batch， time， class） 的预测因子张量。
- 返回类型
张肌
转换器¶
-
类 （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： 可选[str] = 'depthwise'， tanh_on_mem： bool = False， negative_inf： 浮点数 = - 100000000.0）[来源]
torchaudio.models.Emformer¶ 实现 Emformer 中介绍的 Emformer 架构：用于低延迟流式语音识别的基于高效 Memory Transformer 的声学模型 [4]。
- 参数
input_dim （int） – 输入维度。
num_heads （int） - 每个 Emformer 层中的注意力头数。
ffn_dim （int） – 每个 Emformer 层的前馈网络的隐藏层维度。
num_layers （int） - 要实例化的 Emformer 层数。
segment_length （int） - 每个输入段的长度。
dropout （float， optional） - 辍学概率。（默认值：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”， ） 之一。（默认：“depthwise”）
Nonetanh_on_mem （bool， optional） – 如果 ，则对内存元素应用 tanh。（默认：
TrueFalse)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(输入：Torch。张量，长度：torch。Tensor） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 T张肌]¶ 用于训练和非流式推理的 Forward pass。
B： 批量大小; T：批量输入帧的最大数量; D：每帧的特征维度。
- 参数
input （Torch.Tensor） – 话语帧用右上下文帧右填充，其中 形状 （B， T + right_context_length， D）。
长度（割torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效话语帧数。
input
- 返回
- 张肌
输出帧，形状为 （B， T， D）。
- 张肌
输出长度，形状为 （B，） 和第 i 个元素表示 输出帧中第 i 个批处理元素的有效帧数。
- 返回类型
（张量、张量）
-
infer(输入：Torch。张量，长度：torch。Tensor，状态：可选[List[List[torch.Tensor]]] = None） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 T张量，List[List[torch.张肌]]]¶ 用于流式推理的 Forward pass。
B： 批量大小; D：每帧的特征维度。
- 参数
input （Torch.Tensor） – 话语帧用右上下文帧右填充，其中 形状 （B， segment_length + right_context_length， D）。
长度（割torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效帧数。
input状态 （List[List[torch.Tensor]] 或 None，可选） – 张量列表 表示在前面的 .（默认：
inferNone)
- 返回
- 张肌
输出帧，形状为 （B， segment_length， D）。
- 张肌
输出长度，形状为 （B，） 和第 i 个元素表示 输出帧中第 i 个批处理元素的有效帧数。
- 列表[List[Tensor]]
输出状态;表示内部状态的张量列表 在当前调用 .
infer
- 返回类型
（张量， 张量， 列表[List[Tensor]]）
RNN-T 型¶
型¶
RNNT¶
-
类 [来源]
torchaudio.models.RNNT¶ 递归神经网络传感器 （RNN-T） 模型。
注意
要构建模型，请使用其中一个工厂函数。
- 参数
transcriber （torch.nn.Module） – 转录网络。
predictor （torch.nn.Module） - 预测网络。
joiner （torch.nn.Module） – 联合网络。
-
forward(资料来源：Torch。Tensor，source_lengths：torch。Tensor，目标：torch。Tensor，target_lengths：torch。张量，predictor_state：可选[List[List[torch.Tensor]]] = None） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 T张量，List[List[torch.张量]]][来源]¶ 用于训练的向前传球。
B： 批量大小; T： 最大源序列批量长度; U： 最大目标序列批量长度; D：每个源序列元素的特征维度。
- 参数
源 （Torch.Tensor） —— 源帧序列用正确的上下文右填充，其中 形状 （B， T， D）。
source_lengths（Torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效帧数。
sources目标（Torch。Tensor） – 目标序列，形状为 （B， U） 和每个元素 映射到目标元件。
target_lengths（Torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效帧数。
targetspredictor_state （List[List[torch.Tensor]] 或 None，可选） – 张量列表 表示在前面的调用中生成的预测网络内部状态 之。（默认：
forwardNone)
- 返回
- torch.Tensor
联合网络输出，形状为 （B， 最大输出源长度， 最大输出目标长度， output_dim （目标元件的数量））。
- torch.Tensor
输出源长度，形状为 （B，） 和第 i 个元素表示 对于联合网络输出中的第 i 个批次元素，沿 Dim 1 的有效元素数。
- torch.Tensor
输出目标长度，形状为 （B，），第 i 个元素表示 对于联合网络输出中的第 i 个批次元素，沿 dim 2 的有效元素数。
- 列表[列表[Torch.张量]]
输出状态;张量列表 表示当前调用中生成的 Prediction Network 内部状态 之。
forward
- 返回类型
(torch。Tensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 T张量，List[List[torch.张肌]])
-
transcribe_streaming(资料来源：Torch。Tensor，source_lengths：torch。张量，状态：可选[List[List[torch.Tensor]]]） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 T张量，List[List[torch.张量]]][来源]¶ 将转录网络应用于流模式下的源。
B： 批量大小; T： 最大批量源序列段长度; D：每个源序列帧的特征维度。
- 参数
源 （Torch.Tensor） —— 源帧序列片段用正确的上下文右填充，其中 shape （B， T + 右上下文长度， D）。
source_lengths（Torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效帧数。
sourcesstate （List[List[torch.Tensor]] 或 None） – 张量列表 表示在前面的调用中生成的转录网络内部状态 之。
transcribe_streaming
- 返回
- torch.Tensor
output frame sequences（输出帧序列），其中 形状 （B， T // time_reduction_stride， output_dim）。
- torch.Tensor
输出长度，形状为 （B，） 和第 i 个元素表示 输出中第 i 个批次元素的有效元素数。
- 列表[列表[Torch.张量]]
输出状态;张量列表 表示当前调用中生成的转录网络内部状态 之。
transcribe_streaming
- 返回类型
(torch。Tensor、torch 的 Tensor 和 Torch 的 T张量，List[List[torch.张肌]])
-
transcribe(资料来源：Torch。Tensor，source_lengths：torch。Tensor） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 T张量][来源]¶ 将转录网络应用于非流模式下的源。
B： 批量大小; T： 最大源序列批量长度; D：每个源序列帧的特征维度。
- 参数
源 （Torch.Tensor） —— 源帧序列用正确的上下文右填充，其中 shape （B， T + 右上下文长度， D）。
source_lengths（Torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效帧数。
sources
- 返回
- torch.Tensor
output frame sequences（输出帧序列），其中 形状 （B， T // time_reduction_stride， output_dim）。
- torch.Tensor
输出长度，形状为 （B，） 和第 i 个元素表示 输出帧序列中第 i 个批次元素的有效元素数。
- 返回类型
-
predict(目标：Torch。Tensor，target_lengths：torch。张量，状态：可选[List[List[torch.Tensor]]]） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 T张量，List[List[torch.张量]]][来源]¶ 将预测网络应用于目标。
B： 批量大小; U： 最大目标序列批量长度; D： 每个目标序列帧的特征维度。
- 参数
目标（Torch。Tensor） – 目标序列，形状为 （B， U） 和每个元素 映射到目标元件，即在 [0， num_symbols） 范围内。
target_lengths（Torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效帧数。
targetsstate （List[List[torch.Tensor]] 或 None） – 张量列表 表示在前面的调用中生成的内部状态 之。
predict
- 返回
- torch.Tensor
输出帧序列，形状为 （B、U、output_dim）。
- torch.Tensor
输出长度，形状为 （B，） 和第 i 个元素表示 输出中第 i 个批次元素的有效元素数。
- 列表[列表[Torch.张量]]
输出状态;张量列表 表示在当前调用 .
predict
- 返回类型
(torch。Tensor、torch 的 Tensor 和 Torch 的 T张量，List[List[torch.张肌]])
-
join(source_encodings：Torch。Tensor，source_lengths：torch。Tensor，target_encodings：torch。Tensor，target_lengths：torch。Tensor） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 T张量][来源]¶ 将联合网络应用于源编码和目标编码。
B： 批量大小; T： 最大源序列批量长度; U： 最大目标序列批量长度; D：每个源序列和目标序列编码的维度。
- 参数
source_encodings（Torch。Tensor） —— 源编码序列，其中 形状 （B， T， D）。
source_lengths（Torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效序列长度。
source_encodingstarget_encodings（Torch。Tensor） – 形状为 （B， U， D） 的目标编码序列。
target_lengths（Torch。Tensor） – 形状为 （B，） 且第 i 个元素表示 中第 i 个批次元素的有效序列长度。
target_encodings
- 返回
- torch.Tensor
联合网络输出，形状为 （B， T， U， output_dim）。
- torch.Tensor
输出源长度，形状为 （B，） 和第 i 个元素表示 对于联合网络输出中的第 i 个批次元素，沿 Dim 1 的有效元素数。
- torch.Tensor
输出目标长度，形状为 （B，），第 i 个元素表示 对于联合网络输出中的第 i 个批次元素，沿 dim 2 的有效元素数。
- 返回类型
(torch。Tensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 T张肌)
工厂功能¶
emformer_rnnt_model¶
-
torchaudio.models.emformer_rnnt_model(*、input_dim：int、encoding_dim：int、num_symbols：int、segment_length：int、right_context_长度：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： 布尔、symbol_embedding_dim：int、num_lstm_layers：int、lstm_layer_norm：布尔、lstm_layer_norm_epsilon： float，lstm_dropout：float） → torchaudio.models.rnnt.RNNT [源]¶ 构建基于 Emformer 的递归神经网络传感器 （RNN-T） 模型。
注意
对于非流式推理，预期是在输入时调用 transcribe 序列与 right_context_length 帧右连接。
对于流式推理，预期是调用 transcribe_streaming 在包含 segment_length 帧的 Input 块上，这些帧与 right_context_length 帧右连接。
- 参数
input_dim （int） – 传递给转录网络的输入序列帧的维度。
encoding_dim （int） – 转录和预测网络生成的编码的维度 传递给联合网络。
num_symbols （int） – 目标 Tokens 集的基数。
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） - 前者 dropout probability （暂缓者）的 dropout probability （暂缓者辍学概率）。
transformer_activation （str） – 在每个 Emformer 层的 前馈网络。必须是 （“relu”， “gelu”， “silu”） 之一。
transformer_max_memory_size （int） – 要使用的最大内存元素数。
transformer_weight_init_scale_strategy （str） – 每层权重初始化缩放 策略。必须是 （“depthwise”， “constant”， ） 之一。
Nonetransformer_tanh_on_mem （bool） – 如果 ，则对内存元素应用 tanh。
Truesymbol_embedding_dim （int） – 每个目标标记嵌入的维度。
num_lstm_layers （int） - 要实例化的 LSTM 层数。
lstm_layer_norm （bool） – 如果 ，则为 LSTM 层启用层标准化。
Truelstm_layer_norm_epsilon （float） – 在 LSTM 层归一化层中使用的 epsilon 值。
lstm_dropout （float） - LSTM dropout 概率。
- 返回
Emformer RNN-T 模型。
- 返回类型
译码器¶
RNNTBeam搜索¶
-
类（模型：torchaudio.models.rnnt.RNNT，空白：int，温度：浮点 = 1.0，hypo_sort_key： 可选[Callable[[Tuple[List[int]， torch.张量，List[List[torch.张量]]， 浮点]]， 浮点]] = 无， step_max_tokens： int = 100）[来源]
torchaudio.models.RNNTBeamSearch¶ 用于 RNN-T 模型的波束搜索解码器。
- 参数
model （RNNT） – 要使用的 RNN-T 模型。
- 空白 （int） - 词汇表中空白标记的索引。
Temperature （float， optional） （温度 （float， optional） ） – 应用于联合网络输出的温度。 值越大，生成的样本越均匀。（默认值：1.0）
hypo_sort_key （Callable[[Hypothesis]， float] or None， optional） – 计算分数的可调用 对于给定的假设，以对假设进行排名。如果 ，则默认为返回 按标记序列长度标准化的假设分数。（默认值：无）
Nonestep_max_tokens （int， optional） – 每个输入时间步长要发出的最大令牌数。（默认值：100）
- 教程使用：
RNNTBeamSearch
-
forward(输入：Torch。Tensor，长度：torch。张量，beam_width： int） → List[Tuple[List[int]， torch.张量，List[List[torch.张量]]，浮点]][来源]¶ 对给定的输入序列执行光束搜索。
T： 帧数; D：每帧的特征维度。
- 参数
input （Torch.Tensor） – 形状为 （T， D） 或 （1， T， D） 的输入帧序列。
长度（Torch。Tensor） – 输入中的有效帧数 sequence，形状为 （） 或 （1，）。
beam_width （int） – 搜索期间使用的光束大小。
- 返回
top- 通过 Beam 搜索找到的假设。
beam_width- 返回类型
列表[假设]
-
infer(输入：Torch。Tensor，长度：torch。张量，beam_width：int，状态：可选[List[List[torch.Tensor]]] = None， hypothesis： 可选[Tuple[List[int]， torch.张量，List[List[torch.张量]]， float]] = None） → Tuple[List[Tuple[List[int]、Torch。张量，List[List[torch.Tensor]]， float]]， List[List[torch.张量]]][来源]¶ 在流模式下对给定的输入序列执行光束搜索。
T： 帧数; D：每帧的特征维度。
- 参数
input （Torch.Tensor） – 形状为 （T， D） 或 （1， T， D） 的输入帧序列。
长度（Torch。Tensor） – 输入中的有效帧数 sequence，形状为 （） 或 （1，）。
beam_width （int） – 搜索期间使用的光束大小。
state （List[List[torch.Tensor]] 或 None，可选） – 张量列表 表示前面生成的转录网络内部状态 调用。（默认：
None)hypothesis （Hypothesis or None） – 从先前调用到种子的假设 搜索方式。（默认：
None)
- 返回
- 列表[假设]
top- 通过 Beam 搜索找到的假设。
beam_width- 列表[列表[Torch.张量]]
表示转录网络的张量列表 internal 状态。
- 返回类型
（列表[假设]，列表[列表[Torch.张肌]])
Tacotron2 （塔科特龙2）¶
-
类 （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：浮点型 = 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）[来源]
torchaudio.models.Tacotron2¶ Tacotron2 模型基于 Nvidia 的实现。
最初的实现是在 Natural TTS Synthesis 中引入的，通过在 Mel Spectrogram Predictions 上调节 WaveNet [5]。
- 参数
mask_padding （bool， optional） – 使用掩码填充 （Default： ）。
Falsen_mels （int， optional） – mel bins 的数量 （默认值： ）。
80n_symbol （int， optional） – 输入文本的元件数 （Default： ）。
148n_frames_per_step （int， optional） – 每步处理的帧数，仅支持 1 个（默认值：）。
1symbol_embedding_dim （int， optional） – 输入嵌入维度 （Default： ）。
512encoder_n_convolution （int， optional） - 编码器卷积的数量 （默认值： ）。
3encoder_kernel_size （int， optional） – 编码器内核大小 （Default： ）。
5encoder_embedding_dim （int， optional） – 编码器嵌入维度 （Default： ）。
512decoder_rnn_dim （int， optional） – 解码器 LSTM 中的单元数 （默认值： ）。
1024decoder_max_step （int， optional） – 输出梅尔频谱图的最大数量 （默认值： ）。
2000decoder_dropout （float， optional） - 解码器 LSTM 的 Dropout 概率 （默认值： ）。
0.1decoder_early_stopping （bool， optional） – 完成所有样本后继续解码 （Default： ）。
Trueattention_rnn_dim （int， optional） – 关注 LSTM 中的单位数 （默认值： ）。
1024attention_hidden_dim （int， optional） – 注意力隐藏表示的维度 （Default： ）。
128attention_location_n_filter （int， optional） – 注意力模型的筛选条件数量 （Default： ）。
32attention_location_kernel_size （int， optional） – 注意力模型的内核大小 （Default： ）。
31attention_dropout （float， optional） – 注意力 LSTM 的 dropout probability （默认值： ）。
0.1prenet_dim （int， optional） – prenet 层中的 ReLU 单元数 （默认值： ）。
256postnet_n_convolution （int， optional） - 后网卷积的数量 （默认值： ）。
5postnet_kernel_size （int， optional） – Postnet kernel size （默认值： ）。
5postnet_embedding_dim （int， optional） – 后网嵌入维度 （Default： ）。
512gate_threshold （float， optional） – 停止令牌的概率阈值 （Default： ）。
0.5
- 教程使用：
Tacotron2
-
forward(tokens： torch 的 Torch 中。Tensor，token_lengths：torch。Tensor，mel_specgram：torch。张量，mel_specgram_lengths：torch。Tensor） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 T张量][来源]¶ 通过 Tacotron2 模型传递输入。这是在老师 强制模式，一般用于训练。
输入应用 0 填充到 最大长度 。 输入应用 0 填充到 最大长度 。
tokenstoken_lengthsmel_specgrammel_specgram_lengths- 参数
tokens （Tensor） – 形状为 （n_batch，最大值为 token_lengths） 的 Tacotron2 的输入令牌。
token_lengths （Tensor） – 形状为 （n_batch， ） 的每个样本的有效长度。
tokensmel_specgram （Tensor） – 目标梅尔频谱图 形状为 （n_batch、n_mels、最大值 mel_specgram_lengths）。
mel_specgram_lengths （Tensor） - 形状为 （n_batch， ） 的每个梅尔频谱图的长度。
- 返回
- 张肌
Postnet 之前的 Mel 频谱图，形状为 （n_batch， n_mels， max of mel_specgram_lengths）。
- 张肌
Postnet 之后的梅尔频谱图，形状为 （n_batch， n_mels， max of mel_specgram_lengths）。
- 张肌
每个时间步的 stop token 的输出，形状为 （n_batch，最大值为 mel_specgram_lengths）。
- 张肌
来自解码器的注意力权重序列 形状（n_batch、最大 mel_specgram_lengths、最大 token_lengths）。
- 返回类型
[张量、张量、张量、张量]
-
infer(tokens： torch 的 Torch 中。Tensor， lengths： 可选[torch.Tensor] = None） → Tuple[torch.Tensor、torch 的 Tensor 和 Torch 的 TTensor、torch 的 Tensor 和 Torch 的 T张量][来源]¶ 使用 Tacotron2 进行推理。输入是一批编码的 句子 （） 及其相应的长度 （）。这 output 是生成的 MEL 频谱图、其相应的长度，以及 来自 Decoder 的 attention 权重。
tokenslengths输入标记应用 0 填充 max 长度 。
lengths- 参数
tokens （Tensor） – 形状为 （n_batch，最大长度） 的 Tacotron2 的输入令牌。
lengths （Tensor 或 None，可选） – 形状为 （n_batch， ） 的每个样本的有效长度。 如果 ，则假定所有标记都有效。违约：
tokensNoneNone
- 返回
- 张肌
形状为 （n_batch、n_mels、最大值 mel_specgram_lengths） 的预测梅尔频谱图。
- 张肌
形状为 （n_batch， ） 的预测梅尔频谱图的长度。
- 张肌
来自解码器的注意力权重序列，形状为 （n_batch，最大 mel_specgram_lengths，最大长度）。
- 返回类型
（张量、张量、张量）
Wav2字母¶
-
类 （num_classes： int = 40， input_type： str = 'waveform'， num_features： int = 1）[来源]
torchaudio.models.Wav2Letter¶ 来自 Wav2Letter 的 Wav2Letter 模型架构：基于 ConvNet 的端到端语音 识别系统 [6]。
\（\text{padding} = \frac{\text{ceil}（\text{kernel} - \text{stride}）}{2}\）
- 参数
-
forward(x：Torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ - 参数
x （Torch。Tensor） - 维度 （batch_size， num_features， input_length） 的张量。
- 返回
维度 （batch_size， number_of_classes， input_length） 的预测因子张量。
- 返回类型
张肌
Wav2Vec2.0 / HuBERT¶
型¶
Wav2Vec2模型¶
-
class （feature_extractor： torch.nn.Module， encoder： torch.nn.Module， aux： 可选[torch.nn.Module] = 无）[来源]
torchaudio.models.Wav2Vec2Model¶ wav2vec 2.0 中使用的编码器模型 [7]。
注意
要构建模型，请使用其中一个工厂函数。
- 参数
feature_extractor （torch.nn.Module） – 从原始音频 Tensor 中提取特征向量的特征提取器。
encoder （torch.nn.Module） – 将音频特征转换为概率序列的编码器 标签上的分布（负对数似然）。
aux （torch.nn.Module 或 None，可选） – 辅助模块。如果提供，则 encoder 的输出将传递到此模块。
- 教程使用：
Wav2Vec2Model
-
extract_features(waveforms（波形）：Torch（Torch）。Tensor， lengths： 可选[torch.张量] = 无，num_layers：可选[int] = 无） → Tuple[List[torch.Tensor]、可选[torch.张量]][来源]¶ 从原始波形中提取特征向量
这将返回 编码器中的 transformer 块。
- 参数
- 返回
- 张量列表
请求图层中的要素。 每个 Tensor 的形状为：（batch、time frame、feature dimension）
- Tensor 或 None
如果提供了 argument，则返回形状为 （batch， ） 的 Tensor。 它表示每个特征 Tensor 的时间轴上的有效长度。
lengths
- 返回类型
（List[Tensor]， 可选 [Tensor]）
-
forward(waveforms（波形）：Torch（Torch）。Tensor， lengths： 可选[torch.Tensor] = None） → Tuple[torch.Tensor，可选[torch.张量]][来源]¶ 计算标签上的概率分布序列。
- 参数
waveforms （Tensor） - 形状为 （batch， frames） 的音频张量。
lengths （Tensor 或 None，可选） – 指示批处理中每个音频的有效长度。 形状：（batch， ）。 当 包含不同时长的音频时， 通过提供参数，模型将计算 相应的有效输出长度，并在 transformer 注意层。 如果 ，则假定 中的所有音频都具有有效长度。违约：。
waveformslengthsNonewaveformsNone
- 返回
- 张肌
标签上的概率分布序列（以 logit 为单位）。 形状：（batch， frames， num labels）。
- Tensor 或 None
如果提供了 argument，则返回形状为 （batch， ） 的 Tensor。 它表示输出 Tensor 的时间轴上的有效长度。
lengths
- 返回类型
（Tensor， 可选[Tensor]）
HuBERTPretrain模型¶
-
类 （wav2vec2： torchaudio.models.wav2vec2.model.Wav2Vec2Model， mask_generator： torch.nn.modules.module.Module， logit_generator： torch.nn.modules.module.Module， feature_grad_mult： 可选[float]）[来源]
torchaudio.models.HuBERTPretrainModel¶ HuBERT 预训练模型，用于从头开始训练。
注意
- 要构建模型，请使用
[hubert_pretrain_base、hubert_pretrain_large、hubert_pretrain_xlarge]。
- 参数
feature_extractor （torch.nn.Module） – 从原始音频 Tensor 中提取特征向量的特征提取器。
encoder （torch.nn.Module） – 将音频特征转换为概率序列的编码器 标签上的分布（负对数似然）。
mask_generator （torch.nn.Module） – 掩码生成器，用于在训练期间生成用于掩码预测的掩码。
logit_generator （torch.nn.Module） – 预测掩码和未掩码输入的 Logit 生成器。
feature_grad_mult （float 或 None） – 缩放卷积特征提取层梯度的因子。 如果 ，则特征提取层的梯度不受影响。 比例因子不会影响前向通道。
None
-
forward(waveforms（波形）：Torch（Torch）。Tensor，标签：torch。Tensor，audio_lengths：可选[torch.Tensor] = None） → Tuple[torch.Tensor，可选[torch.张量]][来源]¶ 计算标签上的概率分布序列。
- 参数
waveforms （Tensor） - 维度为 [batch， frames] 的音频张量。
labels （Tensor） – 用于预训练的标签。维度为 [batch， frames] 的 Tensor。
audio_lengths （Tensor 或 None，可选） – 指示批处理中每个音频的有效长度。 形状：[batch， ]。 当 包含不同时长的音频时， 通过提供参数，模型将计算 相应的有效输出长度，并在 transformer 注意层。 如果 ，则假定 中的所有音频都具有有效长度。违约：。
waveformslengthsNonewaveformsNone
- 返回
- 张肌
概率分布的掩码序列（在 logit 中）。 形状：（masked_frames，num 个标签）。
- 张肌
未掩蔽的概率分布序列（在 logit 中）。 形状：（unmasked_frames，num 个标签）。
- 张肌
额外罚金损失的特征平均值。 形状：（1，）。
- 返回类型
（张量、张量、张量）
工厂功能¶
wav2vec2_model¶
-
torchaudio.models.wav2vec2_model(extractor_mode： str， extractor_conv_layer_config： 可选[List[元组[int， int， int]]]、extractor_conv_bias：bool、encoder_embed_dim：int、encoder_projection_dropout：float、encoder_pos_conv_内核：int、encoder_pos_conv_groups：int、encoder_num_layers：int、encoder_num_heads：int、encoder_attention_dropout：浮点数、encoder_ff_interm_features：整数、encoder_ff_interm_dropout：浮点数、encoder_dropout：浮点数、encoder_layer_norm_first：bool、encoder_layer_drop：float、aux_num_out：Optional[int]） → torchaudio.models.Wav2Vec2Model[来源]¶ 构建自定义 Wav2Vec2Model
注意
下面的 “feature extractor” 对应于原始实现中的 ConvFeatureExtractionModel。 这在 wav2vec 2.0 [7] 论文中称为“（卷积）特征编码器”。
fairseq下面的 “encoder” 对应于 TransformerEncoder， 这在论文中被称为 “Transformer”。
- 参数
extractor_mode （str） –
特征提取器的操作模式。 有效值为 或 。 如果 ，则应用单个规范化 在第一个 convolution 块中。否则，所有卷积 块将进行层标准化。
"group_norm""layer_norm""group_norm"此选项对应于 from 。
extractor_modefairseqextractor_conv_layer_config （python：integer tuples 列表或 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), ]
此选项对应于 from 。
conv_feature_layersfairseqextractor_conv_bias （布尔值） –
是否为每个卷积运算包含偏差项。
此选项对应于 from 。
conv_biasfairseqencoder_embed_dim （int） –
编码器中嵌入的维度。
此选项对应于 from 。
encoder_embed_dimfairseqencoder_projection_dropout （float） –
投影输入特征后应用的 dropout 概率 自。
encoder_embed_dim此选项对应于 from 。
dropout_inputfairseqencoder_pos_conv_kernel （int） –
卷积位置嵌入的核大小。
此选项对应于 from 。
conv_posfairseqencoder_pos_conv_groups （int） –
卷积位置嵌入的组数。
此选项对应于 from 。
conv_pos_groupsfairseqencoder_num_layers （int） –
transformer block 中的自注意力层数。
此选项对应于 from 。
encoder_layersfairseqencoder_num_heads （int） –
自我注意层中的头部数。
此选项对应于 from 。
encoder_attention_headsfairseqencoder_attention_dropout （float） –
在自我注意层中 softmax 之后应用的 dropout 概率。
此选项对应于 from 。
attention_dropoutfairseqencoder_ff_interm_features （int） –
前馈层中隐藏特征的维度。
此选项对应于 from 。
encoder_ffn_embed_dimfairseqencoder_ff_interm_dropout （float） –
前馈层中应用的 dropout 概率。
此选项与 from 对应。
activation_dropoutfairseqencoder_dropout （float） –
在前馈层末尾应用的 dropout 概率。
此选项对应于 from 。
dropoutfairseqencoder_layer_norm_first （布尔值） –
控制变压器层和每个编码器层的层范数顺序。 如果为 True，则在变压器层中，在馈送特征之前应用层范数 到编码器层。在编码器层中，在编码器层之前和之后应用两层范数 自我关注。 如果为 False，则在变压器层中，在馈送特征后应用层范数 到编码器层。在编码器层中，在 self 之后应用两层范数 注意，前馈和后馈。
此选项对应于 from 。
layer_norm_firstfairseqencoder_layer_drop （浮点数） –
在训练期间丢弃每个编码器层的概率。
此选项对应于 from 。
layerdropfairseqaux_num_out （int 或 None） – 如果提供，请在编码器顶部附加一个额外的线性层，该层可以是 用于微调。
- 返回
生成的模型。
- 返回类型
wav2vec2_base¶
-
torchaudio.models.wav2vec2_base(encoder_projection_dropout：浮点数 = 0.1，encoder_attention_dropout：浮点数 = 0.1，encoder_ff_interm_dropout：浮点数 = 0.1， encoder_dropout： 浮点数 = 0.1， encoder_layer_drop： 浮点数 = 0.1， aux_num_out： 可选[int] = None） → torchaudio.models.Wav2Vec2Model[来源]¶ 使用 wav2vec 2.0 的“基础”架构构建 Wav2Vec2Model [7]
wav2vec2_large¶
-
torchaudio.models.wav2vec2_large(encoder_projection_dropout：浮点数 = 0.1，encoder_attention_dropout：浮点数 = 0.1，encoder_ff_interm_dropout：浮点数 = 0.1， encoder_dropout： 浮点数 = 0.1， encoder_layer_drop： 浮点数 = 0.1， aux_num_out： 可选[int] = None） → torchaudio.models.Wav2Vec2Model[来源]¶ 使用 wav2vec 2.0 的“大型”架构构建 Wav2Vec2Model [7]
wav2vec2_large_lv60k¶
-
torchaudio.models.wav2vec2_large_lv60k(encoder_projection_dropout：浮点数 = 0.1，encoder_attention_dropout：浮点数 = 0.0，encoder_ff_interm_dropout：浮点数 = 0.1， encoder_dropout： 浮点数 = 0.0， encoder_layer_drop： 浮点数 = 0.1， aux_num_out： 可选[int] = None） → torchaudio.models.Wav2Vec2Model[来源]¶ 使用 wav2vec 2.0 的“大型 lv-60k”架构构建 Wav2Vec2Model [7]
hubert_base¶
hubert_large¶
hubert_xlarge¶
hubert_pretrain_model¶
-
torchaudio.models.hubert_pretrain_model(extractor_mode： str， extractor_conv_layer_config： 可选[List[元组[int， int， int]]]、extractor_conv_bias：bool、encoder_embed_dim：int、encoder_projection_dropout：float、encoder_pos_conv_内核：int、encoder_pos_conv_groups：int、encoder_num_layers：int、encoder_num_heads：int、encoder_attention_dropout：浮点数、encoder_ff_interm_features：整数、encoder_ff_interm_dropout：浮点数、encoder_dropout：浮点数、encoder_layer_norm_first：bool、encoder_layer_drop：float、mask_prob：float、mask_selection：str、mask_other：浮点数、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[来源]¶ 构建自定义 HuBERTPretrainModel 用于从头开始训练
注意
下面的 “feature extractor” 对应于原始实现中的 ConvFeatureExtractionModel。 这在 wav2vec 2.0 [7] 论文中称为“（卷积）特征编码器”。
fairseq下面的 “encoder” 对应于 TransformerEncoder， 这在论文中被称为 “Transformer”。
- 参数
extractor_mode （str） –
特征提取器的操作模式。 有效值为 或 。 如果 ，则应用单个规范化 在第一个 convolution 块中。否则，所有卷积 块将进行层标准化。
"group_norm""layer_norm""group_norm"此选项对应于 from 。
extractor_modefairseqextractor_conv_layer_config （python：integer tuples 列表或 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), ]
此选项对应于 from 。
conv_feature_layersfairseqextractor_conv_bias （布尔值） –
是否为每个卷积运算包含偏差项。
此选项对应于 from 。
conv_biasfairseqencoder_embed_dim （int） –
编码器中嵌入的维度。
此选项对应于 from 。
encoder_embed_dimfairseqencoder_projection_dropout （float） –
投影输入特征后应用的 dropout 概率 自。
encoder_embed_dim此选项对应于 from 。
dropout_inputfairseqencoder_pos_conv_kernel （int） –
卷积位置嵌入的核大小。
此选项对应于 from 。
conv_posfairseqencoder_pos_conv_groups （int） –
卷积位置嵌入的组数。
此选项对应于 from 。
conv_pos_groupsfairseqencoder_num_layers （int） –
transformer block 中的自注意力层数。
此选项对应于 from 。
encoder_layersfairseqencoder_num_heads （int） –
自我注意层中的头部数。
此选项对应于 from 。
encoder_attention_headsfairseqencoder_attention_dropout （float） –
在自我注意层中 softmax 之后应用的 dropout 概率。
此选项对应于 from 。
attention_dropoutfairseqencoder_ff_interm_features （int） –
前馈层中隐藏特征的维度。
此选项对应于 from 。
encoder_ffn_embed_dimfairseqencoder_ff_interm_dropout （float） –
前馈层中应用的 dropout 概率。
此选项与 from 对应。
activation_dropoutfairseqencoder_dropout （float） –
在前馈层末尾应用的 dropout 概率。
此选项对应于 from 。
dropoutfairseqencoder_layer_norm_first （布尔值） –
控制变压器层和每个编码器层的层范数顺序。 如果为 True，则在变压器层中，在馈送特征之前应用层范数 到编码器层。在编码器层中，在编码器层之前和之后应用两层范数 自我关注。 如果为 False，则在变压器层中，在馈送特征后应用层范数 到编码器层。在编码器层中，在 self 之后应用两层范数 注意，前馈和后馈。
此选项对应于 from 。
layer_norm_firstfairseqencoder_layer_drop （浮点数） –
在训练期间丢弃每个编码器层的概率。
此选项对应于 from 。
layerdropfairseqmask_prob （浮点数） –
选择每个标记作为要屏蔽的 span 的开始的概率。这将乘以 时间步数除以掩码跨度的长度，以掩盖所有元素的大约此百分比。 但是，由于重叠，实际数量会更小（除非 no_overlap 为 True）。
此选项对应于 from 。
mask_probfairseqmask_selection （str） –
如何选择蒙版长度。选项：[、]。
staticuniformnormalpoisson此选项对应于 from 。
mask_selectionfairseqmask_other （浮点数） –
辅助掩码参数（用于更复杂的分布）。
此选项对应于 from 。
mask_otherfairseqmask_length （int） –
遮罩的长度。
此选项对应于 from 。
mask_lengthfairseqno_mask_overlap （布尔值） –
是否允许蒙版重叠。
此选项对应于 from 。
no_mask_overlapfairseqmask_min_space （int） –
跨度之间的最小间距（如果未启用重叠）。
此选项对应于 from 。
mask_min_spacefairseqmask_channel_prob –
（浮点）： 将特征替换为 0 的概率。
此选项对应于 from 。
mask_channel_probfairseqmask_channel_selection （str） –
如何选择通道蒙版的蒙版长度。选项：[、]。
staticuniformnormalpoisson此选项对应于 from 。
mask_channel_selectionfairseqmask_channel_other （浮点数） –
通道掩码的 Secondary mask 参数（用于更复杂的分布）。
此选项对应于 from 。
mask_channel_otherfairseqmask_channel_length （整数） –
通道遮罩的跨度之间的最小间距（如果未启用重叠）。
此选项对应于 from 。
mask_channel_lengthfairseqno_mask_channel_overlap （布尔值） –
是否允许通道蒙版重叠。
此选项对应于 from 。
no_mask_channel_overlapfairseqmask_channel_min_space （int） –
通道遮罩的跨度之间的最小间距（如果未启用重叠）。
此选项对应于 from 。
mask_channel_min_spacefairseqskip_masked （布尔值） –
如果为 True，则跳过计算掩码帧的损失。
此选项对应于 from 。
skip_maskedfairseqskip_nomask （布尔值） –
如果为 True，则跳过计算未屏蔽帧的损失。
此选项对应于 from 。
skip_nomaskfairseqnum_classes （int） – 标签中的类数。
final_dim （int） –
将最终表示和目标投影到final_dim。
此选项对应于 from 。
final_dimfairseqfeature_grad_mult （float 或 None） –
缩放卷积特征提取层梯度的因子。 比例因子不会影响前向通道。
此选项对应于 from 。
feature_grad_multfairseq
- 返回
生成的模型。
- 返回类型
hubert_pretrain_base¶
-
torchaudio.models.hubert_pretrain_base(encoder_projection_dropout：浮点数 = 0.1，encoder_attention_dropout：浮点数 = 0.1，encoder_ff_interm_dropout：浮点数 = 0.0，encoder_dropout：浮点数 = 0.1，encoder_layer_drop：浮点数 = 0.05，mask_prob： 浮点数 = 0.8，mask_channel_prob：浮点数 = 0.0，mask_channel_length：int = 10，feature_grad_mult： 可选[float] = 0.1， num_classes： int = 100） → torchaudio.models.HuBERTPretrainModel [来源]¶ 使用 HuBERT 的 “base” 架构构建 HuBERTPretrainModel 模型 [8]
- 参数
encoder_projection_dropout （float） – 请参阅
。encoder_attention_dropout （float） – 请参阅
。encoder_ff_interm_dropout （float） – 请参阅
。encoder_dropout （float） – 请参阅
。encoder_layer_drop （float） – 请参阅
。mask_prob （float） – 请参阅
。mask_channel_prob （float） – 请参阅
。mask_channel_length （int） – 请参阅
。num_classes （int， optional） – 请参阅
。
- 返回
生成的模型。
- 返回类型
hubert_pretrain_large¶
-
torchaudio.models.hubert_pretrain_large(encoder_projection_dropout：浮点数 = 0.0，encoder_attention_dropout：浮点数 = 0.0，encoder_ff_interm_dropout：浮点数 = 0.0，encoder_dropout：浮点数 = 0.0，encoder_layer_drop：浮点数 = 0.0，mask_prob： 浮点数 = 0.8，mask_channel_prob：浮点数 = 0.0，mask_channel_length：int = 10，feature_grad_mult： 可选[float] = None） → torchaudio.models.HuBERTPretrainModel[来源]¶ 使用 HuBERT 的“大型”架构构建 HuBERTPretrainModel 模型以进行预训练 [8]
- 参数
- 返回
生成的模型。
- 返回类型
hubert_pretrain_xlarge¶
-
torchaudio.models.hubert_pretrain_xlarge(encoder_projection_dropout：浮点数 = 0.0，encoder_attention_dropout：浮点数 = 0.0，encoder_ff_interm_dropout：浮点数 = 0.0，encoder_dropout：浮点数 = 0.0，encoder_layer_drop：浮点数 = 0.0，mask_prob： 浮点数 = 0.8，mask_channel_prob：浮点数 = 0.0，mask_channel_length：int = 10，feature_grad_mult： 可选[float] = None） → torchaudio.models.HuBERTPretrainModel[来源]¶ 使用 HuBERT 的“超大型”架构构建用于预训练的 HuBERTPretrainModel 模型 [8]
- 参数
- 返回
生成的模型。
- 返回类型
效用函数¶
import_huggingface_model¶
-
torchaudio.models.wav2vec2.utils.import_huggingface_model(原文：torch.nn.Module） → torchaudio.models.Wav2Vec2Model[来源]¶ 从 Hugging Face 的 Transformers 的相应模型对象构建 Wav2Vec2Model。
- 参数
original （torch.nn.Module） – from 的实例。
Wav2Vec2ForCTCtransformers- 返回
导入的模型。
- 返回类型
- 例
>>> 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(原文：torch.nn.Module） → torchaudio.models.Wav2Vec2Model[来源]¶ 从 fairseq 的相应模型对象构建 Wav2Vec2Model。
- 参数
original （torch.nn.Module） – fairseq 的 Wav2Vec2.0 或 HuBERT 模型的实例。 或 之一。
fairseq.models.wav2vec.wav2vec2_asr.Wav2VecEncoderfairseq.models.wav2vec.wav2vec2.Wav2Vec2Modelfairseq.models.hubert.hubert_asr.HubertEncoder- 返回
导入的模型。
- 返回类型
- 示例 — 加载仅预训练模型
>>> 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)
- 示例 - 微调模型
>>> 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¶
-
类 （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）[来源]
torchaudio.models.WaveRNN¶ 基于 fatchord 实现的 WaveRNN 模型。
最初的实现是在 Efficient Neural Audio Synthesis [9] 中引入的。waveform 和 spectrogram 的 input channels 必须为 1。 upsample_scales 的乘积必须等于 hop_length。
- 参数
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)
- 例
>>> 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(波形：手电筒。张量，specgram：torch。Tensor） → torch 的 Tensor 中。张量[来源]¶ 通过 WaveRNN 模型传递输入。
- 参数
waveform – WaveRNN 层的输入波形 （n_batch， 1， （n_time - kernel_size + 1） * hop_length）
specgram – WaveRNN 层的输入频谱图 （n_batch， 1， n_freq， n_time）
- 返回
形状 （n_batch， 1， （n_time - kernel_size + 1） * hop_length， n_classes）
- 返回类型
张肌
-
infer(specgram：Torch。Tensor， lengths： 可选[torch.Tensor] = None） → Tuple[torch.Tensor，可选[torch.张量]][来源]¶ WaveRNN 的推理方法。
此函数目前仅支持多项式采样，该函数假定 网络在交叉熵损失上进行训练。
- 参数
specgram （Tensor） - 一批频谱图。形状：（n_batch、n_freq、n_time）。
lengths （Tensor 或 None，可选） – 指示批处理中每个音频的有效长度。 形状：（batch， ）。 当 包含具有不同持续时间的 spectrograph 时， 通过提供参数，模型将计算 相应的有效输出长度。 如果 ，则假定 中的所有音频都具有有效长度。违约：。
specgramlengthsNonewaveformsNone
- 返回
- 张肌
大小为 （n_batch， 1， n_time） 的推断波形。 1 代表单个通道。
- Tensor 或 None
如果提供了 argument，则返回形状为 （batch， ） 的 Tensor。 它表示输出 Tensor 的时间轴上的有效长度。
lengths
- 返回类型
（Tensor， 可选[Tensor]）
引用¶
- 1
Anmol Gulati、James Qin、Chung-Cheng Chiu、Niki Parmar、Yu Zhang、Jiahui Yu、Wei Han、Shibo Wang、Zhengdong Zhang、Yonghui Wu 和 Ruoming Pang。Conformer：用于语音识别的卷积增强转换器。2020. arXiv：2005.08100.
- 2
Yi Luo 和 Nima Mesgarani。Conv-tasnet：超越了理想的时频幅度掩码，用于语音分离。IEEE/ACM 音频、语音和语言处理汇刊，27（8）：1256–1266,2019 年 8 月。网址：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。深度语音：扩大端到端语音识别。2014. arXiv：1412.5567.
- 4
Yangyang Shi、Yongqiang Wang、Chunyang Wu、Ching-Feng Yeh、Julian Chan、Frank Zhang、Duc Le 和 Mike Seltzer。Emformer：基于高效 memory transformer 的声学模型，用于低延迟流式语音识别。在 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 等。通过在 mel 频谱图预测上调节 wavenet 来自然 tts 合成。2018 年 IEEE 声学、语音和信号处理国际会议 （ICASSP），4779–4783。IEEE，2018 年。
- 6
罗南·科洛伯特、克里斯蒂安·普尔施和加布里埃尔·辛纳夫。Wav2letter：一种基于卷积网络的端到端语音识别系统。2016. arXiv：1609.03193.
- 7（1,2,3,4,5,6）
阿列克谢·巴耶夫斯基、亨利·周、阿卜杜勒拉赫曼·穆罕默德和迈克尔·奥利。Wav2vec 2.0：语音表示的自监督学习框架。2020. arXiv：2006.11477.
- 8（1,2,3,4,5,6）
Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov 和 Abdelrahman Mohamed。Hubert：通过隐藏单元的掩蔽预测进行自我监督的语音表示学习。2021. arXiv：2106.07447.
- 9
纳尔·卡尔赫布伦纳、埃里希·埃尔森、凯伦·西蒙尼扬、塞布·努里、诺曼·卡萨格兰德、爱德华·洛克哈特、弗洛里安·斯廷伯格、亚伦·范登奥德、桑德·迪勒曼和科雷·卡武克茨奥卢。高效的神经音频合成。2018. arXiv：1802.08435.