Transformers documentation

OmniASR

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.23.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2025-11-12 在 HF papers 上发布,并于 2026-11-16 贡献至 Hugging Face Transformers。

OmniASR

FlashAttention SDPA

概述

OmniASR(Omnilingual ASR)是 Meta FAIR 推出的一系列多语言语音识别模型,在 Omnilingual ASR: Open-Source Multilingual Speech Recognition for 1600+ Languages 中介绍,覆盖超过 1,600 种语言——其中包括数百种此前从未被任何 ASR 系统支持的语言。每个模型都搭配了一个 Wav2Vec2 风格的音频编码器(由对 16 kHz 波形进行约 320 倍降采样的卷积层,以及一个 pre-norm Transformer 编码器组成)和以下两种头部之一:

  • CTC 变体(OmniASRForCTC,参见 OmniASR CTC):通过单个线性投影映射到词表,并使用贪心 CTC 进行非自回归解码。
  • ALM(音频语言模型)变体(OmniASRForConditionalGeneration,本页):音频嵌入通过线性投影输入 Llama 解码器,由解码器自回归地生成转录文本。该变体还支持可选的语言条件:传入诸如 "eng_Latn" 这样的语言代码,处理器会将对应的语言标记写入解码器上下文,这通常能提升转录质量。

检查点可在此集合中找到:4 个 ALM 和 4 个 CTC 检查点,涵盖多种规模(300M、1B、3B、7B)。原始权重由 Meta 发布,可在其GitHub 仓库中找到。

该模型由 Eric Bezzam 贡献。

用法

最简单的音频转录方式是使用 apply_transcription_request,它会自动处理聊天模板的格式化,即它是 apply_chat_template 的便捷封装(参见下文 聊天模板)。

简单转录

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

inputs = processor.apply_transcription_request(
    audio="https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
)
inputs.to(model.device, dtype=model.dtype)

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])

语言提示

如果不指定语言,模型将以语言无关模式运行。传入语言代码(例如 "eng_Latn"、"fra_Latn"、"cmn_Hans")会将对应的语言标记写入解码器提示中,这通常能提升转录质量。支持的语言列表及命名规范请参见原始文档中的 此处。对于拥有 ISO 639-1 代码的语言,也接受更常用的代码(例如 "en"、"fr"、"zh")。

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

audio = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav"

# Without language hint (language-agnostic)
inputs = processor.apply_transcription_request(audio=audio).to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(f"Language-agnostic: {processor.decode(generated_ids, skip_special_tokens=True)[0]}")

# With language hint
inputs = processor.apply_transcription_request(audio=audio, language="zh").to(model.device, dtype=model.dtype)
output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(f"Language hint:     {processor.decode(generated_ids, skip_special_tokens=True)[0]}")

批量推理

通过传入音频列表,以及(如果提供)整个批次的单一语言或语言列表(每个音频对应一个语言,None 表示语言无关模式),可以实现批量推理。

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

audio = [
    "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
]

inputs = processor.apply_transcription_request(audio, language=["en", None])
inputs.to(model.device, dtype=model.dtype)

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
for i, text in enumerate(processor.decode(generated_ids, skip_special_tokens=True)):
    print(f"Audio {i + 1}: {text}")

聊天模板

该模型也接受聊天模板输入。上述 apply_transcription_request 的用法是 apply_chat_template 的便捷封装。语言提示作为用户轮次中的 {"type": "language", ...} 项提供;省略该项则选择语言无关模式。

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

conversations = [
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav",
                },
                {"type": "language", "language": "en"},
            ],
        },
    ],
    [
        {
            "role": "user",
            "content": [
                {
                    "type": "audio",
                    "path": "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/mandarin_voxcpm_zh.wav",
                },
                {"type": "language", "language": "zh"},
            ],
        },
    ],
]

inputs = processor.apply_chat_template(
    conversations, tokenize=True, add_generation_prompt=True, return_dict=True
)
inputs.to(model.device, dtype=model.dtype)

output_ids = model.generate(**inputs, max_new_tokens=256)
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
for i, text in enumerate(processor.decode(generated_ids, skip_special_tokens=True)):
    print(f"Audio {i + 1}: {text}")

训练

OmniASR 可以使用模型输出的损失进行训练。将目标转录文本放入 chat template 的 assistant 轮次中,并传入 output_labels=True。音频和填充位置会自动被掩码。

请注意,OmniASR 以小写字母进行转录,因此下文中的(大写)LibriSpeech 转录文本已转换为小写。

from datasets import Audio, load_dataset
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "hf-audio/omniasr-llm-300m-v2"
NUM_SAMPLES = 2

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")
model.train()

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
conversation = [
    [
        {
            "role": "user",
            "content": [
                {"type": "audio", "audio": sample["audio"]["array"]},
                # any supported language code, or no `language` item to train the language-agnostic mode
                {"type": "language", "language": "en"},
            ],
        },
        {"role": "assistant", "content": [{"type": "text", "text": sample["text"].lower()}]},
    ]
    for sample in ds.select(range(NUM_SAMPLES))
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    # only train on the assistant outputs: mask the labels outside the assistant turns
    return_assistant_tokens_mask=True,
    return_tensors="pt",
    processor_kwargs={"output_labels": True},
).to(model.device, dtype=model.dtype)
inputs["labels"][inputs.pop("assistant_masks") == 0] = -100

loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()

Torch 编译

对于自回归转录,torch.compile 通过提供一个 CompileConfig 对象来加速 generate 内部的逐 token 前向传播,该对象需要一个静态缓存。

请注意,StaticCache 只创建一次,并在多次 generate 调用之间复用,以避免重新编译。

在 A100 上,当批处理大小为 4 时,我们观察到约 2.3 倍的加速效果(脚本)。

import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor, CompileConfig, StaticCache

model_id = "hf-audio/omniasr-llm-300m-v2"
NUM_SAMPLES = 4
num_warmup = 3
max_new_tokens = 256

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, dtype=torch.bfloat16).to("cuda").eval()

audio_url = "https://huggingface.co/datasets/bezzam/audio_samples/resolve/main/librispeech_mr_quilter.wav"
inputs = processor.apply_transcription_request(
    audio=[audio_url] * NUM_SAMPLES,
    language="en",
).to(model.device, dtype=model.dtype)

# Created once and reused across `generate` calls, to avoid recompiling at every call
static_cache = StaticCache(
    config=model.config,
    max_cache_len=inputs["input_ids"].shape[1] + max_new_tokens,
)
compile_config = CompileConfig()

# Warmup
with torch.inference_mode():
    for _ in range(num_warmup):
        static_cache.reset()
        _ = model.generate(
            **inputs, max_new_tokens=max_new_tokens, do_sample=False,
            cache=static_cache, compile_config=compile_config,
        )
torch.cuda.synchronize()

# Apply model
with torch.inference_mode():
    static_cache.reset()
    output_ids = model.generate(
        **inputs, max_new_tokens=max_new_tokens, do_sample=False,
        cache=static_cache, compile_config=compile_config,
    )
generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(processor.decode(generated_ids, skip_special_tokens=True)[0])

OmniASRAudioConfig

类 transformers.OmniASRAudioConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)conv_bias: bool = Truenum_attention_heads: int = 16num_hidden_layers: int = 24num_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16intermediate_size: int = 4096attention_dropout: float | int = 0.0hidden_dropout: float | int = 0.1layerdrop: float | int = 0.1activation_dropout: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05hidden_act: str = 'gelu' )

参数

  • hidden_size (int,可选,默认为 1024) — 隐藏表示的维度。
  • conv_dim (tuple[int] 或 list[int],可选,默认为 (512, 512, 512, 512, 512, 512, 512)) — 一个整数元组,用于定义特征编码器中每个一维卷积层的输入和输出通道数。conv_dim 的长度决定了一维卷积层的数量。
  • conv_kernel (tuple[int] 或 list[int],可选,默认为 (10, 3, 3, 3, 3, 2, 2)) — 一个整数元组,用于定义特征编码器中每个一维卷积层的卷积核大小。conv_kernel 的长度决定了卷积层的数量,并且必须与 conv_dim 的长度一致。
  • conv_stride (tuple[int] 或 list[int],可选,默认为 (5, 2, 2, 2, 2, 2, 2)) — 一个整数元组,用于定义特征编码器中每个一维卷积层的步长。conv_stride 的长度定义了卷积层的数量,并且必须与 conv_dim 的长度相匹配。
  • conv_bias (bool,可选,默认为 True) — 一维卷积层是否包含偏置。
  • num_attention_heads (int,可选,默认为 16) — Transformer 解码器中每个注意力层的注意力头数量。
  • num_hidden_layers (int,可选,默认为 24) — Transformer 解码器中的隐藏层数量。
  • num_conv_pos_embeddings (int,可选,默认为 128) — 卷积位置嵌入的数量。定义一维卷积位置嵌入层的核大小。
  • num_conv_pos_embedding_groups (int, 可选, 默认为 16) — 一维卷积位置嵌入层的组数。
  • intermediate_size (int,可选,默认为 4096) — MLP 表示的维度。
  • attention_dropout (Union[float, int],可选,默认为 0.0) — 注意力概率的 dropout 比率。
  • hidden_dropout (Union[float, int],可选,默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
  • layerdrop (Union[float, int],可选,默认为 0.1) — LayerDrop 概率。有关更多详细信息,请参阅 [LayerDrop 论文](参见 https://huggingface.co/papers/1909.11556)。
  • activation_dropout (Union[float, int],可选,默认为 0.1) — 全连接层内部激活值的 dropout 比率。
  • initializer_range (float,可选,默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float,可选,默认为 1e-05) — 层归一化层所使用的 epsilon 值。
  • hidden_act (str,可选,默认为 gelu) — 解码器中的非线性激活函数(函数或字符串)。例如,"gelu"、 "relu"、"silu" 等。

这是用于存储 OmniASRModel 配置的类。它根据指定的参数实例化 Omniasr 模型,并定义模型架构。使用默认值实例化配置将生成与 hf-audio/omniasr-ctc-300m-v2 类似的配置。

配置对象继承自 PreTrainedConfig,可用于控制模型输出。有关更多信息,请参阅 PreTrainedConfig 的文档。

示例:

>>> from transformers import OmniASRAudioConfig, OmniASRAudioModel

>>> # Initializing an OmniASR encoder configuration
>>> configuration = OmniASRAudioConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = OmniASRAudioModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

OmniASRConfig

类 transformers.OmniASRConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 10289initializer_range: float = 0.02bos_token_id: int | None = 0pad_token_id: int | None = 1eos_token_id: int | None = 2 )

参数

  • audio_config (Union[dict, ~configuration_utils.PreTrainedConfig], 可选) — 音频骨干网络的配置对象或字典。
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig],可选) — 文本骨干网络的配置对象或字典。
  • audio_token_id (int,可选,默认为 10289) — 用作输入音频占位符的音频 token 索引。
  • initializer_range (float,可选,默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • bos_token_id (int,可选,默认为 0) — 词汇表中用于表示流起始的 Token id。
  • pad_token_id (int,可选,默认为 1) — 词表中用于填充的 token id。
  • eos_token_id (int,可选,默认为 2) — 词汇表中用于表示流结束(end-of-stream)的 token id。

这是用于存储 OmniASRModel 配置的类。它根据指定的参数实例化 Omniasr 模型,并定义模型架构。使用默认值实例化配置将生成与 hf-audio/omniasr-llm-300m-v2 类似的配置。

配置对象继承自 PreTrainedConfig,可用于控制模型输出。有关更多信息,请参阅 PreTrainedConfig 的文档。

示例:

>>> from transformers import OmniASRForConditionalGeneration, OmniASRConfig

>>> # Initializing an OmniASR-LLM configuration
>>> configuration = OmniASRConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = OmniASRForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

OmniASRFeatureExtractor

类 transformers.OmniASRFeatureExtractor

< >

( feature_size = 1sampling_rate = 16000padding_value = 0.0return_attention_mask = Truedo_normalize = True**kwargs )

参数

  • feature_size (int,可选,默认为 1) — 提取特征的维度。
  • sampling_rate (int,可选,默认为 16000) — 音频文件应被数字化时的采样率,以赫兹 (Hz) 为单位。
  • padding_value (float,可选,默认为 0.0) — 用于填充 padding 值的数值。
  • return_attention_mask (bool,可选,默认为 True) — __call__() 是否应返回 attention_mask。OmniASR 需要该掩码来识别哪些帧是填充,因此只有在返回该掩码时,批量输入才能被正确编码。
  • do_normalize (bool,可选,默认为 True) — 是否将每个音频样本归一化为零均值和单位方差。统计量按样本计算,仅基于其非填充部分,以匹配 原始实现。

构建一个 OmniASR 特征提取器。

OmniASRProcessor

类 transformers.OmniASRProcessor

< >

( feature_extractortokenizerchat_template = Noneaudio_token = '<extra_id_1>'conv_kernel = Noneconv_stride = None )

参数

  • feature_extractor (OmniASRFeatureExtractor) — 特征提取器是必需的输入。
  • tokenizer (TokenizersBackend) — 分词器是必需的输入。
  • chat_template (str) — 一个 Jinja 模板,用于将聊天中的消息列表转换为可分词的字符串。
  • audio_token (str, 可选,默认为 "<extra_id_1>") — 提示词中代表一个语音编码器帧的占位符 token,即 OmniASRConfig.audio_token_id() 对应的 token。
  • conv_kernel (list[int], 可选) — 语音编码器特征编码器中每个卷积的卷积核大小,即 OmniASRAudioConfig.conv_kernel()。用于计算音频输入被下采样后的帧数, 从而确定其提示中包含多少个音频占位符。默认值为 [10, 3, 3, 3, 3, 2, 2]。
  • conv_stride (list[int], 可选) — 语音编码器特征编码器中每个卷积的步长,即 OmniASRAudioConfig.conv_stride()。默认值为 [5, 2, 2, 2, 2, 2, 2]。

构建一个 OmniASRProcessor,它将特征提取器和分词器封装为单个处理器。

OmniASRProcessor 提供了 OmniASRFeatureExtractor 和 TokenizersBackend 的所有功能。有关更多信息,请参阅 ~OmniASRFeatureExtractor 和 ~TokenizersBackend。

apply_chat_template

< >

( conversation*args**kwargs )

与 apply_chat_template() 相同,但会先解析对话的语言代码。 由于聊天模板会按原样写入语言标记,因此需要此覆盖以接受 ISO 639-1 代码(例如 "en" 对应 "eng_Latn"),并在遇到不支持的代码时抛出异常,而不是静默地写入未知标记。

apply_transcription_request

< >

( audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]language: str | list[str] | None = Nonetokenize: bool = True**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> ) → BatchFeature or list[str]

参数

  • audio (str, list[str], np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]) — 要转录的音频。字符串会被解释为本地路径或 URL,并由聊天模板加载器自动加载;NumPy 数组和 PyTorch 张量会被直接传递。
  • language (str 或 list[str],可选) — 语言代码(例如 "eng_Latn" 或 ["eng_Latn", "fra_Latn"]),可以是整个批次使用一个,也可以是每个音频对应一个。对于拥有 ISO 639-1 代码的语言,也接受该代码(例如 "en")。 None 或 "auto" 会选择模型的语言无关模式;明确指定语言名称可以获得更好的转录质量。
  • tokenize (bool,可选,默认为 True) — 是否对提示词进行分词并处理音频。如果为 False,则不会加载音频,提示词将以字符串形式返回,其中包含未展开的音频占位符。将这些提示词与音频一起传递给处理器,即 processor(text=prompts, audio=audio),其输出与 tokenize=True 时相同。
  • **kwargs — 转发给 apply_chat_template() 的额外关键字参数。 处理器关键字参数(例如 text_kwargs、audio_kwargs、……)应通过 processor_kwargs={...} 传递。

返回值

BatchFeature 或 list[str]

当 tokenize=False 时,每个音频对应一个提示词;否则,处理器会输出可直接传递给 OmniASRForConditionalGeneration.generate() 的结果。

无需手动编写聊天模板,即可为语音识别准备输入。

OmniASRAudioModel

类 transformers.OmniASRAudioModel

< >

( config: OmniASRAudioConfig )

参数

  • config (OmniASRAudioConfig) — 模型配置类,包含模型的所有参数。通过配置文件进行初始化不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

OmniASR 语音编码器,这是一种 Wav2Vec2 风格的编码器。

该模型继承自 PreTrainedModel。请查阅父类文档,了解该库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用,有关通用用法和行为的所有事项,请参阅 PyTorch 文档。

forward

< >

( input_values: typing.Optional[torch.Tensor]padding_mask: typing.Optional[torch.Tensor] = Noneoutput_attention_mask: bool = True**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → OmniASREncoderModelOutput or tuple(torch.Tensor)

参数

  • input_values (torch.Tensor,形状为 (batch_size, sequence_length),可选) — 输入原始语音波形的浮点值。可以通过将 .flac 或 .wav 音频文件加载为 list[float]、numpy.ndarray 或 torch.Tensor 类型的数组来获取这些值,例如 使用 torchcodec 库(pip install torchcodec)或 soundfile 库(pip install soundfile)。要将该数组准备为 input_values,应使用 AutoProcessor 进行填充并转换为 torch.Tensor 类型的张量。详情请参见 processor_class.__call__。
  • padding_mask(形状为 (batch_size, 1, sequence_length) 的 torch.Tensor)— 用于填充 input_values 的填充掩码。
  • output_attention_mask (bool,可选,默认为 True) — 是否返回下采样的注意力掩码。仅在提供 padding_mask 时有效。

返回值

OmniASREncoderModelOutput 或 tuple(torch.Tensor)

OmniASREncoderModelOutput 或 torch.Tensor 元组(如果传入 return_dict=False 或 config.return_dict=False),包含根据配置(None)和输入而定的各种元素。

OmniASRAudioModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义,但之后应调用 Module 实例,而不是直接调用此函数,因为前者会负责执行预处理和后处理步骤,而后者则会静默地忽略这些步骤。

  • last_hidden_state(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor)— 模型最后一层输出的隐藏状态序列。

  • pooler_output (torch.Tensor,形状为 (batch_size, hidden_size)) — 序列中第一个 token(分类 token)的最后一层隐藏状态,经过用于辅助预训练任务的层进一步处理后得到。例如,对于 BERT 系列模型,这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重在预训练期间通过下一句预测(分类)目标进行训练。

  • hidden_states (tuple(torch.Tensor),可选,当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组(如果模型具有嵌入层,则包含嵌入层的输出,以及每一层的输出),形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态,以及可选的初始嵌入输出。

  • attentions (tuple(torch.Tensor),可选,当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重,即经过注意力 softmax 之后的权重,用于在自注意力头中计算加权平均值。

  • attention_mask(形状为 (batch_size, sequence_length) 的 torch.Tensor,可选)— 用于在序列压缩后避免对填充(padding)标记索引执行注意力机制的掩码。由于序列长度可能与输入序列长度不同,因此会返回该掩码。掩码值取自 [0, 1]:

    • 1 表示未被屏蔽的 token,
    • 对于被掩码的 token,值为 0。

OmniASRModel

类 transformers.OmniASRModel

< >

( config: OmniASRConfig )

参数

  • config (OmniASRConfig) — 模型配置类,包含模型的所有参数。通过配置文件进行初始化时,不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

OmniASR 模型由 Wav2Vec2 编码器、多模态投影器和 LLama 语言模型组成,不包含语言建模头。

该模型继承自 PreTrainedModel。请查阅父类文档,了解该库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用,有关通用用法和行为的所有事项,请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → OmniASRBaseModelOutputWithPast or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ,可选) — 输入序列中各 token 在词汇表中的索引。默认情况下,填充(padding)将被忽略。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • inputs_embeds(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor,可选) — 可选地,您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • input_values (torch.Tensor,形状为 (batch_size, sequence_length),可选) — 输入原始语音波形的浮点值。可以通过将 .flac 或 .wav 音频文件加载为 list[float]、numpy.ndarray 或 torch.Tensor 类型的数组来获取这些值,例如 使用 torchcodec 库(pip install torchcodec)或 soundfile 库(pip install soundfile)。要将该数组准备为 input_values,应使用 AutoProcessor 进行填充并转换为 torch.Tensor 类型的张量。详情请参见 OmniASRProcessor.__call__()。
  • padding_mask (torch.Tensor,形状为 (batch_size, num_samples),可选) — 用于移除音频中填充部分的掩码。

返回值

OmniASRBaseModelOutputWithPast 或 tuple(torch.Tensor)

OmniASRBaseModelOutputWithPast 或 torch.Tensor 元组(当传入 return_dict=False 或 config.return_dict=False 时),其包含的元素取决于配置(OmniASRConfig)和输入。

OmniASRModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义,但之后应调用 Module 实例,而不是直接调用此函数,因为前者会负责执行预处理和后处理步骤,而后者则会静默地忽略这些步骤。

  • last_hidden_state(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor)— 模型最后一层输出的隐藏状态序列。

    如果使用了cache,则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

  • cache(Cache,可选,在传入 use_cache=True 或 config.use_cache=True 时返回)—— 它是一个 Cache 实例。更多详情,请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态(自注意力块中的键和值,以及如果 config.is_encoder_decoder=True 则还包括交叉注意力块中的键和值),可用于(参见 cache 输入)加速顺序解码。

  • hidden_states (tuple(torch.Tensor),可选,当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组(如果模型具有嵌入层,则包含嵌入层的输出,以及每一层的输出),形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态,以及可选的初始嵌入输出。

  • attentions (tuple(torch.Tensor),可选,当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重,即经过注意力 softmax 之后的权重,用于在自注意力头中计算加权平均值。

  • audio_features(形状为 (num_audio_frames, hidden_size) 的 torch.Tensor,可选)— 多模态投影器之前、未填充音频帧的编码器输出帧。

OmniASRForConditionalGeneration

类 transformers.OmniASRForConditionalGeneration

< >

( config: OmniASRConfig )

参数

  • config (OmniASRConfig) — 模型配置类,包含模型的所有参数。通过配置文件进行初始化时,不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

OmniASR 模型,由 Wav2Vec2 编码器、多模态投影器和 LLama 语言模型组成。

该模型继承自 PreTrainedModel。请查阅父类文档,了解该库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用,有关通用用法和行为的所有事项,请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonecache: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), ,可选) — 输入序列中各 token 在词汇表中的索引。默认情况下,填充(padding)将被忽略。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • input_values(形状为 (batch_size, 1, num_samples) 的 torch.Tensor,可选) — 原始音频波形的浮点值,散布在 input_ids 的音频占位符中。参见 OmniASRModel.forward()。
  • padding_mask (torch.Tensor of shape (batch_size, num_samples), optional) — Mask to avoid running the speech encoder over padding samples of input_values, with 1 for samples that are not padding. Distinct from attention_mask, which covers the decoder sequence.
  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ,可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token,
    • 对于被掩码的 token,值为 0。

    什么是注意力掩码?

  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID?

  • cache (~cache_utils.Cache, 可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常由 cache 在解码的先前阶段返回,当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入,请参阅我们的 kv cache 指南。 如果未传入 cache,则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用 cache,用户应仅输入未处理的 input_ids(即未向该模型提供其过去键值状态的那些),其形状为 (batch_size, unprocessed_length),而不是形状为 (batch_size, sequence_length) 的所有 input_ids。

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size),可选) — 可选地,您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length),可选) — 用于计算因果语言建模损失的标签。标签会在内部进行移位,因此必须与解码器序列对齐——即长度与 input_ids / inputs_embeds 相同,并在不应计入损失的位置(音频上下文和填充部分)设置为 -100。
  • use_cache (bool, 可选) — 如果设置为 True,则会返回 cache 键值状态,可用于加速解码(参见 cache)。
  • logits_to_keep (Union[int, torch.Tensor], 可选,默认为 0) — 如果为 int,则计算最后 logits_to_keep 个 token 的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。生成过程只需要最后一个 token 的 logits,仅针对该 token 进行计算可以节省内存,对于长序列或大词汇量而言,这种节省相当显著。 如果为 torch.Tensor,则必须是一维张量,对应于序列长度维度中需要保留的索引。 这在使用打包张量格式(将批次和序列长度合并为单一维度)时非常有用。

返回值

CausalLMOutputWithPast 或 tuple(torch.Tensor)

一个 CausalLMOutputWithPast 或 torch.Tensor 元组(如果传入了 return_dict=False 或 config.return_dict=False),其包含的元素取决于配置(OmniASRConfig)和输入。

OmniASRForConditionalGeneration 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义,但之后应调用 Module 实例,而不是直接调用此函数,因为前者会负责执行预处理和后处理步骤,而后者则会静默地忽略这些步骤。

  • loss (torch.Tensor,形状为 (1,),可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits(形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.Tensor)— 语言建模头的预测分数(SoftMax 之前每个词汇表 token 的分数)。

  • cache(Cache,可选,在传入 use_cache=True 或 config.use_cache=True 时返回)—— 它是一个 Cache 实例。更多详情,请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 cache 输入)加速顺序解码。

  • hidden_states (tuple(torch.Tensor),可选,当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组(如果模型具有嵌入层,则包含嵌入层的输出,以及每一层的输出),形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态,以及可选的初始嵌入输出。

  • attentions (tuple(torch.Tensor),可选,当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重,即经过注意力 softmax 之后的权重,用于在自注意力头中计算加权平均值。

示例:

>>> from transformers import AutoProcessor, OmniASRForConditionalGeneration
>>> from datasets import load_dataset, Audio

>>> model_id = "hf-audio/omniasr-llm-300m-v2"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = OmniASRForConditionalGeneration.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor.apply_transcription_request(ds[0]["audio"]["array"], language="eng_Latn")
>>> generated_ids = model.generate(**inputs, max_new_tokens=256)
>>> transcription = processor.decode(generated_ids, skip_special_tokens=True)
Update on GitHub