Transformers documentation
Qwen2.5-Omni
Este modelo foi publicado no HF papers em 26/03/2025 e contribuído para o Hugging Face Transformers em 14/04/2025.
Qwen2.5-Omni
Visão geral
O modelo Qwen2.5-Omni é um modelo unificado de múltiplas modalidades proposto no Qwen2.5-Omni Technical Report da equipe Qwen, do Alibaba Group.
O resumo do relatório técnico é o seguinte:
Apresentamos o Qwen2.5-Omni, um modelo multimodal de ponta a ponta projetado para perceber diversas modalidades, incluindo texto, imagens, áudio e vídeo, enquanto gera simultaneamente respostas em texto e fala natural de forma em streaming. Para permitir o streaming de entradas de informações multimodais, tanto os codificadores de áudio quanto os visuais utilizam uma abordagem de processamento por blocos. Essa estratégia desacopla eficazmente o tratamento de longas sequências de dados multimodais, atribuindo as responsabilidades perceptivas ao codificador multimodal e delegando a modelagem de sequências estendidas a um grande modelo de linguagem. Essa divisão de trabalho aprimora a fusão de diferentes modalidades por meio do mecanismo de atenção compartilhado. Para sincronizar os timestamps das entradas de vídeo com o áudio, organizamos o áudio e o vídeo sequencialmente de forma intercalada e propomos uma nova abordagem de incorporação de posição, denominada TMRoPE (Time-aligned Multimodal RoPE). Para gerar texto e fala simultaneamente, evitando interferência entre as duas modalidades, propomos a arquitetura Thinker-Talker. Nesse framework, o Thinker funciona como um grande modelo de linguagem encarregado da geração de texto, enquanto o Talker é um modelo autoregressivo de trilho duplo que utiliza diretamente as representações ocultas do Thinker para produzir tokens de áudio como saída. Tanto o modelo Thinker quanto o Talker são projetados para serem treinados e inferidos de forma de ponta a ponta. Para decodificar tokens de áudio de forma em streaming, introduzimos um DiT de janela deslizante que restringe o campo receptivo, visando reduzir o atraso do pacote inicial. O Qwen2.5-Omni supera o Qwen2-VL e o Qwen2-Audio de tamanho semelhante em capacidades de imagem e áudio. Além disso, o Qwen2.5-Omni alcança desempenho de estado da arte em benchmarks multimodais como o Omni-Bench. Notavelmente, o Qwen2.5-Omni é o primeiro modelo de código aberto a alcançar um nível de desempenho no seguimento de instruções de fala de ponta a ponta comparável às suas capacidades com entradas de texto, conforme evidenciado por benchmarks como MMLU e GSM8K. No que diz respeito à geração de fala, o Talker em streaming do Qwen2.5-Omni supera a maioria das alternativas existentes em streaming e não em streaming em termos de robustez e naturalidade.
Defina
use_kernels=Trueem from_pretrained() para substituir camadas compatíveis por kernels otimizados do Hub. Consulte Carregando kernels para saber mais.
Observações
- Use Qwen2_5OmniForConditionalGeneration para gerar saída de áudio e texto. Para gerar apenas um tipo de saída, use Qwen2_5OmniThinkerForConditionalGeneration para apenas texto e
Qwen2_5OmniTalkersForConditionalGenerationpara apenas áudio. - Em caso de erros de memória insuficiente ao trabalhar com entrada de vídeo, diminua
processor.max_pixels. Por padrão, o máximo é definido para um valor muito grande e visuais de alta resolução não serão redimensionados, a menos que a resolução excedaprocessor.max_pixels. - O processador possui seu próprio método apply_chat_template() para converter mensagens de chat em entradas do modelo.
Exemplo de uso
Qwen2.5-Omni pode ser encontrado no Huggingface Hub.
Inferência de mídia única
O modelo pode aceitar texto, imagens, áudio e vídeos como entrada. Aqui está um exemplo de código para inferência.
import soundfile as sf
from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcessor
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
conversations = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "video", "video": "/path/to/video.mp4"},
{"type": "text", "text": "What can't you hear and see in this video?"},
],
},
]
inputs = processor.apply_chat_template(
conversations,
load_audio_from_video=True,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
fps=1,
# kwargs to be passed to `Qwen2-5-OmniProcessor`
padding=True,
use_audio_in_video=True,
).to(model.device)
# Generation params for audio or text can be different and have to be prefixed with `thinker_` or `talker_`
text_ids, audio = model.generate(**inputs, use_audio_in_video=True, thinker_do_sample=False, talker_do_sample=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
sf.write(
"output.wav",
audio.reshape(-1).detach().cpu().numpy(),
samplerate=24000,
)
print(text)Geração apenas de texto
Para gerar apenas saída de texto e economizar recursos computacionais ao não carregar o modelo de geração de áudio, podemos usar o modelo Qwen2_5OmniThinkerForConditionalGeneration.
from transformers import Qwen2_5OmniProcessor, Qwen2_5OmniThinkerForConditionalGeneration
model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
conversations = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "video", "video": "/path/to/video.mp4"},
{"type": "text", "text": "What can't you hear and see in this video?"},
],
},
]
inputs = processor.apply_chat_template(
conversations,
load_audio_from_video=True,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
fps=1,
# kwargs to be passed to `Qwen2-5-OmniProcessor`
padding=True,
use_audio_in_video=True,
).to(model.device)
text_ids = model.generate(**inputs, use_audio_in_video=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
print(text)Inferência em Lote de Mídia Mista
O modelo pode processar em lote entradas compostas por amostras mistas de vários tipos, como texto, imagens, áudio e vídeos, ao usar o modelo Qwen2_5OmniThinkerForConditionalGeneration. Veja um exemplo.
from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcessor
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto"
)
processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
# Conversation with video only
conversation1 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "video", "path": "/path/to/video.mp4"},
]
}
]
# Conversation with audio only
conversation2 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "audio", "path": "/path/to/audio.wav"},
]
}
]
# Conversation with pure text
conversation3 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [{"type": "text", "text": "who are you?"}],
}
]
# Conversation with mixed media
conversation4 = [
{
"role": "system",
"content": [
{"type": "text", "text": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech."}
],
},
{
"role": "user",
"content": [
{"type": "image", "path": "/path/to/image.jpg"},
{"type": "video", "path": "/path/to/video.mp4"},
{"type": "audio", "path": "/path/to/audio.wav"},
{"type": "text", "text": "What are the elements can you see and hear in these media?"},
],
}
]
conversations = [conversation1, conversation2, conversation3, conversation4]
inputs = processor.apply_chat_template(
conversations,
load_audio_from_video=True,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
fps=1,
# kwargs to be passed to `Qwen2-5-OmniProcessor`
padding=True,
use_audio_in_video=True,
).to(model.thinker.device)
text_ids = model.generate(**inputs, use_audio_in_video=True)
text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
print(text)Geração de áudio em lote
Qwen2_5OmniForConditionalGeneration suporta a geração de saída de áudio em lote. Por exemplo, a geração em lote de texto para fala abaixo. Com um lote contendo mais de uma amostra, o áudio gerado é retornado como uma lista com uma forma de onda por amostra, cada uma já recortada para o seu próprio comprimento, de modo que amostras mais curtas não são preenchidas com áudio spúrio. Uma chamada com uma única amostra ainda retorna um único tensor.
import soundfile as sf
from transformers import AutoModelForTextToWaveform, AutoProcessor
import torch
model_id = "Qwen/Qwen2.5-Omni-7B"
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)
sampling_rate = 24000 # output sampling rate
max_new_tokens = 200 # maximum number of tokens to generate
system_text = (
"You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of "
"perceiving auditory and visual inputs, as well as generating text and speech."
)
texts = [
"Hello, I'm Qwen. How can I help you today?",
"The weather is nice today. Let's go for a walk.",
]
inputs = processor.apply_chat_template(
[
[
{"role": "system", "content": [{"type": "text", "text": system_text}]},
{
"role": "user",
"content": [
{
"type": "text",
"text": (
"Please read the following text aloud exactly as written, with no "
f"additional commentary:\n\n{text}"
),
}
],
},
]
for text in texts
],
tokenize=True,
add_generation_prompt=True,
return_dict=True,
return_tensors="pt",
processor_kwargs={"padding": True},
).to(model.device, dtype=model.dtype)
gen_kwargs = {
"talker_do_sample": True,
"speaker": "Ethan", # Ethan, Chelsie
"talker_max_new_tokens": max_new_tokens,
}
_, pred_waveform = model.generate(**inputs, **gen_kwargs)
for sample_id, audio in enumerate(pred_waveform):
sf.write(
f"qwen2_5_omni_output_{sample_id}.wav",
audio.detach().to(torch.float32).cpu().numpy(),
sampling_rate,
)
print(f"Saved audio to qwen2_5_omni_output_{sample_id}.wav")Dicas de uso
Compromisso entre resolução de imagem
O modelo suporta uma ampla variedade de entradas de resolução. Por padrão, ele utiliza a resolução nativa para a entrada, mas resoluções mais altas podem aprimorar o desempenho, ao custo de mais computação. Os usuários podem definir o número mínimo e máximo de pixels para alcançar uma configuração ideal para suas necessidades.
min_pixels = 128*28*28
max_pixels = 768*28*28
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B", min_pixels=min_pixels, max_pixels=max_pixels)Prompt para saída de áudio
Se os usuários precisarem de saída de áudio, o prompt do sistema deve ser definido como “You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech.”, caso contrário, a saída de áudio pode não funcionar como esperado.
{
"role": "system",
"content": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech.",
}Usar ou não usar saída de áudio
O modelo suporta saídas de texto e de áudio. Se os usuários não precisarem de saídas de áudio, podem definir enable_audio_output na função from_pretrained. Essa opção economiza cerca de ~2GB de memória de GPU, mas a opção return_audio da função generate só poderá ser definida como False.
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
enable_audio_output=False,
)Para obter uma experiência flexível, recomendamos que os usuários definam enable_audio_output como True ao inicializar o modelo por meio da função from_pretrained e, em seguida, decidam se devem retornar áudio quando a função generate for chamada. Quando return_audio é definido como False, o modelo retornará apenas saídas de texto para obter respostas de texto mais rapidamente.
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
enable_audio_output=True,
)
...
text_ids = model.generate(**inputs, return_audio=False)Alterar o tipo de voz do áudio de saída
O Qwen2.5-Omni suporta a capacidade de alterar a voz do áudio de saída. Os usuários podem usar o parâmetro speaker da função generate para especificar o tipo de voz. O checkpoint "Qwen/Qwen2.5-Omni-7B" suporta dois tipos de voz: Chelsie e Ethan, sendo Chelsie uma voz feminina e Ethan uma voz masculina. Por padrão, se speaker não for especificado, o tipo de voz padrão é Chelsie.
text_ids, audio = model.generate(**inputs, speaker="Chelsie")text_ids, audio = model.generate(**inputs, speaker="Ethan")Flash-Attention 2 para acelerar a geração
Primeiro, certifique-se de instalar a versão mais recente do Flash Attention 2:
pip install -U flash-attn --no-build-isolation
Além disso, você deve ter hardware compatível com FlashAttention 2. Leia mais sobre isso na documentação oficial do repositório flash attention. O FlashAttention-2 só pode ser usado quando um modelo é carregado em torch.float16 ou torch.bfloat16.
Para carregar e executar um modelo usando FlashAttention-2, adicione attn_implementation="flash_attention_2" ao carregar o modelo:
from transformers import Qwen2_5OmniForConditionalGeneration
model = Qwen2_5OmniForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-Omni-7B",
device_map="auto",
attn_implementation="flash_attention_2",
)Qwen2_5OmniConfig
classe transformers.Qwen2_5OmniConfig
< 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 = Nonethinker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetalker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetoken2wav_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneenable_audio_output: bool = True )
Parâmetros
- thinker_config (
dict, opcional) — Configuração do submodelo thinker subjacente. - talker_config (
dict, opcional) — Configuração do submodelo talker subjacente. - token2wav_config (
dict, opcional) — Configuração do submodelo de codec subjacente. - enable_audio_output (
bool, opcional, padrãoTrue) — Se habilita a saída de áudio e carrega os módulos talker e token2wav.
Esta é a classe de configuração para armazenar a configuração de um Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 (
... Qwen2_5OmniThinkerConfig,
... Qwen2_5OmniTalkerConfig,
... Qwen2_5OmniToken2WavConfig,
... Qwen2_5OmniForConditionalGeneration,
... Qwen2_5OmniConfig,
... )
>>> # Initializing sub-modules configurations.
>>> thinker_config = Qwen2_5OmniThinkerConfig()
>>> talker_config = Qwen2_5OmniTalkerConfig()
>>> token2wav_config = Qwen2_5OmniToken2WavConfig()
>>> # Initializing a module style configuration
>>> configuration = Qwen2_5OmniConfig(
... thinker_config, talker_config, token2wav_config
... )
>>> # Initializing a model (with random weights)
>>> model = Qwen2_5OmniForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configget_text_config
< source >( *args**kwargs )
Retorna a configuração que deve ser usada com a entrada e saída de texto. Na maioria dos modelos, trata-se da própria instância de configuração original. Em modelos compostos específicos, ela está localizada sob um conjunto de nomes válidos.
Qwen2_5OmniVisionEncoderConfig
classe transformers.Qwen2_5OmniVisionEncoderConfig
< 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 = Nonedepth: int = 32hidden_size: int = 3584hidden_act: str = 'silu'intermediate_size: int = 3420num_heads: int = 16in_channels: int = 3patch_size: int | list[int] | tuple[int, int] = 14spatial_merge_size: int = 2temporal_patch_size: int | list[int] | tuple[int, int] = 2window_size: int = 112out_hidden_size: int = 3584fullatt_block_indexes: list[int] | tuple[int, ...] = (7, 15, 23, 31)initializer_range: float = 0.02rope_parameters: dict | None = None )
Parâmetros
- depth (
int, opcional, padrão32) — Número de camadas do Transformer no codificador de visão. - hidden_size (
int, opcional, padrão3584) — Dimensão das representações ocultas. - hidden_act (
str, opcional, padrãosilu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - intermediate_size (
int, opcional, padrão3420) — Dimensão das representações do MLP. - num_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - in_channels (
int, opcional, padrão3) — O número de canais de entrada. - patch_size (
Union[int, list[int], tuple[int, int]], opcional, padrão14) — O tamanho (resolução) de cada patch. - spatial_merge_size (
int, opcional, padrão2) — O tamanho da janela de mesclagem espacial usada para reduzir o número de tokens visuais ao mesclar patches vizinhos. - temporal_patch_size (
Union[int, list[int], tuple[int, int]], opcional, padrão2) — Tamanho do patch temporal usado no embedding de patch 3D para entradas de vídeo. - window_size (
int, opcional, padrão 11) — Tamanho das janelas. - out_hidden_size (
int, opcional, padrão 3584) — O tamanho oculto de saída do modelo de visão. - fullatt_block_indexes (
int, opcional, padrão[7, 15, 23, 31]) — Índices das camadas com atenção completa - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - rope_parameters (
dict, opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores.
Esta é a classe de configuração para armazenar a configuração de um Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniVisionEncoderConfig, Qwen2_5OmniVisionEncoder
>>> # Initializing a Qwen2_5OmniVisionEncoderConfig
>>> configuration = Qwen2_5OmniVisionEncoderConfig()
>>> # Initializing a Qwen2_5OmniVisionEncoder (with random weights)
>>> model = Qwen2_5OmniVisionEncoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniTextConfig
classe transformers.Qwen2_5OmniTextConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 152064hidden_size: int = 3584intermediate_size: int = 18944num_hidden_layers: int = 28num_attention_heads: int = 28num_key_value_heads: int | None = 4hidden_act: str = 'silu'max_position_embeddings: int = 32768initializer_range: float = 0.02rms_norm_eps: float = 1e-06use_cache: bool = Truerope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneuse_sliding_window: bool = Falsesliding_window: int | None = 32768max_window_layers: int = 28layer_types: list[str] | None = Noneattention_dropout: float | int = 0.0pad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonetie_word_embeddings: bool = True )
Parâmetros
- vocab_size (
int, opcional, padrão152064) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão3584) — Dimensão das representações ocultas. - intermediate_size (
int, opcional, padrão18944) — Dimensão das representações do MLP. - num_hidden_layers (
int, opcional, padrão28) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão28) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - num_key_value_heads (
int, opcional, padrão4) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Senum_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); senum_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão seránum_attention_heads. - hidden_act (
str, opcional, padrãosilu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - max_position_embeddings (
int, opcional, padrão32768) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - rms_norm_eps (
float, opcional, padrão1e-06) — O epsilon usado pelas camadas de normalização rms. - use_cache (
bool, opcional, padrãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou quando o modelo for um modelo generativo somente decodificador. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores. - use_sliding_window (
bool, opcional, padrãoFalse) — Se deve usar atenção com janela deslizante. - sliding_window (
int, opcional, padrão32768) — Tamanho da janela de atenção deslizante. Se forNone, nenhuma janela deslizante é aplicada. - max_window_layers (
int, opcional, padrão28) — O número de camadas que usam atenção completa. As primeirasmax_window_layerscamadas usarão atenção completa, enquanto qualquer camada adicional subsequente usará SWA (Sliding Window Attention). - layer_types (
list[str], opcional) — Uma lista que mapeia explicitamente cada índice de camada com seu tipo de camada. Se não for fornecida, será gerada automaticamente com base nos valores de configuração. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - pad_token_id (
int, opcional) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário. - 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 Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniThinkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig
>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2_5OmniVisionEncoder config
>>> vision_config = Qwen2_5OmniVisionEncoderConfig()
>>> # Initializing a Qwen2.5OmniThinker configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, vision_config)
>>> # Initializing a model from the Qwen-Omni style configuration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniDiTConfig
classe transformers.Qwen2_5OmniDiTConfig
< 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 = Nonehidden_size: int = 1024num_hidden_layers: int = 22num_attention_heads: int = 16ff_mult: int = 2emb_dim: int = 512head_dim: int = 64rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonemax_position_embeddings: int = 32768block_size: int = 24look_ahead_layers: list[int] | tuple[int, ...] = (10,)look_backward_layers: list[int] | tuple[int, ...] = (0, 20)repeats: int = 2num_embeds: int = 8193mel_dim: int = 80dropout: float | int = 0.1enc_emb_dim: int = 192enc_dim: int = 128enc_channels: list[int] | tuple[int, ...] = (256, 256, 256, 256, 768)enc_kernel_sizes: list[int] | tuple[int, ...] = (5, 3, 3, 3, 1)enc_dilations: list[int] | tuple[int, ...] = (1, 2, 3, 4, 1)enc_attention_channels: int = 64enc_res2net_scale: int = 2enc_se_channels: int = 64 )
Parâmetros
- hidden_size (
int, opcional, padrão1024) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão22) — 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. - ff_mult (
int, opcional, padrão 2) — O multiplicador da camada feedforward em cada bloco do transformer. - emb_dim (
int, opcional, padrão 512) — A dimensão da camada de incorporação. - head_dim (
int, opcional, padrão64) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores. - max_position_embeddings (
int, opcional, padrão32768) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - block_size (
int, opcional, padrão 64) — Número de tokens (frames) em cada bloco de processamento. - look_ahead_layers (
list[int], opcional, padrão[10]) — Número de camadas de transformer que podem prestar atenção a blocos futuros - look_backward_layers (
list[int], opcional, padrão[0, 20]) — Número de camadas de transformer que prestam atenção a blocos anteriores além do limite do bloco atual - repeats (
int, opcional, padrão 2) — O número de vezes que os embeddings do codec são repetidos. - num_embeds (
int, opcional, padrão 8193) — O número de embeddings únicos no codec. - mel_dim (
int, opcional, padrão 80) — A dimensão do mel-espectrograma. - dropout (
Union[float, int], opcional, padrão0.1) — A proporção para todas as camadas de dropout. - enc_emb_dim (
int, opcional, padrão 192) — A dimensão do embedding de falante pré-treinado. - enc_dim (
int, opcional, padrão 128) — A dimensão da saída do codificador. - enc_channels (
list[int], opcional, padrão[256, 256, 256, 256, 768]) — Uma lista de canais de saída para cada camada TDNN/SERes2Net no codificador. - enc_kernel_sizes (
list[int], opcional, padrão[5, 3, 3, 3, 1]) — Uma lista de tamanhos de kernel para cada camada no codificador. - enc_dilations (
list[int], opcional, padrão[1, 2, 3, 4, 1]) — Uma lista de dilatações para cada camada no codificador. - enc_attention_channels (
int, opcional, padrão 64) — O número de canais de atenção no SqueezeExcitationBlock. - enc_res2net_scale (
int, opcional, padrão 2) — A escala do bloco Res2Net no codificador. - enc_se_channels (
int, opcional, padrão 64) — O número de canais de saída após o squeeze no SqueezeExcitationBlock.
Esta é a classe de configuração para armazenar a configuração de um Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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.
Qwen2_5OmniBigVGANConfig
classe transformers.Qwen2_5OmniBigVGANConfig
< 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 = Nonemel_dim: int = 80upsample_initial_channel: int = 1536resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11)resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5))upsample_rates: list[int] | tuple[int, ...] = (5, 3, 2, 2, 2, 2)upsample_kernel_sizes: list[int] | tuple[int, ...] = (11, 7, 4, 4, 4, 4) )
Parâmetros
- mel_dim (
int, opcional, padrão 80) — A dimensão do mel-espectrograma. - upsample_initial_channel (
int, opcional, padrão 1536) — O número de canais na camada inicial de upsampling. - resblock_kernel_sizes (
list[int], opcional, padrão[3, 7, 11]) — Uma lista de tamanhos de kernel para cada bloco residual. - resblock_dilation_sizes (
list[list[int]], opcional, padrão[[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — Uma lista de tamanhos de dilatação para cada bloco residual. - upsample_rates (
list[int], opcional, padrão[5, 3, 2, 2, 2, 2]) — Uma lista de taxas de aumento de amostragem para cada camada de aumento de amostragem. - upsample_kernel_sizes (
list[int], opcional, padrão[11, 7, 4, 4, 4, 4]) — Uma lista de tamanhos de kernel para cada camada de upsampling.
Esta é a classe de configuração para armazenar a configuração de um Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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.
Qwen2_5OmniAudioEncoderConfig
classe transformers.Qwen2_5OmniAudioEncoderConfig
< 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 = 128encoder_layers: int = 32encoder_attention_heads: int = 20encoder_ffn_dim: int = 5120d_model: int = 1280dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_function: str = 'gelu'activation_dropout: float | int = 0.0scale_embedding: bool = Falseinitializer_range: float = 0.02max_source_positions: int = 1500n_window: int = 100output_dim: int = 3584 )
Parâmetros
- num_mel_bins (
int, opcional, padrão128) — Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor utilizado na classeAutoFeatureExtractor. - encoder_layers (
int, opcional, padrão32) — Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor denum_layersse não for definido. - encoder_attention_heads (
int, opcional, padrão20) — Número de cabeças de atenção para cada camada de atenção no codificador do Transformer. - encoder_ffn_dim (
int, opcional, padrão5120) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no encoder. - d_model (
int, opcional, padrão1280) — Tamanho das camadas do codificador e da camada pooler. - 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_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. - activation_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as ativações dentro da camada totalmente conectada. - scale_embedding (
bool, opcional, padrãoFalse) — Se as embeddings devem ser escalonadas dividindo por sqrt(d_model). - 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. - n_window (
int, opcional, padrão 100) — O bloco para conv e flash attn no AudioEncoder. - output_dim (
int, opcional, padrão 3584) — A dimensão de saída do AudioEncoder.
Esta é a classe de configuração para armazenar a configuração de um Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniAudioEncoder
>>> # Initializing a Qwen2_5OmniAudioEncoderConfig
>>> configuration = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2_5OmniAudioEncoder (with random weights)
>>> model = Qwen2_5OmniAudioEncoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniProcessor
classe transformers.Qwen2_5OmniProcessor
< source >( image_processor = Nonevideo_processor = Nonefeature_extractor = Nonetokenizer = Nonechat_template = None )
Parâmetros
- image_processor (
Qwen2VLImageProcessor) — O processador de imagem é uma entrada obrigatória. - video_processor (
Qwen2VLVideoProcessor) — O processador de vídeo é uma entrada obrigatória. - feature_extractor (
WhisperFeatureExtractor) — O extrator de recursos é uma entrada obrigatória. - tokenizer (
Qwen2Tokenizer) — O tokenizer é uma entrada obrigatória. - chat_template (
str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.
Constrói um Qwen2_5OmniProcessor que encapsula um processador de imagem, um processador de vídeo, um extrator de recursos e um tokenizer em um único processador.
Qwen2_5OmniProcessor oferece todas as funcionalidades de Qwen2VLImageProcessor, Qwen2VLVideoProcessor, WhisperFeatureExtractor e Qwen2Tokenizer. Consulte ~Qwen2VLImageProcessor, ~Qwen2VLVideoProcessor, ~WhisperFeatureExtractor e ~Qwen2Tokenizer para mais informações.
__call__
< source >( text: str | list[str] | list[list[str]] = Noneimages: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.models.qwen2_5_omni.processing_qwen2_5_omni.Qwen2_5OmniProcessorKwargs'> ) → ~feature_extraction_utils.BatchFeature
Parâmetros
- text (
Union[str, list[str], list[list[str]]], opcional) — 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. - images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, definado_rescale=False. - videos (
Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], opcional) — Vídeo a ser pré-processado. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se passar vídeos com valores de pixel entre 0 e 1, definado_rescale=False. - audio (
Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[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. - min_pixels (
int, kwargs, opcional) — Número mínimo de pixels (altura × largura) para os quadros do vídeo após o redimensionamento. Quadros menores que esse limite serão ampliados para atender ao requisito mínimo. - max_pixels (
int, kwargs, opcional) — Número máximo de pixels (altura × largura) para os quadros do vídeo após o redimensionamento. Quadros maiores que esse limite serão reduzidos para caber dentro do limite. - patch_size (
int, kwargs, opcional) — O tamanho do patch espacial usado pelo codificador de visão. Os quadros do vídeo são divididos em patches desse tamanho nas dimensões de altura e largura. - temporal_patch_size (
int, kwargs, opcional) — O tamanho do patch temporal usado pelo codificador de visão. Isso determina quantos frames consecutivos são agrupados juntos como um único patch temporal. - merge_size (
int, kwargs, opcional) — O tamanho de mesclagem usado para combinar patches espaciais. Vários patches são mesclados para reduzir o comprimento da sequência, mantendo as informações espaciais. - min_frames (
int, kwargs, opcional) — Número mínimo de quadros a serem extraídos do vídeo. Vídeos com menos quadros serão preenchidos ou repetidos para atender a esse requisito. - max_frames (
int, kwargs, opcional) — Número máximo de quadros a serem extraídos do vídeo. Vídeos mais longos serão truncados ou amostrados para se encaixar dentro desse limite. - use_audio_in_video (
bool, kwargs, opcional, padrãoFalse) — Argumento obsoleto - useload_audio_from_videoem vez disso. - load_audio_from_video (
bool, kwargs, opcional, padrãoFalse) — Indica se a informação de áudio deve ser incorporada ao processar vídeos. Quando habilitado, os tokens de áudio são intercalados com os tokens de vídeo com base no alinhamento temporal, criando uma representação multimodal unificada. - seconds_per_chunk (
float, kwargs, opcional, padrão2.0) — A duração (em segundos) de cada trecho de vídeo ao dividir vídeos longos. Este parâmetro controla como os vídeos são divididos em segmentos temporais para processamento. - position_id_per_seconds (
int, kwargs orfloat, optional, defaults to25) — The number of position IDs allocated per second of video. This parameter controls the temporal resolution of position embeddings and is used to align video tokens with audio tokens whenuse_audio_in_video=True. - 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
~feature_extraction_utils.BatchFeature
- data (
dict, opcional) — Dicionário de listas/arrays/tensors retornados pelos métodos call/pad (‘input_values’, ‘attention_mask’, etc.). - tensor_type (
Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. - skip_tensor_conversion (
list[str]ouset[str], opcional) — Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quandotensor_typefor especificado.
Qwen2_5OmniForConditionalGeneration
classe transformers.Qwen2_5OmniForConditionalGeneration
< source >( config: Qwen2_5OmniConfig )
Parâmetros
- config (Qwen2_5OmniConfig) — 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 completo Qwen2.5Omni, um modelo multimodal composto por 3 submodelos:
- Qwen2_5OmniThinkerForConditionalGeneration: um transformer autoregressivo causal que recebe texto, áudio, imagem e vídeo como entrada e prevê tokens de texto.
- Qwen2_5OmniTalkerForConditionalGeneration: um transformer autoregressivo causal recebe os estados ocultos do thinker e a resposta como entrada e prevê tokens de fala.
- Qwen2_5OmniToken2WavModel: um modelo DiT que recebe tokens de fala como entrada e prevê o espectrograma mel, e um vocoder BigVGAN que recebe o espectrograma mel como entrada e prevê a forma de onda.
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.
Um valor simulado para um caminho pontilhado (por exemplo, torch.float32): cadeias de acesso a atributos, chamadas se comportam como decoradores de passagem, repr é o caminho pontilhado, e usá-lo como classe base substitui uma base de type simples (PEP 560 __mro_entries__), de modo que subclasses reais mantêm uma metaclass normal e inspect.signature lê o __init__ real delas, em vez do de um mock.
Qwen2_5OmniPreTrainedModelForConditionalGeneration
classe transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration
< source >( config: PreTrainedConfig*inputs**kwargs )
get_chunked_index
< source >( token_indices: Tensortokens_per_chunk: intremove_index: int ) → list[tuple[int, int]]
Parâmetros
- token_indices (
torch.Tensorde forma(seq_len, )) — Uma lista de valores de índice de token em ordem monotonicamente crescente. - t_ntoken_per_chunk (
int) — Número de tokens por chunk (usado como o limite de tamanho do chunk). - remove_index (
int) Um identificador de índice a ser subtraído detoken_indicesantes da divisão em blocos —
Retorna
list[tuple[int, int]]
Uma lista de tuplas, cada uma representando os índices de início (inclusivo) e fim (exclusivo) de um bloco em token_indices.
Divide a lista de índices de tokens em blocos com base nos intervalos de valores dos tokens.
Dada uma lista de índices de tokens, retorna uma lista de tuplas de índices (início, fim) representando fatias da lista em que os valores dos tokens estão dentro de faixas sucessivas de t_ntoken_per_chunk.
Por exemplo, se t_ntoken_per_chunk for 1000, a função criará blocos de modo que:
- o primeiro bloco contém valores de tokens < 1000,
- o segundo bloco contém valores >= 1000 e < 2000, e assim por diante.
get_rope_index
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneuse_audio_in_video: bool = Falseaudio_seqlens: typing.Optional[torch.LongTensor] = Nonesecond_per_grids: typing.Optional[torch.Tensor] = None )
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão, caso você o forneça. - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada imagem no LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. - 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. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- use_audio_in_video (
bool, opcional) — Se definido comoTrue, usa o áudio no vídeo. - audio_seqlens (
torch.LongTensorde forma(num_audios), opcional) — O comprimento da forma de recurso de cada áudio no LLM. - second_per_grids (
torch.LongTensorde forma(num_videos), opcional) — O intervalo de tempo (em segundos) para cada grade ao longo da dimensão temporal nos IDs de posição 3D.
Calcule o índice 3D rope com base no tempo, na altura e na largura da imagem e do vídeo no LLM.
Explicação: Cada sequência de incorporação contém incorporação de visão e incorporação de texto, ou apenas contém incorporação de texto.
Para uma sequência de incorporação de texto puro, a incorporação de posição rotativa não apresenta diferença em relação aos LLMs modernos. Exemplos: input_ids: [T T T T T], aqui T representa texto. position_ids temporais: [0, 1, 2, 3, 4] position_ids de altura: [0, 1, 2, 3, 4] position_ids de largura: [0, 1, 2, 3, 4]
Para a sequência de incorporação de visão e texto, calculamos a incorporação de posição rotacional 3D para a parte de visão e a incorporação de posição rotacional 1D para a parte de texto. Exemplos: Temporal (Tempo): 3 patches, representando diferentes segmentos do vídeo no tempo. Altura: 2 patches, dividindo cada quadro verticalmente. Largura: 2 patches, dividindo cada quadro horizontalmente. Também temos alguns parâmetros importantes: fps (Frames Per Second): A taxa de quadros do vídeo, definida como 1. Isso significa que um quadro é processado a cada segundo. tokens_per_second: Este é um parâmetro crucial. Ele determina quantos "passos de tempo" ou "tokens temporais" são conceitualmente empacotados em um intervalo de um segundo do vídeo. Neste caso, temos 25 tokens por segundo. Portanto, cada segundo do vídeo será representado com 25 pontos de tempo separados. Essencialmente, define a granularidade temporal. temporal_patch_size: O número de quadros que compõem um patch temporal. Aqui, são 2 quadros. interval: O tamanho do passo para os IDs de posição temporal, calculado como tokens_per_second temporal_patch_size / fps. Neste caso, 25 2 / 1 = 50. Isso significa que cada patch temporal terá uma diferença de 50 nos IDs de posição temporal. input_ids: [V V V V V V V V V V V V T T T T T], aqui V é para visão. vision temporal position_ids: [0, 0, 0, 0, 50, 50, 50, 50, 100, 100, 100, 100] vision height position_ids: [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1] vision width position_ids: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] text temporal position_ids: [101, 102, 103, 104, 105] text height position_ids: [101, 102, 103, 104, 105] text width position_ids: [101, 102, 103, 104, 105] Aqui, calculamos os position_ids de início do texto como o máximo dos position_ids de visão mais 1.
Qwen2_5OmniThinkerConfig
classe transformers.Qwen2_5OmniThinkerConfig
< 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 = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_index: int = 151646image_token_index: int = 151655video_token_index: int = 151656position_id_per_seconds: int = 25seconds_per_chunk: int = 2audio_start_token_id: int = 151647audio_end_token_id: int = 151648user_token_id: int = 872initializer_range: float = 0.02tie_word_embeddings: bool = False )
Parâmetros
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de áudio. - vision_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de visão. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto. - audio_token_index (
int, opcional, padrão151646) — O índice do token de áudio usado como marcador de posição para o áudio de entrada. - image_token_index (
int, opcional, padrão151655) — O índice do token de imagem usado como marcador para as imagens de entrada. - video_token_index (
int, opcional, padrão151656) — O índice do token de vídeo usado como marcador de posição para os vídeos de entrada. - position_id_per_seconds (
int, optional, defaults to 25) — The increment of position id per second. - seconds_per_chunk (
int, opcional, padrão 2) — A duração, em segundos, do trecho de dados de áudio e vídeo. - audio_start_token_id (
int, opcional, padrão 151647) — O índice do token de início de áudio para codificar o prompt de áudio. - audio_end_token_id (
int, opcional, padrão 151648) — O índice do token de fim de áudio para codificar o prompt de áudio. - user_token_id (`int, opcional, padrão 872) — O índice do token de usuário para codificar o token do usuário.
- initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - tie_word_embeddings (
bool, opcional, padrãoFalse) — 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 Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniThinkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig
>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2_5OmniVisionEncoder config
>>> vision_config = Qwen2_5OmniVisionEncoderConfig()
>>> # Initializing a Qwen2_5OmniTextConfig config
>>> text_config = Qwen2_5OmniTextConfig()
>>> # Initializing a Qwen2.5OmniThinker configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, vision_config, text_config)
>>> # Initializing a model from the Qwen-Omni style configuration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniThinkerModel
classe transformers.Qwen2_5OmniThinkerModel
< source >( config: Qwen2_5OmniThinkerConfig )
Parâmetros
- config (Qwen2_5OmniThinkerConfig) — 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 Qwen2.5OmniThinker, que consiste em um backbone de áudio e um modelo de linguagem.
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] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonefeature_attention_mask: typing.Optional[torch.Tensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneuse_audio_in_video: bool | None = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast 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 WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para mais detalhes (Qwen2_5OmniProcessor usa WhisperFeatureExtractor para processar áudios). - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Qwen2VLImageProcessor. Consulte Qwen2VLImageProcessor.call() para mais detalhes (Qwen2_5OmniProcessor usa Qwen2VLImageProcessor para processar imagens). - pixel_values_videos (
torch.Tensorde forma(batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando Qwen2VLVideoProcessor. Consulte Qwen2VLVideoProcessor.call() para mais detalhes (Qwen2_5OmniProcessor usa Qwen2VLVideoProcessor para processar vídeos). - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada imagem no LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. - 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. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- feature_attention_mask (
torch.Tensorde forma(batch_size, feature_sequence_length), opcional) — Máscara para evitar a execução de atenção em índices de recursos 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.
- audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — O comprimento da forma de recurso de cada áudio no LLM. - position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - 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) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - use_audio_in_video (
bool, opcional) — Indica se a trilha de áudio do vídeo deve ser utilizada; deve ser o mesmo valor do parâmetro emprocess_audio_info. - video_second_per_grid (
torch.LongTensorde forma(num_videos), opcional) — Número de segundos por grade para cada vídeo, usado para o mapeamento de recursos temporais. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.
Retorna
BaseModelOutputWithPast ou tuple(torch.Tensor)
Um BaseModelOutputWithPast 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 (Qwen2_5OmniConfig) e das entradas.
O método forward do Qwen2_5OmniThinkerModel 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.
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.
Qwen2_5OmniThinkerForConditionalGeneration
classe transformers.Qwen2_5OmniThinkerForConditionalGeneration
< source >( config: Qwen2_5OmniThinkerConfig )
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonefeature_attention_mask: typing.Optional[torch.Tensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneuse_audio_in_video: bool | None = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast 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 WhisperFeatureExtractor. Consulte WhisperFeatureExtractor.call() para detalhes (Qwen2_5OmniProcessor usa WhisperFeatureExtractor para processar áudios). - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Qwen2VLImageProcessor. Consulte Qwen2VLImageProcessor.call() para mais detalhes (Qwen2_5OmniProcessor usa Qwen2VLImageProcessor para processar imagens). - pixel_values_videos (
torch.Tensorde forma(batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando Qwen2VLVideoProcessor. Consulte Qwen2VLVideoProcessor.call() para mais detalhes (Qwen2_5OmniProcessor usa Qwen2VLVideoProcessor para processar vídeos). - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada imagem no LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. - 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. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- feature_attention_mask (
torch.Tensorde forma(batch_size, feature_sequence_length), opcional) — Máscara para evitar a execução de atenção em índices de recursos 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.
- audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — O comprimento da forma de recurso de cada áudio no LLM. - position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - 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) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., config.vocab_size]ou ser -100 (veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - use_audio_in_video (
bool, opcional) — Indica se a trilha de áudio do vídeo deve ser utilizada; deve ser o mesmo valor do parâmetro emprocess_audio_info. - video_second_per_grid (
torch.LongTensorde forma(num_videos), opcional) — Número de segundos por grade para cada vídeo, usado para o mapeamento de recursos temporais. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.
Retorna
CausalLMOutputWithPast ou tuple(torch.Tensor)
Um CausalLMOutputWithPast 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 (Qwen2_5OmniConfig) e das entradas.
O método forward de Qwen2_5OmniThinkerForConditionalGeneration 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.
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 (pontuações para cada token do vocabulário antes do SoftMax).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) que podem ser usados (veja a entrada
past_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.
Exemplo:
>>> from transformers import Qwen2_5OmniProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> thinker = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> conversations = [
>>> {'role': 'system', 'content': 'You are a helpful voice chat bot, and please respond to me in a casual conversation manner using random voice.'},
>>> {"role": "user", "content": [
>>> {"type": "image", "image": "https://www.ilankelman.org/stopsigns/australia.jpg"},
>>> {"type": "audio", "audio": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/audio/glass_breaking.mp3"},
>>> ]},
>>> ]
>>> inputs = processor.apply_chat_template(
conversations,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
return_tensors="pt"
)
>>> # Generate
>>> generation = thinker.generate(**inputs, max_new_tokens=2048)
>>> generate_ids = generation[:, inputs.input_ids.size(1):]
>>> response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]get_audio_features
< source >( input_features: Tensorfeature_attention_mask: typing.Optional[torch.LongTensor] = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- input_features (
torch.Tensor) — Os tensores correspondentes aos áudios de entrada. - feature_attention_mask (
torch.LongTensor, opcional) — Máscara para evitar a execução de atenção nos índices de recursos de preenchimento. Valores da máscara selecionados em[0, 1]: - audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — O comprimento da forma de recurso de cada áudio no LLM.
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 (Qwen2_5OmniConfig) e das entradas.
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.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]get_image_features
< source >( pixel_values: Tensorimage_grid_thw: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada imagem no LLM.
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 (Qwen2_5OmniConfig) e das entradas.
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.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]get_video_features
< source >( pixel_values_videos: Tensorvideo_grid_thw: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- pixel_values_videos (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes aos vídeos de entrada. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM.
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 (Qwen2_5OmniConfig) e das entradas.
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.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen2_5OmniThinkerForConditionalGeneration
>>> model = Qwen2_5OmniThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]Qwen2_5OmniThinkerTextModel
classe transformers.Qwen2_5OmniThinkerTextModel
< source >( config: Qwen2_5OmniTextConfig )
Parâmetros
- config (Qwen2_5OmniTextConfig) — 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 texto Qwen2 5 Omni puro, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.
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] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → BaseModelOutputWithPast 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.
- 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. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - 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) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
BaseModelOutputWithPast ou tuple(torch.Tensor)
Um BaseModelOutputWithPast 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 (Qwen2_5OmniConfig) e das entradas.
O método forward do Qwen2_5OmniThinkerTextModel 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.
Qwen2_5OmniTalkerConfig
classe transformers.Qwen2_5OmniTalkerConfig
< 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_token_index: int = 151646image_token_index: int = 151655video_token_index: int = 151656vocab_size: int = 8448tts_text_start_token_id: int = 151860tts_text_end_token_id: int = 151861tts_text_pad_token_id: int = 151859tts_codec_start_token_id: int = 8293tts_codec_end_token_id: int = 8294tts_codec_pad_token_id: int = 8292tts_codec_mask_token_id: int = 8296vision_start_token_id: int = 151652vision_end_token_id: int = 151653embedding_size: int = 3584hidden_size: int = 3584intermediate_size: int = 18944num_hidden_layers: int = 28num_attention_heads: int = 28num_key_value_heads: int = 4hidden_act: str = 'silu'max_position_embeddings: int = 32768rms_norm_eps: float = 1e-06head_dim: int = 128use_cache: bool = Truetie_word_embeddings: bool = Falseuse_sliding_window: bool = Falsesliding_window: int | None = 32768max_window_layers: int = 28attention_dropout: float | int = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneposition_id_per_seconds: int = 25seconds_per_chunk: int = 2audio_start_token_id: int = 151647audio_end_token_id: int = 151648initializer_range: float = 0.02spatial_merge_size: int = 2layer_types: list[str] | None = Nonepad_token_id: int | None = None )
Parâmetros
- audio_token_index (
int, opcional, padrão151646) — O índice do token de áudio usado como marcador de posição para o áudio de entrada. - image_token_index (
int, opcional, padrão151655) — O índice do token de imagem usado como marcador para as imagens de entrada. - video_token_index (
int, opcional, padrão151656) — O índice do token de vídeo usado como marcador de posição para os vídeos de entrada. - vocab_size (
int, opcional, padrão8448) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - tts_text_start_token_id (
int, opcional, padrão 151860) — O índice do token de início de texto tts para codificar o início do texto tts. - tts_text_end_token_id (
int, opcional, padrão 151861) — O índice do token de fim de texto tts para codificar o fim do texto tts. - tts_text_pad_token_id (
int, opcional, padrão 151859) — O índice do token de preenchimento (pad) do texto tts para codificar o preenchimento do texto tts. - tts_codec_start_token_id (
int, opcional, padrão 8293) — O índice do token de início do codec tts para codificar o início do codec tts. - tts_codec_end_token_id (
int, opcional, padrão 8294) — O índice do token de fim do codec tts para codificar o fim do codec tts. - tts_codec_pad_token_id (
int, opcional, padrão 8292) — O índice do token de preenchimento do codec tts para codificar o preenchimento do codec tts. - tts_codec_mask_token_id (
int, opcional, padrão 8296) — O índice do token de máscara do codec tts para codificar a máscara do codec tts. - vision_start_token_id (
int, opcional, padrão151652) — ID do token que marca o início de um segmento visual na sequência de entrada multimodal. - vision_end_token_id (
int, opcional, padrão151653) — ID do token que marca o fim de um segmento visual na sequência de entrada multimodal. - embedding_size (
int, opcional, padrão3584) — Dimensão dos embeddings e dos estados ocultos. - hidden_size (
int, opcional, padrão3584) — Dimensão das representações ocultas. - intermediate_size (
int, opcional, padrão18944) — Dimensão das representações do MLP. - num_hidden_layers (
int, opcional, padrão28) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão28) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - num_key_value_heads (
int, opcional, padrão4) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Senum_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); senum_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão seránum_attention_heads. - hidden_act (
str, opcional, padrãosilu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - max_position_embeddings (
int, opcional, padrão32768) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - rms_norm_eps (
float, opcional, padrão1e-06) — O epsilon usado pelas camadas de normalização rms. - head_dim (
int, opcional, padrão128) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads - use_cache (
bool, opcional, padrãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou quando o modelo for um modelo generativo somente decodificador. - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - use_sliding_window (
bool, opcional, padrãoFalse) — Se deve usar atenção com janela deslizante. - sliding_window (
int, opcional, padrão32768) — Tamanho da janela de atenção deslizante. Se forNone, nenhuma janela deslizante é aplicada. - max_window_layers (
int, opcional, padrão28) — O número de camadas que usam atenção completa. As primeirasmax_window_layerscamadas usarão atenção completa, enquanto qualquer camada adicional subsequente usará SWA (Sliding Window Attention). - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores. - position_id_per_seconds (
int, optional, defaults to 25) — The increment of position id per second. - seconds_per_chunk (
int, opcional, padrão 2) — A duração, em segundos, do trecho de dados de áudio e vídeo. - audio_start_token_id (
int, opcional, padrão 151647) — O índice do token de início de áudio para codificar o prompt de áudio. - audio_end_token_id (
int, opcional, padrão 151648) — O índice do token de fim de áudio para codificar o prompt de áudio. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - spatial_merge_size (
int, opcional, padrão2) — O tamanho da janela de mesclagem espacial usada para reduzir o número de tokens visuais ao mesclar patches vizinhos. - layer_types (
list[str], opcional) — Uma lista que mapeia explicitamente cada índice de camada com seu tipo de camada. Se não for fornecida, será gerada automaticamente com base nos valores de configuração. - pad_token_id (
int, opcional) — ID do token usado para preenchimento no vocabulário.
Esta é a classe de configuração para armazenar a configuração de um Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniTalkerForConditionalGeneration, Qwen2_5OmniThinkerConfig, Qwen2_5OmniAudioEncoderConfig, Qwen2_5OmniVisionEncoderConfig
>>> # Initializing a Qwen2_5OmniAudioEncoder config
>>> audio_config = Qwen2_5OmniAudioEncoderConfig()
>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()
>>> # Initializing a Qwen2_5Omni configuration
>>> configuration = Qwen2_5OmniThinkerConfig(audio_config, text_config)
>>> # Initializing a model from the qwen2-audio style configuration
>>> model = Qwen2_5OmniTalkerForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniTalkerForConditionalGeneration
classe transformers.Qwen2_5OmniTalkerForConditionalGeneration
< source >( config: Qwen2_5OmniTalkerConfig )
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonethinker_reply_part: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneinput_text_ids: typing.Optional[torch.LongTensor] = Noneimage_grid_thw: typing.Optional[torch.LongTensor] = Nonevideo_grid_thw: typing.Optional[torch.LongTensor] = Noneuse_audio_in_video: bool | None = Noneaudio_feature_lengths: typing.Optional[torch.LongTensor] = Nonevideo_second_per_grid: typing.Optional[torch.LongTensor] = None**kwargs ) → Qwen2_5OmniTalkerCausalLMOutputWithPast 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.
- 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. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - 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). - thinker_reply_part (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Estados ocultos da saída do modelo thinker que representam a parte de resposta em texto a ser processada. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - input_text_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — IDs de tokens de entrada para conteúdo apenas de texto, usados para o cálculo de posição em contextos multimodais. - image_grid_thw (
torch.LongTensorde forma(num_images, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada imagem no LLM. - video_grid_thw (
torch.LongTensorde forma(num_videos, 3), opcional) — A dimensão temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. - use_audio_in_video (
bool, opcional) — Indica se a trilha de áudio do vídeo deve ser utilizada; deve ser o mesmo valor do parâmetro emprocess_audio_info. - audio_feature_lengths (
torch.LongTensorde forma(num_audios), opcional) — O comprimento da forma de recurso de cada áudio no LLM. - video_second_per_grid (
torch.LongTensorde forma(num_videos), opcional) — Número de segundos por grade para cada vídeo, usado para o mapeamento de recursos temporais.
Retorna
Qwen2_5OmniTalkerCausalLMOutputWithPast ou tuple(torch.Tensor)
Um Qwen2_5OmniTalkerCausalLMOutputWithPast 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 (Qwen2_5OmniConfig) e das entradas.
O método forward de Qwen2_5OmniTalkerForConditionalGeneration 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.
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 (pontuações para cada token do vocabulário antes do SoftMax).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) que podem ser usados (veja a entrada
past_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.
thinker_reply_part (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Estados ocultos do modelo thinker que são usados como entrada para o modelo talker. Esses estados representam a resposta codificada que o modelo talker usará para gerar tokens de fala.
Exemplo:
>>> from io import BytesIO
>>> from urllib.request import urlopen
>>> import librosa
>>> from transformers import AutoProcessor, Qwen2_5OmniTalkerForConditionalGeneration
>>> model = Qwen2_5OmniTalkerForConditionalGeneration.from_pretrained("Qwen/Qwen2-Audio-7B")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2-Audio-7B")
>>> prompt = "<|audio_bos|><|AUDIO|><|audio_eos|>Generate the caption in English:"
>>> url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/audio/glass_breaking.mp3"
>>> audio, _ = librosa.load(BytesIO(urlopen(url).read()), sr=self.processor.feature_extractor.sampling_rate)
>>> inputs = processor(text=prompt, audio=audio, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Generate the caption in English: Glass is breaking."Qwen2_5OmniTalkerModel
classe transformers.Qwen2_5OmniTalkerModel
< source >( config: Qwen2_5OmniTalkerConfig )
Parâmetros
- config (Qwen2_5OmniTalkerConfig) — 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 Qwen2 5 Omni puro, que gera estados ocultos brutos sem nenhum head específico no topo.
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] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → BaseModelOutputWithPast 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.
- 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. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - 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) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
BaseModelOutputWithPast ou tuple(torch.Tensor)
Um BaseModelOutputWithPast 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 (Qwen2_5OmniConfig) e das entradas.
O método forward do Qwen2_5OmniTalkerModel 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.
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.
Qwen2_5OmniToken2WavConfig
classe transformers.Qwen2_5OmniToken2WavConfig
< 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 = Nonedit_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonebigvgan_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )
Parâmetros
Esta é a classe de configuração para armazenar a configuração de um Qwen2 5 OmniModel. Ela é usada para instanciar um modelo Qwen2 5 Omni 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 Qwen/Qwen2.5-Omni-7B
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 Qwen2_5OmniToken2WavModel, DiT_Args, BigVGAN_Args
>>> # Initialize DiT configuration
>>> dit_config = DiT_Args(
... dim=1024,
... depth=22,
... heads=16,
... ff_mult=2
... )
>>> # Initialize BigVGAN configuration
>>> bigvgan_config = BigVGAN_Args(
... mel_dim=80,
... upsample_rates=[5,3,2,2,2,2]
... )
>>> # Initialize main configuration
>>> config = Qwen2_5OmniToken2WavConfig(dit_config, bigvgan_config)
>>> # Initialize model with config
>>> model = Qwen2_5OmniToken2Wav(config)
>>> # Accessing the model configuration
>>> configuration = model.configQwen2_5OmniToken2WavModel
classe transformers.Qwen2_5OmniToken2WavModel
< source >( config: Qwen2_5OmniToken2WavConfig )
Parâmetros
- config (Qwen2_5OmniToken2WavConfig) — 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 completo Qwen2.5Omni Token2Wav. Consiste em um modelo DiT que recebe tokens de fala como entrada e prevê o espectrograma mel, e um vocoder BigVGAN que recebe o espectrograma mel como entrada e prevê a forma de onda.
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 >( codeconditioningreference_melnum_steps = 10guidance_scale = 0.5sway_coefficient = -1.0**kwargs )
Gera uma forma de onda a partir do código de entrada e dos parâmetros de condicionamento.
Qwen2_5OmniToken2WavDiTModel
classe transformers.Qwen2_5OmniToken2WavDiTModel
< source >( config: Qwen2_5OmniDiTConfig )
Parâmetros
- config (Qwen2_5OmniDiTConfig) — 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 completo Qwen2.5Omni Token2WavDiT. Ele recebe tokens de fala como entrada e prevê o espectrograma mel.
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.
Qwen2_5OmniToken2WavBigVGANModel
classe transformers.Qwen2_5OmniToken2WavBigVGANModel
< source >( config: Qwen2_5OmniBigVGANConfig )
Parâmetros
- config (Qwen2_5OmniBigVGANConfig) — 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 completo Qwen2.5Omni Token2WavBigVGAN. Ele recebe o espectrograma mel como entrada e prevê a forma de onda.
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.