Transformers documentation
MOSS-Transcribe-Diarize
Este modelo foi contribuído para o Hugging Face Transformers em 2026-10-14.
MOSS-Transcribe-Diarize
Visão geral
MOSS-Transcribe-Diarize 0.9B é um modelo de compreensão de áudio de ponta a ponta para transcrição de longa duração com múltiplos falantes, diarização de falantes e timestamps. Ele combina um encoder no estilo Whisper, uma etapa de mesclagem de quadros 4×, um projetor multimodal e um modelo de linguagem Qwen3.
O checkpoint do modelo está disponível em: itazap/MOSS-Transcribe-Diarize-HF
As principais funcionalidades incluem:
- Transcrição e diarização conjuntas em uma única passagem, com segmentos formatados como
[start][S01]text[end]. - Áudio de longa duração por meio de divisão em janelas Whisper no processador; o modelo reorganiza os fragmentos por amostra.
- Transcrição com prompt por meio de
apply_transcription_requestou do modelo de chat. - Suporte multilíngue em mais de 50 idiomas.
Este modelo foi contribuído por Ita Zaporozhets, da equipe do Hugging Face. Consulte o model card e o repositório OpenMOSS para mais detalhes.
Uso
A maioria dos exemplos abaixo usa
apply_transcription_request, uma função de conveniência que monta o chat template para você. Consulte Uso avançado com o chat template para a chamada equivalente deapply_chat_template.
Transcrição e diarização básicas
Cada turno de fala é decodificado como um segmento [start][S0N]text[end]. processor.decode pode retornar a string decodificada bruta, os segmentos analisados como uma lista de dicts (return_format="parsed") ou apenas a transcrição concatenada (return_format="transcription_only").
from transformers import AutoProcessor, AutoModelForCausalLM
model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/podcast_sample.wav"
inputs = processor.apply_transcription_request(audio_url)
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=512)
generated_ids = outputs[:, inputs.input_ids.shape[1] :]
decoded = processor.decode(generated_ids, skip_special_tokens=True)
print("RAW OUTPUT:", decoded)
parsed = processor.decode(generated_ids, return_format="parsed")[0]
print("\nPARSED (list of dicts):")
for segment in parsed:
print(segment)
transcription = processor.decode(generated_ids, return_format="transcription_only")
print("\nTRANSCRIPTION ONLY:", transcription[0])
"""
RAW OUTPUT: ["[0.48][S01] Hey everyone, welcome back to the show.[2.43][2.46][S01] Today, we're talking about the best way to learn a new skill.[5.22][5.43][S01] I'm here with Jordan to dig into it.[7.14][8.40][S02] Thanks for having me.[9.42][9.63][S02] My take is that consistency beats intensity every single time.[12.87][13.14][S01] That makes sense.[13.92][13.92][S01] Even 20 minutes a day adds up over a few months.[16.17][16.32][S02] Exactly, and writing down small wins keeps you motivated along the way.[19.62]"]
PARSED (list of dicts):
{'Start': 0.48, 'End': 2.43, 'Speaker': 1, 'Content': 'Hey everyone, welcome back to the show.'}
{'Start': 2.46, 'End': 5.22, 'Speaker': 1, 'Content': "Today, we're talking about the best way to learn a new skill."}
{'Start': 5.43, 'End': 7.14, 'Speaker': 1, 'Content': "I'm here with Jordan to dig into it."}
{'Start': 8.4, 'End': 9.42, 'Speaker': 2, 'Content': 'Thanks for having me.'}
{'Start': 9.63, 'End': 12.87, 'Speaker': 2, 'Content': 'My take is that consistency beats intensity every single time.'}
{'Start': 13.14, 'End': 13.92, 'Speaker': 1, 'Content': 'That makes sense.'}
{'Start': 13.92, 'End': 16.17, 'Speaker': 1, 'Content': 'Even 20 minutes a day adds up over a few months.'}
{'Start': 16.32, 'End': 19.62, 'Speaker': 2, 'Content': 'Exactly, and writing down small wins keeps you motivated along the way.'}
TRANSCRIPTION ONLY: Hey everyone, welcome back to the show. Today, we're talking about the best way to learn a new skill. I'm here with Jordan to dig into it. Thanks for having me. My take is that consistency beats intensity every single time. That makes sense. Even 20 minutes a day adds up over a few months. Exactly, and writing down small wins keeps you motivated along the way.
"""Prompt personalizado e hotwords
apply_transcription_request aceita keywords para direcionar a transcrição para termos específicos (por exemplo, nomes próprios ou vocabulário específico de um domínio), renderizados como 热词列表： (“lista de palavras-chave”) no modelo de chat. Um prompt personalizado pode ser passado junto para fornecer contexto adicional.
Abaixo, transcrevemos um clipe de áudio que menciona “Yorùbá”, comparando com e sem a passagem dele como palavra-chave.
from transformers import AutoProcessor, AutoModelForCausalLM
model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav"
# Without keywords
inputs = processor.apply_transcription_request(audio_url)
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(f"WITHOUT keywords: {transcription[0]}")
# With keywords
inputs = processor.apply_transcription_request(audio_url, keywords=["Mandarin", "Yorùbá"])
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(f"WITH keywords : {transcription[0]}")
"""
WITHOUT keywords: Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yoruba, with over 50 million speakers.
WITH keywords : Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yorùbá, with over 50 million speakers.
"""Uso avançado com o modelo de chat
apply_transcription_request é equivalente a um chat template com uma turn de usuário que contém apenas áudio:
from transformers import AutoProcessor, AutoModelForCausalLM
model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
conversation = [
{
"role": "user",
"content": [
{"type": "audio", "url": audio_url},
],
},
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
).to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
decoded = processor.decode(
outputs[:, inputs.input_ids.shape[1] :],
skip_special_tokens=True,
)
print(decoded)Inferência em lote
Passe uma lista de áudios e, opcionalmente, uma lista correspondente de prompts e/ou palavras-chave para transcrever um lote em uma única chamada.
Defina uma entrada como None para ignorá-la para aquela amostra.
from transformers import AutoProcessor, AutoModelForCausalLM
model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
# `from_pretrained` is used here for convenience, the model can also be built from a config directly.
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
audio = [
"https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav",
"https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav",
]
keywords = [None, ["Mandarin", "Yorùbá"]]
inputs = processor.apply_transcription_request(audio, keywords=keywords)
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(transcription)Treinamento
Passe as transcrições de destino, no formato de saída do modelo com marcações de tempo e de falante, para apply_transcription_request com transcription. Os labels retornados são usados para calcular a perda.
from transformers import AutoModelForCausalLM, AutoProcessor
model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
model.train()
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
transcription = (
"[0.00][S01] Welcome to this demonstration of automatic speech recognition and speaker diarization using an "
"end-to-end transformer model.[7.47]"
)
inputs = processor.apply_transcription_request(audio_url, transcription=transcription)
inputs.to(model.device, dtype=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. device_map="auto" envolve a passagem direta com hooks do accelerate que causam recompilações repetidas, portanto, carregue o modelo diretamente em um único dispositivo.
Em uma B200, observamos uma aceleração de ~2,1x para um tamanho de lote de 4.
import time
import torch
from transformers import AutoProcessor, AutoModelForCausalLM
model_id = "itazap/MOSS-Transcribe-Diarize-HF"
num_warmup = 5
num_runs = 20
# Load processor + model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda")
# Prepare static inputs
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
inputs = processor.apply_transcription_request([audio_url] * 4).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")Para transcrição autoregressiva, torch.compile acelera as passadas de frente por token dentro de generate ao
fornecer um objeto CompileConfig em vez de compilar model.forward diretamente.
import torch
from transformers import AutoProcessor, AutoModelForCausalLM, CompileConfig
model_id = "itazap/MOSS-Transcribe-Diarize-HF"
num_warmup = 3
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda")
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
inputs = processor.apply_transcription_request([audio_url] * 4).to(model.device, torch.bfloat16)
compile_config = CompileConfig()
# Warmup
for _ in range(num_warmup):
_ = model.generate(**inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config)
# Apply model
generated_ids = model.generate(
**inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config
)
transcription = processor.decode(generated_ids[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(transcription)MossTranscribeDiarizeConfig
classe transformers.MossTranscribeDiarizeConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 151671projector_hidden_act: str = 'silu'projector_bias: bool = Trueaudio_merge_size: int = 4audio_chunk_size: int = 480000tie_word_embeddings: bool = True )
Parâmetros
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de á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ão151671) — O índice do token de áudio usado como marcador para o áudio de entrada. - projector_hidden_act (
str, opcional, padrãosilu) — A função de ativação usada pelo projetor multimodal. - projector_bias (
bool, opcional, padrãoTrue) — Se deve usar viés no projetor multimodal. - audio_merge_size (
int, opcional, padrão 4) — Número de quadros consecutivos do codificador Whisper concatenados antes do projetor multimodal. - audio_chunk_size (
int, opcional, padrão 480000) — Tamanho da janela do codificador Whisper em amostras de áudio bruto, usado compadding_maskpara recuperaraudio_chunk_mapping. - tie_word_embeddings (
bool, opcional, padrãoTrue) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo.
Esta é a classe de configuração para armazenar a configuração de um MossTranscribeDiarizeModel. Ela é usada para instanciar um modelo Moss Transcribe Diarize 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 hf-audio/MOSS-Transcribe-Diarize-HF
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> from transformers import MossTranscribeDiarizeForConditionalGeneration, MossTranscribeDiarizeConfig
>>> # Initializing a MossTranscribeDiarize configuration
>>> configuration = MossTranscribeDiarizeConfig()
>>> # Initializing a model from the configuration
>>> model = MossTranscribeDiarizeForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMossTranscribeDiarizeAudioConfig
classe transformers.MossTranscribeDiarizeAudioConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_mel_bins: int = 80num_hidden_layers: int = 24num_attention_heads: int = 16intermediate_size: int = 4096activation_function: str = 'gelu'hidden_size: int = 1024dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0initializer_range: float = 0.02max_source_positions: int = 1500 )
Parâmetros
- num_mel_bins (
int, opcional, padrão80) — Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor usado na classeAutoFeatureExtractor. - num_hidden_layers (
int, opcional, padrão24) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - intermediate_size (
int, opcional, padrão4096) — Dimensão das representações do MLP. - activation_function (
str, opcional, padrãogelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - hidden_size (
int, opcional, padrão1024) — Dimensão das representações ocultas. - dropout (
Union[float, int], opcional, padrão0.0) — A proporção para todas as camadas de dropout. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - activation_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as ativações dentro da camada totalmente conectada. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - max_source_positions (
int, opcional, padrão 1500) — O comprimento máximo da sequência de recursos de filtro-banco log-mel com o qual este modelo pode ser utilizado.
Esta é a classe de configuração para armazenar a configuração de um MossTranscribeDiarizeModel. Ela é usada para instanciar um modelo Moss Transcribe Diarize 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 hf-audio/MOSS-Transcribe-Diarize-HF
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> from transformers import MossTranscribeDiarizeAudioConfig, MossTranscribeDiarizeAudioModel
>>> # Initializing a MossTranscribeDiarizeAudioConfig
>>> configuration = MossTranscribeDiarizeAudioConfig()
>>> # Initializing a MossTranscribeDiarizeAudioModel (with random weights)
>>> model = MossTranscribeDiarizeAudioModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMossTranscribeDiarizeAudioModel
classe transformers.MossTranscribeDiarizeAudioModel
< source >( config: MossTranscribeDiarizeAudioConfig )
Parâmetros
- config (MossTranscribeDiarizeAudioConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo de áudio MOSS-Transcribe-Diarize, que é um codificador Whisper.
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_featuresattention_mask = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- input_features (
torch.Tensorde forma(batch_size, feature_size, sequence_length)) — Recursos log-mel extraídos da forma de onda bruta da fala, uma linha por janela de 30s do Whisper. Veja call(). - attention_mask (
torch.Tensor, opcional) — O MossTranscribeDiarize não suporta mascaramento deinput_features; este argumento é mantido por compatibilidade, mas não é utilizado.
Retorna
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Um BaseModelOutputWithPooling 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 (MossTranscribeDiarizeConfig) e das entradas.
O método forward do MossTranscribeDiarizeAudioModel 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
Moduleem 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
MossTranscribeDiarizeFeatureExtractor
classe transformers.MossTranscribeDiarizeFeatureExtractor
< source >( feature_size = 80sampling_rate = 16000hop_length = 160chunk_length = 30n_fft = 400padding_value = 0.0dither = 0.0return_attention_mask = False**kwargs )
Constrói um extrator de recursos MOSS-Transcribe-Diarize.
Este é um WhisperFeatureExtractor que, adicionalmente, divide áudios com duração superior a chunk_length segundos em blocos consecutivos de janela Whisper antes de extrair os recursos log-mel e relata o comprimento original do áudio bruto de cada amostra por meio de padding_mask (em oposição a input_features_mask, que marca os quadros válidos por bloco).
__call__
< source >( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = Nonedevice: str | None = 'cpu'**kwargs ) → BatchFeature
Parâmetros
- raw_speech (
np.ndarray,list[float],list[np.ndarray],list[list[float]]) — A sequência ou lote de sequências a serem processadas. Somente áudio mono-canal. - truncation (
bool, opcional, padrãoTrue) — Ativa a truncagem para cortar cada trecho den_samplesparan_samples. - pad_to_multiple_of (
int, opcional) — Se definido, aplica padding ao áudio bruto de cada bloco até um múltiplo deste valor. - device (
str, opcional, padrão"cpu") — Dispositivo usado para calcular o espectrograma log-mel.
Retorna
com input_features (recursos log-mel, uma linha por bloco), input_features_mask
(máscara de quadros válidos por bloco) e padding_mask (máscara de amostras brutas válidas, uma linha por amostra de entrada).
Divide cada amostra de áudio em blocos consecutivos de n_samples amostras, extrai os recursos log-mel por bloco e relata o comprimento original do áudio bruto de cada amostra por meio de padding_mask.
MossTranscribeDiarizeProcessor
classe transformers.MossTranscribeDiarizeProcessor
< source >( feature_extractor = Nonetokenizer = Nonechat_template: str | None = Noneaudio_token: str = '<|audio_pad|>'audio_bos_token: str = '<|audio_start|>'audio_eos_token: str = '<|audio_end|>'audio_tokens_per_second: float = 12.5audio_merge_size: int = 4time_marker_every_seconds: int = 2 )
Parâmetros
- feature_extractor (
MossTranscribeDiarizeFeatureExtractor) — O extrator de recursos é uma entrada obrigatória. - tokenizer (
Qwen2Tokenizer) — O tokenizer é uma entrada obrigatória. - chat_template (
str, opcional) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. - audio_token (
str, opcional, padrão"<|audio_pad|>") — Token especial usado para representar entradas de áudio no modelo de chat. - audio_bos_token (
str, opcional, padrão"<|audio_start|>") — Token especial que marca o início do trecho de áudio no modelo de chat. - audio_eos_token (
str, opcional, padrão"<|audio_end|>") — Token especial que marca o fim da faixa de áudio no modelo de chat. - audio_tokens_per_second (
float, opcional, padrão 12.5) — Número esperado de tokens de placeholder de áudio por segundo de áudio de entrada. - audio_merge_size (
int, opcional, padrão 4) — Fator de mesclagem de quadros do Whisper usado ao contar tokens de áudio. - time_marker_every_seconds (
int, opcional, padrão 2) — Insere tokens numéricos de marcador de tempo no intervalo de áudio a cada N segundos. Defina como0para desativar os marcadores de tempo e emitir um intervalo de placeholder de áudio simples.
Constrói um MossTranscribeDiarizeProcessor que encapsula um extrator de recursos e um tokenizer em um único processador.
MossTranscribeDiarizeProcessor oferece todas as funcionalidades de MossTranscribeDiarizeFeatureExtractor e Qwen2Tokenizer. Consulte ~MossTranscribeDiarizeFeatureExtractor e ~Qwen2Tokenizer para mais informações.
__call__
< source >( text: str | list[str]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = False**kwargs: *<class 'transformers.models.moss_transcribe_diarize.processing_moss_transcribe_diarize.MossTranscribeDiarizeProcessorKwargs'> ) → BatchFeature
Parâmetros
- text (
Union[str, list[str]]) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, definais_split_into_words=Truepara 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 (
strou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo NumPy.
- **kwargs (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
Um dicionário com texto tokenizado (input_ids, attention_mask) e
recursos de áudio (input_values, padding_mask).
apply_chat_template
< source >( conversation: list[dict[str, str]] | list[list[dict[str, str]]]chat_template: str | None = Nonetools: list[dict] | None = Nonedocuments: list[dict[str, str]] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool | str = Falsereturn_assistant_tokens_mask: bool = Falsetokenize: bool = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = 'auto'return_dict: bool = Falseload_audio_from_video: bool = Falseprocessor_kwargs: dict | None = None**kwargs )
Assim como o método apply_chat_template em tokenizadores, este método aplica um modelo Jinja às conversas de entrada para convertê-las em uma única string tokenizável.
A entrada é esperada no seguinte formato, em que o conteúdo de cada mensagem é uma lista consistindo de texto e, opcionalmente, entradas de imagem ou vídeo. Também é possível fornecer uma imagem, vídeo, URL ou caminho local, que será usado para formar pixel_values quando return_dict=True. Se não for fornecido, será obtido apenas o texto formatado, opcionalmente o texto tokenizado.
conversation = [ { “role”: “user”, “content”: [ {“type”: “image”, “url”: “https://www.ilankelman.org/stopsigns/australia.jpg”}, {“type”: “text”, “text”: “Please describe this image in detail.”}, ], }, ]
apply_transcription_request
< source >( 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 = Nonekeywords: str | list[str] | list[list[str]] | None = Nonetranscription: str | list[str] | None = Nonetokenize: bool = True**kwargs: *<class 'transformers.models.moss_transcribe_diarize.processing_moss_transcribe_diarize.MossTranscribeDiarizeProcessorKwargs'> )
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 (
stroulist[str], opcional) — Prompt(s) personalizado(s) para incluir na vez do usuário. Uma lista deve ter o mesmo comprimento que o lote. QuandoNone, o modelo de chat fornece o prompt padrão de diarização com carimbo de data e hora. - keywords (
str,list[str]oulist[list[str]], opcional) — Termos de hotwords/domínio (por exemplo, substantivos próprios) para direcionar a transcrição para a grafia correta. Uma string ou lista plana de strings é compartilhada em todo o lote; uma lista aninhada fornece palavras-chave separadas para cada amostra de áudio. - transcription (
stroulist[str], opcional) — Transcrição(ões) de referência para o treinamento, uma por áudio, no formato de saída do modelo (por exemplo,"[0.00][S01] Hello world.[1.20]"). Quando fornecida, cada transcrição é gravada como a resposta do assistente elabelssão retornadas (vejaoutput_labelsem call()). - tokenize (
bool, opcional, padrãoTrue) — Se deve tokenizar os prompts e processar o áudio. SeFalse, 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 quetokenize=True. - **kwargs —
Argumentos de palavra-chave adicionais encaminhados para apply_chat_template().
Os kwargs do processador (por exemplo,
text_kwargs,audio_kwargs, …) devem ser passados comoprocessor_kwargs={...}.
Prepare os dados de entrada para transcrição / diarização sem escrever manualmente o modelo de chat, seja para inferência ou, quando transcription for fornecido, para treinamento.
MossTranscribeDiarizeModel
classe transformers.MossTranscribeDiarizeModel
< source >( config: MossTranscribeDiarizeConfig )
Parâmetros
- config (MossTranscribeDiarizeConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo MOSS-Transcribe-Diarize: encoder Whisper, fusão temporal 4x, projetor multimodal e modelo de linguagem Qwen3.
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MossTranscribeDiarizeModelOutputWithPast or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- input_features (
torch.Tensorde forma(batch_size, sequence_length, feature_dim), opcional) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando MossTranscribeDiarizeFeatureExtractor. Consulte MossTranscribeDiarizeFeatureExtractor.call() para obter detalhes (MossTranscribeDiarizeProcessor usa MossTranscribeDiarizeFeatureExtractor para processar áudios). - input_features_mask (
torch.Tensorde forma(num_chunks, feature_sequence_length), opcional) — Máscara que marca os índices de recursos válidos (não preenchidos), com uma linha para cada linha de recursos log-mel em blocos eminput_features. Usada para calcular o comprimento válido da saída do codificador de cada bloco. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Encaminhada como está para o modelo de linguagem. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Incorporações pré-calculadas, em vez de passarinput_ids. Quandoinput_featurestambém é fornecido,input_idsainda é obrigatório para que as posições dos marcadores de áudio eminputs_embedspossam ser localizadas e preenchidas com as incorporações de áudio. - padding_mask (
torch.Tensorde forma(batch_size, max_audio_length), opcional) — Máscara que marca o comprimento de áudio bruto válido de cada amostra de áudio. Usada comconfig.audio_chunk_sizepara recuperaraudio_chunk_mapping.
Retorna
MossTranscribeDiarizeModelOutputWithPast ou tuple(torch.Tensor)
Um MossTranscribeDiarizeModelOutputWithPast 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 (MossTranscribeDiarizeConfig) e das entradas.
O método forward do MossTranscribeDiarizeModel 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
Moduleem 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.Se
past_key_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se
config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entradapast_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
audio_hidden_states (
torch.Tensor, opcional) — Estados ocultos de áudio projetados.
get_audio_features
< source >( input_features: Tensorinput_features_mask: Tensorpadding_mask: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- input_features (
torch.Tensorde forma(batch_size, sequence_length, feature_dim)) — Os tensors correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando MossTranscribeDiarizeFeatureExtractor. Consulte MossTranscribeDiarizeFeatureExtractor.call() para detalhes (MossTranscribeDiarizeProcessor usa MossTranscribeDiarizeFeatureExtractor para processar os áudios). - input_features_mask (
torch.Tensorde forma(num_chunks, feature_sequence_length)) — Máscara que marca os índices de recursos válidos (não preenchidos), com uma linha para cada linha de recursos log-mel segmentados eminput_features. Usada para calcular o comprimento válido da saída do codificador de cada segmento. - padding_mask (
torch.Tensorde forma(batch_size, max_audio_length)) — Máscara que indica o comprimento de áudio bruto válido de cada amostra de áudio, com uma linha por amostra. Usada em conjunto comconfig.audio_chunk_sizepara recuperaraudio_chunk_mapping.
Retorna
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Um BaseModelOutputWithPooling 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 (MossTranscribeDiarizeConfig) e das entradas.
Extraia os embeddings de áudio do MOSS a partir de características log-mel, reorganizando o áudio de múltiplos blocos por amostra.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
MossTranscribeDiarizeForConditionalGeneration
classe transformers.MossTranscribeDiarizeForConditionalGeneration
< source >( config: MossTranscribeDiarizeConfig )
Parâmetros
- config (MossTranscribeDiarizeConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo MOSS-Transcribe-Diarize para geração condicional com transcrição e diarização de falantes.
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0padding_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MossTranscribeDiarizeCausalLMOutputWithPast or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- input_features (
torch.Tensorde forma(batch_size, sequence_length, feature_dim), opcional) — Os tensors correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando MossTranscribeDiarizeFeatureExtractor. Consulte MossTranscribeDiarizeFeatureExtractor.call() para obter detalhes (MossTranscribeDiarizeProcessor usa MossTranscribeDiarizeFeatureExtractor para processar os áudios). - input_features_mask (
torch.Tensorde forma(num_chunks, feature_sequence_length), opcional) — Máscara que marca os índices de recursos válidos (não preenchidos), com uma linha para cada linha de recursos log-mel em blocos eminput_features. Usada para calcular o comprimento válido da saída do codificador de cada bloco. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Encaminhada como está para o modelo de linguagem. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos 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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Incorporações pré-calculadas, em vez de passarinput_ids. Quandoinput_featurestambém é fornecido,input_idsainda é obrigatório para que as posições dos marcadores de áudio eminputs_embedspossam ser localizadas e preenchidas com as incorporações de áudio. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_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 umtorch.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). - padding_mask (
torch.Tensorde forma(batch_size, max_audio_length), opcional) — Máscara que marca o comprimento de áudio bruto válido de cada amostra de áudio. Usada comconfig.audio_chunk_sizepara recuperaraudio_chunk_mapping.
Retorna
MossTranscribeDiarizeCausalLMOutputWithPast ou tuple(torch.Tensor)
Um MossTranscribeDiarizeCausalLMOutputWithPast 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 (MossTranscribeDiarizeConfig) e das entradas.
O método forward de MossTranscribeDiarizeForConditionalGeneration sobrescreve 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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem.past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache.hidden_states (
tuple[torch.Tensor], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
audio_hidden_states (
torch.Tensor, opcional) — Estados ocultos do codificador de áudio após a projeção.
Exemplo:
>>> from transformers import MossTranscribeDiarizeForConditionalGeneration, AutoProcessor
>>> model_id = "hf-audio/MOSS-Transcribe-Diarize-HF"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = MossTranscribeDiarizeForConditionalGeneration.from_pretrained(model_id, device_map="auto")
>>> inputs = processor.apply_transcription_request("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
>>> inputs = inputs.to(model.device, dtype=model.dtype)
>>> outputs = model.generate(**inputs, do_sample=False, max_new_tokens=500)
>>> processor.batch_decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True)