# Qwen2.5-Omni

## Visão geral

O modelo [Qwen2.5-Omni](https://qwenlm.github.io/blog/qwen2.5-omni/) é um modelo unificado de múltiplas modalidades proposto no [Qwen2.5-Omni Technical Report](https://huggingface.co/papers/2503.20215) 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 sequências longas de dados multimodais, atribuindo as responsabilidades perceptuais 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 atua 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 robustez e naturalidade.*

> [!TIP]
> Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir camadas compatíveis por kernels otimizados do Hub. Consulte [Carregando kernels](../kernel_doc/loading_kernels) para saber mais.

## Observações

- Use [Qwen2_5OmniForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniForConditionalGeneration) para gerar saída de áudio e texto. Para gerar apenas um tipo de saída, use [Qwen2_5OmniThinkerForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerForConditionalGeneration) para apenas texto e `Qwen2_5OmniTalkersForConditionalGeneration` para 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 exceda `processor.max_pixels`.
- O processador possui seu próprio método [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) para converter mensagens de chat em entradas do modelo.

## Exemplo de uso

`Qwen2.5-Omni` pode ser encontrado no [Huggingface Hub](https://huggingface.co/Qwen).

### 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.

```python
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`.

```python
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.

```python
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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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.

```python
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.

```python
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.

```python
{
    "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`.

```python
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.

```python
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`.

```python
text_ids, audio = model.generate(**inputs, speaker="Chelsie")
```

```python
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:

```bash
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](https://github.com/Dao-AILab/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:

```python
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[[transformers.Qwen2_5OmniConfig]]

#### transformers.Qwen2_5OmniConfig[[transformers.Qwen2_5OmniConfig]]

```python
transformers.Qwen2_5OmniConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, thinker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, talker_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, token2wav_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, enable_audio_output: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L533)

**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ão `True`) : 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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import (
...     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.config
```

#### get_text_config[[transformers.Qwen2_5OmniConfig.get_text_config]]

```python
get_text_config(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L586)

**Parâmetros:**

decoder (`Optional[bool]`, *opcional*, padrão `False`) : Se definido como `True`, busca apenas nomes de configurações de decodificador.

Retorna a configuração que deve ser usada com IO de texto. Na maioria dos modelos, é a própria instância de configuração original. Em modelos compostos específicos, ela está sob um conjunto de nomes válidos.

## Qwen2_5OmniVisionEncoderConfig[[transformers.Qwen2_5OmniVisionEncoderConfig]]

#### transformers.Qwen2_5OmniVisionEncoderConfig[[transformers.Qwen2_5OmniVisionEncoderConfig]]

```python
transformers.Qwen2_5OmniVisionEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, depth: int = 32, hidden_size: int = 3584, hidden_act: str = 'silu', intermediate_size: int = 3420, num_heads: int = 16, in_channels: int = 3, patch_size: int | list[int] | tuple[int, int] = 14, spatial_merge_size: int = 2, temporal_patch_size: int | list[int] | tuple[int, int] = 2, window_size: int = 112, out_hidden_size: int = 3584, fullatt_block_indexes: list[int] | tuple[int, ...] = (7, 15, 23, 31), initializer_range: float = 0.02, rope_parameters: dict | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L30)

**Parâmetros:**

depth (`int`, *opcional*, padrão `32`) : Número de camadas do Transformer no codificador de visão.

hidden_size (`int`, *opcional*, padrão `3584`) : Dimensão das representações ocultas.

hidden_act (`str`, *opcional*, padrão `silu`) : 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ão `3420`) : Dimensão das representações do MLP.

num_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

in_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `14`) : O tamanho (resolução) de cada patch.

spatial_merge_size (`int`, *opcional*, padrão `2`) : O tamanho da janela de mesclagem espacial usada para reduzir o número de tokens visuais mesclando patches vizinhos.

temporal_patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `2`) : 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ão `0.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 para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import 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.config
```

## Qwen2_5OmniTextConfig[[transformers.Qwen2_5OmniTextConfig]]

#### transformers.Qwen2_5OmniTextConfig[[transformers.Qwen2_5OmniTextConfig]]

```python
transformers.Qwen2_5OmniTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 152064, hidden_size: int = 3584, intermediate_size: int = 18944, num_hidden_layers: int = 28, num_attention_heads: int = 28, num_key_value_heads: int | None = 4, hidden_act: str = 'silu', max_position_embeddings: int = 32768, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, use_sliding_window: bool = False, sliding_window: int | None = 32768, max_window_layers: int = 28, layer_types: list[str] | None = None, attention_dropout: float | int = 0.0, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L128)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `152064`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `3584`) : Dimensão das representações ocultas.

intermediate_size (`int`, *opcional*, padrão `18944`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão `28`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `28`) : 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ão `4`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_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 cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`.

hidden_act (`str`, *opcional*, padrão `silu`) : 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ão `32768`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms.

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de 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 para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

use_sliding_window (`bool`, *opcional*, padrão `False`) : Se deve usar atenção com janela deslizante.

sliding_window (`int`, *opcional*, padrão `32768`) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada.

max_window_layers (`int`, *opcional*, padrão `28`) : O número de camadas que usam atenção completa. As primeiras `max_window_layers` camadas 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 config.

attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) 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ão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do 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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import 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.config
```

## Qwen2_5OmniDiTConfig[[transformers.Qwen2_5OmniDiTConfig]]

#### transformers.Qwen2_5OmniDiTConfig[[transformers.Qwen2_5OmniDiTConfig]]

```python
transformers.Qwen2_5OmniDiTConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1024, num_hidden_layers: int = 22, num_attention_heads: int = 16, ff_mult: int = 2, emb_dim: int = 512, head_dim: int = 64, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, max_position_embeddings: int = 32768, block_size: int = 24, look_ahead_layers: list[int] | tuple[int, ...] = (10,), look_backward_layers: list[int] | tuple[int, ...] = (0, 20), repeats: int = 2, num_embeds: int = 8193, mel_dim: int = 80, dropout: float | int = 0.1, enc_emb_dim: int = 192, enc_dim: int = 128, enc_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 = 64, enc_res2net_scale: int = 2, enc_se_channels: int = 64)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L391)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `1024`) : Dimensão das representações ocultas.

num_hidden_layers (`int`, *opcional*, padrão `22`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `16`) : 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ão `64`) : 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 para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

max_position_embeddings (`int`, *opcional*, padrão `32768`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

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 são permitidas a 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ão `0.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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Qwen2_5OmniBigVGANConfig[[transformers.Qwen2_5OmniBigVGANConfig]]

#### transformers.Qwen2_5OmniBigVGANConfig[[transformers.Qwen2_5OmniBigVGANConfig]]

```python
transformers.Qwen2_5OmniBigVGANConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, mel_dim: int = 80, upsample_initial_channel: int = 1536, resblock_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))
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L456)

**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 upsampling para cada camada de upsampling.

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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Qwen2_5OmniAudioEncoderConfig[[transformers.Qwen2_5OmniAudioEncoderConfig]]

#### transformers.Qwen2_5OmniAudioEncoderConfig[[transformers.Qwen2_5OmniAudioEncoderConfig]]

```python
transformers.Qwen2_5OmniAudioEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_mel_bins: int = 128, encoder_layers: int = 32, encoder_attention_heads: int = 20, encoder_ffn_dim: int = 5120, d_model: int = 1280, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_function: str = 'gelu', activation_dropout: float | int = 0.0, scale_embedding: bool = False, initializer_range: float = 0.02, max_source_positions: int = 1500, n_window: int = 100, output_dim: int = 3584)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L77)

**Parâmetros:**

num_mel_bins (`int`, *opcional*, padrão `128`) : Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor usado na classe `AutoFeatureExtractor`.

encoder_layers (`int`, *opcional*, padrão `32`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

encoder_attention_heads (`int`, *opcional*, padrão `20`) : Número de cabeças de atenção para cada camada de atenção no codificador do Transformer.

encoder_ffn_dim (`int`, *opcional*, padrão `5120`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no codificador.

d_model (`int`, *opcional*, padrão `1280`) : Tamanho das camadas do codificador e da camada pooler.

dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

activation_function (`str`, *opcional*, padrão `gelu`) : 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ão `0.0`) : A taxa de dropout para as ativações dentro da camada totalmente conectada.

scale_embedding (`bool`, *opcional*, padrão `False`) : Se as embeddings devem ser escalonadas dividindo por sqrt(d_model).

initializer_range (`float`, *opcional*, padrão `0.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 os quais este modelo pode ser utilizado.

n_window (`int`, *opcional*, padrão 100) : O chunk 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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import 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.config
```

## Qwen2_5OmniProcessor[[transformers.Qwen2_5OmniProcessor]]

#### transformers.Qwen2_5OmniProcessor[[transformers.Qwen2_5OmniProcessor]]

```python
transformers.Qwen2_5OmniProcessor(image_processor = None, video_processor = None, feature_extractor = None, tokenizer = None, chat_template = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/processing_qwen2_5_omni.py#L119)

**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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) oferece todas as funcionalidades de [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [Qwen2VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor), [WhisperFeatureExtractor](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) e [Qwen2Tokenizer](/docs/transformers/main/pt/model_doc/qwen2#transformers.Qwen2Tokenizer). Consulte [~Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [~Qwen2VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor), [~WhisperFeatureExtractor](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) e [~Qwen2Tokenizer](/docs/transformers/main/pt/model_doc/qwen2#transformers.Qwen2Tokenizer) para mais informações.

#### __call__[[transformers.Qwen2_5OmniProcessor.__call__]]

```python
__call__(text: str | list[str] | list[list[str]] = None, images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, videos: 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] = None, audio: 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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/processing_qwen2_5_omni.py#L137)

**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 pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para 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 estiver passando imagens com valores de pixel entre 0 e 1, defina `do_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 para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_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 de 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 de 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 quadros 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 adequar a esse limite.

use_audio_in_video (`bool`, *kwargs*, *opcional*, padrão `False`) : Argumento obsoleto - use `load_audio_from_video` em vez disso.

load_audio_from_video (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve incorporar informações de áudio ao processar vídeos. Quando ativado, 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ão `2.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* ou `float`, *opcional*, padrão `25`) : O número de IDs de posição alocados por segundo de vídeo. Este parâmetro controla a resolução temporal dos embeddings de posição e é usado para alinhar tokens de vídeo com tokens de áudio quando `use_audio_in_video=True`.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

**Retorna:** `~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]` ou `set[str]`, *opcional*) -- Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado.

## Qwen2_5OmniForConditionalGeneration[[transformers.Qwen2_5OmniForConditionalGeneration]]

#### transformers.Qwen2_5OmniForConditionalGeneration[[transformers.Qwen2_5OmniForConditionalGeneration]]

```python
transformers.Qwen2_5OmniForConditionalGeneration(config: Qwen2_5OmniConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3717)

**Parâmetros:**

config ([Qwen2_5OmniConfig](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo completo Qwen2.5Omni, um modelo multimodal composto por 3 submodelos:
- [Qwen2_5OmniThinkerForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniThinkerForConditionalGeneration):
um transformer auto-regressivo causal recebe texto, áudio, imagem e vídeo como entrada e prevê tokens de texto.
- [Qwen2_5OmniTalkerForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniTalkerForConditionalGeneration):
um transformer auto-regressivo causal recebe os estados ocultos do thinker e a resposta como entrada e prevê tokens de fala.
- [Qwen2_5OmniToken2WavModel](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniToken2WavModel):
Um modelo DiT recebe tokens de fala como entrada e prevê o espectrograma mel, e um vocoder BigVGAN recebe o espectrograma mel como entrada e prevê a forma de onda.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.Qwen2_5OmniForConditionalGeneration.forward]]

```python
forward(*args, **kwargs)
```

Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock.

## Qwen2_5OmniPreTrainedModelForConditionalGeneration[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration]]

#### transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration]]

```python
transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration(config: PreTrainedConfig, *inputs, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L155)

#### get_chunked_index[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration.get_chunked_index]]

```python
get_chunked_index(token_indices: Tensor, tokens_per_chunk: int, remove_index: int)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L178)

**Parâmetros:**

token_indices (`torch.Tensor` de forma `(seq_len, )`) : Uma lista de valores de índice de tokens em ordem crescente monotônica.

t_ntoken_per_chunk (`int`) : Número de tokens por bloco (usado como o limite de tamanho do bloco).

remove_index (`int`) Um id de índice a ser subtraído de `token_indices` antes 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[[transformers.Qwen2_5OmniPreTrainedModelForConditionalGeneration.get_rope_index]]

```python
get_rope_index(input_ids: typing.Optional[torch.LongTensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, use_audio_in_video: bool = False, audio_seqlens: typing.Optional[torch.LongTensor] = None, second_per_grids: typing.Optional[torch.Tensor] = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L215)

**Parâmetros:**

input_ids (`torch.LongTensor` de 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.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM.

video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores da 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 como `True`, usa o áudio do vídeo.

audio_seqlens (`torch.LongTensor` de forma `(num_audios)`, *opcional*) : O comprimento da forma de recurso de cada áudio no LLM.

second_per_grids (`torch.LongTensor` de 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.

**Retorna:**

position_ids (`torch.LongTensor` de forma `(3, batch_size, sequence_length)`) mrope_position_deltas (`torch.Tensor` de forma `(batch_size)`)

Calcule o índice rope 3D com base no temporal, 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[[transformers.Qwen2_5OmniThinkerConfig]]

#### transformers.Qwen2_5OmniThinkerConfig[[transformers.Qwen2_5OmniThinkerConfig]]

```python
transformers.Qwen2_5OmniThinkerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_index: int = 151646, image_token_index: int = 151655, video_token_index: int = 151656, position_id_per_seconds: int = 25, seconds_per_chunk: int = 2, audio_start_token_id: int = 151647, audio_end_token_id: int = 151648, user_token_id: int = 872, initializer_range: float = 0.02, tie_word_embeddings: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L212)

**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ão `151646`) : O índice do token de áudio usado como marcador de posição para o áudio de entrada.

image_token_index (`int`, *opcional*, padrão `151655`) : O índice do token de imagem usado como marcador para as imagens de entrada.

video_token_index (`int`, *opcional*, padrão `151656`) : O índice do token de vídeo usado como marcador para os vídeos de entrada.

position_id_per_seconds (`int`, *opcional*, padrão 25) : O incremento do id de posição por segundo.

seconds_per_chunk (`int`, *opcional*, padrão 2) : A duração, em segundos, do bloco 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 do usuário para codificar o token do usuário.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do 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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import 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.config
```

## Qwen2_5OmniThinkerModel[[transformers.Qwen2_5OmniThinkerModel]]

#### transformers.Qwen2_5OmniThinkerModel[[transformers.Qwen2_5OmniThinkerModel]]

```python
transformers.Qwen2_5OmniThinkerModel(config: Qwen2_5OmniThinkerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1668)

**Parâmetros:**

config ([Qwen2_5OmniThinkerConfig](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.Qwen2_5OmniThinkerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, feature_attention_mask: typing.Optional[torch.Tensor] = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, use_audio_in_video: bool | None = None, video_second_per_grid: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1843)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

input_features (`torch.Tensor` de 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](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor). Veja [WhisperFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para detalhes ([Qwen2_5OmniProcessor](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) usa [WhisperFeatureExtractor](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) para processar áudios).

pixel_values (`torch.Tensor` de 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](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Veja [Qwen2VLImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Qwen2_5OmniProcessor](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) usa [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) para processar imagens).

pixel_values_videos (`torch.Tensor` de 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](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Veja [Qwen2VLVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Qwen2_5OmniProcessor](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) usa [Qwen2VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) para processar vídeos).

image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM.

video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

feature_attention_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos í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.LongTensor` de forma `(num_audios)`, *opcional*) : O comprimento da forma de recurso de cada áudio no LLM.

position_ids (`torch.LongTensor` de 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]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

use_audio_in_video (`bool`, *opcional*) : Se deve ou não usar a trilha de áudio no vídeo, deve ser o mesmo que o parâmetro em `process_audio_info`.

video_second_per_grid (`torch.LongTensor` de 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_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

O método forward do [Qwen2_5OmniThinkerModel](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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 entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## Qwen2_5OmniThinkerForConditionalGeneration[[transformers.Qwen2_5OmniThinkerForConditionalGeneration]]

#### transformers.Qwen2_5OmniThinkerForConditionalGeneration[[transformers.Qwen2_5OmniThinkerForConditionalGeneration]]

```python
transformers.Qwen2_5OmniThinkerForConditionalGeneration(config: Qwen2_5OmniThinkerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1959)

#### forward[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, feature_attention_mask: typing.Optional[torch.Tensor] = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, use_audio_in_video: bool | None = None, video_second_per_grid: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2017)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

input_features (`torch.Tensor` de 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](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor). Veja [WhisperFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para detalhes ([Qwen2_5OmniProcessor](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) usa [WhisperFeatureExtractor](/docs/transformers/main/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) para processar áudios).

pixel_values (`torch.Tensor` de 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](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Veja [Qwen2VLImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Qwen2_5OmniProcessor](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) usa [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) para processar imagens).

pixel_values_videos (`torch.Tensor` de 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](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Veja [Qwen2VLVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Qwen2_5OmniProcessor](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniProcessor) usa [Qwen2VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) para processar vídeos).

image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM.

video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

feature_attention_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos í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.LongTensor` de forma `(num_audios)`, *opcional*) : O comprimento da forma de recurso de cada áudio no LLM.

position_ids (`torch.LongTensor` de 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]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

use_audio_in_video (`bool`, *opcional*) : Se deve ou não usar a trilha de áudio no vídeo, deve ser o mesmo que o parâmetro em `process_audio_info`.

video_second_per_grid (`torch.LongTensor` de 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_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`

Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

O método forward de [Qwen2_5OmniThinkerForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token).
- **logits** (`torch.Tensor` de 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 quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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 quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.get_audio_features]]

```python
get_audio_features(input_features: Tensor, feature_attention_mask: typing.Optional[torch.LongTensor] = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1999)

**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 de máscara selecionados em `[0, 1]`:

audio_feature_lengths (`torch.LongTensor` de forma `(num_audios)`, *opcional*) : O comprimento da forma de recurso de cada áudio no LLM.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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 quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_grid_thw: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1986)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada.

image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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 quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.Qwen2_5OmniThinkerForConditionalGeneration.get_video_features]]

```python
get_video_features(pixel_values_videos: Tensor, video_grid_thw: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1973)

**Parâmetros:**

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes aos vídeos de entrada.

video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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 quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.Qwen2_5OmniThinkerTextModel]]

#### transformers.Qwen2_5OmniThinkerTextModel[[transformers.Qwen2_5OmniThinkerTextModel]]

```python
transformers.Qwen2_5OmniThinkerTextModel(config: Qwen2_5OmniTextConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1548)

**Parâmetros:**

config ([Qwen2_5OmniTextConfig](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.Qwen2_5OmniThinkerTextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L1575)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de 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]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

**Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

O método forward do [Qwen2_5OmniThinkerTextModel](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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 entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## Qwen2_5OmniTalkerConfig[[transformers.Qwen2_5OmniTalkerConfig]]

#### transformers.Qwen2_5OmniTalkerConfig[[transformers.Qwen2_5OmniTalkerConfig]]

```python
transformers.Qwen2_5OmniTalkerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, audio_token_index: int = 151646, image_token_index: int = 151655, video_token_index: int = 151656, vocab_size: int = 8448, tts_text_start_token_id: int = 151860, tts_text_end_token_id: int = 151861, tts_text_pad_token_id: int = 151859, tts_codec_start_token_id: int = 8293, tts_codec_end_token_id: int = 8294, tts_codec_pad_token_id: int = 8292, tts_codec_mask_token_id: int = 8296, vision_start_token_id: int = 151652, vision_end_token_id: int = 151653, embedding_size: int = 3584, hidden_size: int = 3584, intermediate_size: int = 18944, num_hidden_layers: int = 28, num_attention_heads: int = 28, num_key_value_heads: int = 4, hidden_act: str = 'silu', max_position_embeddings: int = 32768, rms_norm_eps: float = 1e-06, head_dim: int = 128, use_cache: bool = True, tie_word_embeddings: bool = False, use_sliding_window: bool = False, sliding_window: int | None = 32768, max_window_layers: int = 28, attention_dropout: float | int = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, position_id_per_seconds: int = 25, seconds_per_chunk: int = 2, audio_start_token_id: int = 151647, audio_end_token_id: int = 151648, initializer_range: float = 0.02, spatial_merge_size: int = 2, layer_types: list[str] | None = None, pad_token_id: int | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L278)

**Parâmetros:**

audio_token_index (`int`, *opcional*, padrão `151646`) : O índice do token de áudio usado como marcador de posição para o áudio de entrada.

image_token_index (`int`, *opcional*, padrão `151655`) : O índice do token de imagem usado como marcador para as imagens de entrada.

video_token_index (`int`, *opcional*, padrão `151656`) : O índice do token de vídeo usado como marcador para os vídeos de entrada.

vocab_size (`int`, *opcional*, padrão `8448`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_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 de texto tts para codificar o preenchimento do texto tts.

tts_codec_start_token_id (`int`, *opcional*, padrão 8293) : O índice do token inicial 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 final 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ão `151652`) : 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ão `151653`) : ID do token que marca o fim de um segmento visual na sequência de entrada multimodal.

embedding_size (`int`, *opcional*, padrão `3584`) : Dimensionalidade dos embeddings e dos estados ocultos.

hidden_size (`int`, *opcional*, padrão `3584`) : Dimensão das representações ocultas.

intermediate_size (`int`, *opcional*, padrão `18944`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão `28`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `28`) : 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ão `4`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_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 cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`.

hidden_act (`str`, *opcional*, padrão `silu`) : 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ão `32768`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms.

head_dim (`int`, *opcional*, padrão `128`) : 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ão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

use_sliding_window (`bool`, *opcional*, padrão `False`) : Se deve usar atenção com janela deslizante.

sliding_window (`int`, *opcional*, padrão `32768`) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada.

max_window_layers (`int`, *opcional*, padrão `28`) : O número de camadas que usam atenção completa. As primeiras `max_window_layers` camadas usarão atenção completa, enquanto qualquer camada adicional subsequente usará SWA (Sliding Window Attention).

attention_dropout (`Union[float, int]`, *opcional*, padrão `0.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 para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

position_id_per_seconds (`int`, *opcional*, padrão 25) : O incremento do id de posição por segundo.

seconds_per_chunk (`int`, *opcional*, padrão 2) : A duração, em segundos, do bloco 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ão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

spatial_merge_size (`int`, *opcional*, padrão `2`) : O tamanho da janela de mesclagem espacial usada para reduzir o número de tokens visuais mesclando 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 config.

pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) 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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import 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.config
```

## Qwen2_5OmniTalkerForConditionalGeneration[[transformers.Qwen2_5OmniTalkerForConditionalGeneration]]

#### transformers.Qwen2_5OmniTalkerForConditionalGeneration[[transformers.Qwen2_5OmniTalkerForConditionalGeneration]]

```python
transformers.Qwen2_5OmniTalkerForConditionalGeneration(config: Qwen2_5OmniTalkerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2300)

#### forward[[transformers.Qwen2_5OmniTalkerForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, thinker_reply_part: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, input_text_ids: typing.Optional[torch.LongTensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, use_audio_in_video: bool | None = None, audio_feature_lengths: typing.Optional[torch.LongTensor] = None, video_second_per_grid: typing.Optional[torch.LongTensor] = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2334)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de 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]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

thinker_reply_part (`torch.Tensor` de 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.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

input_text_ids (`torch.LongTensor` de 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.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM.

video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM.

use_audio_in_video (`bool`, *opcional*) : Se deve ou não usar a trilha de áudio no vídeo, deve ser o mesmo que o parâmetro em `process_audio_info`.

audio_feature_lengths (`torch.LongTensor` de forma `(num_audios)`, *opcional*) : O comprimento da forma de recurso de cada áudio no LLM.

video_second_per_grid (`torch.LongTensor` de 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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

O método forward de [Qwen2_5OmniTalkerForConditionalGeneration](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token).
- **logits** (`torch.Tensor` de 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 quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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 quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **thinker_reply_part** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Estados ocultos do modelo thinker que são usados como entrada para o modelo talker. Esses representam a resposta codificada que o modelo talker usará para gerar tokens de fala.

Exemplo:

```python
>>> 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[[transformers.Qwen2_5OmniTalkerModel]]

#### transformers.Qwen2_5OmniTalkerModel[[transformers.Qwen2_5OmniTalkerModel]]

```python
transformers.Qwen2_5OmniTalkerModel(config: Qwen2_5OmniTalkerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2185)

**Parâmetros:**

config ([Qwen2_5OmniTalkerConfig](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.Qwen2_5OmniTalkerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L2212)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de 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]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

**Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniConfig)) e das entradas.

O método forward do [Qwen2_5OmniTalkerModel](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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 entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## Qwen2_5OmniToken2WavConfig[[transformers.Qwen2_5OmniToken2WavConfig]]

#### transformers.Qwen2_5OmniToken2WavConfig[[transformers.Qwen2_5OmniToken2WavConfig]]

```python
transformers.Qwen2_5OmniToken2WavConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, dit_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, bigvgan_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/configuration_qwen2_5_omni.py#L484)

**Parâmetros:**

dit_config (`DiT_Args`, *opcional*) : Classe de configuração para o módulo Diffusion Transformer (DiT) responsável por gerar espectrogramas mel.

bigvgan_config (`BigVGAN_Args`, *opcional*) : Classe de configuração para o módulo BigVGAN responsável por converter mel-espectrogramas em formas de onda.

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](https://huggingface.co/Qwen/Qwen2.5-Omni-7B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import 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.config
```

## Qwen2_5OmniToken2WavModel[[transformers.Qwen2_5OmniToken2WavModel]]

#### transformers.Qwen2_5OmniToken2WavModel[[transformers.Qwen2_5OmniToken2WavModel]]

```python
transformers.Qwen2_5OmniToken2WavModel(config: Qwen2_5OmniToken2WavConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3646)

**Parâmetros:**

config ([Qwen2_5OmniToken2WavConfig](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniToken2WavConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo 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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.Qwen2_5OmniToken2WavModel.forward]]

```python
forward(code, conditioning, reference_mel, num_steps = 10, guidance_scale = 0.5, sway_coefficient = -1.0, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3675)

Gera uma forma de onda a partir do código de entrada e dos parâmetros de condicionamento.

## Qwen2_5OmniToken2WavDiTModel[[transformers.Qwen2_5OmniToken2WavDiTModel]]

#### transformers.Qwen2_5OmniToken2WavDiTModel[[transformers.Qwen2_5OmniToken2WavDiTModel]]

```python
transformers.Qwen2_5OmniToken2WavDiTModel(config: Qwen2_5OmniDiTConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3475)

**Parâmetros:**

config ([Qwen2_5OmniDiTConfig](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniDiTConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo completo Qwen2.5Omni Token2WavDiT. Ele recebe tokens de fala como entrada e prevê o espectrograma mel.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

## Qwen2_5OmniToken2WavBigVGANModel[[transformers.Qwen2_5OmniToken2WavBigVGANModel]]

#### transformers.Qwen2_5OmniToken2WavBigVGANModel[[transformers.Qwen2_5OmniToken2WavBigVGANModel]]

```python
transformers.Qwen2_5OmniToken2WavBigVGANModel(config: Qwen2_5OmniBigVGANConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_5_omni/modeling_qwen2_5_omni.py#L3337)

**Parâmetros:**

config ([Qwen2_5OmniBigVGANConfig](/docs/transformers/main/pt/model_doc/qwen2_5_omni#transformers.Qwen2_5OmniBigVGANConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo completo Qwen2.5Omni Token2WavBigVGAN. Ele recebe o espectrograma mel como entrada e prevê a forma de onda.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.