Transformers documentation
VoxtralRealtime
Ce modèle a été contribué à Hugging Face Transformers le 2026-02-16.
VoxtralRealtime
VoxtralRealtime est un modèle de transcription vocale en flux développé par Mistral AI, conçu pour la reconnaissance automatique de la parole (ASR) en temps réel. Contrairement au modèle hors ligne Voxtral, qui traite des fichiers audio complets, VoxtralRealtime est architecturé pour une transcription incrémentale à faible latence, en traitant l'audio par segments au fur et à mesure de leur réception.
Le modèle combine un encodeur audio avec un décodeur de modèle de langage basé sur Mistral, en utilisant des embeddings de conditionnement temporel et des convolutions causales avec des caches de bourrage pour permettre une inférence en streaming efficace.
Utilisation
Transcription hors ligne
Pour transcrire des fichiers audio complets, utilisez directement le processeur et le modèle. La longueur de génération est déterminée automatiquement à partir de la durée de l’audio.
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])Transcription hors ligne par lots
Plusieurs échantillons audio peuvent être transcrits en un seul passage avant :
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)Transcription en streaming
Il s'agit d'une fonctionnalité expérimentale et l'API est susceptible d'évoluer.
Pour la transcription en temps réel, l’audio est découpé en segments selon :
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)Ce modèle a été contribué par Eustache Le Bihan.
VoxtralRealtimeConfig
classe transformers.VoxtralRealtimeConfig
< source >( 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 )
Paramètres
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone audio. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte. - projector_hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation utilisée par le projecteur multimodal. - audio_length_per_tok (
int, facultatif, valeur par défaut : 8) — Le nombre de trames audio correspondant à chaque jeton de texte. - default_num_delay_tokens (
int, facultatif, valeur par défaut : 6) — Nombre de jetons de délai utilisés par défaut pour le streaming. - downsample_factor (
int, facultatif, valeur par défaut : 4) — Facteur de sous-échantillonnage appliqué aux caractéristiques audio avant la projection. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur.
Ceci est la classe de configuration destinée à stocker la configuration d'un VoxtralRealtimeModel. Elle est utilisée pour instancier un modèle Voxtral Realtime en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de mistralai/Voxtral-Mini-4B-Realtime-2602
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
>>> 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.configVoxtralRealtimeEncoderConfig
classe transformers.VoxtralRealtimeEncoderConfig
< source >( 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 )
Paramètres
- vocab_size (
int, facultatif, par défaut131072) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut1280) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut5120) — Dimension des représentations du MLP. - num_hidden_layers (
int, facultatif, par défaut32) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut32) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - activation_function (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - num_mel_bins (
int, facultatif, par défaut128) — Nombre de caractéristiques mel utilisées par trame d’entrée. Doit correspondre à la valeur utilisée dans la classeAutoFeatureExtractor. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - hidden_act (
str, facultatif, par défautsilu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - max_position_embeddings (
int, facultatif, par défaut1500) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], facultatif) — Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus longs. - sliding_window (
int, facultatif, valeur par défaut750) — Taille de la fenêtre d'attention glissante. SiNone, aucune fenêtre glissante n'est appliquée. - head_dim (
int, facultatif, par défaut64) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur.
Ceci est la classe de configuration destinée à stocker la configuration d'un VoxtralRealtimeModel. Elle est utilisée pour instancier un modèle Voxtral Realtime en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de mistralai/Voxtral-Mini-4B-Realtime-2602
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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.configVoxtralRealtimeTextConfig
classe transformers.VoxtralRealtimeTextConfig
< source >( 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 )
Paramètres
- vocab_size (
int, facultatif, par défaut32000) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut4096) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut14336) — Dimension des représentations du MLP. - num_hidden_layers (
int, facultatif, par défaut32) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut32) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_key_value_heads (
int, facultatif, valeur par défaut8) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Sinum_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), sinum_key_value_heads=1le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut seranum_attention_heads. - head_dim (
int, facultatif) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - hidden_act (
str, facultatif, par défautsilu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - max_position_embeddings (
int, facultatif, par défaut131072) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - rms_norm_eps (
float, facultatif, valeur par défaut1e-06) — L'épsilon utilisé par les couches de normalisation rms. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - pad_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut1) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], facultatif) — Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus longs. - sliding_window (
int, facultatif, par défaut4096) — Taille de la fenêtre d'attention glissante. SiNone, aucune fenêtre glissante n'est appliquée. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention.
Ceci est la classe de configuration destinée à stocker la configuration d'un VoxtralRealtimeModel. Elle est utilisée pour instancier un modèle Voxtral Realtime en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de mistralai/Voxtral-Mini-4B-Realtime-2602
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
VoxtralRealtimeFeatureExtractor
classe transformers.VoxtralRealtimeFeatureExtractor
< source >( feature_size = 128sampling_rate = 16000hop_length = 160n_fft = 400win_length = 400padding_value = 0.0global_log_mel_max = 1.5**kwargs )
Paramètres
- feature_size (
int, facultatif, par défaut 128) — La dimension des caractéristiques des fonctionnalités extraites. - sampling_rate (
int, facultatif, valeur par défaut 16000) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz). - hop_length (
int, facultatif, par défaut 160) — Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence Mel. - n_fft (
int, facultatif, par défaut 512) — Taille de la transformée de Fourier. - win_length (
int, facultatif, par défaut 400) — La longueur de la fenêtre pour le calcul de la STFT. - padding_value (
float, facultatif, valeur par défaut 0.0) — Valeur de bourrage utilisée pour bourrer l'audio. Doit correspondre à des silences.
Construit un extracteur de fonctionnalités VOXTRAL_REALTIME.
Cet extracteur de fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.
Cette classe extrait les caractéristiques de la banque de filtres mel à partir de la parole brute à l'aide d'une implémentation numpy personnalisée de la Short Time Fourier Transform, qui doit correspondre à l'équivalent torch.stft de pytorch.
VoxtralRealtimeProcessor
classe transformers.VoxtralRealtimeProcessor
< source >( feature_extractortokenizer )
Construit un VoxtralRealtimeProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.
VoxtralRealtimeProcessor propose toutes les fonctionnalités de VoxtralRealtimeFeatureExtractor et de MistralCommonBackend. Consultez ~VoxtralRealtimeFeatureExtractor et ~MistralCommonBackend pour plus d’informations.
__call__
< source >( 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.models.voxtral_realtime.processing_voxtral_realtime.VoxtralRealtimeProcessorKwargs'> ) → BatchFeature
Paramètres
- audio (
AudioInput, facultatif) — Audio d'entrée ou lot d'audios sous forme de tableaux NumPy ou de tenseurs PyTorch. - is_streaming (
bool, facultatif, valeur par défautFalse) — Indique s'il faut traiter l'audio en mode streaming. SiTrue, l'audio peut être transmis par morceaux en utilisantis_first_audio_chunkpour distinguer le premier morceau des suivants. - is_first_audio_chunk (
bool, facultatif, valeur par défautTrue) — Indique si l'audio actuel est le premier fragment d'une session de streaming. SiTrue, l'audio est encodé dans une requête de transcription complète avec le texte tokenisé. SiFalse, seules les caractéristiques audio sont extraites (l'encodage du texte est ignoré). Doit êtreTruelorsqueis_streaming=False.
Retourne
Un BatchFeature avec les champs suivants :
- input_ids — Liste des identifiants de jetons à fournir au modèle. Renvoyé lorsque
is_first_audio_chunk=True. - attention_mask — Liste d'indices spécifiant les jetons auxquels le modèle doit prêter attention.
Retourné lorsque
is_first_audio_chunk=True. - input_features — Caractéristiques du spectrogramme de Mel extraites de l'entrée audio.
- num_delay_tokens — Le nombre de jetons de délai utilisés pour le streaming.
Méthode principale pour préparer l'entrée audio du modèle Voxtral Realtime. Cette méthode encode l'audio en une requête de transcription à l'aide de mistral_common, tokenise le texte résultant et extrait les caractéristiques du spectrogramme de Mel à l'aide de l'extracteur de caractéristiques. Prend en charge les modes en streaming et non en streaming.
VoxtralRealtimeEncoder
classe transformers.VoxtralRealtimeEncoder
< source >( config: VoxtralRealtimeEncoderConfig )
Paramètres
- config (VoxtralRealtimeEncoderConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
L'encodeur de VoxtralRealtime, qui est un encodeur Whisper.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_features: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = 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.FloatTensor)
Paramètres
- input_features (
torch.FloatTensorde forme(batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de VoxtralRealtimeFeatureExtractor. VoirVoxtralRealtimeFeatureExtractor.__call__()pour plus de détails (VoxtralRealtimeProcessor utilise VoxtralRealtimeFeatureExtractor pour le traitement des audios). - position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - padding_cache (
VoxtralRealtimeConv1dPaddingCache, facultatif) — Cache de bourrage pour les couches convolutives afin de maintenir l'état entre les blocs de flux. - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - use_padding_cache (
bool, facultatif) — Indique s'il faut utiliser le cache de bourrage. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Retourne
BaseModelOutputWithPooling ou tuple(torch.FloatTensor)
Un BaseModelOutputWithPooling ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (VoxtralRealtimeConfig) et des entrées.
La méthode forward de VoxtralRealtimeEncoder redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.pooler_output (
torch.FloatTensorde forme(batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire à travers les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
VoxtralRealtimeModel
classe transformers.VoxtralRealtimeModel
< source >( config: VoxtralRealtimeConfig )
Paramètres
- config (VoxtralRealtimeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle VoxtralRealtime, qui se compose d'un encodeur de type Whisper en flux, d'un projecteur multi-modal, d'un modèle de langage basé sur Mistral et d'un embedding temporel, sans tête de modélisation du langage.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = Noneencoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = Nonenum_delay_tokens: typing.Union[int, torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VoxtralRealtimeModelOutputWithPast or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- input_features (
torch.FloatTensorde forme(batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de VoxtralRealtimeFeatureExtractor. VoirVoxtralRealtimeFeatureExtractor.__call__()pour plus de détails (VoxtralRealtimeProcessor utilise VoxtralRealtimeFeatureExtractor pour le traitement des audios). - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - encoder_past_key_values (
Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) pour l'encodeur. - padding_cache (
VoxtralRealtimeConv1dPaddingCache, facultatif) — Cache de bourrage pour les couches convolutives afin de maintenir l'état entre les blocs de flux. - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - encoder_inputs_embeds (
torch.FloatTensor, facultatif) — Facultativement, au lieu de passerinput_features, vous pouvez choisir de passer directement une représentation intégrée pour l’encodeur. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - num_delay_tokens (
intoutorch.Tensor, facultatif) — Nombre de jetons de délai utilisés lors de la préparation des entrées.
Retourne
VoxtralRealtimeModelOutputWithPast ou tuple(torch.FloatTensor)
Un VoxtralRealtimeModelOutputWithPast ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (VoxtralRealtimeConfig) et des entrées.
La méthode forward du modèle VoxtralRealtimeModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
- encoder_past_key_values (
Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) pour l'encodeur audio, qui peuvent être utilisés pour accélérer le décodage séquentiel. - padding_cache (
VoxtralRealtimeConv1dPaddingCache, facultatif) — Cache de bourrage pour les couches de convolution afin de maintenir l'état entre les segments de flux. - audio_hidden_states (
torch.FloatTensor, facultatif) — États cachés audio projetés avant d'être ajoutés aux embeddings de texte.
VoxtralRealtimeForConditionalGeneration
classe transformers.VoxtralRealtimeForConditionalGeneration
< source >( config: VoxtralRealtimeConfig )
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = Noneencoder_inputs_embeds: typing.Optional[torch.FloatTensor] = 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.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- input_features (
torch.FloatTensorde forme(batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de VoxtralRealtimeFeatureExtractor. VoirVoxtralRealtimeFeatureExtractor.__call__()pour plus de détails (VoxtralRealtimeProcessor utilise VoxtralRealtimeFeatureExtractor pour le traitement des audios). - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - encoder_past_key_values (
Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) pour l'encodeur, qui peuvent être utilisés pour accélérer le décodage séquentiel. - padding_cache (
VoxtralRealtimeConv1dPaddingCache, facultatif) — Cache de bourrage pour les couches convolutives afin de maintenir l'état entre les blocs de flux. - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - encoder_inputs_embeds (
torch.FloatTensor, facultatif) — Facultativement, au lieu de passerinput_features, vous pouvez choisir de passer directement une représentation intégrée pour l’encodeur. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - logits_to_keep (
Union[int, torch.Tensor], facultatif, valeur par défaut0) — Si c'est unint, calcule les logits pour leslogits_to_keepderniers jetons. Si0, calcule les logits pour tous lesinput_ids(cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est untorch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence). - num_delay_tokens (
intoutorch.Tensor, facultatif) — Nombre de jetons de délai utilisés lors de la préparation des entrées, voir ~VoxtralRealtimeProcessor pour plus de détails.
Retourne
VoxtralRealtimeCausalLMOutputWithPast ou tuple(torch.FloatTensor)
Un VoxtralRealtimeCausalLMOutputWithPast ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments selon la configuration (VoxtralRealtimeConfig) et les entrées.
La méthode forward de VoxtralRealtimeForConditionalGeneration redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
- encoder_past_key_values (
Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention) pour l'encodeur audio, qui peuvent être utilisés pour accélérer le décodage séquentiel. - padding_cache (
VoxtralRealtimeConv1dPaddingCache, facultatif) — Cache de bourrage pour les couches de convolution afin de maintenir l'état entre les blocs de flux.
Exemple :
>>> 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)