Transformers documentation

VoxtralRealtime

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2026-02-16 贡献至 Hugging Face Transformers。

VoxtralRealtime

VoxtralRealtime 是由 Mistral AI 推出的流式语音转文本模型,专为实时自动语音识别(ASR)而设计。与处理完整音频文件的离线 Voxtral 模型不同,VoxtralRealtime 采用低延迟、增量式转写架构,通过分块处理实时到达的音频来实现该目标。

该模型将音频编码器与基于 Mistral 的语言模型解码器相结合,利用时间条件嵌入以及带有填充缓存的因果卷积,以实现高效的流式推理。

用法

离线转录

要转录完整的音频文件,请直接使用处理器和模型。生成长度会根据音频长度自动确定。

from datasets import load_dataset

from transformers import AutoProcessor, VoxtralRealtimeForConditionalGeneration


repo_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"

processor = AutoProcessor.from_pretrained(repo_id)
model = VoxtralRealtimeForConditionalGeneration.from_pretrained(repo_id, device_map="auto")

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = ds[0]["audio"]["array"]

inputs = processor(audio, return_tensors="pt").to(model.device)
inputs = inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs)
decoded_outputs = processor.batch_decode(outputs, skip_special_tokens=True)

print(decoded_outputs[0])

批量离线转录

可以在单次前向传播中转写多个音频样本:

from datasets import load_dataset

from transformers import AutoProcessor, VoxtralRealtimeForConditionalGeneration


repo_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"

processor = AutoProcessor.from_pretrained(repo_id)
model = VoxtralRealtimeForConditionalGeneration.from_pretrained(repo_id, device_map="auto")

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = [ds[i]["audio"]["array"] for i in range(2)]

inputs = processor(audio, return_tensors="pt").to(model.device)
inputs = inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs)
decoded_outputs = processor.batch_decode(outputs, skip_special_tokens=True)

for decoded_output in decoded_outputs:
    print(decoded_output)

流式转录

这是一个实验性功能,API 可能会发生变化。

对于实时转录,音频将按照以下规则分块:

from threading import Thread

import numpy as np
import torch
from datasets import load_dataset

from transformers import (
    TextIteratorStreamer,
    VoxtralRealtimeForConditionalGeneration,
    VoxtralRealtimeProcessor,
)


model_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"
processor = VoxtralRealtimeProcessor.from_pretrained(model_id)
model = VoxtralRealtimeForConditionalGeneration.from_pretrained(model_id, device_map=torch.accelerator.current_accelerator())

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = ds[0]["audio"]["array"]
# Manually pad the audio to account for right padding tokens required by the model
xaudio = np.pad(audio, (0, processor.num_right_pad_tokens * processor.raw_audio_length_per_tok))

first_chunk_inputs = processor(
    audio[:processor.num_samples_first_audio_chunk],
    is_streaming=True,
    is_first_audio_chunk=True,
    return_tensors="pt"
)
first_chunk_inputs.to(model.device, dtype=model.dtype)

def input_features_generator():
    yield first_chunk_inputs.input_features

    mel_frame_idx = processor.num_mel_frames_first_audio_chunk
    hop_length = processor.feature_extractor.hop_length
    win_length = processor.feature_extractor.win_length

    start_idx = mel_frame_idx * hop_length - win_length // 2
    end_idx = start_idx + processor.num_samples_per_audio_chunk

    while (end_idx:=start_idx + processor.num_samples_per_audio_chunk) < audio.shape[0]:
        inputs = processor(
            audio[start_idx:end_idx],
            is_streaming=True,
            is_first_audio_chunk=False,
            return_tensors="pt"
        )
        inputs.to(model.device, dtype=model.dtype)
        yield inputs.input_features

        mel_frame_idx += processor.audio_length_per_tok
        start_idx = mel_frame_idx * hop_length - win_length // 2

streamer = TextIteratorStreamer(processor.tokenizer, skip_special_tokens=True, clean_up_tokenization_spaces=True)
generate_kwargs = {
    "input_ids": first_chunk_inputs.input_ids,
    "input_features": input_features_generator(),
    "num_delay_tokens": first_chunk_inputs.num_delay_tokens,
    "streamer": streamer,
}
thread = Thread(target=model.generate, kwargs=generate_kwargs)
thread.start()

# Iterate over the streamer to get text chunks as they are generated
print("Model output (streaming):", end=" ", flush=True)
for text_chunk in streamer:
    print(text_chunk, end="", flush=True)

该模型由 Eustache Le Bihan 贡献。

VoxtralRealtimeConfig

class transformers.VoxtralRealtimeConfig

< >

( 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 = Noneprojector_hidden_act: str = 'gelu'audio_length_per_tok: int = 8default_num_delay_tokens: int = 6downsample_factor: int = 4tie_word_embeddings: bool = Trueuse_cache: bool = True )

参数

  • audio_config (Union[dict, ~configuration_utils.PreTrainedConfig], 可选) — 音频骨干网络的配置对象或字典。
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig],可选) — 文本骨干网络的配置对象或字典。
  • projector_hidden_act (str, 可选, 默认为 gelu) — 多模态投影器使用的激活函数。
  • audio_length_per_tok (int,可选,默认为 8) — 每个文本 token 对应的音频帧数。
  • default_num_delay_tokens (int,可选,默认为 6) — 用于流式处理的默认延迟 token 数量。
  • downsample_factor (int,可选,默认为 4) — 在投影之前应用于音频特征的降采样因子。
  • tie_word_embeddings (bool,可选,默认为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。
  • use_cache (bool,可选,默认为 True) — 模型是否应返回最后一次键/值注意力(并非所有模型都使用)。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。

这是用于存储 VoxtralRealtimeModel 配置的类。它根据指定的参数实例化 Voxtral Realtime 模型,并定义模型架构。使用默认值实例化配置将得到与 mistralai/Voxtral-Mini-4B-Realtime-2602 类似的配置。

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

>>> from transformers import VoxtralRealtimeForConditionalGeneration, VoxtralRealtimeConfig

>>> # Initializing a VoxtralRealtime configuration
>>> configuration = VoxtralRealtimeConfig()

>>> # Initializing a model with random weights
>>> model = VoxtralRealtimeForConditionalGeneration(configuration)

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

VoxtralRealtimeEncoderConfig

class transformers.VoxtralRealtimeEncoderConfig

< >

( 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 = Nonevocab_size: int = 131072hidden_size: int = 1280intermediate_size: int = 5120num_hidden_layers: int = 32num_attention_heads: int = 32activation_function: str = 'gelu'num_mel_bins: int = 128initializer_range: float = 0.02attention_dropout: float | int = 0.0hidden_act: str = 'silu'max_position_embeddings: int = 1500rms_norm_eps: float = 1e-05rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 750head_dim: int = 64use_cache: bool = True )

参数

  • vocab_size (int,可选,默认为 131072) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • hidden_size (int,可选,默认为 1280) — 隐藏表示的维度。
  • intermediate_size (int,可选,默认为 5120) — MLP 表示的维度。
  • num_hidden_layers (int,可选,默认为 32) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int,可选,默认为 32) — Transformer 解码器中每个注意力层的注意力头数量。
  • activation_function (str,可选,默认为 gelu) — 解码器中的非线性激活函数(函数或字符串)。例如,"gelu"、"relu"、"silu" 等。
  • num_mel_bins (int, 可选,默认为 128) — 每个输入帧使用的 mel 特征数量。应与 AutoFeatureExtractor 类中使用的值相对应。
  • initializer_range (float,可选,默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • attention_dropout (Union[float, int],可选,默认为 0.0) — 注意力概率的 dropout 比率。
  • hidden_act (str,可选,默认为 silu) — 解码器中的非线性激活函数(函数或字符串)。例如,"gelu"、 "relu"、"silu" 等。
  • max_position_embeddings (int,可选,默认为 1500) — 该模型可能使用的最大序列长度。
  • rms_norm_eps (float,可选,默认为 1e-05) — RMS 归一化层使用的 epsilon 值。
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含 rope_theta 的值,并且如果希望使用 RoPE 处理更长的 max_position_embeddings,则可选地包含用于缩放的参数。
  • sliding_window (int,可选,默认为 750) — 滑动窗口注意力的窗口大小。如果为 None,则不应用滑动窗口。
  • head_dim (int,可选,默认为 64) — 注意力头维度。如果为 None,则默认为 hidden_size // num_attention_heads
  • use_cache (bool,可选,默认为 True) — 模型是否应返回最后一次键/值注意力(并非所有模型都使用)。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。

这是用于存储 VoxtralRealtimeModel 配置的类。它根据指定的参数实例化 Voxtral Realtime 模型,并定义模型架构。使用默认值实例化配置将得到与 mistralai/Voxtral-Mini-4B-Realtime-2602 类似的配置。

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

示例:

>>> from transformers import VoxtralRealtimeEncoderConfig, VoxtralRealtimeEncoder

>>> # Initializing a VoxtralRealtimeEncoderConfig
>>> configuration = VoxtralRealtimeEncoderConfig()

>>> # Initializing a VoxtralRealtimeEncoder (with random weights)
>>> model = VoxtralRealtimeEncoder(configuration)

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

VoxtralRealtimeTextConfig

class transformers.VoxtralRealtimeTextConfig

< >

( 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 = Nonevocab_size: int = 32000hidden_size: int = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-06use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int | None = 4096attention_dropout: float | int = 0.0 )

参数

  • vocab_size (int,可选,默认为 32000) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • hidden_size (int,可选,默认为 4096) — 隐藏表示的维度。
  • intermediate_size (int,可选,默认为 14336) — MLP 表示的维度。
  • num_hidden_layers (int,可选,默认为 32) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int,可选,默认为 32) — Transformer 解码器中每个注意力层的注意力头数量。
  • num_key_value_heads (int, 可选,默认为 8) — 这是用于实现 Grouped Query Attention 的 key_value 头数。如果 num_key_value_heads=num_attention_heads,模型将使用 Multi Head Attention (MHA);如果 num_key_value_heads=1,模型将使用 Multi Query Attention (MQA);否则使用 GQA。在将多头检查点转换为 GQA 检查点时,每个组的 key 和 value 头应通过对该组内所有原始头进行 meanpooling 来构建。更多详情请参阅 这篇论文。如果未指定,则默认为 num_attention_heads。
  • head_dim (int,可选) — 注意力头维度。如果为 None,则默认为 hidden_size // num_attention_heads
  • hidden_act (str,可选,默认为 silu) — 解码器中的非线性激活函数(函数或字符串)。例如,"gelu"、 "relu"、"silu" 等。
  • max_position_embeddings (int,可选,默认为 131072) — 该模型可能使用的最大序列长度。
  • initializer_range (float,可选,默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • rms_norm_eps (float,可选,默认为 1e-06) — RMS 归一化层使用的 epsilon 值。
  • use_cache (bool,可选,默认为 True) — 模型是否应返回最后一次键/值注意力(并非所有模型都使用)。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。
  • pad_token_id (int, 可选) — 词表中用于填充的 token id。
  • bos_token_id (int,可选,默认为 1) — 词汇表中用于表示流起始的 token id。
  • eos_token_id (Union[int, list[int]],可选,默认为 2) — 词汇表中用于表示流结束(end-of-stream)的 token id。
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含 rope_theta 的值,并且如果希望使用 RoPE 处理更长的 max_position_embeddings,则可选地包含用于缩放的参数。
  • sliding_window (int,可选,默认为 4096) — 滑动窗口注意力的窗口大小。如果为 None,则不应用滑动窗口。
  • attention_dropout (Union[float, int],可选,默认为 0.0) — 注意力概率的 dropout 比率。

这是用于存储 VoxtralRealtimeModel 配置的类。它根据指定的参数实例化 Voxtral Realtime 模型,并定义模型架构。使用默认值实例化配置将得到与 mistralai/Voxtral-Mini-4B-Realtime-2602 类似的配置。

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

VoxtralRealtimeFeatureExtractor

class transformers.VoxtralRealtimeFeatureExtractor

< >

( feature_size = 128sampling_rate = 16000hop_length = 160n_fft = 400win_length = 400padding_value = 0.0global_log_mel_max = 1.5**kwargs )

参数

  • feature_size (int,可选,默认为 128) — 提取特征的维度。
  • sampling_rate (int,可选,默认为 16000) — 音频文件应被数字化时的采样率,以赫兹 (Hz) 为单位。
  • hop_length (int,可选,默认为 160) — 用于获取梅尔频率系数的 STFT 中重叠窗口的长度。
  • n_fft (int,可选,默认为 512) — 傅里叶变换的大小。
  • win_length (int,可选,默认为 400) — 用于 STFT 计算的窗口长度。
  • padding_value (float,可选,默认为 0.0) — 用于填充音频的填充值。该值应对应静音。

构建一个 VOXTRAL_REALTIME 特征提取器。

该特征提取器继承自 SequenceFeatureExtractor,其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。

此类使用自定义的 numpy 实现的Short Time Fourier Transform从原始语音中提取 mel 滤波器组特征,其结果应与 pytorch 的torch.stft等效。

VoxtralRealtimeProcessor

class transformers.VoxtralRealtimeProcessor

< >

( feature_extractortokenizer )

参数

  • feature_extractor(VoxtralRealtimeFeatureExtractor)— 特征提取器是必需的输入。
  • tokenizer (MistralCommonBackend) — tokenizer 是必需的输入。

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

VoxtralRealtimeProcessor 提供了 VoxtralRealtimeFeatureExtractor 和 MistralCommonBackend 的所有功能。有关更多信息,请参阅 ~VoxtralRealtimeFeatureExtractor 和 ~MistralCommonBackend。

__call__

< >

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

参数

  • audio (AudioInput,可选) — 以 NumPy 数组或 PyTorch 张量形式输入单个音频或音频批次。
  • is_streaming (bool,可选,默认为 False) — 是否以流式模式处理音频。当设置为 True 时,可以分块传入音频,并使用 is_first_audio_chunk 来区分第一个块与后续块。
  • is_first_audio_chunk (bool,可选,默认为 True) — 当前音频是否为流式会话中的第一个数据块。当为 True 时,音频将被编码为包含分词文本的完整转录请求。当为 False 时,仅提取音频特征(跳过文本编码)。当 is_streaming=False 时,必须为 True。

返回值

BatchFeature

一个包含以下字段的 BatchFeature:

  • input_ids — 要输入模型的 token id 列表。当 is_first_audio_chunk=True 时返回。
  • attention_mask — 指定模型应关注哪些 token 的索引列表。 当 is_first_audio_chunk=True 时返回。
  • input_features — 从音频输入中提取的梅尔频谱特征。
  • num_delay_tokens — 用于流式传输的延迟 token 数量。

用于为 Voxtral Realtime 模型准备音频输入的主要方法。该方法使用 mistral_common 将音频编码为转录请求,对生成的文本进行分词,并使用特征提取器提取梅尔频谱特征。支持流式和非流式两种模式。

VoxtralRealtimeEncoder

class transformers.VoxtralRealtimeEncoder

< >

( config: VoxtralRealtimeEncoderConfig )

参数

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

VoxtralRealtime 编码器,即 Whisper 编码器。

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

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

forward

< >

( input_features: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.voxtral_realtime.modeling_voxtral_realtime.VoxtralRealtimeConv1dPaddingCache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneuse_padding_cache: bool | None = Noneattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

参数

  • input_features (torch.Tensor,形状为 (batch_size, sequence_length, feature_dim),可选) — 与输入音频特征对应的张量。可以使用 VoxtralRealtimeFeatureExtractor 获取音频特征。有关详细信息,请参阅 VoxtralRealtimeFeatureExtractor.__call__()(VoxtralRealtimeProcessor 使用 VoxtralRealtimeFeatureExtractor 来处理音频)。
  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID?

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

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

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

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

  • padding_cache (VoxtralRealtimeConv1dPaddingCache,可选) — 用于卷积层填充的缓存,以在流式块之间保持状态。
  • inputs_embeds(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor,可选) — 可选地,您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • use_cache (bool,可选) — 如果设置为 True,则会返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。
  • use_padding_cache (bool,可选) — 是否使用填充缓存。
  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ,可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token,
    • 对于被掩码的 token,值为 0。

    什么是注意力掩码?

返回值

BaseModelOutputWithPooling 或 tuple(torch.Tensor)

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

VoxtralRealtimeEncoder 的 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 之后的权重,用于在自注意力头中计算加权平均值。

VoxtralRealtimeModel

class transformers.VoxtralRealtimeModel

< >

( config: VoxtralRealtimeConfig )

参数

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

VoxtralRealtime 模型由流式 Whisper 风格的编码器、多模态投影器、基于 Mistral 的语言模型以及时间嵌入组成,不包含语言建模头。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.voxtral_realtime.modeling_voxtral_realtime.VoxtralRealtimeConv1dPaddingCache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonenum_delay_tokens: typing.Union[int, torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VoxtralRealtimeModelOutputWithPast or tuple(torch.Tensor)

参数

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

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

    什么是输入 ID?

  • input_features (torch.Tensor,形状为 (batch_size, sequence_length, feature_dim),可选) — 与输入音频特征对应的张量。可以使用 VoxtralRealtimeFeatureExtractor 获取音频特征。有关详细信息,请参阅 VoxtralRealtimeFeatureExtractor.__call__()(VoxtralRealtimeProcessor 使用 VoxtralRealtimeFeatureExtractor 来处理音频)。
  • 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?

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

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

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

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

  • encoder_past_key_values (Cache, 可选) — 编码器的预计算隐藏状态(自注意力块中的键和值)。
  • padding_cache (VoxtralRealtimeConv1dPaddingCache,可选) — 用于卷积层填充的缓存,以在流式块之间保持状态。
  • inputs_embeds(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor,可选) — 可选地,您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • encoder_inputs_embeds (torch.Tensor, 可选) — 可选地,您可以选择直接传入编码器的嵌入表示,而不是传入 input_features。
  • use_cache (bool,可选) — 如果设置为 True,则会返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。
  • num_delay_tokens (int 或 torch.Tensor,可选) — 准备输入时使用的延迟 token 数量。

返回值

VoxtralRealtimeModelOutputWithPast 或 tuple(torch.Tensor)

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

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

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

  • encoder_past_key_values (Cache, 可选) — 音频编码器的预计算隐藏状态(自注意力块中的键和值),可用于加速顺序解码。
  • padding_cache (VoxtralRealtimeConv1dPaddingCache,可选) — 用于卷积层填充的缓存,以在流式块之间保持状态。
  • audio_hidden_states (torch.Tensor,可选) — 在添加到文本嵌入之前,投影后的音频隐藏状态。

VoxtralRealtimeForConditionalGeneration

class transformers.VoxtralRealtimeForConditionalGeneration

< >

( config: VoxtralRealtimeConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.voxtral_realtime.modeling_voxtral_realtime.VoxtralRealtimeConv1dPaddingCache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0num_delay_tokens: typing.Union[int, torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VoxtralRealtimeCausalLMOutputWithPast or tuple(torch.Tensor)

参数

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

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

    什么是输入 ID?

  • input_features (torch.Tensor,形状为 (batch_size, sequence_length, feature_dim),可选) — 与输入音频特征对应的张量。可以使用 VoxtralRealtimeFeatureExtractor 获取音频特征。有关详细信息,请参阅 VoxtralRealtimeFeatureExtractor.__call__()(VoxtralRealtimeProcessor 使用 VoxtralRealtimeFeatureExtractor 来处理音频)。
  • 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?

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

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

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

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

  • encoder_past_key_values (Cache, 可选) — 编码器的预计算隐藏状态(自注意力块中的键和值),可用于加速顺序解码。
  • padding_cache (VoxtralRealtimeConv1dPaddingCache,可选) — 用于卷积层填充的缓存,以在流式块之间保持状态。
  • inputs_embeds(形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor,可选) — 可选地,您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • encoder_inputs_embeds (torch.Tensor, 可选) — 可选地,您可以选择直接传入编码器的嵌入表示,而不是传入 input_features。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length),可选) — 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内,或为 -100(参见 input_ids 的文档字符串)。索引值设为 -100 的 token 将被忽略(即被掩码),损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。
  • use_cache (bool,可选) — 如果设置为 True,则会返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。
  • logits_to_keep (Union[int, torch.Tensor], 可选,默认为 0) — 如果为 int,则计算最后 logits_to_keep 个 token 的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。生成过程只需要最后一个 token 的 logits,仅针对该 token 进行计算可以节省内存,对于长序列或大词汇量而言,这种节省相当显著。 如果为 torch.Tensor,则必须是一维张量,对应于序列长度维度中需要保留的索引。 这在使用打包张量格式(将批次和序列长度合并为单一维度)时非常有用。
  • num_delay_tokens (int 或 torch.Tensor,可选) — 准备输入时使用的延迟 token 数量,详情请参见 ~VoxtralRealtimeProcessor。

返回值

VoxtralRealtimeCausalLMOutputWithPast 或 tuple(torch.Tensor)

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

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

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

  • encoder_past_key_values (Cache, 可选) — 音频编码器的预计算隐藏状态(自注意力块中的键和值),可用于加速顺序解码。
  • padding_cache (VoxtralRealtimeConv1dPaddingCache,可选) — 用于卷积层填充的缓存,以在流式块之间保持状态。

示例:

>>> import torch
>>> from transformers import VoxtralRealtimeForConditionalGeneration, AutoProcessor
>>> from datasets import load_dataset

>>> repo_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"

>>> processor = AutoProcessor.from_pretrained(repo_id)
>>> model = VoxtralRealtimeForConditionalGeneration.from_pretrained(repo_id, dtype=torch.bfloat16, device_map="auto")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio = ds[0]["audio"]["array"]

>>> inputs = processor(audio, return_tensors="pt")
>>> inputs = inputs.to(model.device, dtype=model.dtype)

>>> outputs = model.generate(**inputs)
>>> processor.batch_decode(outputs, skip_special_tokens=True)

get_audio_features

< >

( *args**kwargs )

Update on GitHub