# VibeVoice ASR ## Visão geral VibeVoice ASR é um modelo de reconhecimento automático de fala da Microsoft que combina tokenizadores de áudio acústicos e semânticos com um modelo de linguagem causal para transcrição robusta de fala para texto. O modelo utiliza os tokenizadores acústicos e semânticos do VibeVoice, que processam áudio em 24kHz, em conjunto com um decodificador de linguagem baseado em Qwen2 para gerar transcrições. Consulte o [relatório técnico](https://huggingface.co/papers/2601.18184) para mais detalhes. O checkpoint do modelo está disponível em: [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF) Destaques: - **🕒 Processamento em uma única passagem de 60 minutos**: Diferentemente dos modelos de ASR convencionais que dividem o áudio em trechos curtos (frequentemente perdendo o contexto global), o VibeVoice ASR aceita até **60 minutos** de áudio contínuo dentro do limite de 64K tokens. Isso garante o rastreamento consistente dos falantes e a coerência semântica ao longo da hora inteira. - **👤 Hotwords personalizadas**: Os usuários podem fornecer hotwords personalizadas (por exemplo, nomes específicos, termos técnicos ou informações de contexto) para orientar o processo de reconhecimento, melhorando significativamente a precisão em conteúdo específico de domínio. - **📝 Transcrição rica (Quem, Quando, O quê)**: O modelo executa conjuntamente ASR, diarização e marcação de tempo, produzindo uma saída estruturada que indica *quem* disse *o quê* e *quando*. - **🌍 Suporte a multilíngue e code-switching**: Suporta mais de 50 idiomas, não requer configuração explícita de idioma e lida nativamente com code-switching dentro e entre falas. Este modelo foi contribuído por [Eric Bezzam](https://huggingface.co/bezzam). ## Uso O modelo suporta diversas funcionalidades de reconhecimento automático de fala. ### Transcrição com marcação de tempo por falante Um recurso notável do VibeVoice ASR é a capacidade de transcrever conteúdo com múltiplos falantes, indicando quem falou e quando. ```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. """ ``` O modelo VibeVoice ASR é treinado para gerar uma string que se assemelha a uma estrutura JSON. A flag `return_format="parsed"` tenta retornar a saída gerada como uma lista de dicts, enquanto `return_format="transcription_only"` tenta extrair apenas o áudio transcrito. Se falharem, a saída gerada é retornada como está. ### Fornecendo contexto Também é possível fornecer contexto. Isso pode ser útil quando certas palavras não podem ser transcritas corretamente, como nomes próprios. Abaixo, transcrevemos um áudio em que o locutor (com sotaque alemão) fala sobre o VibeVoice, comparando com e sem o contexto "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. """ ``` ### Inferência em lote A inferência em lote é possível passando uma lista de áudios e, se fornecidos, uma lista de prompts. O número de entradas de áudio e prompts deve corresponder (para prompts, você pode definir uma entrada como `None` se não for necessário para um determinado áudio). ```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) ``` ### Ajustando o tamanho dos blocos do tokenizer (por exemplo, em caso de falta de memória) Um recurso fundamental do VibeVoice ASR é a capacidade de transcrever até 60 minutos de áudio contínuo. Isso é feito ao dividir o áudio em segmentos de 60 segundos (1440000 amostras a 24 kHz) e ao armazenar em cache os estados de convolução entre cada segmento. No entanto, se blocos de 60 segundos forem grandes demais para o seu dispositivo, o argumento `acoustic_tokenizer_chunk_size` passado para `generate` pode ser ajustado. *Observe que ele deve ser um múltiplo do comprimento do salto (3200 para o tokenizer acústico original).* ```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) ``` ### Modelo de chat O VibeVoice ASR também aceita entradas de modelo de chat (`apply_transcription_request` é, na verdade, um wrapper para `apply_chat_template` por conveniência): ```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) ``` ### Treinamento O VibeVoice ASR pode ser treinado com a perda (loss) gerada pelo modelo. ```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 O modelo pode ser compilado para inferência/treino mais rápidos. ```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") ``` ### Uso do Pipeline O modelo pode ser usado como um pipeline, mas você terá que definir seus próprios métodos para analisar a saída bruta. ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/configuration_vibevoice_asr.py#L31) **Parâmetros:** acoustic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *opcional*) : O objeto de configuração ou dicionário do tokenizer acústico. Este tokenizer extrai características acústicas do áudio. semantic_tokenizer_encoder_config (`Union[VibeVoiceAcousticTokenizerConfig, dict]`, *opcional*) : O objeto de configuração ou dicionário do tokenizador semântico. Este tokenizador extrai características semânticas do áudio. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. audio_token_id (`int`, *opcional*, padrão `151648`) : O índice do token de áudio usado como marcador para o áudio de entrada. audio_bos_token_id (`int`, *opcional*, padrão 151646) : O índice do token de início de sequência de áudio. audio_eos_token_id (`int`, *opcional*, padrão 151647) : O índice do token de fim de sequência de áudio. acoustic_tokenizer_chunk_size (`int`, *opcional*, padrão 1440000) : O tamanho do bloco (em número de amostras) a ser usado ao tokenizar entradas de áudio. O padrão corresponde a 60 segundos a 24 kHz. Esta é a classe de configuração para armazenar a configuração de um VibeVoiceAsrModel. Ela é usada para instanciar um modelo Vibevoice Asr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [microsoft/VibeVoice-ASR-HF](https://huggingface.co/microsoft/VibeVoice-ASR-HF) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```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|>') ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L48) **Parâmetros:** feature_extractor (`VibeVoiceAcousticTokenizerFeatureExtractor`) : O extrator de recursos para processamento de áudio. tokenizer (`Qwen2TokenizerFast`) : O tokenizador para processamento de texto. chat_template (`str`, *opcional*) : Um modelo Jinja que será usado para converter listas de mensagens em um chat em uma string tokenizável. audio_token (`str`, *opcional*, padrão `"<|box_start|>"`) : O placeholder do token de áudio a ser usado no modelo de chat. audio_bos_token (`str`, *opcional*, padrão `"<|object_ref_start|>"`) : O token placeholder de início de sequência de áudio a ser usado no modelo de chat. audio_eos_token (`str`, *opcional*, padrão `"<|object_ref_end|>"`) : O token placeholder de fim de sequência de áudio a ser usado no modelo de chat. audio_duration_token (`str`, *opcional*, padrão `"<|AUDIO_DURATION|>"`) : O token placeholder de duração de áudio a ser usado no modelo de chat. Constrói um processador VibeVoice ASR que encapsula [VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/main/pt/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) e [Qwen2TokenizerFast](/docs/transformers/main/pt/model_doc/qwen2#transformers.Qwen2Tokenizer) em um único processador que herda tanto as funcionalidades de extração de características de áudio quanto as de tokenização. Veja o [__call__()](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) para mais informações. #### __call__[[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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L94) **Parâmetros:** text (`Union[str, list[str]]`) : A sequência ou lote de sequências a serem codificadas. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio. output_labels (`bool`, *opcional*, padrão=False) : Se deve retornar rótulos para o treinamento. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados. **Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) Um dicionário com texto tokenizado (`input_ids`, `attention_mask`) e recursos de áudio (`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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L177) **Parâmetros:** audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Áudio para transcrever. Strings são interpretadas como caminhos locais ou URLs e serão carregadas automaticamente pelo carregador do modelo de chat; arrays NumPy e tensores PyTorch são encaminhados diretamente. prompt (`str` ou `list[str]`, *opcional*) : Prompt(s) personalizado(s) para incluir na vez do usuário como contexto extra. Uma lista deve ter o mesmo comprimento que o lote. Quando `None`, nenhum contexto adicional é fornecido. tokenize (`bool`, *opcional*, padrão `True`) : Se deve tokenizar os prompts e processar o áudio. Se `False`, o áudio não é carregado e os prompts são retornados como strings com placeholders de áudio não expandidos. Passá-los com o áudio para o processador, `processor(text=prompts, audio=audio)`, produz as mesmas saídas que `tokenize=True`. - ****kwargs** : Argumentos de palavra-chave adicionais encaminhados para [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (por exemplo, `text_kwargs`, `audio_kwargs`, ...). **Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) ou `list[str]` Um prompt por áudio quando `tokenize=False`, caso contrário, o processador gera saídas prontas para serem passadas para [VibeVoiceAsrForConditionalGeneration.generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate). Prepare os dados de entrada para reconhecimento automático de fala sem escrever manualmente o modelo de chat. #### decode[[transformers.VibeVoiceAsrProcessor.decode]] ```python decode(*args, return_format = 'raw', **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/processing_vibevoice_asr.py#L233) **Parâmetros:** return_format (`str`, *opcional*, padrão `"raw"`) : As opções são: - `"raw"`: Retorna uma lista de strings decodificadas brutas do tokenizer, sem nenhum processamento. - `"parsed"`: Retorna uma lista de listas de objetos de dicionário processados para cada fala de cada falante, com timestamps. - `"transcription_only"`: Retorna uma lista de strings de transcrição extraídas. `skip_special_tokens` é aplicado automaticamente (definido de forma rígida) como `True` para `"parsed"` e `"transcription_only"`. Encaminha os argumentos para [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) e, opcionalmente, analisa a saída em formato de dicionário. O VibeVoice ASR gera transcrições em um formato semelhante a um dicionário, por exemplo: ``` [ '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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L304) **Parâmetros:** config ([VibeVoiceAsrConfig](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo VibeVoice ASR (tokenizador acústico + tokenizador semântico + projetor multimodal + modelo de linguagem), sem uma cabeça de modelagem de linguagem. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L379) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para padding e conversão em um tensor do tipo `torch.Tensor`. Consulte [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) para mais detalhes. padding_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de operações nos índices de recursos de preenchimento. sample (`bool`, *opcional*, padrão `True`) : Se deve adicionar ruído gaussiano aos latentes acústicos, como no modelo original (σ-VAE: a escala do ruído é extraída por item do lote de N(0, `vae_std`)). Se False, a saída do codificador é usada como está, de modo que a saída é determinística. **Retorna:** `VibeVoiceAsrModelOutputWithPast` ou `tuple(torch.Tensor)` Um `VibeVoiceAsrModelOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([VibeVoiceAsrConfig](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) e das entradas. O método forward do [VibeVoiceAsrModel](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrModel) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos de áudio projetados. ## VibeVoiceAsrForConditionalGeneration[[transformers.VibeVoiceAsrForConditionalGeneration]] #### transformers.VibeVoiceAsrForConditionalGeneration[[transformers.VibeVoiceAsrForConditionalGeneration]] ```python transformers.VibeVoiceAsrForConditionalGeneration(config: VibeVoiceAsrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L435) **Parâmetros:** config ([VibeVoiceAsrConfig](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo VibeVoice ASR com tokenizadores acústicos pré-treinados e um modelo de linguagem. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L445) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para padding e conversão em um tensor do tipo `torch.Tensor`. Consulte [VibeVoiceAsrProcessor.__call__()](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrProcessor.__call__) para mais detalhes. padding_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de operações nos índices de recursos de preenchimento. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`. logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). sample (`bool`, *opcional*, padrão `True`) : Se deve adicionar ruído gaussiano aos latentes acústicos, como no modelo original (σ-VAE: a escala do ruído é extraída por item do lote de N(0, `vae_std`)). Se False, a saída do codificador é usada como está, de modo que a saída é determinística. **Retorna:** `VibeVoiceAsrCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Um `VibeVoiceAsrCausalLMOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([VibeVoiceAsrConfig](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrConfig)) e das entradas. O método forward de [VibeVoiceAsrForConditionalGeneration](/docs/transformers/main/pt/model_doc/vibevoice_asr#transformers.VibeVoiceAsrForConditionalGeneration) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem. - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão. - **past_key_values** (`Cache`, *opcional*) -- Instância de Cache. - **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos de áudio projetados. Exemplo: ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_asr/modeling_vibevoice_asr.py#L442)