# VibeVoice ASR ## Aperçu VibeVoice ASR est un modèle de reconnaissance vocale automatique de Microsoft qui combine des tokeniseurs audio acoustiques et sémantiques avec un modèle de langage causal pour une transcription robuste de la parole en texte. Le modèle utilise les tokeniseurs acoustiques et sémantiques de VibeVoice, qui traitent l’audio à 24 kHz, associés à un décodeur de langage basé sur Qwen2 pour générer les transcriptions. Consultez le [rapport technique](https://huggingface.co/papers/2601.18184) pour plus de détails. Le point de contrôle du modèle est disponible à l'adresse suivante : [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF) Points forts : - **🕒 Traitement en un seul passage de 60 minutes** : Contrairement aux modèles ASR conventionnels qui découpent l'audio en courts segments (souvent au détriment du contexte global), VibeVoice ASR accepte jusqu'à **60 minutes** d'audio continu dans une longueur de 64K jetons. Cela garantit un suivi cohérent des locuteurs et une cohérence sémantique sur l'ensemble de l'heure. - **👤 Mots-clés personnalisés** : Les utilisateurs peuvent fournir des mots-clés personnalisés (par exemple, des noms spécifiques, des termes techniques ou des informations de contexte) pour orienter le processus de reconnaissance, ce qui améliore considérablement la précision sur les contenus spécifiques à un domaine. - **📝 Transcription riche (qui, quand, quoi)** : le modèle effectue conjointement l’ASR, la diarisation et la datation, produisant une sortie structurée qui indique *qui* a dit *quoi* et *quand*. - **🌍 Prise en charge multilingue et du code-switching** : il prend en charge plus de 50 langues, ne nécessite aucun paramétrage explicite de la langue et gère nativement le code-switching au sein et entre les énoncés. Ce modèle a été contribué par [Eric Bezzam](https://huggingface.co/bezzam). ## Utilisation Le modèle prend en charge diverses fonctionnalités de reconnaissance vocale automatique. ### Transcription horodatée par locuteur L'une des caractéristiques notables de VibeVoice ASR est sa capacité à transcrire des contenus à plusieurs locuteurs, en indiquant qui a parlé et à quel moment. ```python from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration model_id = "microsoft/VibeVoice-ASR-HF" processor = AutoProcessor.from_pretrained(model_id) model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto") print(f"Model loaded on {model.device} with dtype {model.dtype}") # Prepare inputs using `apply_transcription_request` inputs = processor.apply_transcription_request( audio="https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav", ).to(model.device, model.dtype) # Apply model output_ids = model.generate(**inputs) generated_ids = output_ids[:, inputs["input_ids"].shape[1] :] transcription = processor.decode(generated_ids)[0] print("\n" + "=" * 60) print("RAW OUTPUT") print("=" * 60) print(transcription) transcription = processor.decode(generated_ids, return_format="parsed")[0] print("\n" + "=" * 60) print("TRANSCRIPTION (list of dicts)") print("=" * 60) for speaker_transcription in transcription: print(speaker_transcription) # Remove speaker labels, only get raw transcription transcription = processor.decode(generated_ids, return_format="transcription_only")[0] print("\n" + "=" * 60) print("TRANSCRIPTION ONLY") print("=" * 60) print(transcription) """ ============================================================ RAW OUTPUT ============================================================ <|im_start|>assistant [{"Start":0,"End":15.43,"Speaker":0,"Content":"Hello everyone and welcome to the Vibe Voice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me."},{"Start":15.43,"End":21.05,"Speaker":1,"Content":"Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings."},{"Start":21.05,"End":31.66,"Speaker":0,"Content":"Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible."},{"Start":31.66,"End":40.93,"Speaker":1,"Content":"Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it."}]<|im_end|> <|endoftext|> ============================================================ TRANSCRIPTION (list of dicts) ============================================================ {'Start': 0, 'End': 15.43, 'Speaker': 0, 'Content': "Hello everyone and welcome to the Vibe Voice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me."} {'Start': 15.43, 'End': 21.05, 'Speaker': 1, 'Content': "Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings."} {'Start': 21.05, 'End': 31.66, 'Speaker': 0, 'Content': "Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible."} {'Start': 31.66, 'End': 40.93, 'Speaker': 1, 'Content': "Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it."} ============================================================ TRANSCRIPTION ONLY ============================================================ Hello everyone and welcome to the Vibe Voice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me. Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings. Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible. Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it. """ ``` Le modèle VibeVoice ASR est entraîné pour générer une chaîne de caractères ressemblant à une structure JSON. L'option `return_format="parsed"` tente de renvoyer la sortie générée sous forme de liste de dictionnaires, tandis que `return_format="transcription_only"` tente d'extraire uniquement l'audio transcrit. En cas d'échec, la sortie générée est renvoyée telle quelle. ### Fournir un contexte Il est également possible de fournir un contexte. Cela peut être utile si certains mots ne peuvent pas être transcrits correctement, comme les noms propres. Ci-dessous, nous transcrivons un audio où l’orateur (avec un accent allemand) parle de VibeVoice, en comparant avec et sans le contexte « About VibeVoice ». ```python from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration model_id = "microsoft/VibeVoice-ASR-HF" processor = AutoProcessor.from_pretrained(model_id) model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto") print(f"Model loaded on {model.device} with dtype {model.dtype}") # Without context inputs = processor.apply_transcription_request( audio="https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", ).to(model.device, model.dtype) output_ids = model.generate(**inputs) generated_ids = output_ids[:, inputs["input_ids"].shape[1] :] transcription = processor.decode(generated_ids, return_format="transcription_only")[0] print(f"WITHOUT CONTEXT: {transcription}") # With context inputs = processor.apply_transcription_request( audio="https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", prompt="About VibeVoice", ).to(model.device, model.dtype) output_ids = model.generate(**inputs) generated_ids = output_ids[:, inputs["input_ids"].shape[1] :] transcription = processor.decode(generated_ids, return_format="transcription_only")[0] print(f"WITH CONTEXT : {transcription}") """ WITHOUT CONTEXT: Revevoices is a novel framework designed for generating expressive, long-form, multi-speaker conversational audio. WITH CONTEXT : VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio. """ ``` ### Inférence par lots L'inférence par lots est possible en transmettant une liste d'audio et, le cas échéant, une liste de prompts. Le nombre d'entrées audio et de prompts doit correspondre (pour les prompts, vous pouvez définir une entrée sur `None` si elle n'est pas nécessaire pour un audio donné). ```python from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration model_id = "microsoft/VibeVoice-ASR-HF" audio = [ "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav" ] prompts = ["About VibeVoice", None] processor = AutoProcessor.from_pretrained(model_id) model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto") print(f"Model loaded on {model.device} with dtype {model.dtype}") inputs = processor.apply_transcription_request(audio, prompt=prompts).to(model.device, model.dtype) output_ids = model.generate(**inputs) generated_ids = output_ids[:, inputs["input_ids"].shape[1] :] transcription = processor.decode(generated_ids, return_format="transcription_only") print(transcription) ``` ### Ajustement du chunk du tokenizer (par exemple, en cas de mémoire insuffisante) L’une des fonctionnalités clés de VibeVoice ASR est sa capacité à transcrire jusqu’à 60 minutes d’audio continu. Cela est réalisé en découpant l’audio en segments de 60 secondes (1440000 échantillons à 24 kHz) et en mettant en cache les états de convolution entre chaque segment. Cependant, si des segments de 60 secondes sont trop volumineux pour votre appareil, l'argument `acoustic_tokenizer_chunk_size` transmis à `generate` peut être ajusté. *Notez qu'il doit être un multiple de la longueur de saut (3200 pour le tokenizer acoustique d'origine).* ```python from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration acoustic_tokenizer_chunk_size = 64000 # default is 1440000 (60s @ 24kHz) model_id = "microsoft/VibeVoice-ASR-HF" audio = [ "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav" ] prompts = ["About VibeVoice", None] processor = AutoProcessor.from_pretrained(model_id) model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto") print(f"Model loaded on {model.device} with dtype {model.dtype}") inputs = processor.apply_transcription_request(audio, prompt=prompts).to(model.device, model.dtype) output_ids = model.generate(**inputs, acoustic_tokenizer_chunk_size=acoustic_tokenizer_chunk_size) generated_ids = output_ids[:, inputs["input_ids"].shape[1] :] transcription = processor.decode(generated_ids, return_format="transcription_only") print(transcription) ``` ### Modèle de chat VibeVoice ASR accepte également les entrées de modèle de chat (`apply_transcription_request` est en réalité un wrapper de `apply_chat_template` pour plus de commodité) : ```python from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration model_id = "microsoft/VibeVoice-ASR-HF" processor = AutoProcessor.from_pretrained(model_id) model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto") chat_template = [ [ { "role": "user", "content": [ {"type": "text", "text": "About VibeVoice"}, { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", }, ], } ], [ { "role": "user", "content": [ { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav", }, ], } ], ] inputs = processor.apply_chat_template( chat_template, tokenize=True, return_dict=True, ).to(model.device, model.dtype) output_ids = model.generate(**inputs) generated_ids = output_ids[:, inputs["input_ids"].shape[1] :] transcription = processor.decode(generated_ids, return_format="transcription_only") print(transcription) ``` ### Entraînement VibeVoice ASR peut être entraîné à l'aide de la perte produite par le modèle. ```python from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration model_id = "microsoft/VibeVoice-ASR-HF" processor = AutoProcessor.from_pretrained(model_id) model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto") model.train() # Prepare batch of 2 # -- NOTE: the original model is trained to output transcription, speaker ID, and timestamps in JSON-like format. Below we are only using the transcription text as the label chat_template = [ [ { "role": "user", "content": [ {"type": "text", "text": "VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio."}, { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", }, ], } ], [ { "role": "user", "content": [ {"type": "text", "text": "Hello everyone and welcome to the VibeVoice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me. Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings. Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible. Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it."}, { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav", }, ], } ], ] inputs = processor.apply_chat_template( chat_template, tokenize=True, return_dict=True, output_labels=True, ).to(model.device, model.dtype) loss = model(**inputs).loss print("Loss:", loss.item()) loss.backward() ``` ### Torch compile Le modèle peut être compilé pour accélérer l’inférence/la formation. ```python import time import torch from transformers import AutoProcessor, VibeVoiceAsrForConditionalGeneration model_id = "microsoft/VibeVoice-ASR-HF" num_warmup = 5 num_runs = 20 # Load processor + model processor = AutoProcessor.from_pretrained(model_id) model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, device_map="auto") # Prepare static inputs chat_template = [ [ { "role": "user", "content": [ { "type": "text", "text": "VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio.", }, { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", }, ], } ], ] * 4 # batch size 4 inputs = processor.apply_chat_template( chat_template, tokenize=True, return_dict=True, ).to(model.device, torch.bfloat16) # Benchmark without compile print("Warming up without compile...") with torch.no_grad(): for _ in range(num_warmup): _ = model(**inputs) torch.accelerator.synchronize() print("\nBenchmarking without torch.compile...") torch.accelerator.synchronize() start = time.time() with torch.no_grad(): for _ in range(num_runs): _ = model(**inputs) torch.accelerator.synchronize() no_compile_time = (time.time() - start) / num_runs print(f"Average time without compile: {no_compile_time:.4f}s") # Benchmark with compile print("\nCompiling model...") model = torch.compile(model) print("Warming up with compile (includes graph capture)...") with torch.no_grad(): for _ in range(num_warmup): _ = model(**inputs) torch.accelerator.synchronize() print("\nBenchmarking with torch.compile...") torch.accelerator.synchronize() start = time.time() with torch.no_grad(): for _ in range(num_runs): _ = model(**inputs) torch.accelerator.synchronize() compile_time = (time.time() - start) / num_runs print(f"Average time with compile: {compile_time:.4f}s") speedup = no_compile_time / compile_time print(f"\nSpeedup: {speedup:.2f}x") ``` ### Utilisation du pipeline Le modèle peut être utilisé comme un pipeline, mais vous devrez définir vos propres méthodes pour analyser la sortie brute. ```python from transformers import pipeline model_id = "microsoft/VibeVoice-ASR-HF" pipe = pipeline("any-to-any", model=model_id, device_map="auto") chat_template = [ { "role": "user", "content": [ {"type": "text", "text": "About VibeVoice"}, { "type": "audio", "path": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav", }, ], } ] outputs = pipe(text=chat_template, return_full_text=False) print("\n" + "=" * 60) print("RAW PIPELINE OUTPUT") print("=" * 60) print(outputs[0]["generated_text"]) print("\n" + "=" * 60) print("DICT OUTPUT") print("=" * 60) dict_output = pipe.processor.extract_speaker_dict(outputs[0]["generated_text"]) print(dict_output) print("\n" + "=" * 60) print("TRANSCRIPT OUTPUT") print("=" * 60) transcription = pipe.processor.extract_transcription(outputs[0]["generated_text"]) print(transcription) ``` ## VibeVoiceAsrConfig[[transformers.VibeVoiceAsrConfig]] #### transformers.VibeVoiceAsrConfig[[transformers.VibeVoiceAsrConfig]] ```python transformers.VibeVoiceAsrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, acoustic_tokenizer_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_tokenizer_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 151648, audio_bos_token_id: int = 151646, audio_eos_token_id: int = 151647, acoustic_tokenizer_chunk_size: int = 1440000) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/configuration_vibevoice_asr.py#L31) **Paramètres :** acoustic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *facultatif*) : L'objet de configuration ou le dictionnaire du tokenizer acoustique. Ce tokenizer extrait les caractéristiques acoustiques de l'audio. semantic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *facultatif*) : L'objet de configuration ou le dictionnaire du tokenizer sémantique. Ce tokenizer extrait les caractéristiques sémantiques de l'audio. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte. audio_token_id (`int`, *facultatif*, valeur par défaut `151648`) : L'index du jeton audio utilisé comme espace réservé pour l'audio en entrée. audio_bos_token_id (`int`, *facultatif*, valeur par défaut 151646) : L'index du jeton de début de séquence audio. audio_eos_token_id (`int`, *facultatif*, valeur par défaut 151647) : L'index du jeton de fin de séquence audio. acoustic_tokenizer_chunk_size (`int`, *facultatif*, valeur par défaut 1440000) : La taille des blocs (en nombre d'échantillons) à utiliser lors de la tokenisation des entrées audio. La valeur par défaut correspond à 60 secondes à 24 kHz. Ceci est la classe de configuration destinée à stocker la configuration d'un VibeVoiceAsrModel. Elle est utilisée pour instancier un modèle Vibevoice Asr 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 [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import VibeVoiceAsrForConditionalGeneration, VibeVoiceAsrConfig, VibeVoiceAcousticTokenizerEncoderConfig, Qwen2Config >>> # Initializing VibeVoice acoustic and semantic encoder configs >>> acoustic_config = VibeVoiceAcousticTokenizerEncoderConfig() >>> semantic_config = VibeVoiceAcousticTokenizerEncoderConfig(hidden_size=128) >>> # Initializing a Qwen2 config >>> text_config = Qwen2Config() >>> # Initializing a VibeVoice ASR configuration >>> configuration = VibeVoiceAsrConfig(acoustic_config, semantic_config, text_config) >>> # Initializing a model from the vibevoice_asr style configuration >>> model = VibeVoiceAsrForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## VibeVoiceAsrProcessor[[transformers.VibeVoiceAsrProcessor]] #### transformers.VibeVoiceAsrProcessor[[transformers.VibeVoiceAsrProcessor]] ```python transformers.VibeVoiceAsrProcessor(feature_extractor, tokenizer, chat_template = None, audio_token = '<|box_start|>', audio_bos_token = '<|object_ref_start|>', audio_eos_token = '<|object_ref_end|>', audio_duration_token = '<|AUDIO_DURATION|>') ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L48) **Paramètres :** feature_extractor (`VibeVoiceAcousticTokenizerFeatureExtractor`) : extracteur de caractéristiques pour le traitement audio. tokenizer (`Qwen2TokenizerFast`) : le tokenizer pour le traitement du texte. chat_template (`str`, *facultatif*) : Un modèle Jinja qui sera utilisé pour convertir les listes de messages d'une conversation en une chaîne tokenisable. audio_token (`str`, *facultatif*, valeur par défaut `"<|box_start|>"`) : Jeton audio à utiliser comme espace réservé dans le modèle de discussion. audio_bos_token (`str`, *facultatif*, valeur par défaut `"<|object_ref_start|>"`) : Le jeton de début de séquence audio à utiliser comme espace réservé dans le modèle de discussion. audio_eos_token (`str`, *facultatif*, par défaut `"<|object_ref_end|>"`) : Le jeton de fin de séquence audio à utiliser comme espace réservé dans le modèle de discussion. audio_duration_token (`str`, *facultatif*, valeur par défaut `"<|AUDIO_DURATION|>"`) : Le jeton de remplacement de la durée audio à utiliser dans le modèle de discussion. Construit un processeur VibeVoice ASR qui encapsule [VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/main/fr/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) et [Qwen2TokenizerFast](/docs/transformers/main/fr/model_doc/qwen2#transformers.Qwen2Tokenizer) dans un seul processeur héritant à la fois des fonctionnalités d'extraction de caractéristiques audio et de tokenisation. Voir [__call__()](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) pour plus d’informations. #### __appel__[[transformers.VibeVoiceAsrProcessor.__call__]] ```python __call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L94) **Paramètres :** text (`Union[str, list[str]]`) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *facultatif*) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio. output_labels (`bool`, *facultatif*, défaut=False) : Indique s'il faut retourner les étiquettes pour l'entraînement. return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge. **Retourne :** [BatchFeature](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.BatchFeature) Un dictionnaire contenant le texte tokenisé (`input_ids`, `attention_mask`) et les caractéristiques audio (`input_values`, `padding_mask`). #### apply_transcription_request[[transformers.VibeVoiceAsrProcessor.apply_transcription_request]] ```python apply_transcription_request(audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], prompt: str | list[str] | None = None, tokenize: bool = True, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L177) **Paramètres :** audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Audio à transcrire. Les chaînes de caractères sont interprétées comme des chemins locaux ou des URL et seront chargées automatiquement par le chargeur de modèle de chat ; les tableaux NumPy et les tenseurs PyTorch sont transmis directement. prompt (`str` ou `list[str]`, *facultatif*) : Prompt(s) personnalisé(s) à inclure dans le tour de l'utilisateur en tant que contexte supplémentaire. Une liste doit avoir la même longueur que le lot. Si la valeur est `None`, aucun contexte supplémentaire n'est fourni. tokenize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut tokeniser les prompts et traiter l'audio. Si `False`, l'audio n'est pas chargé et les prompts sont renvoyés sous forme de chaînes avec des placeholders audio non développés. Les transmettre avec l'audio au processeur, `processor(text=prompts, audio=audio)`, produit les mêmes sorties que `tokenize=True`. - ****kwargs** : Arguments supplémentaires transmis à [apply_chat_template()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (par exemple `text_kwargs`, `audio_kwargs`, ...). **Retourne :** [BatchFeature](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.BatchFeature) ou `list[str]` Un prompt par audio lorsque `tokenize=False`, sinon le processeur renvoie des données prêtes à être transmises à [VibeVoiceAsrForConditionalGeneration.generate()](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationMixin.generate). Préparez les entrées pour la reconnaissance automatique de la parole sans rédiger manuellement le modèle de discussion. #### decode[[transformers.VibeVoiceAsrProcessor.decode]] ```python decode(*args, return_format = 'raw', **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L233) **Paramètres :** return_format (`str`, *facultatif*, par défaut `"raw"`) : Les options sont : - `"raw"` : Renvoie une liste de chaînes brutes décodées par le tokenizer, sans aucune analyse. - `"parsed"` : Renvoie une liste de listes d'objets dictionnaire analysés pour chaque énoncé d'un locuteur, avec des horodatages. - `"transcription_only"` : Renvoie une liste de chaînes de transcription extraites. `skip_special_tokens` est automatiquement appliqué (fixé de manière stricte) à `True` pour `"parsed"` et `"transcription_only"`. Transmet les arguments à [decode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) et, le cas échéant, analyse la sortie de type dictionnaire. VibeVoice ASR renvoie les transcriptions dans un format de type dictionnaire, par exemple : ``` [ 'assistant ":0.0,"End":7.56,"Speaker":0,"Content":"text"}] 'assistant ":0,"End":5.20,"Speaker":0,"Content":"text"}] ] ``` ## VibeVoiceAsrModel[[transformers.VibeVoiceAsrModel]] #### transformers.VibeVoiceAsrModel[[transformers.VibeVoiceAsrModel]] ```python transformers.VibeVoiceAsrModel(config: VibeVoiceAsrConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L304) **Paramètres :** config ([VibeVoiceAsrConfig](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle VibeVoice ASR (tokeniseur acoustique + tokeniseur sémantique + projecteur multimodal + modèle de langage), sans tête de modélisation du langage. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.VibeVoiceAsrModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, sample: bool = True, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L379) **Paramètres :** input_ids (`torch.LongTensor` de 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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée vocale. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, il faut utiliser [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) pour le bourrage (padding) et la conversion en tenseur de type `torch.Tensor`. Voir [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) pour plus de détails. padding_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'effectuer des opérations sur les indices de caractéristiques de bourrage. sample (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter du bruit gaussien aux latents acoustiques, comme dans le modèle d'origine (σ-VAE : l'échelle du bruit est tirée par élément du lot à partir de N(0, `vae_std`)). Si la valeur est False, la sortie de l'encodeur est utilisée telle quelle, ce qui rend la sortie déterministe. **Retourne :** `VibeVoiceAsrModelOutputWithPast` ou `tuple(torch.Tensor)` Un `VibeVoiceAsrModelOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([VibeVoiceAsrConfig](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) et les entrées. La méthode forward du modèle [VibeVoiceAsrModel](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrModel) 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 `Module` plutô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.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **audio_hidden_states** (`torch.Tensor`, *facultatif*) -- États cachés audio projetés. ## VibeVoiceAsrForConditionalGeneration[[transformers.VibeVoiceAsrForConditionalGeneration]] #### transformers.VibeVoiceAsrForConditionalGeneration[[transformers.VibeVoiceAsrForConditionalGeneration]] ```python transformers.VibeVoiceAsrForConditionalGeneration(config: VibeVoiceAsrConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L435) **Paramètres :** config ([VibeVoiceAsrConfig](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle VibeVoice ASR avec des tokeniseurs acoustiques pré-entraînés et un modèle de langage. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.VibeVoiceAsrForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, sample: bool = True, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L445) **Paramètres :** input_ids (`torch.LongTensor` de 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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée vocale. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, il faut utiliser [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) pour le bourrage (padding) et la conversion en tenseur de type `torch.Tensor`. Voir [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) pour plus de détails. padding_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'effectuer des opérations sur les indices de caractéristiques de bourrage. labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`. logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_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 faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'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). sample (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter du bruit gaussien aux latents acoustiques, comme dans le modèle d'origine (σ-VAE : l'échelle du bruit est tirée par élément du lot à partir de N(0, `vae_std`)). Si la valeur est False, la sortie de l'encodeur est utilisée telle quelle, ce qui rend la sortie déterministe. **Retourne :** `VibeVoiceAsrCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Un `VibeVoiceAsrCausalLMOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([VibeVoiceAsrConfig](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) et les entrées. La méthode forward de [VibeVoiceAsrForConditionalGeneration](/docs/transformers/main/fr/model_doc/vibevoice_asr#transformers.VibeVoiceAsrForConditionalGeneration) 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 `Module` plutô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. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage. - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction. - **past_key_values** (`Cache`, *facultatif*) -- Instance de cache. - **hidden_states** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **audio_hidden_states** (`torch.Tensor`, *facultatif*) -- États cachés audio projetés. Exemple : ```python >>> from transformers import VibeVoiceAsrForConditionalGeneration, AutoProcessor >>> model_id = "microsoft/VibeVoice-ASR-HF" >>> processor = AutoProcessor.from_pretrained(model_id) >>> model = VibeVoiceAsrForConditionalGeneration.from_pretrained(model_id, dtype="auto", device_map="auto") ``` #### get_audio_features[[transformers.VibeVoiceAsrForConditionalGeneration.get_audio_features]] ```python get_audio_features(*args, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L442)