Whisper
概览
Whisper模型在Alec Radford、Jong Wook Kim、Tao Xu、Greg Brockman、Christine McLeavey和Ilya Sutskever发表的《通过大规模弱监督实现鲁棒的语音识别》一文中提出。
该论文的摘要如下
我们研究了仅通过预测网络上的大量音频转录本来训练的语音处理系统的能力。当扩展到包含680,000小时的多语言和多项任务监督的多语言和多功能监督时,这些模型在标准基准上表现出良好的泛化能力,并且通常与先前完全监督的成果竞争力,但在无微调需求的零样本迁移设置中。当与人类相比时,模型的准确性和鲁棒性接近人类。我们正在发布模型和推理代码,以便作为进一步研究鲁棒语音处理的基础。
该模型由 Arthur Zucker 贡献。这个模型的Tensorflow版本由 amyeroberts 贡献。原始代码可在此处找到。
使用技巧
模型通常无需任何微调即可表现出色。
该架构遵循经典的编码器-解码器架构,这意味着它依赖于generate()函数进行推理。
可以使用WhisperProcessor准备模型所需的音频,并将预测的ID解码回文本。
要将模型和处理器转换,我们推荐使用以下
python src/transformers/models/whisper/convert_openai_to_hf.py --checkpoint_path "" --pytorch_dump_folder_path "Arthur/whisper-3" --convert_preprocessor True
脚本将自动从OpenAI检查点确定所有必要的参数。需要安装tiktoken
库以将OpenAI分词器转换为tokenizers
版本。
推理
以下是使用预训练的Whisper模型逐个转录音频样本的步骤指南
>>> from datasets import load_dataset
>>> from transformers import WhisperProcessor, WhisperForConditionalGeneration
>>> # Select an audio file and read it:
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio_sample = ds[0]["audio"]
>>> # Load the Whisper model in Hugging Face format:
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> # Use the model and processor to transcribe the audio:
>>> input_features = processor(
... audio_sample["array"], sampling_rate=audio_sample["sampling_rate"], return_tensors="pt"
... ).input_features
>>> # Generate token ids
>>> predicted_ids = model.generate(input_features)
>>> # Decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
>>> transcription[0]
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
Whisper兼容以下针对短篇和长篇生成的优化
- PyTorch缩放点积注意力(SDP):闪速注意力和内存高效注意力内核。默认启用,适用于
torch>=2.1.1
。 - Flash Attention 2:通过更好的并行性和工作分区改进了闪速注意力的实现。
- torch.compile:JIT编译正向传递以调度到高效的融合内核。
以下代码示例启用了SDP和torch.compile
,以实现最多5倍更快的推理
>>> from datasets import load_dataset
>>> from transformers import WhisperProcessor, WhisperForConditionalGeneration
>>> # Select an audio file and read it:
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio_sample = ds[0]["audio"]
>>> # Load the Whisper model with SDPA attention
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en", attn_implementation="sdpa")
>>> # Enable static cache and compile the forward pass
>>> model.generation_config.cache_implementation = "static"
>>> model.forward = torch.compile(model.forward, mode="reduce-overhead", fullgraph=True)
>>> # Use the model and processor to transcribe the audio:
>>> input_features = processor(
... audio_sample["array"], sampling_rate=audio_sample["sampling_rate"], return_tensors="pt"
... ).input_features
>>> # Compile the forward pass
>>> for _ in range(2):
>>> model.generate(input_features)
>>> # Generate token ids using compiled graph (fast!)
>>> predicted_ids = model.generate(input_features)
>>> # Decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
>>> transcription[0]
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
有关每个优化的更多详细信息,请参阅上面的文档。
资源
以下是Hugging Face和社区(🌎表示)提供的官方资源列表,以帮助您开始使用Whisper。如果您想提交资源供收录,请随时提交Pull Request,我们会进行审查!资源应尽量展示新内容,而非重复现有资源。
- 微调Whisper以提升您的数据集的下游表现。
- Distil-Whisper:针对英语的6倍速度快、2倍小型的蒸馏Whisper模型。我们发布了模型检查点和蒸馏代码。
- 一个分支,包含将Whisper模型在Hugging Face格式转换为OpenAI格式的脚本(示例) 🌎。
pip install -U openai-whisper python convert_hf_to_openai.py \ --checkpoint openai/whisper-tiny \ --whisper_dump_path whisper-tiny-openai.pt
WhisperConfig
class transformers.WhisperConfig
< source >( vocab_size = 51865 num_mel_bins = 80 encoder_layers = 4 encoder_attention_heads = 6 decoder_layers = 4 decoder_attention_heads = 6 decoder_ffn_dim = 1536 encoder_ffn_dim = 1536 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 decoder_start_token_id = 50257 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 384 dropout = 0.0 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 scale_embedding = False max_source_positions = 1500 max_target_positions = 448 pad_token_id = 50256 bos_token_id = 50256 eos_token_id = 50256 suppress_tokens = None begin_suppress_tokens = [220, 50256] use_weighted_layer_sum = False classifier_proj_size = 256 apply_spec_augment = False mask_time_prob = 0.05 mask_time_length = 10 mask_time_min_masks = 2 mask_feature_prob = 0.0 mask_feature_length = 10 mask_feature_min_masks = 0 median_filter_width = 7 **kwargs )
参数
- vocab_size (
int
, 可选,默认为 51865) — Whisper 模型词汇表大小。定义了在调用 WhisperModel 时传递的decoder_input_ids
所能表征的不同符号的数量。 - num_mel_bins (
int
, 可选,默认为 80) — 每个输入特征使用的梅尔特征数。应与WhisperProcessor
类中使用的值相对应。 - encoder_layers (
int
, 可选,默认为 4) — 编码器层数。 - decoder_layers (
int
, 可选,默认为 4) — 解码器层数。 - encoder_attention_heads(《int》,可选,默认为6)—— 变换器编码器中每个注意力层的注意力头数。
- decoder_attention_heads(《int》,可选,默认为6)—— 变换器解码器中每个注意力层的注意力头数。
- encoder_ffn_dim(《int》,可选,默认为1536)—— 编码器中“中间”层(通常称为前馈层)的维度。
- decoder_start_token_id (
int
,可选,默认为 50257) — 对应于 “<|startoftranscript|>” 符号,当没有提供decoder_input_ids
给generate
函数时,将自动使用。它用于根据任务引导模型的生成过程。 - use_cache (
bool
,可选,默认为True
) — 模型是否应该返回最后一个键/值注意力(不是所有模型都使用)。 - is_encoder_decoder (
bool
,可选,默认为True
) — 模型是否作为编码器/解码器使用。 - 激活函数 (
str
, 可选, 默认为"gelu"
) — 编码器和池器中使用的非线性激活函数(函数或字符串)。如果为字符串,支持的值为"gelu"
、"relu"
、"silu"
和"gelu_new"
。 - d_model (
int
, 可选, 默认为 384) — 层数的维度。 - dropout (
float
, 可选, 默认为 0.1) — 隐藏层中所有全连接层的dropout概率。 - attention_dropout (
float
, 可选, 默认值为 0.0) — 注意力概率的dropout比例。 - activation_dropout (
float
, 可选, 默认值为 0.0) — 完全连接层中激活的dropout比例。 - init_std (
float
, 可选, 默认值为 0.02) — 使用截断正态分布初始化所有权重矩阵的标准差。 - scale_embedding (
bool
, 可选, 默认为 False) — 通过除以 d_model 的平方根来缩放嵌入。 -
<strong>max_source_positions</strong> ( int
, 可选, 默认为 1500) — 该模型可能用到的最大 log-mel 滤波器组特征序列长度。</em> <em><code>— 通常设置较大的值以防万一(例如,512 或 1024 或 2048)。</code> </em> <取样标记结束 — > - max_target_positions (
int
, 可选, 默认为 448) — 该模型可能用到的最大序列长度。通常设置为某个较大的值以防万一(例如,512 或 1024 或 2048)。 - pad_token_id (
int
, 可选, 默认为 50256) — 填充标记的 ID。 - bos_token_id (
int
, 可选, 默认为 50256) — 流的开始标记的 ID。 - eos_token_id (
int
, 可选, 默认为 50256) — 流的结束标记的 ID。 - suppress_tokens (
List[int]
, 可选) — 用于generate
函数中不发音标记的列表。NON_SPEECH_TOKENS 和 NON_SPEECH_TOKENS_MULTI 分别对应英语
和多语言
模型。 - begin_suppress_tokens(《List[int]》,可选,默认为
[220,50256]
)—表示在采样过程中将被抑制的标记列表。初始化为空标记ID(《blank_token_id》)和“eos_token_id”() - use_weighted_layer_sum(《bool》,可选,默认为
False
) —是否使用层的加权平均输出。仅在使用WhisperForAudioClassification的实例时相关。 - classifier_proj_size(《int》,可选,默认为256) —在token平均池化之前投影的维度。仅在WhisperForAudioClassification的实例中使用时相关。<
- apply_spec_augment (
bool
, 可选,默认为False
) — 是否将 SpecAugment 数据增强应用于特征编码器的输出。有关参考,请参阅 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。 - mask_time_prob (
float
, 可选,默认为 0.05) — 沿时间轴所有特征向量中被遮挡的百分比(介于 0 到 1 之间)。遮挡过程在轴上生成mask_time_prob*len(time_axis)/mask_time_length
个独立的遮挡。如果从每个特征向量被选为要遮挡的向量范围的起始点的概率推理,则 mask_time_prob 应为prob_vector_start*mask_time_length
。请注意,重叠可能会降低实际遮障向量的百分比。这仅在apply_spec_augment == True
时相关。 - mask_time_length (
int
, 可选,默认为 10) — 沿时间轴向量范围的长度。 - mask_time_min_masks (
int
,可选,默认为2),—— 沿时间轴生成的长度为mask_feature_length
的最小掩码数量,每个时间步,不受mask_feature_prob
影响。只有在 “mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks” 的情况下才相关 - mask_feature_prob (
float
,可选,默认为 0.0)—— 在特征轴上所有特征向量中将要被掩码的百分比(在 0 和 1 之间)。掩码过程在轴上生成mask_feature_prob*len(feature_axis)/mask_time_length
个独立的掩码。如果根据每个特征向量被选择为要掩码的向量范围开始的可能性的推理,mask_feature_prob 应为prob_vector_start*mask_feature_length
。请注意,重叠可能会降低实际掩码向量的百分比。此选项仅在apply_spec_augment is True
时才相关。 - mask_feature_length (
int
,可选,默认为10)—— 沿特征轴的向量跨度长度。 - mask_feature_min_masks (
int
, 可选, 默认为 0), — 在特征轴上生成的最小mask_feature_length
长度的掩码数量,每次时间步长,不考虑mask_feature_prob
。只有当mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks
时才相关。 - median_filter_width (
int
, 可选, 默认为 7), — 在计算标记时间戳时用于平滑跨注意力输出的中值滤波器宽度。应为奇数。
这是存储 WhisperModel 配置的配置类。它根据指定的参数实例化 Whisper 模型,定义模型架构。使用默认值实例化配置将产生与 Whisper openai/whisper-tiny 架构类似的配置。
配置对象继承自 PretrainedConfig,可以用来控制模型输出。详细信息请参阅PretrainedConfig 文档。
示例
>>> from transformers import WhisperConfig, WhisperModel
>>> # Initializing a Whisper tiny style configuration
>>> configuration = WhisperConfig()
>>> # Initializing a model (with random weights) from the tiny style configuration
>>> model = WhisperModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
WhisperTokenizer
类 transformers.WhisperTokenizer
< 源代码 >( vocab_file merges_file normalizer_file = None errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' pad_token = None add_prefix_space = False language = None task = None predict_timestamps = False **kwargs )
参数
- vocab_file (
str
) — 词汇文件的路径。 - merges_file (
str
) — 合并文件路径。 - normalizer_file (
str
, 可选) — 正规化文件路径。可选。 - errors (
str
, 可选,默认为"replace"
) — 解码字节到UTF-8时遵循的范式。更多信息请参阅 bytes.decode。 - unk_token(《字符串》,可选,默认为
"<|endoftext|>"
)——未知标记。不在词汇表中的标记无法转换为ID,并将其设置为此标记。 - bos_token(《字符串》,可选,默认为
"<|endoftext|>"
)——序列开始标记。《decoder_start_token_id》用于生成时将第一个标记设置为“"<|startoftranscript|>"
”。 - eos_token(《字符串》,可选,默认为
"<|endoftext|>"
)——序列结束标记。 - pad_token (
str
, 可选) — 用于填充的标记,例如当批处理不同长度的序列时。 - add_prefix_space (
bool
, 可选, 默认值False
) — 是否在输入前添加一个初始空格。这允许将首词视为任何其他词。 - language (
str
, 可选) — 文本转写的语言。对于多语言语音识别和语音翻译任务,相应的语言id标记附加到序列的开始处,例如对于西班牙语,将标记““<|es|>”
附加到序列的开始。这只应用于多语言微调。 - task (
str
, 可选) — 在序列开头附加的任务标识符(如果有)。这应用于多语言微调,语音识别时使用"transcribe"
,语音翻译时使用"translate"
。 - predict_timestamps (
bool
, 可选,默认为False
) — 是否省略序列开头<|notimestamps|>
令牌。
构建一个Whisper标记器。
此标记器继承自 PreTrainedTokenizer,其中包含一些主要方法。用户应查阅超类以获取有关此类方法的更多信息。
set_prefix_tokens
< 源 >( language: 字符串 str = None task: 字符串 str = None predict_timestamps: 布尔 bool = None )
覆盖附加到标签序列开始的标记前缀。此方法可以作为独立方法使用来
从序列中构建模型输入,并追加eos_token_id。
get_special_tokens_mask
< 来源 >( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊标记的标记列表中检索序列ID。此方法在调用tokenizer的prepare_for_model
方法添加特殊标记时调用。
create_token_type_ids_from_sequences
< 来源 >( token_ids_0: 列表 token_ids_1: 可选 = None ) → 列表[int]
为传递的序列创建对应的标记类型ID。 什么是标记类型ID?
如果模型有特殊的构建方式,应该在子类中覆盖。
批量解码
< source >( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → List[str]
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]
) — 编码后的输入 ID 列表。可以通过__call__
方法获取。 - skip_special_tokens (
bool
, 可选, 默认为False
) — 在解码过程中是否移除特殊标记。 - clean_up_tokenization_spaces (
bool
, 可选) — 是否清理标记化空间。如果为None
,则默认为self.clean_up_tokenization_spaces
。 - kwargs (额外关键字参数,可选) — 将传递给底层模型特定的解码方法。
返回
List[str]
解码句子的列表。
通过调用解码将token id列表转换为字符串列表。
decode
< 源 >( token_ids : bool = False clean_up_tokenization_spaces : bool = None output_offsets : float = 0.02 decode_with_timestamps : bool = False normalize basic_normalize remove_diacritics **kwargs ) → str
参数
- token_ids (
Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]
) — 分词输入id列表。可以通过使用__call__
方法获得。 - skip_special_tokens (
bool
, 可选, 默认为False
) — 解码时是否移除特殊标记。 - clean_up_tokenization_spaces (
bool
, 可选) — 是否清理分词空格。如果为None
,将默认为self.clean_up_tokenization_spaces
(在tokenizer_config
中可用)。 - output_offsets (
bool
, 可选, 默认为False
) — 是否输出标记的偏移量。仅当模型预测了时间戳时应设置。 - time_precision (
float
, 可选, 默认为 0.02) — 将标记转换为时间的时间比率。 - decode_with_timestamps (
bool
, 可选, 默认为False
) — 是否带有时间戳解码。在原始文本中包含时间戳时适用。 - normalize (
bool
, 可选, 默认为False
) — 是否应用英文文本规范化器到解码后的文本。只在目标文本为英语时适用。否则,应应用基本文本规范化器。 - basic_normalize (
bool
, 可选, 默认为False
) — 是否将基本文本规范化应用于解码后的文本。适用于多语言目标文本。 - remove_diacritics (
bool
, 可选, 默认为False
) — 在应用基本文本规范化时是否删除变音符号。删除变音符号可能会毁坏解码文本中的信息,因此应谨慎使用。 - kwargs (附加关键字参数,可选) — 将传递到底层特定模型解码方法。
返回
str
解码的句子。
使用分词器和词汇表将字符串中的id序列转换为字符串,可选择删除特殊标记和清理分词空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))
。
使用 BasicTextNormalizer
类对给定的字符串进行归一化,该类对多语言文本执行常见转换。
使用 EnglishTextNormalizer
类对给定的字符串进行归一化,该类对英语文本执行常见转换。
WhisperTokenizerFast
类 transformers.WhisperTokenizerFast
< source >( vocab_file = None merges_file = None normalizer_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' add_prefix_space = False language = None task = None predict_timestamps = False **kwargs )
参数
- vocab_file (
str
, 可选) — 词汇文件路径。 - merges_file (
str
, 可选) — 合并文件的路径。 - normalizer_file (
str
, 可选) — 正态化文件的路径。 - tokenizer_file (
str
, 可选) — 包含加载分词器所需所有信息的tokenizers文件路径(通常具有.json扩展名)。 - unk_token (
str
, 可选, 默认为"<|endoftext|>"
) — 未知标记。不在词汇表中的标记无法转换为ID,并将其设置为该标记。 - bos_token (
str
, 可选, 默认为"<|endoftext|>"
) — 序列开始标记。当生成时,使用decoder_start_token_id
将第一个标记设置为"<|startoftranscript|>"
。 - eos_token (
str
, 可选, 默认为"<|endoftext|>"
) — 序列结束标记。 - add_prefix_space (
bool
, 可选, 默认为False
) — 是否在输入前添加一个初始空格。这允许将开头单词视为任何其他单词。(Whisper 算法通过前面的空格检测单词的开始)。 - language (
str
, 可选) — 转写文本的语言。对于多语言语音识别和语音翻译任务,应将相应的语言id标记附加到序列的开头,例如,对于西班牙语,标记"<|es|>"
附加到序列开头。仅用于多语言微调。 - task (
str
, 可选) — 用于附加到序列开头的任务标识符(如果有)。应用于多语言细调,使用"transcribe"
表示语音识别和"translate"
表示语音翻译。 - predict_timestamps (
bool
, 可选, 默认为False
) — 是否在序列开头省略<|notimestamps|>
标记。
构建一个“快速”Whisper分词器(由HuggingFace的tokenizers库支持)。
该分词器继承自PreTrainedTokenizerFast,其中包含大多数主要方法。用户应参考该超类以获取有关这些方法的更多信息。
set_prefix_tokens
< source >( language: 字符串 str = None task: 字符串 str = None predict_timestamps: 布尔 bool = None )
覆盖附加到标签序列开始的标记前缀。此方法可以作为独立方法使用来
从序列中构建模型输入,并追加eos_token_id。
get_special_tokens_mask
< source >( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊标记的标记列表中检索序列ID。此方法在调用tokenizer的prepare_for_model
方法添加特殊标记时调用。
create_token_type_ids_from_sequences
< source >( token_ids_0: 列表 token_ids_1: 可选 = None ) → 列表[int]
为传递的序列创建对应的标记类型ID。 什么是标记类型ID?
如果模型有特殊的构建方式,应该在子类中覆盖。
批量解码
< 来源 >( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → List[str]
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]
) — tokenized 输入 ids 列表。可以使用__call__
方法获取。 - skip_special_tokens (
bool
, 可选, 默认False
) — 解码时是否移除特殊标记。 - clean_up_tokenization_spaces (
bool
, 可选) — 是否清理标记化空格。如果为None
,则默认为self.clean_up_tokenization_spaces
。 - kwargs (额外的关键字参数, 可选) — 将传递给底层模型特定的解码方法。
返回
List[str]
解码句子的列表。
通过调用解码将token id列表转换为字符串列表。
decode
< source >( token_ids : bool = False clean_up_tokenization_spaces : bool = None output_offsets : float = 0.02 decode_with_timestamps : bool = False normalize basic_normalize remove_diacritics **kwargs ) → str
参数
- token_ids (
Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]
) — 分词输入id列表。可以使用__call__
方法获取。 - skip_special_tokens (
bool
, 可选, 默认为False
) — 是否在解码时删除特殊标记。 - clean_up_tokenization_spaces (
bool
, 可选) — 是否清理分词空间。如果为None
,则默认为self.clean_up_tokenization_spaces
(在tokenizer_config
中可用)。 - output_offsets (
bool
, 可选,默认为False
) — 是否输出标记的偏移量。仅在模型预测时间戳时设置此值。 - time_precision (
float
, 可选,默认为 0.02) — 将标记转换为时间的时间比率。 - decode_with_timestamps (
bool
, 可选, 默认为False
) — 是否在原始文本中包含时间戳进行解码。 - normalize (
bool
, 可选, 默认为False
) — 是否将英语文本规范化器应用于解码文本。仅适用于目标和文本为英语的情况。否则,应用基本文本规范化器。 - basic_normalize (
bool
, 可选, 默认为False
) — 是否将基本文本规范化器应用于解码文本。适用于多语言目标文本。 - remove_diacritics (
bool
, 可选, 默认为False
) —— 在应用基本文本标准化时是否移除附音符号。移除附音符号可能会破坏解码文本中的信息,因此应谨慎使用。 - kwargs(附加关键字参数,可选)—— 将传递给底层模型特定的解码方法。
返回
str
解码的句子。
使用分词器和词汇表将字符串中的id序列转换为字符串,可选择删除特殊标记和清理分词空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))
。
使用 BasicTextNormalizer
类对给定的字符串进行归一化,该类对多语言文本执行常见转换。
使用 EnglishTextNormalizer
类对给定的字符串进行归一化,该类对英语文本执行常见转换。
WhisperFeatureExtractor
类 transformers.WhisperFeatureExtractor
< 源代码 >( 特征大小 = 80 采样率 = 16000 跳跃长度 = 160 块长度 = 30 n_fft = 400 填充值 = 0.0 返回注意力掩码 = False **kwargs )
参数
- 特征大小 (
int
, 可选, 默认为 80) — 提取特征的特征维度。 - 采样率 (
int
, 可选, 默认为 16000) — 音频文件应数字化的采样频率,以赫兹(Hz)为单位。 - ——— hop_length (
int
,可选,默认为160)—— 使用STFT计算梅尔频率系数时重叠窗口的长度。 - ——— chunk_length (
int
,可选,默认为30)—— 用来截取和填充更长或更短音频序列的采样率样本的最大块数。 - ——— n_fft (
int
,可选,默认为400)——傅里叶变换的大小。 - padding_value (
浮点数
, 可选, 默认为 0.0) — 用于填充音频的填充值。应该对应于静音部分。
构建一个 Whisper 特征提取器。
此特征提取器继承自 SequenceFeatureExtractor,其中包含大多数主要方法。用户应参考该超类以获取有关这些方法的更多信息。
此类使用自定义 numpy 实现 短时傅里叶变换
从原始语音提取梅尔滤波器组特征,这应该与 pytorch 的 torch.stft
等价。
__call__
< 源 >( raw_speech: 联合 truncation: 布尔 = True pad_to_multiple_of: 可选 = None return_tensors: 联合 = None return_attention_mask: 可选 = None padding: 可选 = 'max_length' max_length: 可选 = None sampling_rate: 可选 = None do_normalize: 可选 = None device: 可选 = 'cpu' return_token_timestamps: 可选 = None **kwargs )
参数
- raw_speech (
np.ndarray
,List[float]
,List[np.ndarray]
,List[List[float]]
) — 要填充的序列或序列批。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表的列表。必须是单声道音频,不是立体声,即每个时间步长只有一个浮点数。 - 截断 (
bool
, 可选, 默认为True
) — 启用截断,将长度超过 max_length 的输入序列截断到 max_length。 - pad_to_multiple_of (
int
, 可选, 默认为 None) — 如果设置为 True,将序列填充到提供值的倍数。 这在启用具有计算能力 greater_than_or_equal_to 7.5 (Volta) 的 NVIDIA 硬件上的 Tensor 核,或在受益于序列长度为 128 倍数的 TPUs 上特别有用。 - return_attention_mask (
bool
, 可选) — 是否返回注意力掩码。如果保留为默认值,将根据特定的特征提取器的默认设置返回注意力掩码。对于 Whisper 模型,在批推理中必须传递
attention_mask
,以避免细微的错误。 - do_normalize (
bool
, optional, defaults toFalse
) — 是否对输入进行零均值单位方差归一化。归一化可以显著提高模型的性能。 - device (
str
, optional, defaults to'cpu'
) — 指定在_torch_extract_fbank_features
方法中计算音频信号的log-mel频谱图的设备。例如:“电脑”“cuda”// HTML_TAG_END --> - {// HTML_TAG_START --}return_token_timestamps (
bool
, optional, defaults toNone
) — 是否返回输入原始语音的帧数。这些帧数可以由模型用于计算词级时间戳。// HTML_TAG_END -->
将序列特征化和准备用于模型一个或多个序列的主方法。如果可用,使用PyTorch进行STFT计算,否则使用较慢的基于NumPy的版本。
WhisperProcessor
类 transformers.WhisperProcessor
< 源代码 >( feature_extractor tokenizer )
参数
- feature_extractor (
WhisperFeatureExtractor
) — 一个WhisperFeatureExtractor的实例。功能提取器是必需输入。 - tokenizer (
WhisperTokenizer
) — WhisperTokenizer 的一个实例。分词器是必需的输入。
构建一个 Whisper 处理器,该处理器将 Whisper 功能提取器和 Whisper 分词器封装到一个处理器中。
WhisperProcessor 提供了 WhisperFeatureExtractor 和 WhisperTokenizer 的所有功能。请参阅 call() 和 decode() 获取更多信息。
from_pretrained
< source >( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )
参数
- pretrained_model_name_or_path (
str
oros.PathLike
) — This can be either:- a string, the model id of a pretrained feature_extractor hosted inside a model repo on huggingface.co.
- a path to a directory containing a feature extractor file saved using the save_pretrained() method, e.g.,
./my_model_directory/
. - a path or url to a saved feature extractor JSON file, e.g.,
./my_model_directory/preprocessor_config.json
. **kwargs — Additional keyword arguments passed along to both from_pretrained() and~tokenization_utils_base.PreTrainedTokenizer.from_pretrained
.
创建与预训练模型关联的处理器。
这个类方法只是简单地调用了特征提取器from_pretrained()、图像处理器ImageProcessingMixin和分词器~tokenization_utils_base.PreTrainedTokenizer.from_pretrained
方法。有关更多信息,请参阅上述方法的文档字符串。
save_pretrained
< source >( save_directory push_to_hub: bool = False **kwargs )
参数
- save_directory (
str
或os.PathLike
) — 将特征提取器JSON文件和分词器文件保存的目录(如果目录不存在,则创建)。 - $push_to_hub (
bool
, 可选, 默认为False
) — 是否在保存模型后将其推送到 Hugging Face 模型中心。您可以使用repo_id
指定要推送到的存储库(默认为您命名空间中保存目录的名称)。$ - $kwargs (
Dict[str, Any]
, 可选) — 传递给 push_to_hub() 方法的额外关键字参数。$
将此处理器(特征提取器、标记器等)的属性保存到指定的目录,以便可以使用 from_pretrained() 方法重新加载。
此类方法只是调用 save_pretrained() 和 save_pretrained() 方法。有关更多信息,请参阅上述方法的文档字符串。
此方法将其所有参数转发到 WhisperTokenizer 的 batch_decode()。请参阅此方法的文档字符串以获取更多信息。
此方法将其所有参数转发到 WhisperTokenizer 的 decode()。请参阅此方法的文档字符串以获取更多信息。
WhisperModel
类 transformers.WhisperModel
< source >( config: WhisperConfig )
参数
- config (WhisperConfig) — 模型配置类,包含所有模型参数。用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看from_pretrained()方法以加载模型权重。
裸 Whisper 模型输出原始隐藏状态,没有顶部任何特定头部。此模型继承自 PreTrainedModel。检查超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并查阅 PyTorch 文档,了解所有与通用用途和行为相关的问题。
前向
< 源代码 >( input_features: 可选 = None attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None head_mask: 可选 = None decoder_head_mask: 可选 = None cross_attn_head_mask: 可选 = None encoder_outputs: 可选 = None past_key_values: 并联类型 = None decoder_inputs_embeds: 可选 = None decoder_position_ids: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None cache_position: 可选 = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_features (形状为
(batch_size, feature_size, sequence_length)
的torch.FloatTensor
) — 从原始语音波形中提取的梅尔特征。原始语音波形可以通过将.flac
或.wav
音频文件加载到List[float]
或numpy.ndarray
类型的数组中获取,例如通过 soundfile 库(pip install soundfile
)。要将数组准备成input_features
,应使用 AutoFeatureExtractor 提取梅尔特征,填充并将其转换为类型为torch.FloatTensor
的张量。有关详细信息,请参阅 call()。 - attention_mask (形状为
(batch_size, sequence_length)
的可选torch.LongTensor
) — 避免在填充标记的索引上执行 SpecAugment 数据增强的掩码。选取的掩码值范围在[0, 1]
:- 为 未掩码 的标记选择 1;
- 为 已掩码 的标记选择 0。
- decoder_input_ids (
torch.LongTensor
形状为(batch_size, target_sequence_length)
, 可选) — 词汇表中的解码输入序列的索引。 - decoder_attention_mask (
torch.LongTensor
形状为(batch_size, target_sequence_length)
, 可选) — 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。默认情况下还会使用因果掩码。modeling_whisper._prepare_decoder_attention_mask
并按需修改。更多关于默认策略的信息,请参阅 BART 论文中的图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(torchobby.FloatTensor)
, optional) — 一个包含元组的元组,包含(last_hidden_state
,optional:hidden_states
,optional:attentions
)。其中,last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,这是一个在编码器最后一个层的输出处的隐藏状态序列。用于解码器的交叉注意力中。 - past_key_values (
EncoderDecoderCache
或tuple(tuple(torchobby.FloatTensor))
, optional) — 可以用于加速自回归(顺序)解码的预计算隐藏状态。存在四组预计算隐藏状态:自我注意力块中的键和值状态(2)和交叉注意力块中的键和值状态(2)。当传递use_cache=True
或当config.use_cache=True
时,返回past_key_values
。 - decoder_inputs_embeds (
torch.FloatTensor
of shape(batch_size, target_sequence_length, hidden_size)
, optional) — 可选,您可以选择直接传递嵌入表示,而不是传递decoder_input_ids
。如果使用了past_key_values
,则可选择只输入最后一个decoder_inputs_embeds
(参见past_key_values
)。如果您想在将decoder_input_ids
索引转换为相关向量方面比模型的内部嵌入查找矩阵有更多控制,则这非常有用。 - use_cache (
bool
, optional) — 如果设置为True
,则会返回past_key_values
的键值状态,可用于加速解码(参见past_key_values
)。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回的张量中的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。更多详情请见返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回ModelOutput而不是普通的元组。 - cache_position (
torch.LongTensor
of shape(sequence_length)
, optional) — 表示输入序列标记在序列中的位置的索引。它用于在正确的位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput或tuple(torch.FloatTensor)
transformers.modeling_outputs.Seq2SeqModelOutput或tuple(torch.FloatTensor)(如果return_dict=False
被传递或当config.return_dict=False
时),根据配置(WhisperConfig)和输入包含各种元素。
-
last_hidden_state (
torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
) — 模型解码器最后一层的隐藏状态序列。如果使用
past_key_values
,则只输出序列的最后一个隐藏状态,形状为(batch_size, 1, 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
输入)以加速顺序解码。 -
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
时返回)—— 每个层对应的形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor)
,可选,在传递output_attentions=True
时返回,或者在config.output_attentions=True
时返回)—— 每个层对应的形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
序列。解码器交叉注意力层的注意力权重,在注意力softmax后使用,用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)—— 模型编码器最后层的输出隐藏状态序列。 -
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
时返回)—— 每个层对应的形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
序列。编码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
WhisperModel的forward方法覆盖了__call__
特殊方法。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperModel
>>> from datasets import load_dataset
>>> model = WhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], 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, 512]
根据SpecAugment协议提取沿时间轴和/或特征轴的特征掩码。
WhisperForConditionalGeneration
类 transformers.WhisperForConditionalGeneration
< 源代码 >( config: WhisperConfig )
参数
- 配置 (WhisperConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重,只有配置。检查from_pretrained()方法来加载模型权重。
带有语言建模头的Whisper模型。可用于自动语音识别。此模型继承自PreTrainedModel。检查超类文档了解库为所有模型实现的方法(如下载或保存、调整输入嵌入大小、剪枝头部等。)
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并查阅 PyTorch 文档,了解所有与通用用途和行为相关的问题。
前向
< 源码 >( input_features: 可选 = None attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None head_mask: 可选 = None decoder_head_mask: 可选 = None cross_attn_head_mask: 可选 = None encoder_outputs: 可选 = None past_key_values: 联合 = None decoder_inputs_embeds: 可选 = None decoder_position_ids: 可选 = None labels: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None cache_position: 可选 = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_features (
torch.FloatTensor
of shape(batch_size, feature_size, sequence_length)
) — 从原始语音波形中提取的梅尔特征。通过将一个.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中,可以得到原始语音波形,例如使用soundfile库(pip install soundfile
)。为了将数组准备为input_features
,应使用AutoFeatureExtractor进行提取梅尔特征、填充和转换为类型为torch.FloatTensor
的张量。请参阅call() - attention_mask (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — 用于防止在填充标记索引上进行SpecAugment数据增强的掩码。掩码值选取范围在[0, 1]
内:- 1代表未被掩盖的标记,
- 0代表被掩盖的标记。
- decoder_input_ids (
torch.LongTensor
of shape(batch_size, target_sequence_length)
, optional) ——词汇表中的解码器输入序列标记的索引。可以使用WhisperTokenizer获取索引。有关详细信息,请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
Whisper使用
decoder_start_token_id
作为decoder_input_ids
生成的起始标记。如果使用past_key_values
,则可选地只需输入最后decoder_input_ids
(请参阅past_key_values
)。 - decoder_attention_mask (
torch.LongTensor
of shape(batch_size, target_sequence_length)
, optional) ——默认行为:生成一个张量,忽略decoder_input_ids
中的填充标记。默认情况下也将使用前向掩码。modeling_whisper._prepare_decoder_attention_mask并按需修改。更多信息,请参阅BART论文中的图1所述的默认策略。
- 头掩码 (
torch.Tensor
形状为(encoder_layers, encoder_attention_heads)
,可选) — 用于在编码器中去除选择的注意力模块的头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未掩码,
- 0 表示头部 已掩码。
- 解码器头掩码 (
torch.Tensor
形状为(decoder_layers, decoder_attention_heads)
,可选) — 用于去除解码器中选择的注意力模块的头部的掩码。掩码值在[0, 1]
中选择:- 1 表示头部 未掩码,
- 0 表示头部 已掩码。
- 交叉注意力头掩码 (
torch.Tensor
形状为(decoder_layers, decoder_attention_heads)
,可选) — 用于去除交叉注意力模块中选择的头部。掩码值在[0, 1]
中选择:- 1 表示头部 未掩码,
- 0 表示头部 已掩码。
-
encoder_outputs ( tuple(tuple(torch.FloatTensor)
, 可选) — Tuple 包含last_hidden_state
、可选:hidden_states
、可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选) 是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力中。 -
past_key_values ( EncoderDecoderCache
或tuple(tuple(torch.FloatTensor))
, 可选) — 预计算隐藏状态,可用于加速自回归(顺序)解码。有四组预计算隐藏状态:自注意力块和交叉注意力块中的键和值状态(各2组)。当传入use_cache=True
或时config.use_cache=True
允许两种格式:
- EncoderDecoderCache 实例;
- 长度为
config.n_layers
的tuple(torch.FloatTensor)
的元组,每个元组包含形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的 2 个张量以及形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的 2 个附加张量。
如果使用
past_key_values
,用户可以可选地仅输入最后一个decoder_input_ids
(没有给此模型提供过去键值状态的那些)的形状为(batch_size, 1)
,而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。 - decoder_inputs_embeds (
torch.FloatTensor
of shape(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 而不是普通元组。 - cache_position (
torch.LongTensor
of shape(sequence_length)
, 可选) — 表示输入序列令牌在序列中的位置的索引。它用于在正确位置更新缓存并推断完整序列长度。 - labels (
torch.LongTensor
of shape(batch_size, sequence_length)
, 可选) — 用于计算语言模型损失的标签。索引应位于[0, ..., config.vocab_size]
或-100(参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅对具有标签在[0, ..., config.vocab_size]
的标记进行计算。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.Seq2SeqLMOutput 或一个包含torch.FloatTensor
的元组(如果传递了return_dict=False
或当config.return_dict=False
),包含各种元素,具体取决于配置(WhisperConfig)和输入。
-
loss (
torch.FloatTensor
of shape(1,)
, 可选 -
logits (
torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言模型头部的预测分数(SoftMax之前的每个词汇表的分数)。 -
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
时返回)—— 每个层对应的形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor)
,可选,在传递output_attentions=True
时返回,或者在config.output_attentions=True
时返回)—— 每个层对应的形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
序列。解码器交叉注意力层的注意力权重,在注意力softmax后使用,用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)—— 模型编码器最后层的输出隐藏状态序列。 -
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
时返回)—— 每个层对应的形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
序列。编码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
WhisperForConditionalGeneration 前向方法,重写了__call__
特殊方法。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], 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
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
生成
< source >( input_features: 可选 = None generation_config: 可选 = None logits_processor: 可选 = None stopping_criteria: 可选 = None prefix_allowed_tokens_fn: 可选 = None synced_gpus: 布尔类型 = False return_timestamps: 可选 = None task: 可选 = None language: 联合类型 = None is_multilingual: 可选 = None prompt_ids: 可选 = None prompt_condition_type: 可选 = None condition_on_prev_tokens: 可选 = None temperature: 联合类型 = None compression_ratio_threshold: 可选 = None logprob_threshold: 可选 = None no_speech_threshold: 可选 = None num_segment_frames: 可选 = None attention_mask: 可选 = None time_precision: 浮点数 = 0.02 return_token_timestamps: 可选 = None return_segments: 布尔类型 = False return_dict_in_generate: 可选 = None **kwargs ) → ModelOutput 或 torch.LongTensor
或 Dict[str, Any]
参数
- input_features (
torch.Tensor
of shape(batch_size, feature_size, sequence_length)
, optional) — 从原始语音波形中提取的对数梅尔特征的浮点值。原始语音波形可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中(例如,使用soundfile库(pip install soundfile
))来获得。要将数组准备成input_features
,应使用AutoFeatureExtractor提取梅尔特征、填充并将其转换为类型为torch.FloatTensor
的张量。有关详细信息,请参阅call()。 - generation_config (
~generation.GenerationConfig
, optional) — 用于生成调用作为基本参数化的生成配置。传递给generate
的匹配generation_config
属性的**kwargs
将覆盖它们。如果没有提供generation_config
,将使用默认值,其加载优先级如下:1) 如果存在,从generation_config.json
模型文件中加载;2) 从模型配置中加载。请注意,未指定的参数将继承GenerationConfig的默认值,其文档应进行检查以参数化生成。 - logits_processor (
LogitsProcessorList
, 可选) — 自定义的 logits 处理器,以补充从参数和生成配置构建的默认 logits 处理器。如果传递了在使用参数或生成配置已创建的 logits 处理器,将抛出一个错误。此功能面向高级用户。 - stopping_criteria (
StoppingCriteriaList
, 可选) — 自定义的停止条件,以补充从参数和生成配置构建的默认停止条件。如果传递了在使用参数或生成配置已创建的停止条件,将抛出一个错误。此功能面向高级用户。 - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], List[int]]
, 可选) — 如果提供,此函数将约束 beam search 只允许在每个步骤使用受允许的 token。如果未提供,将不应用任何约束。此函数接受两个参数:批 IDbatch_id
和input_ids
。它必须返回一个列表,该列表包含根据批 IDbatch_id
和先前生成的 tokeninput_ids
限制的下一生成步骤允许的 token。该参数对于基于前缀的约束生成很有用,如 自回归实体检索 中所述。 - synced_gpus (
bool
, 可选, 默认为False
) — 是否在达到最大长度(ZeRO阶段3需要)的情况下继续运行while循环 - return_timestamps (
bool
, 可选) — 是否与文本一起返回时间戳。这启用了WhisperTimestampsLogitsProcessor
。 - task (
str
, 可选) — 用于生成的任务,可以是“translate”或“transcribe”。将相应地更新model.config.forced_decoder_ids
。 - 语言 (
str
或str
列表,可选) — 用于生成的语言标记,可以是<|en|>
、en
或english
的形式。对于分批生成,可以传入语言标记列表。所有可能的语言标记可以在model.generation_config.lang_to_id
字典中找到。 - is_multilingual strong> (
bool
,可选) — 模型是否为多语言。 - prompt_ids (
torch.Tensor
,可选) — 由将文本传递到get_prompt_ids()
生成的 token ID 矩阵,用作每个块的提示。这可以用来提供“提示工程”上下文,例如自定义词汇或专有名词,使其更可能导致正确预测这些单词。不能与decoder_start_token_id
同时使用,因为它会覆盖此值。 - prompt_condition_type (
str
, 可选) — 仅适用于长文本转录。与prompt_ids
相关联的条件类型。‘first-segment’ 表示只对第一个段落的prompt_ids
进行条件约束。‘all-segments’ 表示对每个段落都进行条件约束。请确保在‘all-segments’的情况下启用condition_on_prev_tokens
。默认为 ‘first-segment’。对于短期转录,仅支持 ‘first-segment’。 - condition_on_prev_tokens (
bool
, 可选) — 仅适用于长文本转录。是否对每个段落在前一段的基础上进行条件约束。如 Whisper 论文 所示,这有助于提高性能。 - temperature (
float
或float
列表,可选) — 用于生成的温度。传入单个float
值和do_sample=True
会启动使用采样进行的生成。对于长文本转录,可以通过传入例如 (0.0, 0.2, 0.4, 0.6, 0.8, 1.0) 的浮点数列表来激活温度回退。如 Whisper 论文 所示,这可以有助于提高性能。 - 压缩比例阈值 (
浮点数
, 可选) — 仅适用于长格式转录。如果定义,将计算每个段的zlib压缩率。如果某段的压缩率高于压缩比例阈值
,将激活温度回落:丢弃生成的段,并用更高的温度重新生成。该功能的直觉是,压缩率非常高的段存在大量重复。通过增加温度注入更多随机性可以减少不必要的重复。如果定义了压缩比例阈值
,请确保温度
是值列表。压缩比例阈值
的一个常见值是 1.35。根据Whisper 论文所示,这可以帮助提高性能。 - 对数概率阈值 (
浮点数
, 可选) — 仅适用于长格式转录。如果定义,将计算每个段的对数概率平均值。如果给定段的对数概率低于对数概率阈值
,将激活温度回落:丢弃生成的段,并用更高的温度重新生成。该功能的直觉是,对数概率较低的段可以通过增加温度注入更多随机性来改进。如果定义了对数概率阈值
,请确保温度
是值列表。对数概率阈值
的一个常见值是 -1.0。根据Whisper 论文所示,这可以帮助提高性能。 - no_speech_threshold (浮点型,可选)— 仅适用于长文本转录。如果定义,则“无语音”标记与
logprob_threshold
结合用于确定一个片段是否只包含静音。在这种情况下,会跳过该片段的转录。如《Whisper论文》所示[1],这有助于提高性能。 - num_segment_frames (整型,可选)— 单个片段由多少个帧组成。如果没有定义,则
num_segment_frames
默认为模型的步长与最大输入长度的乘积。 - attention_mask (PyTorch张量,可选)— 在使用批量大小 > 1 进行长文本转录时需要传递
attention_mask
。 - time_precision (
int
,可选,默认为0.02) — 输出token的持续时间(秒)。例如:0.02意味着生成的token平均account for 20 ms。 - return_token_timestamps (
bool
,可选) — 是否返回与文本相关的token级时间戳。这可以在不使用或使用return_timestamps
选项的情况下使用。要获取word级时间戳,请使用分词器将token分组为单词。 - return_segments (
bool
,可选,默认为False) — 是否额外返回所有段落的列表。请注意,此选项只能在执行长文本转录时启用。 - return_dict_in_generate (
bool
, 可选,默认为False
)— 是否返回一个ModelOutput
对象而不是只返回生成的tokens。注意,在进行长格式转录时,只有当return_segments
设置为True时,才可以选择启用return_dict_in_generate
。在这种情况下,每个段落的生成输出将被添加到每个段落的输出中。 - kwargs (
Dict[str, Any]
, 可选) — 对generate_config
和/或模型特定kwargs的即兴参数化,这些kwargs将被转发到模型的forward
函数中。如果模型是编码器-解码器模型,则编码器特定的kwargs不应加前缀,而解码器特定的kwargs应加前缀decoder_。
返回
ModelOutput或torch.LongTensor
或Dict[str, Any]
ModelOutput(如果return_dict_in_generate=True
或当config.return_dict_in_generate=True
)或torch.FloatTensor
或当return_segments=True
时的段落数据。
如果传入的输入大于30秒/大于3000个mel输入特征且return_segments=True
,则返回一个生成序列ID的字典,称为sequences
,以及一个每个生成的段的列表。
否则,如果传入的输入小于等于30秒/大于等于3000个mel输入特征,可能的ModelOutput类型
只返回生成的输出序列ID。
将log-mel输入特征转录或翻译成一组自动回归生成的token ID。
大多数生成控制参数都在generation_config
中设置,如果未传递,则将设置为模型的默认生成配置。您可以通过将对应的参数传递给generate()来覆盖任何generation_config
,例如.generate(inputs, num_beams=4, do_sample=True)
。
有关生成策略和代码示例的概述,请参阅以下指南。
示例
- 长格式转录:要转录或翻译超过30秒的音频,不截断处理音频文件,并一次性传递所有mel特征以生成。
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset, Audio
>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> model.cuda()
>>> # load audios > 30 seconds
>>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"]
>>> # resample to 16kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
>>> # take first 8 audios and retrieve array
>>> audio = ds[:8]["audio"]
>>> audio = [x["array"] for x in audio]
>>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio
>>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000)
>>> inputs = inputs.to("cuda", torch.float32)
>>> # transcribe audio to ids
>>> generated_ids = model.generate(**inputs)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."
- 简短转写:如果传入的mel输入特征小于30秒,则整个音频将使用一次调用生成。
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], 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
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
WhisperForCausalLM
类 transformers.WhisperForCausalLM
< source >( config )
参数
- config (WhisperConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载模型关联的权重,只会加载配置。请检查from_pretrained()方法以加载模型权重。
顶部的语言模型头上的Whisper解码器(与输入嵌入相关的权重线性层)。
此模型继承自PreTrainedModel。请查看超类文档,了解库为所有模型实现的通用方法(例如下载或保存,调整输入嵌入大小,剪枝头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并查阅 PyTorch 文档,了解所有与通用用途和行为相关的问题。
前向
< source >( input_ids: LongTensor = None attention_mask: Optional = None encoder_outputs: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
) — 输入序列token在词汇表中的索引。如果提供,默认会忽略padding。索引可以使用AutoTokenizer获得。有关详细信息,请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。什么是输入ID? - attention_mask (形状为
(batch_size, sequence_length)
的torch.Tensor
,可选) — 避免在padding的token索引上执行注意力操作的掩码。掩码值选择在[0, 1]
:- 1 表示 未掩码的token,
- 0 表示 掩码的token。 什么是注意力掩码?
- encoder_outputs (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选) — 在编码器最后一个层的输出处的隐藏状态序列。如果模型配置为解码器,则用于交叉注意力。 - 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 表示头部 被掩码.
- 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)
,而不是所有decoder_input_ids
的形状为(batch_size, sequence_length)
。 - inputs_embeds (
torch.FloatTensor
形状为(batch_size, sequence_length, hidden_size)
, 可选) — 可选的,而不是传递input_ids
,您可以选择直接传递一个嵌入式表示。这在您想要比模型的内部嵌入查找矩阵有更多控制权如何将input_ids
索引转换为关联向量时很有用。 - labels (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — 用于计算掩码语言模型损失的标签。索引应为[0, ..., config.vocab_size]
或 -100(见input_ids
文档字符串)。索引为-100
的标记将被忽略(掩码),损失仅对标签在[0, ..., config.vocab_size]
范围内的标记进行计算。 - use_cache (
bool
, optional) — 如果设置为True
,会返回past_key_values
的键值状态,可用于加速解码(见past_key_values
)。- 1 用于未掩码的标记,
- 0 用于掩码标记。
- output_attentions (
bool
, optional) — 是否返回所有注意力的张量。有关更多详细信息,请参阅返回的张量中的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。请参阅返回张量下的hidden_states
获取更多信息。 - return_dict (
bool
, 可选) — 是否返回ModelOutput 而不是普通的元组。 - cache_position (
torch.LongTensor
形状为(sequence_length)
, 可选) — 表示输入序列标记在序列中的位置的索引。它用于在正确的位置更新缓存并推断完整序列长度。
返回
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个由 torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
),它包含根据配置(WhisperConfig)和输入的各种元素。
-
loss (
torch.FloatTensor
的长度为(1,),可选,当提供
labels
时返回) — 语言模型损失(用于下一标记预测)。 -
logits (
torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言模型头部的预测分数(SoftMax之前的每个词汇表的分数)。 -
hidden_states (
tuple(torch.FloatTensor)
, 可选,在传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入输出 + 各层输出),形状为(batch_size, sequence_length, hidden_size)
。模型在每个输出层以及可选的初始嵌入输出处的隐藏状态。
-
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
时返回)—— 每个层对应的形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
序列。通过注意力 softmax 的交叉注意力权重,用于在交叉注意力头中计算加权平均。
-
past_key_values (
tuple(tuple(torch.FloatTensor))
, 可选,在传递use_cache=True
或当config.use_cache=True
时返回) — 长度为config.n_layers
的torch.FloatTensor
元组的元组,如果模型在编码器-解码器设置中使用,则每个元组包含自注意力和交叉注意力层的缓存键、值状态。只有在config.is_decoder = True
时才相关。包含预计算的隐藏状态(注意力块中的键和值),可用于(参见
past_key_values
输入)以加速顺序解码。
示例
>>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor
>>> import torch
>>> from datasets import load_dataset
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2")
>>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> sample = ds[0]["audio"]
>>> input_features = processor(
... sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt"
... ).input_features
>>> predicted_ids = model.generate(input_features, assistant_model=assistant_model)
>>> # decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.'
WhisperForAudioClassification
class transformers.WhisperForAudioClassification
< source >( config )
参数
- input_features (
torch.FloatTensor
形状为(batch_size, feature_size, sequence_length)
) — 从原始语音波形提取的梅尔特征浮点值。原始语音波形可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中获取,例如通过 soundfile 库(pip install soundfile
)。要将数组准备好为input_features
,应使用 AutoFeatureExtractor 提取梅尔特征,填充,并将其转换为类型为torch.FloatTensor
的张量。参见 call() - head_mask (
torch.Tensor
形状为(encoder_layers, encoder_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)
,可选)是编码器最后一层的隐藏状态序列。 - output_attentions (
bool
, 可选) — 是否返回所有注意力的张量。详情请见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐蔽状态。详情请见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
在数据分类头部上方(在池化输出上的线性层)带有 sequence 分类 Whisper 编码器模型,用于像 SUPERB 关键词检测等任务。
前向
< 来源 >( input_features: 可选 = None head_mask: 可选 = None encoder_outputs: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)
参数
- input_features (
torch.FloatTensor
of shape(batch_size, feature_size, sequence_length)
) — 从原始语音波形中提取的梅尔(Mel)特征浮点值。原始语音波形可以通过将.flac
或.wav
音频文件加载到一个类型为List[float]
或numpy.ndarray
的数组中获取,例如使用soundfile库(pip install soundfile
)。要将数组准备好为input_features
,应使用AutoFeatureExtractor
提取梅尔特征,填充和转换为类型为torch.FloatTensor
的张量。详见AutoFeatureExtractor
。查看call()方法。 - head_mask (
torch.Tensor
of shape(encoder_layers, encoder_attention_heads)
, optional) — 用于取消激活编码器中注意力模块中选定头的掩码。掩码值选择在[0, 1]
之间:- 1表示头未被掩码,
- 0表示头被掩码。
- encoder_outputs (
tuple(tuple(torch.FloatTensor)
, optional) — 包含一个元组,该元组由 (last_hidden_state
,optional:hidden_states
,optional:attentions
) 组成,last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional) 是编码器最后一层的隐藏状态序列。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回ModelOutput而不是原始元组。 - labels (
torch.LongTensor
,形状(batch_size,)
,可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_outputs.SequenceClassifierOutput或tuple(torch.FloatTensor)
这是一个transformers.modeling_outputs.SequenceClassifierOutput或一个由torch.FloatTensor
组成的元组(如果传递了return_dict=False
或当config.return_dict=False
时),它包括各种元素,具体取决于配置(WhisperConfig)和输入。
-
loss (
torch.FloatTensor
,形状(1,)
,可选,当提供时返回) — 分类(或如果config.num_labels == 1则为回归)损失。 -
logits (
torch.FloatTensor
,形状(batch_size, config.num_labels)
) — 分类(如果config.num_labels == 1则为回归)的得分(在SoftMax之前)。 -
hidden_states (
tuple(torch.FloatTensor)
, 可选,在传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(如果模型有嵌入层,则为嵌入输出 + 各层输出),形状为(batch_size, sequence_length, hidden_size)
。模型在每个输出层以及可选的初始嵌入输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor)
, 可选,在传递output_attentions=True
或当config.output_attentions=True
时返回) — 每层torch.FloatTensor
的元组,形状为(batch_size, num_heads, sequence_length, sequence_length)
。通过注意力 softmax 后的注意力权重,用于在自我注意力头中计算加权平均。
WhisperForAudioClassification的前向方法覆盖了__call__
特殊方法。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperForAudioClassification
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)
>>> sample = next(iter(ds))
>>> inputs = feature_extractor(
... sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features
>>> with torch.no_grad():
... logits = model(input_features).logits
>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'Afrikaans'
TFWhisperModel
类 transformers.TFWhisperModel
< 源代码 >( config: WhisperConfig **kwargs )
参数
- config (WhisperConfig) — 包含所有模型参数的配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。请查看 from_pretrained() 方法以加载模型权重。
没有在顶部添加任何特定头部的裸Whisper模型,输出原始隐藏状态。该模型继承自 TFPreTrainedModel。有关库为其所有模型(如下载或保存、调整输入嵌入、剪枝头部等)实现的通用方法的文档,请查看超类文档。
这个模型也是 keras.Model 的子类。将其视为常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档,以了解所有与通用用法和行为相关的事项。
调用
< 源代码 >( input_features: TFModelInputType | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: 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: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: Optional[Tuple[Union[np.ndarray, tf.Tensor]]] = 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 ) → transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
参数
- input_features (形状为
tf.Tensor
的(batch_size, feature_size, sequence_length)特征浮点值)— 从原始语音波形中提取的fbank特征浮点值。原始语音波形可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中来获得,例如使用soundfile库(pip install soundfile
)。要将数组准备成 input_features,应使用AutoFeatureExtractor来提取fbank特征、填充并转换为类型为tf.Tensor
的张量。请参阅call()。 - decoder_input_ids (形状为
tf.Tensor
的(batch_size, target_sequence_length)
,非必需)— 词汇表中的解码器输入序列标记的索引。索引可以使用
SpeechToTextTokenizer
获取。请参阅PreTrainedTokenizer.encode("
和PreTrainedTokenizer.call(). - decoder_attention_mask (形状为
(batch_size, target_sequence_length)
的tf.Tensor
,可选) — 默认操作:生成一个忽略decoder_input_ids
中的垫片标记的张量。默认情况下还会使用因果掩码。如果您想更改填充行为,应阅读
modeling_whisper._prepare_decoder_attention_mask
并根据您的需求进行修改。有关默认策略的更多信息,请参阅 论文 中的图 1。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)
的tf.Tensor
,可选) — 用于取消编码器中注意力模块选择的头部的掩码。掩码值选择范围在[0, 1]
:- 1 表示头部没有被 掩码;
- 0 表示头部被 掩码。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)
的tf.Tensor
,可选) — 用于取消解码器中注意力模块选择的头部的掩码。掩码值选择范围在[0, 1]
:- 1 表示头部没有被 掩码;
- 0 表示头部被 掩码。
- cross_attn_head_mask (
tf.Tensor
of shape(decoder_layers, decoder_attention_heads)
, 可选) — 用于取消激活跨注意力模块中选定头的掩码。掩码值选择在[0, 1]
范围内:- 1 表示头 未掩码,
- 0 表示头 已掩码。
- encoder_outputs (
tuple(tuple(tf.Tensor)
, 可选) — 元组包含(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的跨注意力中。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的结果张量。请参阅返回张量下的attentions
以获取更多详细信息。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。请参阅返回张量下的hidden_states
以获取更多详细信息。 - return_dict (
bool
, 可选) — 是否返回ModelOutput对象而不是普通元组。
返回
transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)
一个transformers.modeling_tf_outputs.TFSeq2SeqModelOutput对象或一个包含各种元素(根据配置(WhisperConfig)和输入进行组合的tf.Tensor
元组(如果传递了return_dict=False
或当config.return_dict=False
)。
-
last_hidden_state (模型编码器最后一个层输出时的隐藏状态张量
tf.Tensor
的形状为(batch_size, sequence_length, hidden_size)
)如果使用
past_key_values
,则只输出序列的最后一个隐藏状态,形状为(batch_size, 1, hidden_size)
。 -
past_key_values (当传递
use_cache=True
时返回的List[tf.Tensor]
,可选,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。)包含预计算的解码器隐藏状态(注意力块中的键和值),可用于(见
past_key_values
输入)加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor)
, 可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(嵌入式输出 + 各层输出)。每个层输出的解码器隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(tf.Tensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(嵌入式输出 + 各层输出)。每个层输出的编码器隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。编码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
TFWhisperModel 的前向方法,覆盖了 __call__
特殊方法。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> import tensorflow as tf
>>> from transformers import TFWhisperModel, AutoFeatureExtractor
>>> from datasets import load_dataset
>>> model = TFWhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="tf")
>>> input_features = inputs.input_features
>>> decoder_input_ids = tf.convert_to_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, 512]
TFWhisperModel
类 transformers.TFWhisperForConditionalGeneration
< source >( config: WhisperConfig **kwargs )
参数
- config (WhisperConfig) — 包含模型所有参数的配置类。使用配置文件初始化时不会加载模型相关的权重,仅加载配置。检查from_pretrained()方法来加载模型权重。
具有语言模型头部的Whisper模型。可用于自动语音识别。此模型从TFPreTrainedModel继承。请检查超类文档,了解库为其所有模型(如下载或保存、调整输入嵌入的大小、剪枝头部等)实现的通用方法。
这个模型也是 keras.Model 的子类。将其视为常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档,以了解所有与通用用法和行为相关的事项。
调用
< source >( input_features: TFModelInputType 或 None = None decoder_input_ids: np.ndarray 或 tf.Tensor 或 None = None decoder_attention_mask: np.ndarray 或 tf.Tensor 或 None = None decoder_position_ids: 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: 可选 [Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None past_key_values: 可选 [Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: 可选 [Tuple[Union[np.ndarray, tf.Tensor]]] = None labels: np.ndarray 或 tf.Tensor 或 None = None use_cache: 可选 [bool] = None output_attentions: 可选 [bool] = None output_hidden_states: 可选 [bool] = None return_dict: 可选 [bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)
参数
- input_features (
tf.Tensor
of shape(batch_size, feature_size, sequence_length)
) — 从原始语音波形中提取的fbank特征的浮点值。可以通过加载.flac
或.wav
音频文件到一个类型为List[float]
或numpy.ndarray
的数组中(例如通过soundfile库(pip install soundfile
))来获取原始语音波形。为了准备数组到input_features
,应使用AutoFeatureExtractor提取fbank特征、填充和转换为类型为tf.Tensor
的张量。参见call()。 - decoder_input_ids (
tf.Tensor
of shape(batch_size, target_sequence_length)
, optional) — 词典中解码器输入序列标记的索引。可以使用
SpeechToTextTokenizer
获取索引。有关详细信息,请参阅PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。SpeechToText使用
eos_token_id
作为decoder_input_ids
生成的起始标记。如果使用past_key_values
,则可选地仅需输入最后的decoder_input_ids
(请参阅past_key_values
)。 - decoder_attention_mask (
tf.Tensor
的形状为(batch_size, target_sequence_length)
, 可选) — 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。默认情况下还会使用因果掩码。如果您想更改填充行为,应阅读
modeling_whisper._prepare_decoder_attention_mask
并根据您的需求进行修改。更多信息见论文中的图1。 - 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 (
tuple(tuple(tf.Tensor)
,可选) — 由以下内容构成的元组:(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选> 是编码器最后层输出的隐藏状态序列。用于解码器的交叉注意力中。 - past_key_values (
tuple(tuple(tf.Tensor))
, 可选,当传递use_cache=True
时返回或当config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(tuple(tf.Tensor))
元组,每个元组包含2个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的tensor和2个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的tensor。包含预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于(参见past_key_values
输入)加速序列解码。如果使用past_key_values
,用户可以选择只输入形状为(batch_size, 1)
的最后decoder_input_ids
(那些没有将过去的键值状态提供给此模型的)而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。 - decoder_inputs_embeds (
tf.Tensor
为(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
, optional) — 是否返回ModelOutput对象而不是普通元组。 - labels (
tf.Tensor
of shape(batch_size, sequence_length)
, optional) — 计算语言模型损失的标签。索引应在[0, ..., config.vocab_size]
或 -100(见input_ids
文档字符串)之间。设置为-100
的索引的标记将被忽略(掩码),只计算包含标签[0, ..., config.vocab_size]
的标记的损失。
返回
transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)
transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一个tf.Tensor
的元组(如果传递了 return_dict=False
或 config.return_dict=False
),包括根据配置(WhisperConfig)和输入的各种元素。
-
loss (
tf.Tensor
of shape(n,)
, optional, where n is the number of non-masked labels, returned whenlabels
is provided) — 语言模型损失。 -
logits (
tf.Tensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言模型头部的预测分数(在 SoftMax 之前的每个词汇的分数)。 -
past_key_values (当传递
use_cache=True
时返回的List[tf.Tensor]
,可选,每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)
。)包含预计算的解码器隐藏状态(注意力块中的键和值),可用于(见
past_key_values
输入)加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor)
, 可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(嵌入式输出 + 各层输出)。每个层输出的解码器隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(tf.Tensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力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
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(嵌入式输出 + 各层输出)。每个层输出的编码器隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。编码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
TFWhisperForConditionalGeneration的前向方法,覆盖了__call__
特殊方法。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFWhisperForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = TFWhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="tf")
>>> input_features = inputs.input_features
>>> generated_ids = model.generate(input_features=input_features)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
FlaxWhisperModel
类 transformers.FlaxWhisperModel
< 来源 >( config: WhisperConfig input_shape: Tuple = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )
参数
- config (WhisperConfig) — Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.
- dtype (
jax.numpy.dtype
, 可选,默认为jax.numpy.float32
) — 计算的数据类型。可以是以下之一:jax.numpy.float32
,jax.numpy.float16
(在GPU上)和jax.numpy.bfloat16
(在TPU上)。这可以用来启用在GPU或TPU上的混合精度训练或半精度推理。如果指定了dtype
,所有计算都将使用该数据类型执行。注意,这仅指定了计算的数据类型,并不影响模型参数的数据类型。 如果你想更改模型参数的数据类型,请参阅 to_fp16() 和 to_bf16()。
一个裸Whisper模型变换器,输出原始隐藏状态而不带有任何特定的头部。此模型继承自 FlaxPreTrainedModel。检查超类文档以了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入尺寸、修剪头部等)。此模型也是Flax Linen flax.nn.Module的子类。将其用作常规Flax模块,并参考Flax文档获取所有与一般使用和行为相关的内容。最后,此模型支持固有的JAX功能,例如:
__call__
< source >( input_features: Array decoder_input_ids: Array attention_mask: 可选 = None decoder_attention_mask: 可选 = None position_ids: 可选 = None decoder_position_ids: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput or tuple(torch.FloatTensor)
参数
- input_features (
numpy.ndarray
of shape(batch_size, feature_size, sequence_length)
) — 从原始语音波形提取的梅尔特征浮点值。原始语音波形可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中来获取,例如通过 soundfile 库(pip install soundfile
)。要准备数组为input_features
,应使用 WhisperFeatureExtractor 提取特征、填充并转换为类型为numpy.ndarray
的张量。请参阅 call() - attention_mask (
numpy.ndarray
尺寸为(batch_size, sequence_length)
,可选) — Whisper 不支持input_features
的遮蔽,此参数保留以兼容性,但未使用。默认情况下,输入日志梅尔谱图中沉默部分将被忽略。 - decoder_input_ids (
numpy.ndarray
尺寸为(batch_size, target_sequence_length)
,可选) — 解码器输入序列令牌在词汇表中的索引。可以使用 WhisperTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。解码器输入ID是什么? Whisper 使用decoder_start_token_id
作为decoder_input_ids
生成的起始令牌。 - decoder_attention_mask (
numpy.ndarray
尺寸为(batch_size, target_sequence_length)
,可选) — 默认行为:生成一个忽略decoder_input_ids
中填充令牌的张量。默认情况下还将使用因果掩码。如果您想更改填充行为,应修改以满足您的需求。有关默认策略的更多信息,请参阅 论文 中的图 1。 - position_ids (
numpy.ndarray
形状为(batch_size, sequence_length)
, 可选) - Whisper 在编码器中不使用position_ids
作为input_features
总是相同的大小且不使用掩码,但为了兼容性保留此参数。默认情况下,输入对数梅尔频谱图中的静音被忽略。 - decoder_position_ids (
numpy.ndarray
形状为(batch_size, sequence_length)
, 可选) - 每个解码器输入序列标记在整个位置嵌入中的位置索引。选择在范围[0, config.max_position_embeddings - 1]
内。 - output_attentions (
bool
, 可选) - 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回的张量下的attentions
。 - output_hidden_states (bool,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的
hidden_states
。 - return_dict (bool,可选)— 是否返回ModelOutput对象而不是普通元组。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput或tuple(torch.FloatTensor)
A transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput或是一个包含torch.FloatTensor
的元组(当return_dict=False
被传入或当config.return_dict=False
时),它包含各种元素,这些元素取决于配置(WhisperConfig)和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的jnp.ndarray)— 模型解码器输出最后层的隐藏状态序列。如果使用
past_key_values
,则只输出序列的最后一个隐藏状态,形状为(batch_size, 1, hidden_size)
。 -
past_key_values (形状为
tuple(tuple(jnp.ndarray))
的元组,可选,在传入use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(jnp.ndarray)
的元组,每个元组包含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(jnp.ndarray)
的元组,可选,在传入output_hidden_states=True
或config.output_hidden_states=True
时返回)— 包含嵌入输出和每个层输出的形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray的元组。每个层输出的解码器隐藏状态以及初始嵌入输出。
-
decoder_attentions (形状为
tuple(jnp.ndarray)
的元组,可选,在传入output_attentions=True
或config.output_attentions=True
时返回)— 包含每个层的形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray的元组。解码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
-
cross_attentions (
jnp.ndarray
的元组,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 包含每个层jnp.ndarray
的元组(每个层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器交叉注意力层的注意力权重,在注意力softmax后使用,用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
,可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
jnp.ndarray
的元组,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 包含每个层(从嵌入层的输出到一个层的输出)的jnp.ndarray
的元组,形状为(batch_size, sequence_length, hidden_size)
。每个层输出的编码器隐藏状态以及初始嵌入输出。
-
encoder_attentions (
jnp.ndarray
的元组,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 包含每个层jnp.ndarray
的元组(每个层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
FlaxWhisperPreTrainedModel
的向前方法,重写了特殊方法__call__
。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, FlaxWhisperModel
>>> tokenizer = AutoTokenizer.from_pretrained("openai/whisper-tiny")
>>> model = FlaxWhisperModel.from_pretrained("openai/whisper-tiny")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
FlaxWhisperForConditionalGeneration
类 transformers.FlaxWhisperForConditionalGeneration
<source>( config: WhisperConfig input_shape: Tuple = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )
参数
- config (WhisperConfig) — 模型配置类,包含所有模型参数。用配置文件初始化模型不会加载模型相关的权重,只加载配置。查看from_pretrained()方法的用法来加载模型权重。
- dtype (
jax.numpy.dtype
, 可选, 默认为jax.numpy.float32
) — 计算的数据类型。可以是以下之一:jax.numpy.float32
,jax.numpy.float16
(在GPU上)和jax.numpy.bfloat16
(在TPU上)。这可用来在GPU或TPU上启用混合精度训练或半精度推理。如果指定,所有计算都将使用给定的dtype
执行。注意,这只会指定计算的数据类型,不会影响模型参数的数据类型。如果您想更改模型参数的数据类型,请参阅to_fp16()和to_bf16()。
带有语言建模头部的Whisper模型。该模型继承自FlaxPreTrainedModel。查看超类文档获取库为所有模型实现的方法(例如下载或保存、调整输入嵌入大小、剪枝头部等)。该模型也是一个Flax Linen flax.nn.Module子类。将其作为常规Flax模块使用,并参考Flax文档获取所有有关通用用途和行为的信息。最后,该模型支持JAX的固有特性,如
__call__
< 源代码 >( input_features): 数组 decoder_input_ids): 数组 attention_mask): 可选 = None decoder_attention_mask): 可选 = None position_ids): 可选 = None output_attentions): 可选 = None output_hidden_states): 可选 = None return_dict): 可选 = None train): 布尔值 = Falseparams): 字典 = Nonedropout_rng): PRNGKey = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)
参数
- input_features (形状为
(batch_size, feature_size, sequence_length)
的numpy.ndarray
)——从原始语音波形提取的梅尔特征浮点值。原始语音波形可以通过将.flac
或.wav
音频文件加载到一个类型为List[float]
或numpy.ndarray
的数组中获取,例如通过 soundfile 库(pip install soundfile
)实现。要将数组准备为input_features
,应使用 WhisperFeatureExtractor 来提取特征、填充并将其转换为类型为numpy.ndarray
的张量。请参阅 call() - attention_mask (形状为
(batch_size, sequence_length)
的numpy.ndarray
,可选)——Whisper 不支持对input_features
进行掩码,此参数保留以供兼容,但不使用。默认情况下,输入对数梅尔频谱图中的静音将被忽略。 - decoder_input_ids (
numpy.ndarray
of shape(batch_size, target_sequence_length)
, optional) — 词汇表中解码器输入序列标记的索引。可以使用 WhisperTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。解码器输入ID是什么? Whisper 使用decoder_start_token_id
作为decoder_input_ids
生成的起始标记。 - decoder_attention_mask (
numpy.ndarray
of shape(batch_size, target_sequence_length)
, optional) — 默认行为:生成一个忽略垫子标记的decoder_input_ids
的张量。默认情况下,还将使用因果掩码。如果您想更改填充行为,应修改以满足需求。有关默认策略的更多信息,请参阅论文中的图1。 - position_ids (
numpy.ndarray
of shape(batch_size, sequence_length)
, optional) — Whisper 不在编码器中使用position_ids
作为input_features
的大小总是相同,不使用掩码,但为了兼容性保留了此参数。默认情况下,忽略输入对数梅尔频谱图中的静音。 - decoder_position_ids (numpy.ndarray 形为
(batch_size, sequence_length)
的数组,可选) — 每个解码输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - output_attentions (bool,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的
attentions
。 - output_hidden_states (bool,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的
hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 而不是普通的元组。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或由 torch.FloatTensor
组成的元组(如果传递 return_dict=False
或当 config.return_dict=False
时),包含根据配置(WhisperConfig)和输入的不同元素。
-
logits (
jnp.ndarray
of shape(batch_size, sequence_length, config.vocab_size)
) —— 语言建模头部的预测分数(在 SoftMax 之前每个词汇表符号的分数)。 -
past_key_values (形状为
tuple(tuple(jnp.ndarray))
的元组,可选,在传入use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(jnp.ndarray)
的元组,每个元组包含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(jnp.ndarray)
的元组,可选,在传入output_hidden_states=True
或config.output_hidden_states=True
时返回)— 包含嵌入输出和每个层输出的形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray的元组。每个层输出的解码器隐藏状态以及初始嵌入输出。
-
decoder_attentions (形状为
tuple(jnp.ndarray)
的元组,可选,在传入output_attentions=True
或config.output_attentions=True
时返回)— 包含每个层的形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray的元组。解码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
-
cross_attentions (
jnp.ndarray
的元组,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 包含每个层jnp.ndarray
的元组(每个层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器交叉注意力层的注意力权重,在注意力softmax后使用,用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
,可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
jnp.ndarray
的元组,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 包含每个层(从嵌入层的输出到一个层的输出)的jnp.ndarray
的元组,形状为(batch_size, sequence_length, hidden_size)
。每个层输出的编码器隐藏状态以及初始嵌入输出。
-
encoder_attentions (
jnp.ndarray
的元组,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 包含每个层jnp.ndarray
的元组(每个层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均。
FlaxWhisperPreTrainedModel
的向前方法,重写了特殊方法__call__
。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
转录示例
>>> from transformers import WhisperProcessor, FlaxWhisperForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = FlaxWhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en", from_pt=True)
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="np")
>>> input_features = inputs.input_features
>>> generated_ids = model.generate(input_ids=input_features)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
FlaxWhisperForAudioClassification
class transformers.FlaxWhisperForAudioClassification
< source >( config: WhisperConfig input_shape: Tuple = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )
参数
- config (WhisperConfig) — 模型配置类,包含所有模型的参数。使用配置文件初始化时不会加载与模型相关的权重,只有配置。请参阅from_pretrained()方法以加载模型权重。
- dtype (
jax.numpy.dtype
, 可选,默认为jax.numpy.float32
) — 计算数据类型。可以是jax.numpy.float32
、jax.numpy.float16
(在GPU上)和jax.numpy.bfloat16
(在TPU上)。这可以用于在GPU或TPU上启用混合精度训练或半精度推理。如果指定,所有计算将以给定的dtype
执行。注意,这仅指定了计算的数据类型,并不会影响模型参数的数据类型。如果希望更改模型参数的数据类型,请参阅to_fp16()和to_bf16()。
在顶部的音频分类头部之上的Whisper模型。此模型继承自FlaxPreTrainedModel。请查看超类文档,了解库为实现所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、剪枝头部等)。此模型也是Flax Linen flax.nn.Module的子类。将其用作常规Flax模块,并参考Flax文档了解所有有关通用使用和行为的问题。最后,此模型支持继承的JAX功能,例如
__call__
< 源 >( input_features: 数组 attention_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None train: 布尔 = False params: 字典 = None dropout_rng: PRNGKey = None **kwargs ) → transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput or tuple(torch.FloatTensor)
参数
- input_features (
numpy.ndarray
形状(batch_size, feature_size, sequence_length)
) — 从原始语音波形中提取的梅尔特征浮点值。可以通过将.flac
或.wav
音频文件加载到一个类型为List[float]
或numpy.ndarray
的数组中(例如,通过 soundfile 库(pip install soundfile
))来获取原始语音波形。要把数组准备成input_features
,应使用 WhisperFeatureExtractor 提取特征、填充并转换成一个类型为numpy.ndarray
的张量。请参阅call() - attention_mask (
numpy.ndarray
形状(batch_size, sequence_length)
,可选) — Whisper 不支持对input_features
进行屏蔽,此参数保留以保持兼容性,但未使用。默认情况下,输入对数梅尔频谱图中的静音将被忽略。 - decoder_input_ids (
numpy.ndarray
形状为(batch_size, target_sequence_length)
,可选) — 词汇库中解码输入序列的标记索引。可以使用 WhisperTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。了解 解码输入ID是什么? Whisper 使用decoder_start_token_id
作为decoder_input_ids
生成的起始标记。 - decoder_attention_mask (
numpy.ndarray
形状为(batch_size, target_sequence_length)
,可选) — 默认行为:生成一个忽略decoder_input_ids
中填充标记的张量。默认情况下,也会使用因果掩码。如需更改填充行为,请根据您的需求进行修改。参见论文中的图1以获取更多关于默认策略的信息。 - position_ids (
numpy.ndarray
形状为(batch_size, sequence_length)
,可选) — Whisper 在编码器中不使用position_ids
作为input_features
总是相同的大小并且不使用掩码,但此参数仍保留以保持兼容性。默认情况下,将忽略输入 log mel 声谱图中的静音。 - decoder_position_ids (
numpy.ndarray
of shape(batch_size, sequence_length)
, optional) — 每个解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回ModelOutput代替普通元组。
返回
transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput或tuple(torch.FloatTensor)
A transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput或
-
logits (
jnp.ndarray
形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1则为回归)得分(在SoftMax之前)。 -
hidden_states (
tuple(jnp.ndarray)
,可选,在传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 第一个数组是嵌入输出,其余每个数组是每个层输出的jnp.ndarray (形状为(batch_size, sequence_length, hidden_size)
)。每层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray)
,可选,在传递output_attentions=True
或config.output_attentions=True
时返回) — 每层的jnp.ndarray的tuple(形状为(batch_size, num_heads, sequence_length, sequence_length)
)。通过注意力 softmax 后的注意力权重,用于在自我注意力头中计算加权平均。
FlaxWhisperForAudioClassification的前向方法覆盖了特殊方法__call__
。
尽管需要在这个函数内定义正向传递的配方,但应该代替这个函数调用Module
实例,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
转录示例
>>> import jax.numpy as jnp
>>> from transformers import AutoFeatureExtractor, FlaxWhisperForAudioClassification
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = FlaxWhisperForAudioClassification.from_pretrained(
... "sanchit-gandhi/whisper-medium-fleurs-lang-id", from_pt=True
... )
>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True, trust_remote_code=True)
>>> sample = next(iter(ds))
>>> inputs = feature_extractor(
... sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="np"
... )
>>> input_features = inputs.input_features
>>> logits = model(input_features).logits
>>> predicted_class_ids = jnp.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'af_za'