Transformers 文档
语音转文本
并获得增强的文档体验
开始使用
Speech2Text
概述
Speech2Text 模型在 fairseq S2T：使用 fairseq 进行快速语音到文本建模 中由 Changhan Wang、Yun Tang、Xutai Ma、Anne Wu、Dmytro Okhonko、Juan Pino 提出。它是一个基于 Transformer 的 seq2seq（编码器-解码器）模型，专为端到端自动语音识别 (ASR) 和语音翻译 (ST) 而设计。它使用卷积下采样器将语音输入的长度减少 3/4，然后再将其馈送到编码器。该模型使用标准的自回归交叉熵损失进行训练，并自回归地生成转录/翻译。Speech2Text 已在多个数据集上针对 ASR 和 ST 进行了微调：LibriSpeech、CoVoST 2、MuST-C。
推理
Speech2Text 是一个语音模型，它接受从语音信号中提取的 log-mel 滤波器组特征的浮点张量。它是一个基于 Transformer 的 seq2seq 模型，因此转录/翻译是自回归生成的。generate() 方法可用于推理。
Speech2TextFeatureExtractor 类负责提取 log-mel 滤波器组特征。Speech2TextProcessor 将 Speech2TextFeatureExtractor 和 Speech2TextTokenizer 封装到单个实例中，以提取输入特征并解码预测的 token id。
特征提取器依赖于 torchaudio，分词器依赖于 sentencepiece，因此请务必在运行示例之前安装这些软件包。您可以选择使用 pip install transformers"[speech, sentencepiece]" 将它们作为额外的语音依赖项安装，或者使用 pip install torchaudio sentencepiece 单独安装这些软件包。此外，torchaudio 需要 libsndfile 软件包的开发版本，可以通过系统软件包管理器安装。在 Ubuntu 上，可以按如下方式安装：apt install libsndfile1-dev
- ASR 和语音翻译
>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset
>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt")
>>> generated_ids = model.generate(inputs["input_features"], attention_mask=inputs["attention_mask"])
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription
['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel']多语言语音翻译
对于多语言语音翻译模型，
eos_token_id用作decoder_start_token_id，并且目标语言 id 被强制作为第一个生成的 token。要强制将目标语言 id 作为第一个生成的 token，请将forced_bos_token_id参数传递给generate()方法。以下示例展示了如何使用 facebook/s2t-medium-mustc-multilingual-st 检查点将英语语音翻译成法语文本。
>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset
>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt")
>>> generated_ids = model.generate(
... inputs["input_features"],
... attention_mask=inputs["attention_mask"],
... forced_bos_token_id=processor.tokenizer.lang_code_to_id["fr"],
... )
>>> translation = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> translation
["(Vidéo) Si M. Kilder est l'apossible des classes moyennes, et nous sommes heureux d'être accueillis dans son évangile."]请参阅 模型中心 以查找 Speech2Text 检查点。
Speech2TextConfig
类 transformers.Speech2TextConfig
< source >( vocab_size = 10000 encoder_layers = 12 encoder_ffn_dim = 2048 encoder_attention_heads = 4 decoder_layers = 6 decoder_ffn_dim = 2048 decoder_attention_heads = 4 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 scale_embedding = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 max_source_positions = 6000 max_target_positions = 1024 num_conv_layers = 2 conv_kernel_sizes = (5, 5) conv_channels = 1024 input_feat_per_channel = 80 input_channels = 1 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 10000) — Speech2Text 模型的词汇量大小。定义了调用 Speech2TextModel 时传递的inputs_ids可以表示的不同 token 的数量。 - encoder_layers (
int, 可选, 默认为 12) — 编码器层数。 - encoder_ffn_dim (
int, 可选, 默认为 2048) — 编码器中“中间”（通常称为前馈）层的维度。 - encoder_attention_heads (
int, 可选, 默认为 4) — Transformer 编码器中每个注意力层的注意力头数。 - decoder_layers (
int, 可选, 默认为 6) — 解码器层数。 - decoder_ffn_dim (
int, 可选, 默认为 2048) — 解码器中“中间”（通常称为前馈）层的维度。 - decoder_attention_heads (
int, 可选, 默认为 4) — Transformer 解码器中每个注意力层的注意力头数。 - encoder_layerdrop (
float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文。 - decoder_layerdrop (
float, 可选, 默认为 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回上次的键/值注意力 (并非所有模型都使用)。 - is_encoder_decoder (
bool, 可选, 默认为True) — 模型是否设置为用于序列到序列任务的编码器-解码器架构。 - activation_function (
str或function, 可选, 默认为"relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。 - d_model (
int, 可选, 默认为 256) — 层和池化器层的维度。 - dropout (
float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - attention_dropout (
float, 可选, 默认为 0.0) — attention 概率的 dropout 比率。 - activation_dropout (
float, 可选, 默认为 0.0) — 全连接层内部激活的 dropout 比率。 - init_std (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - decoder_start_token_id (
int, 可选, 默认为 2) — 解码序列时解码器的初始 token ID。 - scale_embedding (
bool, 可选, 默认为True) — 嵌入是否按d_model的平方根缩放。 - pad_token_id (
int, 可选, 默认为 1) — Padding token id（填充 token id）。 - bos_token_id (
int, 可选, 默认为 0) — 序列开始 token 的 id。 - eos_token_id (
int, 可选, 默认为 2) — 序列结束 token 的 id。 - max_source_positions (
int, 可选, 默认为 6000) — 此模型可能使用的 log-mel 滤波器组特征的最大序列长度。 - max_target_positions (
int, 可选, 默认为 1024) — 此模型可能使用的最大序列长度。 通常，为了以防万一，将其设置为较大的值（例如，512 或 1024 或 2048）。 - num_conv_layers (
int, 可选, 默认为 2) — conv 模块中 1D 卷积层的数量。 - conv_kernel_sizes (
Tuple[int], 可选, 默认为(5, 5)) — 一个整数元组，定义 conv 模块中每个 1D 卷积层的内核大小。conv_kernel_sizes的长度必须与num_conv_layers匹配。 - conv_channels (
int, 可选, 默认为 1024) — 一个整数，定义 conv 模块中除最后一个卷积层之外的每个卷积层的输出通道数。 - input_feat_per_channel (
int, 可选, 默认为 80) — 一个整数，指定特征向量的大小。 这也是 log-mel 滤波器组特征的维度。 - input_channels (
int, 可选, 默认为 1) — 一个整数，指定输入特征向量的输入通道数。
这是用于存储 Speech2TextModel 配置的配置类。 它用于根据指定的参数实例化 Speech2Text 模型，从而定义模型架构。 使用默认值实例化配置将产生与 Speech2Text facebook/s2t-small-librispeech-asr 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。 有关更多信息，请阅读 PretrainedConfig 中的文档。
示例
>>> from transformers import Speech2TextConfig, Speech2TextModel
>>> # Initializing a Speech2Text s2t_transformer_s style configuration
>>> configuration = Speech2TextConfig()
>>> # Initializing a model (with random weights) from the s2t_transformer_s style configuration
>>> model = Speech2TextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configSpeech2TextTokenizer
class transformers.Speech2TextTokenizer
< source >( vocab_file spm_file bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' unk_token = '<unk>' do_upper_case = False do_lower_case = False tgt_lang = None lang_codes = None additional_special_tokens = None sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None **kwargs )
参数
- vocab_file (
str) — 包含词汇表的文件。 - spm_file (
str) — SentencePiece 模型文件的路径 - bos_token (
str, 可选, 默认为"<s>") — 句子开头的 token。 - eos_token (
str, 可选, 默认为"</s>") — 句子结尾的 token。 - unk_token (
str, 可选, 默认为"<unk>") — 未知 token。 词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充的 token，例如在对不同长度的序列进行批处理时。 - do_upper_case (
bool, 可选, 默认为False) — 解码时是否将输出转换为大写。 - do_lower_case (
bool, 可选, 默认为False) — token 化时是否将输入转换为小写。 - tgt_lang (
str, 可选) — 表示目标语言的字符串。 - sp_model_kwargs (
dict, 可选) — 将传递给SentencePieceProcessor.__init__()方法。 SentencePiece 的 Python 封装器 可用于设置：-
enable_sampling: 启用子词正则化。 -
nbest_size: 用于 unigram 的采样参数。 对于 BPE-Dropout 无效。nbest_size = {0,1}: 不执行采样。nbest_size > 1: 从 nbest_size 结果中采样。nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（lattice）中采样。
-
alpha: unigram 采样的平滑参数和 BPE-dropout 的合并操作的 dropout 概率。
-
- **kwargs — 传递给 PreTrainedTokenizer 的附加关键字参数
构建 Speech2Text tokenizer。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含一些主要方法。 用户应参考超类以获取有关此类方法的更多信息。
通过附加 eos_token_id，从序列构建模型输入。
get_special_tokens_mask
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊令牌的令牌列表中检索序列 ID。当使用 tokenizer prepare_for_model 方法添加特殊令牌时，会调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
创建与传递的序列相对应的令牌类型 ID。 什么是令牌类型 ID？
如果模型有构建这些 ID 的特殊方式，则应在子类中重写。
Speech2TextFeatureExtractor
class transformers.Speech2TextFeatureExtractor
< source >( feature_size = 80 sampling_rate = 16000 num_mel_bins = 80 padding_value = 0.0 dither = 0.0 do_ceptral_normalize = True normalize_means = True normalize_vars = True **kwargs )
参数
- feature_size (
int, 可选, 默认为 80) — 提取特征的特征维度。 - sampling_rate (
int, 可选, 默认为 16000) — 音频文件应数字化的采样率，以赫兹 (Hz) 表示。 - num_mel_bins (
int, 可选, 默认为 80) — Mel 频率箱的数量。 - padding_value (
float, 可选, 默认为 0.0) — 用于填充 padding 向量的值。 - dither (
float, 可选, 默认为 0.0) — 添加抖动。换句话说，向每个帧添加小的 Gaussian 噪声。例如，使用 4.0 添加抖动，其正态分布以 0.0 为中心，标准差为 4.0（假设 kaldi 波形范围为 [-32k,+32k]）。值 0.0 表示不抖动。抖动具有与mel_floor相似的效果。当信号中存在 VAD 截止时，它可以减少具有硬零部分的信号的高 log_mel_fbank 值。 - do_ceptral_normalize (
bool, 可选, 默认为True) — 是否对提取的特征应用 utterance-level 倒谱均值和方差归一化。 - normalize_means (
bool, 可选, 默认为True) — 是否对提取的特征进行零均值归一化。 - normalize_vars (
bool, 可选, 默认为True) — 是否对提取的特征进行单位方差归一化。
构建 Speech2Text 特征提取器。
此特征提取器继承自 Speech2TextFeatureExtractor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
如果安装了 TorchAudio，此类会使用它从原始语音中提取 mel 滤波器组特征；否则，使用 numpy。它还会对提取的特征应用 utterance-level 倒谱均值和方差归一化。
__call__
< source >( raw_speech: typing.Union[numpy.ndarray, typing.List[float], typing.List[numpy.ndarray], typing.List[typing.List[float]]] padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False max_length: typing.Optional[int] = None truncation: bool = False pad_to_multiple_of: typing.Optional[int] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None sampling_rate: typing.Optional[int] = None return_attention_mask: typing.Optional[bool] = None **kwargs )
参数
- raw_speech (
np.ndarray,List[float],List[np.ndarray],List[List[float]]) — 要填充的序列或序列批次。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表的列表。必须是单声道音频，而不是立体声，即每个时间步单个浮点值。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为True) — 选择一种策略来填充返回的序列（根据模型的填充侧和填充索引），可以是以下之一：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不填充）。'max_length'：填充到max_length参数指定的长度，如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认)：不填充（即，可以输出具有不同长度序列的批次）。
- max_length (
int, 可选) — 返回列表的最大长度，以及可选的填充长度（见上文）。 - truncation (
bool) — 激活<0xC2><0xA0>truncation<0xC2><0xA0>以将输入序列裁剪到<0xC2><0xA0>max_length<0xC2><0xA0>长度，如果输入序列长度超过<0xC2><0xA0>max_length<0xC2><0xA0>长度。 - pad_to_multiple_of (
int, 可选) — 如果设置，将序列填充到所提供值的倍数。这对于在计算能力为
>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Cores 的使用，或者在受益于序列长度为 128 倍数的 TPUs 上尤其有用。 - return_attention_mask (
bool, 可选) — 是否返回 attention mask。 如果保留为默认值，将根据特定 feature_extractor 的默认值返回 attention mask。对于 Speech2TextTransformer 模型，应始终为批量推理传递
attention_mask，以避免细微的错误。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensors 而不是 python 整数列表。 可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- sampling_rate (
int, 可选) —raw_speech输入被采样的采样率。 强烈建议在前向调用时传递sampling_rate以防止静默错误。 - padding_value (
float, 可选, 默认为 0.0) — 用于填充填充值/向量的值。
主要方法，用于提取特征并为模型准备一个或多个序列。
Speech2TextProcessor
class transformers.Speech2TextProcessor
< 源码 >( feature_extractor tokenizer )
参数
- feature_extractor (
Speech2TextFeatureExtractor) — Speech2TextFeatureExtractor 的一个实例。 feature extractor 是必需的输入。 - tokenizer (
Speech2TextTokenizer) — Speech2TextTokenizer 的一个实例。 tokenizer 是必需的输入。
构建一个 Speech2Text processor，它将 Speech2Text feature extractor 和 Speech2Text tokenizer 封装到一个单独的 processor 中。
Speech2TextProcessor 提供了 Speech2TextFeatureExtractor 和 Speech2TextTokenizer 的所有功能。 有关更多信息，请参阅 call() 和 decode()。
当在正常模式下使用时，此方法将其所有参数转发到 call() 的 Speech2TextFeatureExtractor 并返回其输出。 如果在 as_target_processor() 上下文中使用，此方法将其所有参数转发到 call() 的 Speech2TextTokenizer。 请参考上述两种方法的文档字符串以获取更多信息。
from_pretrained
< 源码 >( pretrained_model_name_or_path: typing.Union[str, os.PathLike] cache_dir: typing.Union[str, os.PathLike, NoneType] = None force_download: bool = False local_files_only: bool = False token: typing.Union[str, bool, NoneType] = None revision: str = 'main' **kwargs )
参数
- pretrained_model_name_or_path (
str或os.PathLike) — 这可以是：- 一个字符串，即托管在 huggingface.co 模型仓库内的 pretrained feature_extractor 的模型 ID。
- 一个目录的路径，该目录包含使用 save_pretrained() 方法保存的特征提取器文件，例如，
./my_model_directory/。 - 保存的特征提取器 JSON文件的路径或 URL，例如，
./my_model_directory/preprocessor_config.json。
- **kwargs — 传递给 from_pretrained() 和
~tokenization_utils_base.PreTrainedTokenizer.from_pretrained的附加关键字参数。
实例化与 pretrained 模型关联的 processor。
此类方法只是调用 feature extractor from_pretrained()，image processor ImageProcessingMixin 和 tokenizer ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。 请参考上述方法的文档字符串以获取更多信息。
save_pretrained
< 源码 >( save_directory push_to_hub: bool = False **kwargs )
参数
- save_directory (
str或os.PathLike) — 将在其中保存特征提取器 JSON 文件和 tokenizer 文件的目录（如果目录不存在，则将创建目录）。 - push_to_hub (
bool, 可选, 默认为False) — 是否在保存后将您的模型推送到 Hugging Face 模型 hub。 您可以使用repo_id指定要推送到的仓库（默认为您命名空间中save_directory的名称）。 - kwargs (
Dict[str, Any], 可选) — 传递给 push_to_hub() 方法的附加关键字参数。
将此 processor 的属性（feature extractor、tokenizer...）保存在指定目录中，以便可以使用 from_pretrained() 方法重新加载它。
此类方法只是调用 save_pretrained() 和 save_pretrained()。 请参考上述方法的文档字符串以获取更多信息。
此方法将其所有参数转发到 batch_decode() 的 Speech2TextTokenizer。 请参考此方法的文档字符串以获取更多信息。
Speech2TextModel
class transformers.Speech2TextModel
< 源码 >( config: Speech2TextConfig )
参数
- config (Speech2TextConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
裸 Speech2Text 模型，输出原始隐藏状态，顶部没有任何特定的 head。 此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch Module，并参考 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( input_features: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
- input_features (
torch.FloatTensor, 形状为(batch_size, sequence_length, feature_size)) — 从原始语音波形中提取的fbank特征的浮点数值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如 通过 soundfile 库 (pip install soundfile)。要将数组准备成input_features，应该使用 AutoFeatureExtractor 来提取fbank特征，进行填充并转换为torch.FloatTensor类型的张量。参见 call() - attention_mask (
torch.Tensor, 形状为(batch_size, sequence_length), 可选) — 掩码，用于避免在填充 token 索引上执行卷积和注意力机制。掩码值在[0, 1]中选择：- 1 表示 token 未被掩码，
- 0 表示 token 已被掩码。
- decoder_input_ids (
torch.LongTensor, 形状为(batch_size, target_sequence_length), 可选) — 解码器输入序列 token 在词汇表中的索引。索引可以使用
SpeechToTextTokenizer获得。参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。SpeechToText 使用
eos_token_id作为decoder_input_ids生成的起始 token。如果使用past_key_values，则可以选择只输入最后的decoder_input_ids（参见past_key_values）。 - decoder_attention_mask (
torch.LongTensor, 形状为(batch_size, target_sequence_length), 可选) — 默认行为：生成一个忽略decoder_input_ids中的填充 token 的张量。因果掩码也将默认使用。如果您想更改填充行为，您应该阅读
modeling_speech_to_text._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。 - head_mask (
torch.Tensor, 形状为(encoder_layers, encoder_attention_heads), 可选) — 掩码，用于置空编码器中注意力模块的选定头。掩码值在[0, 1]中选择：- 1 表示头 未被掩码，
- 0 表示头 已被掩码。
- decoder_head_mask (
torch.Tensor, 形状为(decoder_layers, decoder_attention_heads), 可选) — 掩码，用于置空解码器中注意力模块的选定头。掩码值在[0, 1]中选择：- 1 表示头 未被掩码，
- 0 表示头 已被掩码。
- cross_attn_head_mask (
torch.Tensor, 形状为(decoder_layers, decoder_attention_heads), 可选) — 掩码，用于置空交叉注意力模块的选定头。掩码值在[0, 1]中选择：- 1 表示头 未被掩码，
- 0 表示头 已被掩码。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成，其中last_hidden_state的形状为(batch_size, sequence_length, hidden_size), 可选) 是编码器最后一层的输出处的隐藏状态序列。用于解码器的交叉注意力机制中。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，其中每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。如果使用
past_key_values，用户可以选择仅输入最后的decoder_input_ids(那些没有将其过去的键值状态提供给此模型的) ，形状为(batch_size, 1)而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (
torch.FloatTensor, 形状为(batch_size, target_sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。 如果使用past_key_values，则可以选择只输入最后的decoder_inputs_embeds（参见past_key_values）。如果您想比模型的内部嵌入查找矩阵更灵活地控制如何将decoder_input_ids索引转换为关联的向量，这将非常有用。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是纯元组。
返回值
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时) ，包含各种元素，具体取决于配置 (Speech2TextConfig) 和输入。
-
loss (
torch.FloatTensor, 形状为(1,), 可选, 当提供labels时返回) — 语言建模损失。 -
logits (
torch.FloatTensor, 形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表 token 的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，其中每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（对于嵌入的输出，如果模型具有嵌入层，则为一个；对于每层的输出，则为一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器的最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（对于嵌入的输出，如果模型具有嵌入层，则为一个；对于每层的输出，则为一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
Speech2TextModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> import torch
>>> from transformers import Speech2TextModel, AutoFeatureExtractor
>>> from datasets import load_dataset
>>> model = Speech2TextModel.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(
... ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 256]Speech2TextForConditionalGeneration
class transformers.Speech2TextForConditionalGeneration
< source >( config: Speech2TextConfig )
参数
- config (Speech2TextConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Speech2Text 模型。可用于摘要。此模型继承自 PreTrainedModel。请查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch Module，并参考 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( input_features: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
- input_features (形状为
(batch_size, sequence_length, feature_size)的torch.FloatTensor) — 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如 通过 soundfile 库 (pip install soundfile)。要将数组准备为input_features，应该使用 AutoFeatureExtractor 来提取 fbank 特征、填充并转换为torch.FloatTensor类型的张量。 请参阅 call() - attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 解码器输入序列标记在词汇表中的索引。索引可以使用
SpeechToTextTokenizer获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。SpeechToText 使用
eos_token_id作为decoder_input_ids生成的起始标记。 如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充标记。默认情况下，也会使用因果掩码。如果您想更改填充行为，则应阅读
modeling_speech_to_text._prepare_decoder_attention_mask并根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的torch.Tensor, 可选) — 用于使编码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可选) — 用于使解码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可选) — 用于使交叉注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成。last_hidden_state的形状为(batch_size, sequence_length, hidden_size), 可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力中。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，其中每个元组都有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），这些状态可用于（请参阅
past_key_values输入）加速顺序解码。如果使用
past_key_values，则用户可以选择仅输入最后的decoder_input_ids(那些没有将其过去的键值状态提供给此模型的) 形状为(batch_size, 1)而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor, 可选) — 或者，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。 如果使用past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将decoder_input_ids索引转换为关联向量，这将非常有用。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算语言建模损失的标签。索引应在[0, ..., config.vocab_size]或 -100 中（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩盖），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。
返回值
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时) ，包含各种元素，具体取决于配置 (Speech2TextConfig) 和输入。
-
loss (
torch.FloatTensor, 形状为(1,), 可选, 当提供labels时返回) — 语言建模损失。 -
logits (
torch.FloatTensor, 形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇表 token 的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，其中每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可以用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（对于嵌入的输出，如果模型具有嵌入层，则为一个；对于每层的输出，则为一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器的最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（对于嵌入的输出，如果模型具有嵌入层，则为一个；对于每层的输出，则为一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
Speech2TextForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset
>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(
... ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features
>>> generated_ids = model.generate(inputs=input_features)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'TFSpeech2TextModel
class transformers.TFSpeech2TextModel
< source >( config: Speech2TextConfig *inputs **kwargs )
参数
- config (Speech2TextConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
裸 Speech2Text 模型输出原始隐藏状态，顶部没有任何特定的头。此模型继承自 TFPreTrainedModel。请查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解所有与常规用法和行为相关的内容。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，当使用诸如 model.fit() 之类的方法时，对于您来说“应该可以正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，您可以使用以下三种可能性来收集第一个位置参数中的所有输入张量
- 仅使用
input_ids且没有其他内容的单个张量：model(input_ids) - 具有可变长度的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 子类化 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_features: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False **kwargs ) → transformers.modeling_tf_outputs.TFSeq2SeqModelOutput or tuple(tf.Tensor)
参数
- input_features (
tf.Tensor，形状为(batch_size, sequence_length, feature_size)) — 从原始语音波形中提取的fbank特征的浮点数值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如 通过 soundfile 库 (pip install soundfile)。要将数组准备为input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征，进行填充并转换为浮点张量。 请参阅 call() - attention_mask (
tf.Tensor，形状为({0})，可选) — 避免对填充 token 索引执行 attention 的掩码。在[0, 1]中选择的掩码值：- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
- decoder_input_ids (
tf.Tensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列 token 的索引。索引可以使用 Speech2TextTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。
SpeechToText 使用
eos_token_id作为decoder_input_ids生成的起始 token。 如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。对于翻译和摘要训练，应提供
decoder_input_ids。 如果未提供decoder_input_ids，则模型将通过将input_ids向右移动来创建此张量，以进行遵循论文的去噪预训练。 - decoder_attention_mask (
tf.Tensor，形状为(batch_size, target_sequence_length)，可选) — 默认情况下将创建，并忽略 pad token。 不建议在大多数用例中设置此项。 - head_mask (
tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于使编码器中 attention 模块的选定 head 失效的掩码。在[0, 1]中选择的掩码值：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- decoder_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使解码器中 attention 模块的选定 head 失效的掩码。在[0, 1]中选择的掩码值：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- cross_attn_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使 cross-attention 模块的选定 head 失效的掩码。在[0, 1]中选择的掩码值：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- encoder_outputs (
tf.FloatTensor，可选) — 编码器最后一层的输出处的隐藏状态。用于解码器的 cross-attention。 形状为(batch_size, sequence_length, hidden_size)的序列是 - past_key_values (
Tuple[Tuple[tf.Tensor]]，长度为config.n_layers) — 包含 attention 块的预计算键和值隐藏状态。 可用于加速解码。 如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids(那些没有将其过去的键值状态提供给此模型的) 形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (
tf.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。 如果使用past_key_values，则可以选择仅输入最后一个decoder_inputs_embeds（请参阅past_key_values）。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将decoder_input_ids索引转换为关联向量，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参阅返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。
返回值
transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包括各种元素，具体取决于配置 (Speech2TextConfig) 和输入。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出处的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
List[tf.Tensor]，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器的预计算隐藏状态（attention 块中的键和值），可以用于（请参阅
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（embeddings 的输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
decoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（embeddings 的输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
encoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
TFSpeech2TextModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFSpeech2TextModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> model = TFSpeech2TextModel.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFSpeech2TextForConditionalGeneration
class transformers.TFSpeech2TextForConditionalGeneration
< source >( config: Speech2TextConfig )
参数
- config (Speech2TextConfig) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Speech2Text 模型。 可用于摘要。 此模型继承自 TFPreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 head 等）。
此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解所有与常规用法和行为相关的内容。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于这种支持，当使用诸如 model.fit() 之类的方法时，对于您来说“应该可以正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，您可以使用以下三种可能性来收集第一个位置参数中的所有输入张量
- 仅使用
input_ids且没有其他内容的单个张量：model(input_ids) - 具有可变长度的列表，其中包含一个或多个输入张量，顺序与文档字符串中给出的顺序相同：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 字典，其中一个或多个输入张量与文档字符串中给出的输入名称相关联：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 子类化 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_features: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
参数
- input_features (
tf.Tensor，形状为(batch_size, sequence_length, feature_size)) — 从原始语音波形中提取的fbank特征的浮点数值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中来获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备成input_features，应该使用 AutoFeatureExtractor 来提取fbank特征，进行填充并转换为浮点张量。请参阅 call() - attention_mask (
tf.Tensor，形状为({0}), 可选) — 用于避免在填充标记索引上执行注意力机制的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
- decoder_input_ids (
tf.Tensor，形状为(batch_size, target_sequence_length), 可选) — 解码器输入序列标记在词汇表中的索引。索引可以使用 Speech2TextTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
SpeechToText 使用
eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择只输入最后的decoder_input_ids(那些没有将其过去的键值状态提供给此模型的)，请参阅past_key_values。对于翻译和摘要训练，应该提供
decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行遵循论文的去噪预训练。 - decoder_attention_mask (
tf.Tensor，形状为(batch_size, target_sequence_length), 可选) — 默认情况下将会创建，并忽略填充标记。不建议在大多数用例中设置此项。 - head_mask (
tf.Tensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 用于使编码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- decoder_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 用于使解码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- cross_attn_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 用于使交叉注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- encoder_outputs (
tf.FloatTensor, 可选) — 编码器最后一层的输出处的隐藏状态。在解码器的交叉注意力中使用。形状为(batch_size, sequence_length, hidden_size)的序列是 - past_key_values (
Tuple[Tuple[tf.Tensor]]，长度为config.n_layers) — 包含注意力块的预计算的键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids(那些没有将其过去的键值状态提供给此模型的)，形状为(batch_size, 1)而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (
tf.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可以选择仅输入最后的decoder_inputs_embeds(请参阅past_key_values)。如果您想要比模型的内部嵌入查找矩阵更好地控制如何将decoder_input_ids索引转换为关联的向量，这将非常有用。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码 (请参阅past_key_values)。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（诸如 dropout 模块之类的一些模块在训练和评估之间具有不同的行为）。 - labels (
tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或 -100 中 (请参阅input_ids文档字符串)。索引设置为-100的标记将被忽略 (掩码)，损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。
返回值
transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时) ，包含各种元素，具体取决于配置 (Speech2TextConfig) 和输入。
-
loss (
tf.Tensor，形状为(n,), 可选, 当提供labels时返回，其中 n 是非掩码标签的数量) — 语言建模损失。 -
logits (
tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表标记的分数）。 -
past_key_values (
List[tf.Tensor]，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器的预计算隐藏状态（attention 块中的键和值），可以用于（请参阅
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（embeddings 的输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
decoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（embeddings 的输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出以及初始嵌入输出处的隐藏状态。
-
encoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
TFSpeech2TextForConditionalGeneration 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> import tensorflow as tf
>>> from transformers import Speech2TextProcessor, TFSpeech2TextForConditionalGeneration
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> model = TFSpeech2TextForConditionalGeneration.from_pretrained(
... "facebook/s2t-small-librispeech-asr", from_pt=True
... )
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> ds.set_format(type="tf")
>>> input_features = processor(
... ds["speech"][0], sampling_rate=16000, return_tensors="tf"
... ).input_features # Batch size 1
>>> generated_ids = model.generate(input_features)
>>> transcription = processor.batch_decode(generated_ids)