# Qwen3-Omni-MOE

## Visão geral

O modelo Qwen3-Omni-MOE é um modelo unificado de múltiplas modalidades proposto no [Qwen3-Omni Technical Report](https://huggingface.co/papers/2509.17765) pela equipe Qwen, do Alibaba Group.

O resumo do relatório técnico é o seguinte:

Apresentamos o Qwen3-Omni, um modelo multimodal único que, pela primeira vez, mantém desempenho de estado da arte em texto, imagem, áudio e vídeo, sem qualquer degradação em relação aos equivalentes unimodais. O Qwen3-Omni iguala o desempenho de modelos unimodais de mesmo tamanho dentro da série Qwen e se destaca particularmente em tarefas de áudio. Em 36 benchmarks de áudio e audiovisual, o Qwen3-Omni alcança SOTA de código aberto em 32 benchmarks e SOTA geral em 22, superando modelos de código fechado robustos, como Gemini-2.5-Pro, Seed-ASR e GPT-4o-Transcribe. O Qwen3-Omni adota uma arquitetura MoE Thinker-Talker que unifica percepção e geração em texto, imagens, áudio e vídeo, resultando em texto fluente e fala natural em tempo real. Ele suporta interação por texto em 119 idiomas, compreensão de fala em 19 idiomas e geração de fala em 10 idiomas. Para reduzir a latência do primeiro pacote na síntese em streaming, o Talker prevê autoregressivamente codecs de fala discretos usando um esquema multi-codebook. Aproveitando a capacidade representativa desses codebooks, substituímos a difusão por blocos, computacionalmente intensiva, por uma ConvNet causal leve, permitindo streaming a partir do primeiro frame de codec. Em configurações de cold-start, o Qwen3-Omni atinge uma latência teórica de ponta a ponta do primeiro pacote de 234 ms. Para fortalecer ainda mais o raciocínio multimodal, introduzimos um modelo Thinking que raciocina explicitamente sobre entradas de qualquer modalidade. Como a comunidade de pesquisa atualmente carece de um modelo de legendagem de áudio de uso geral, ajustamos finamente o Qwen3-Omni-30B-A3B para obter o Qwen3-Omni-30B-A3B-Captioner, que produz legendas detalhadas e com baixa alucinação para entradas de áudio arbitrárias. O Qwen3-Omni-30B-A3B, o Qwen3-Omni-30B-A3B-Thinking e o Qwen3-Omni-30B-A3B-Captioner são publicamente liberados sob a licença Apache 2.0.

## Observações

- Use [Qwen3OmniMoeForConditionalGeneration](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeForConditionalGeneration) para gerar saída de áudio e texto. Para gerar apenas um tipo de saída, use [Qwen3OmniMoeThinkerForConditionalGeneration](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeThinkerForConditionalGeneration) para saída apenas de texto e [Qwen3OmniMoeTalkerForConditionalGeneration](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerForConditionalGeneration) para saída apenas de á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/v5.23.0/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) para converter mensagens de chat em entradas do modelo.

## Exemplo de uso

`Qwen3-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 Qwen3OmniMoeForConditionalGeneration, Qwen3OmniMoeProcessor

model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    device_map="auto"
)
processor = Qwen3OmniMoeProcessor.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")

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 `Qwen3OmniMoeProcessor`
    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 `Qwen3OmniMoeThinkerForConditionalGeneration`.

```python
from transformers import Qwen3OmniMoeProcessor, Qwen3OmniMoeThinkerForConditionalGeneration

model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    device_map="auto",
)
processor = Qwen3OmniMoeProcessor.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")

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 `Qwen3OmniMoeProcessor`
    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 `Qwen3OmniMoeThinkerForConditionalGeneration`. Veja um exemplo.

```python
import soundfile as sf
from transformers import Qwen3OmniMoeForConditionalGeneration, Qwen3OmniMoeProcessor

model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    device_map="auto"
)
processor = Qwen3OmniMoeProcessor.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")

# 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 `Qwen3OmniMoeProcessor`
    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

[Qwen3OmniMoeForConditionalGeneration](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeForConditionalGeneration) 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/Qwen3-Omni-30B-A3B-Instruct"
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)
sampling_rate = 24000  # output sampling rate
max_new_tokens = 128  # 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? Just let me know!",
    "The weather is nice today.",
]
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"qwen3_omni_output_{sample_id}.wav", audio.detach().to(torch.float32).cpu().numpy(), sampling_rate)
    print(f"Saved audio to qwen3_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/Qwen3-Omni-30B-A3B-Instruct", 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.

```json
{
    "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 = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    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 = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    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 Qwen3-Omni-MOE 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/Qwen3-Omni-30B-A3B-Instruct"` 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 Qwen3OmniMoeForConditionalGeneration

model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-Omni-30B-A3B-Instruct",
    device_map="auto",
    attn_implementation="flash_attention_2",
)
```

## Qwen3OmniMoeConfig[[transformers.Qwen3OmniMoeConfig]]

#### transformers.Qwen3OmniMoeConfig[[transformers.Qwen3OmniMoeConfig]]

```python
transformers.Qwen3OmniMoeConfig(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, code2wav_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, enable_audio_output: bool = True, im_start_token_id: int = 151644, im_end_token_id: int = 151645, tts_pad_token_id: int = 151671, tts_bos_token_id: int = 151672, tts_eos_token_id: int = 151673, system_token_id: int = 8948, user_token_id: int = 872, assistant_token_id: int = 77091, initializer_range: float | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L539)

**Parâmetros:**

thinker_config (`dict`, *opcional*) : Configuração do submodelo thinker subjacente.

talker_config (`dict`, *opcional*) : Configuração do submodelo talker subjacente.

code2wav_config (`dict`, *opcional*) : Configuração do submodelo code2wav subjacente.

enable_audio_output (`bool`, *opcional*, padrão `True`) : Se habilita a saída de áudio e carrega os módulos talker e code2wav.

im_start_token_id (`int`, *opcional*, padrão 151644) : ID do token para o início da imagem

im_end_token_id (`int`, *opcional*, padrão 151645) : ID do token para o fim da imagem

tts_pad_token_id (`int`, *opcional*, padrão 151671) : ID do token para o preenchimento (padding) no TTS

tts_bos_token_id (`int`, *opcional*, padrão 151672) : ID do token para o início da sequência em TTS

tts_eos_token_id (`int`, *opcional*, padrão 151673) : ID do token para o fim da sequência no TTS de imagem

system_token_id (`int`, *opcional*, padrão 8948) : ID do token para o prompt do sistema

user_token_id (`int`, *opcional*, padrão 872) : ID do token para o prompt do usuário

assistant_token_id (`int`, *opcional*, padrão 77091) : ID do token para o prompt do assistente

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

Esta é a classe de configuração para armazenar a configuração de um Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import (
...     Qwen3OmniMoeThinkerConfig,
...     Qwen3OmniMoeTalkerConfig,
...     Qwen3OmniMoeCode2WavConfig,
...     Qwen3OmniMoeForConditionalGeneration,
...     Qwen3OmniMoeConfig,
... )

>>> # Initializing a Qwen3OmniMoe style configuration
>>> configuration = Qwen3OmniMoeConfig()

>>> # Initializing a model from the configuration
>>> model = Qwen3OmniMoeForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

#### get_text_config[[transformers.Qwen3OmniMoeConfig.get_text_config]]

```python
get_text_config(decoder = False)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L613)

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

## Qwen3OmniMoeThinkerConfig[[transformers.Qwen3OmniMoeThinkerConfig]]

#### transformers.Qwen3OmniMoeThinkerConfig[[transformers.Qwen3OmniMoeThinkerConfig]]

```python
transformers.Qwen3OmniMoeThinkerConfig(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, position_id_per_seconds: int = 25, audio_start_token_id: int = 151647, user_token_id: int = 872, initializer_range: float = 0.02, tie_word_embeddings: bool = False, audio_token_id: int = 151646, image_token_id: int = 151655, video_token_id: int = 151656)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L195)

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

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

audio_start_token_id (`int`, *opcional*, padrão 151647) : O ID do token de início de áudio para codificar o prompt de áudio.

user_token_id (`int`, *opcional*, padrão 872) : O id 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.

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

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

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

Esta é a classe de configuração para armazenar a configuração de um Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import Qwen3OmniMoeThinkerModel, Qwen3OmniMoeThinkerConfig

>>> # Initializing a default Qwen3OmniMoeThinkerConfig
>>> configuration = Qwen3OmniMoeThinkerConfig()

>>> # Initializing a model (with random weights) from the default configuration
>>> model = Qwen3OmniMoeThinkerModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen3OmniMoeTalkerConfig[[transformers.Qwen3OmniMoeTalkerConfig]]

#### transformers.Qwen3OmniMoeTalkerConfig[[transformers.Qwen3OmniMoeTalkerConfig]]

```python
transformers.Qwen3OmniMoeTalkerConfig(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, code_predictor_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_code_groups: int = 32, thinker_hidden_size: int = 2048, codec_eos_token_id: int = 4198, accept_hidden_layer: int = 18, codec_nothink_id: int = 4203, codec_think_bos_id: int = 4204, codec_think_eos_id: int = 4205, codec_pad_id: int = 4196, codec_bos_id: int = 4197, audio_token_id: int = 151646, image_token_id: int = 151655, video_token_id: int = 151656, vision_start_token_id: int = 151652, position_id_per_seconds: int = 25, audio_start_token_id: int = 151669, speaker_id: dict | None = None, initializer_range: float = 0.02, tie_word_embeddings: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L404)

**Parâmetros:**

code_predictor_config (`dict`, *opcional*) : Um dicionário de parâmetros de configuração usados para inicializar um [Qwen3OmniMoeTalkerCodePredictorConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerCodePredictorConfig). Se não for fornecido, os padrões serão usados.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto.

num_code_groups (`int`, *opcional*, padrão 32) : Número de grupos de codebook usados na sequência de tokens acústicos previstos, correspondendo à representação VQ de múltiplos codebooks.

thinker_hidden_size (`int`, *opcional*, padrão 2048) : Tamanho da dimensão oculta do módulo thinker usado para raciocínio intermediário ou planejamento latente antes da geração de áudio.

codec_eos_token_id (`int`, *opcional*, padrão 4198) : ID do token que representa o token de fim de fala na sequência gerada pelo codec.

accept_hidden_layer (`int`, *opcional*, padrão 18) : Índice da camada oculta cuja saída é usada para aceitar ou refinar tokens gerados durante o processo de think-and-speak.

codec_nothink_id (`int`, *opcional*, padrão 4203) : ID do token que indica que nenhuma etapa de raciocínio é necessária durante a geração.

codec_think_bos_id (`int`, *opcional*, padrão 4204) : ID do token que marca o início de uma sequência de raciocínio.

codec_think_eos_id (`int`, *opcional*, padrão 4205) : ID do token que marca o fim de uma sequência de raciocínio.

codec_pad_id (`int`, *opcional*, padrão 4196) : ID do token de padding usado nas sequências de entrada do codec.

codec_bos_id (`int`, *opcional*, padrão 4197) : ID do token de início de fala em sequências de codec.

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

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

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

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.

position_id_per_seconds (`int`, *opcional*, padrão 25) : Número de IDs de posição alocados por segundo de conteúdo de áudio, usado para alinhamento temporal na geração.

audio_start_token_id (`int`, *opcional*, padrão 151669) : ID do token que indica o início de um segmento de geração de áudio na saída.

speaker_id (`dict`, *opcional*) : Dicionário de nome do falante para id do falante.

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 Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import Qwen3OmniMoeTalkerConfig, Qwen3OmniMoeTalker

>>> # Initialize a Qwen3OmniMoeTalkerConfig with default sub-configurations
>>> config = Qwen3OmniMoeTalkerConfig(
...     num_code_groups=32,
...     thinker_hidden_size=2048,
... )

>>> # Initialize the full Qwen3-Omni Talker model
>>> model = Qwen3OmniMoeTalker(config)

>>> # Access the model configuration
>>> config = model.config
>>> print(config.text_config)  # Access text decoder configuration
>>> print(config.code_predictor_config)  # Access code predictor configuration
```

## Qwen3OmniMoeTextConfig[[transformers.Qwen3OmniMoeTextConfig]]

#### transformers.Qwen3OmniMoeTextConfig[[transformers.Qwen3OmniMoeTextConfig]]

```python
transformers.Qwen3OmniMoeTextConfig(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 = 3584, hidden_size: int = 2048, 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, 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, attention_bias: bool = False, sliding_window: int | None = None, attention_dropout: float | int = 0.0, decoder_sparse_step: int = 1, moe_intermediate_size: int = 768, num_experts_per_tok: int = 8, num_experts: int = 128, norm_topk_prob: bool = True, output_router_logits: bool = False, router_aux_loss_coef: float = 0.001, mlp_only_layers: list[int] | None = None, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L109)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `3584`) : 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 `2048`) : 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.

attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.

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

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

decoder_sparse_step (`int`, *opcional*, padrão 1) : A frequência da camada MoE.

moe_intermediate_size (`int`, *opcional*, padrão `768`) : Tamanho intermediário dos MLPs dos especialistas roteados.

num_experts_per_tok (`int`, *opcional*, padrão `8`) : Número de especialistas para os quais cada token deve ser roteado. Este é o valor top-k para o roteamento por escolha de token.

num_experts (`int`, *opcional*, padrão `128`) : Número de especialistas roteados nas camadas MoE.

norm_topk_prob (`bool`, *opcional*, padrão `True`) : Se as pesos dos especialistas roteados devem ser normalizados.

output_router_logits (`bool`, *opcional*, padrão `False`) : Indica se os logits do roteador devem ser retornados pelo modelo. Ativar essa opção também permite que o modelo outpute a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador.

router_aux_loss_coef (`float`, *opcional*, padrão `0.001`) : Coeficiente da perda auxiliar de balanceamento de carga. Usado para penalizar o roteamento desigual de especialistas em modelos MoE.

mlp_only_layers (`list[int]`, *opcional*, padrão `[]`) : Indica quais camadas usam Qwen3OmniMoeTextMLP em vez de Qwen3OmniMoeTextSparseMoeBlock A lista contém o índice da camada, de 0 a num_layers-1, se houver num_layers camadas Se `mlp_only_layers` estiver vazio, `decoder_sparse_step` é usado para determinar a esparsidade.

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.

Esta é a classe de configuração para armazenar a configuração de um Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

```python
>>> from transformers import Qwen3OmniMoeTextModel, Qwen3OmniMoeTextConfig

>>> # Initializing a Qwen3OmniMoeText style configuration
>>> configuration = Qwen3OmniMoeTextConfig()

>>> # Initializing a model from the Qwen3-15B-A2B" style configuration
>>> model = Qwen3OmniMoeTextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen3OmniMoeVisionEncoderConfig[[transformers.Qwen3OmniMoeVisionEncoderConfig]]

#### transformers.Qwen3OmniMoeVisionEncoderConfig[[transformers.Qwen3OmniMoeVisionEncoderConfig]]

```python
transformers.Qwen3OmniMoeVisionEncoderConfig(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 = 27, hidden_size: int = 1152, hidden_act: str = 'gelu_pytorch_tanh', intermediate_size: int = 4304, num_heads: int = 16, in_channels: int = 3, patch_size: int | list[int] | tuple[int, int] = 16, spatial_merge_size: int = 2, temporal_patch_size: int | list[int] | tuple[int, int] = 2, out_hidden_size: int = 3584, num_position_embeddings: int = 2304, deepstack_visual_indexes: list[int] | tuple[int, ...] = (8, 16, 24), initializer_range: float = 0.02, rope_parameters: dict | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L76)

**Parâmetros:**

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

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

hidden_act (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : 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 `4304`) : 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 `16`) : 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.

out_hidden_size (`int`, *opcional*, padrão 3584) : O tamanho oculto de saída do modelo de visão.

num_position_embeddings (`int`, *opcional*, padrão 2304) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado

deepstack_visual_indexes (`list[int]`, *opcional*, padrão `[8, 16, 24]`) : Índice das camadas para embeddings deepstack.

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 Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Qwen3OmniMoeAudioEncoderConfig[[transformers.Qwen3OmniMoeAudioEncoderConfig]]

#### transformers.Qwen3OmniMoeAudioEncoderConfig[[transformers.Qwen3OmniMoeAudioEncoderConfig]]

```python
transformers.Qwen3OmniMoeAudioEncoderConfig(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 = 50, output_dim: int = 3584, n_window_infer: int = 800, conv_chunksize: int = 500, downsample_hidden_size: int = 480)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L30)

**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) : Comprimento máximo da sequência para as entradas

n_window (`int`, *opcional*, padrão 50) : Número de janelas

output_dim (`int`, *opcional*, padrão 3584) : Dimensionalidade da saída

n_window_infer (`int`, *opcional*, padrão `800`) : Número de janelas durante a inferência

conv_chunksize (`int`, *opcional*, padrão `500`) : Tamanho do bloco de cada entrada para a camada convolucional

downsample_hidden_size (`int`, *opcional*, padrão `480`) : Tamanho oculto na camada de downsampling

Esta é a classe de configuração para armazenar a configuração de um Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Qwen3OmniMoeTalkerTextConfig[[transformers.Qwen3OmniMoeTalkerTextConfig]]

#### transformers.Qwen3OmniMoeTalkerTextConfig[[transformers.Qwen3OmniMoeTalkerTextConfig]]

```python
transformers.Qwen3OmniMoeTalkerTextConfig(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 = 3072, hidden_size: int = 1024, intermediate_size: int = 2048, num_hidden_layers: int = 20, num_attention_heads: int = 16, num_key_value_heads: int = 2, hidden_act: str = 'silu', max_position_embeddings: int = 32768, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, sliding_window: int | None = None, attention_dropout: float | int = 0.0, decoder_sparse_step: int = 1, moe_intermediate_size: int = 384, num_experts_per_tok: int = 8, num_experts: int = 128, norm_topk_prob: bool = False, output_router_logits: bool = False, router_aux_loss_coef: float = 0.001, mlp_only_layers: list[int] | None = None, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L312)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `3072`) : 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 `1024`) : Dimensão das representações ocultas.

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

num_hidden_layers (`int`, *opcional*, padrão `20`) : 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.

num_key_value_heads (`int`, *opcional*, padrão `2`) : 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.

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.

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.

attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.

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

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

decoder_sparse_step (`int`, *opcional*, padrão 1) : A frequência da camada MoE.

moe_intermediate_size (`int`, *opcional*, padrão `384`) : Tamanho intermediário dos MLPs dos especialistas roteados.

num_experts_per_tok (`int`, *opcional*, padrão `8`) : Número de especialistas para os quais cada token deve ser roteado. Este é o valor top-k para o roteamento por escolha de token.

num_experts (`int`, *opcional*, padrão `128`) : Número de especialistas roteados nas camadas MoE.

norm_topk_prob (`bool`, *opcional*, padrão `False`) : Se as pesos dos especialistas roteados devem ser normalizados.

output_router_logits (`bool`, *opcional*, padrão `False`) : Indica se os logits do roteador devem ser retornados pelo modelo. Ativar essa opção também permite que o modelo outpute a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador.

router_aux_loss_coef (`float`, *opcional*, padrão `0.001`) : Coeficiente da perda auxiliar de balanceamento de carga. Usado para penalizar o roteamento desigual de especialistas em modelos MoE.

mlp_only_layers (`list[int]`, *opcional*, padrão `[]`) : Indica quais camadas usam Qwen3OmniMoeTalkerTextMLP em vez de Qwen3OmniMoeTalkerTextSparseMoeBlock A lista contém o índice da camada, de 0 a num_layers-1, se houver num_layers camadas. Se `mlp_only_layers` estiver vazio, `decoder_sparse_step` é usado para determinar a esparsidade.

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.

Esta é a classe de configuração para armazenar a configuração de um Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

```python
>>> from transformers import Qwen3OmniMoeTalkerTextModel, Qwen3OmniMoeTalkerTextConfig

>>> # Initializing a Qwen3OmniMoeTalkerText style configuration
>>> configuration = Qwen3OmniMoeTalkerTextConfig()

>>> # Initializing a model from the Qwen3-15B-A2B" style configuration
>>> model = Qwen3OmniMoeTalkerTextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Qwen3OmniMoeTalkerCodePredictorConfig[[transformers.Qwen3OmniMoeTalkerCodePredictorConfig]]

#### transformers.Qwen3OmniMoeTalkerCodePredictorConfig[[transformers.Qwen3OmniMoeTalkerCodePredictorConfig]]

```python
transformers.Qwen3OmniMoeTalkerCodePredictorConfig(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 = 2048, hidden_size: int = 1024, intermediate_size: int = 3072, num_hidden_layers: int = 5, num_attention_heads: int = 16, num_key_value_heads: int = 8, head_dim: int = 128, hidden_act: str = 'silu', max_position_embeddings: int = 32768, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, sliding_window: int | None = None, 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, num_code_groups: int = 32)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/configuration_qwen3_omni_moe.py#L244)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `2048`) : 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 `1024`) : Dimensão das representações ocultas.

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

num_hidden_layers (`int`, *opcional*, padrão `5`) : 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.

num_key_value_heads (`int`, *opcional*, padrão `8`) : 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`.

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

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.

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.

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.

attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.

sliding_window (`int`, *opcional*) : 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.

num_code_groups (`int`, *opcional*, padrão 32) : Número de grupos de codebook usados na sequência de tokens acústicos previstos, correspondendo à representação VQ de múltiplos codebooks.

Esta é a classe de configuração para armazenar a configuração de um Qwen3 Omni MoeModel. Ela é usada para instanciar um modelo Qwen3 Omni Moe 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/Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Qwen3OmniMoeForConditionalGeneration[[transformers.Qwen3OmniMoeForConditionalGeneration]]

#### transformers.Qwen3OmniMoeForConditionalGeneration[[transformers.Qwen3OmniMoeForConditionalGeneration]]

```python
transformers.Qwen3OmniMoeForConditionalGeneration(config: Qwen3OmniMoeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L3950)

## Qwen3OmniMoeThinkerTextModel[[transformers.Qwen3OmniMoeThinkerTextModel]]

#### transformers.Qwen3OmniMoeThinkerTextModel[[transformers.Qwen3OmniMoeThinkerTextModel]]

```python
transformers.Qwen3OmniMoeThinkerTextModel(config: Qwen3OmniMoeTextConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L1623)

**Parâmetros:**

config ([Qwen3OmniMoeTextConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTextConfig)) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Parte textual do Qwen3OmniMoeThinker, não sendo um modelo puramente de texto, pois o DeepStack integra recursos visuais nos estados ocultos iniciais.

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Qwen3OmniMoeThinkerTextModel.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, visual_pos_masks: typing.Optional[torch.Tensor] = None, deepstack_visual_embeds: list[torch.Tensor] | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L1648)

**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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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/v5.23.0/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/v5.23.0/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`).

visual_pos_masks (`torch.Tensor` de forma `(batch_size, seqlen)`, *opcional*) : A máscara das posições visuais.

deepstack_visual_embeds (`list[torch.Tensor]`, *opcional*) : Os embeddings visuais deepstack. A forma é (num_layers, visual_seqlen, embed_dim). O recurso é extraído das diferentes camadas do codificador visual e alimentado nos estados ocultos do decodificador. Ele vem do paper DeepStack(https://arxiv.org/abs/2406.04334).

**Retorna:** `MoeModelOutputWithPast` ou `tuple(torch.Tensor)`

Um `MoeModelOutputWithPast` 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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward do [Qwen3OmniMoeThinkerTextModel](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeThinkerTextModel) 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.
- **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/v5.23.0/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.
- **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_probs=True` e `config.add_router_probs=True` são passados ou quando `config.output_router_probs=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, sequence_length, num_experts)`.

  Logits brutos do roteador (pós-softmax) calculados pelos roteadores de MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts.

## Qwen3OmniMoeThinkerModel[[transformers.Qwen3OmniMoeThinkerModel]]

#### transformers.Qwen3OmniMoeThinkerModel[[transformers.Qwen3OmniMoeThinkerModel]]

```python
transformers.Qwen3OmniMoeThinkerModel(config: Qwen3OmniMoeThinkerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L1752)

**Parâmetros:**

config ([Qwen3OmniMoeThinkerConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeThinkerConfig)) : 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/v5.23.0/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/v5.23.0/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.Qwen3OmniMoeThinkerModel.forward]]

```python
forward(input_ids = None, input_features = None, pixel_values = None, pixel_values_videos = None, image_grid_thw = None, video_grid_thw = None, attention_mask = None, feature_attention_mask = None, audio_feature_lengths = None, position_ids = None, past_key_values = None, inputs_embeds = None, use_cache = None, output_router_logits: bool | None = None, use_audio_in_video = None, video_second_per_grid = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L1935)

**Parâmetros:**

input_ids (`` of shape `(batch_size, sequence_length)`) : Í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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

input_features (`` of shape `(batch_size, sequence_length, feature_dim)`) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [WhisperFeatureExtractor](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor). Veja [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para detalhes ([Qwen3OmniMoeProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeProcessor) usa [WhisperFeatureExtractor](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) para processar áudios).

pixel_values (`` of shape `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Veja [Qwen2VLImageProcessor.__call__()](/docs/transformers/v5.23.0/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Qwen3OmniMoeProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeProcessor) usa [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) para processar imagens).

pixel_values_videos (`` of shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Veja [Qwen2VLVideoProcessor.__call__()](/docs/transformers/v5.23.0/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Qwen3OmniMoeProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeProcessor) usa [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) para processar vídeos).

image_grid_thw (`` of shape `(num_images, 3)`) : O temporal, a altura e a largura da forma dos recursos de cada imagem no LLM.

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

attention_mask (`` of shape `(batch_size, sequence_length)`) : Mask to avoid performing attention on padding token indices. Mask values selected in `[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 (`` of shape `(batch_size, sequence_length)`) : Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (``) : Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.  Only [Cache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.Cache) instance is allowed as input, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache). If no `past_key_values` are passed, [DynamicCache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.DynamicCache) will be initialized by default.  The model will output the same cache format that is fed as input.  If `past_key_values` are used, the user is expected to input only unprocessed `input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, unprocessed_length)` instead of all `input_ids` of shape `(batch_size, sequence_length)`.

inputs_embeds (`` of shape `(batch_size, sequence_length, hidden_size)`) : Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model's internal embedding lookup matrix.

use_cache (``) : If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`).

output_router_logits (`bool`, *opcional*) : Indica se os logits de todos os roteadores devem ser retornados. Eles são úteis para calcular a perda do roteador e não devem ser retornados durante a inferência.

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:** `MoeModelOutputWithPast` ou `tuple(torch.Tensor)`

Um `MoeModelOutputWithPast` 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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward do [Qwen3OmniMoeThinkerModel](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeThinkerModel) 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.
- **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/v5.23.0/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.
- **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_probs=True` e `config.add_router_probs=True` são passados ou quando `config.output_router_probs=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, sequence_length, num_experts)`.

  Logits brutos do roteador (pós-softmax) calculados pelos roteadores de MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts.

## Qwen3OmniMoeThinkerForConditionalGeneration[[transformers.Qwen3OmniMoeThinkerForConditionalGeneration]]

#### transformers.Qwen3OmniMoeThinkerForConditionalGeneration[[transformers.Qwen3OmniMoeThinkerForConditionalGeneration]]

```python
transformers.Qwen3OmniMoeThinkerForConditionalGeneration(config: Qwen3OmniMoeThinkerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2161)

#### forward[[transformers.Qwen3OmniMoeThinkerForConditionalGeneration.forward]]

```python
forward(input_ids = None, input_features = None, pixel_values = None, pixel_values_videos = None, image_grid_thw = None, video_grid_thw = None, attention_mask = None, feature_attention_mask = None, audio_feature_lengths = None, position_ids = None, past_key_values = None, inputs_embeds = None, labels = None, use_cache = None, output_router_logits: bool | None = None, use_audio_in_video = None, video_second_per_grid = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2224)

**Parâmetros:**

input_ids (`` of shape `(batch_size, sequence_length)`) : Í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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

input_features (`` of shape `(batch_size, sequence_length, feature_dim)`) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [WhisperFeatureExtractor](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor). Veja [WhisperFeatureExtractor.__call__()](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) para detalhes ([Qwen3OmniMoeProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeProcessor) usa [WhisperFeatureExtractor](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) para processar áudios).

pixel_values (`` of shape `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Veja [Qwen2VLImageProcessor.__call__()](/docs/transformers/v5.23.0/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Qwen3OmniMoeProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeProcessor) usa [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor) para processar imagens).

pixel_values_videos (`` of shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Veja [Qwen2VLVideoProcessor.__call__()](/docs/transformers/v5.23.0/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Qwen3OmniMoeProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeProcessor) usa [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) para processar vídeos).

image_grid_thw (`` of shape `(num_images, 3)`) : O temporal, a altura e a largura da forma dos recursos de cada imagem no LLM.

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

attention_mask (`` of shape `(batch_size, sequence_length)`) : Mask to avoid performing attention on padding token indices. Mask values selected in `[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 (`` of shape `(batch_size, sequence_length)`) : Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (``) : Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.  Only [Cache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.Cache) instance is allowed as input, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache). If no `past_key_values` are passed, [DynamicCache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.DynamicCache) will be initialized by default.  The model will output the same cache format that is fed as input.  If `past_key_values` are used, the user is expected to input only unprocessed `input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, unprocessed_length)` instead of all `input_ids` of shape `(batch_size, sequence_length)`.

inputs_embeds (`` of shape `(batch_size, sequence_length, hidden_size)`) : Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model's internal embedding lookup matrix.

labels (`` of shape `(batch_size, sequence_length)`) : Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]

use_cache (``) : If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`).

output_router_logits (`bool`, *opcional*) : Indica se os logits de todos os roteadores devem ser retornados. Eles são úteis para calcular a perda do roteador e não devem ser retornados durante a inferência.

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:** `MoeCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Um `MoeCausalLMOutputWithPast` 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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward de [Qwen3OmniMoeThinkerForConditionalGeneration](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeThinkerForConditionalGeneration) 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).
- **aux_loss** (`torch.Tensor`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.output_router_logits=True`, e o modelo treina seu roteador com uma perda de balanceamento de carga) -- Perda auxiliar de balanceamento de carga para os módulos esparsos. Modelos que equilibram seus especialistas com um viés de roteador em vez disso (DeepSeek-V3 e as arquiteturas derivadas dele) retornam `None` aqui, mas ainda retornam `router_logits`.
- **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.output_router_logits=True`) -- Tupla de `torch.Tensor` (um para cada camada esparsa) com forma `(batch_size * sequence_length, num_experts)`.

  Logits brutos do roteador calculados pelos roteadores MoE. Podem ser usados para calcular uma perda de balanceamento de carga ou para inspecionar como os tokens são distribuídos entre os especialistas.
- **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/v5.23.0/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 Qwen3OmniMoeProcessor, Qwen3OmniMoeThinkerForConditionalGeneration

>>> thinker = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-Omni-7B")
>>> processor = Qwen3OmniMoeProcessor.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.Qwen3OmniMoeThinkerForConditionalGeneration.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/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2206)

**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/v5.23.0/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) 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, Qwen3OmniMoeThinkerForConditionalGeneration

>>> model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")

>>> 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.Qwen3OmniMoeThinkerForConditionalGeneration.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/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2193)

**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:** `BaseModelOutputWithDeepstackFeatures` ou `tuple(torch.Tensor)`

Um `BaseModelOutputWithDeepstackFeatures` 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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) 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.
- **deepstack_features** (`List[torch.Tensor]`, *opcional*) -- Lista de hidden-states (feature maps) das camadas deepstack.

Exemplo:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen3OmniMoeThinkerForConditionalGeneration

>>> model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")

>>> 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.Qwen3OmniMoeThinkerForConditionalGeneration.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/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2180)

**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:** `BaseModelOutputWithDeepstackFeatures` ou `tuple(torch.Tensor)`

Um `BaseModelOutputWithDeepstackFeatures` 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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) 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.
- **deepstack_features** (`List[torch.Tensor]`, *opcional*) -- Lista de hidden-states (feature maps) das camadas deepstack.

Exemplo:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, Qwen3OmniMoeThinkerForConditionalGeneration

>>> model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")
>>> processor = AutoProcessor.from_pretrained("Qwen/Qwen3-Omni-30B-A3B-Instruct")

>>> 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]
```

## Qwen3OmniMoeTalkerForConditionalGeneration[[transformers.Qwen3OmniMoeTalkerForConditionalGeneration]]

#### transformers.Qwen3OmniMoeTalkerForConditionalGeneration[[transformers.Qwen3OmniMoeTalkerForConditionalGeneration]]

```python
transformers.Qwen3OmniMoeTalkerForConditionalGeneration(config: Qwen3OmniMoeTalkerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L3086)

**Parâmetros:**

config ([Qwen3OmniMoeTalkerConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerConfig)) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O Modelo Qwen3 Omni Moe para geração de tokens condicionada a outras modalidades (por exemplo, geração de texto a partir de imagem e texto).

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Qwen3OmniMoeTalkerForConditionalGeneration.forward]]

```python
forward(input_ids = None, attention_mask = None, use_audio_in_video = None, audio_feature_lengths = None, video_second_per_grid = None, image_grid_thw = None, video_grid_thw = None, position_ids = None, past_key_values = None, inputs_embeds = None, labels = None, use_cache = None, output_router_logits = None, residual_codes = None, trailing_text_hidden = None, tts_pad_embed = None, generation_step = None, talker_input_ids = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L3118)

**Parâmetros:**

input_ids (`` of shape `(batch_size, sequence_length)`) : Í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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`` of shape `(batch_size, sequence_length)`) : Mask to avoid performing attention on padding token indices. Mask values selected in `[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)

use_audio_in_video (`bool`, *opcional*) : Se definido como `True`, usa o áudio do vídeo.

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.

image_grid_thw (`` of shape `(num_images, 3)`) : O temporal, a altura e a largura da forma dos recursos de cada imagem no LLM.

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

position_ids (`` of shape `(batch_size, sequence_length)`) : Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (``) : Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.  Only [Cache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.Cache) instance is allowed as input, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache). If no `past_key_values` are passed, [DynamicCache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.DynamicCache) will be initialized by default.  The model will output the same cache format that is fed as input.  If `past_key_values` are used, the user is expected to input only unprocessed `input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, unprocessed_length)` instead of all `input_ids` of shape `(batch_size, sequence_length)`.

inputs_embeds (`` of shape `(batch_size, sequence_length, hidden_size)`) : Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model's internal embedding lookup matrix.

labels (`` of shape `(batch_size, sequence_length)`) : Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]

use_cache (``) : If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`).

output_router_logits (``) : Se deve ou não retornar os logits de todos os roteadores. Eles são úteis para calcular a perda do roteador e não devem ser retornados durante a inferência.

residual_codes (`torch.Tensor`) : Os códigos residuais previstos da etapa anterior.

trailing_text_hidden (`torch.Tensor`) : Estados ocultos de texto do thinker após o primeiro token.

tts_pad_embed (`torch.Tensor`) : Tensor de incorporação de `tts_pad_token_id`.

generation_step (`int`) : Etapa de geração desde o pré-preenchimento, usada para sincronizar com `trailing_text_hidden`.

talker_input_ids (`torch.Tensor`) : ids de entrada do thinker, usados para calcular o RoPE 3d.

**Retorna:** `MoeCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Um `MoeCausalLMOutputWithPast` 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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward de [Qwen3OmniMoeTalkerForConditionalGeneration](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerForConditionalGeneration) 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).
- **aux_loss** (`torch.Tensor`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.output_router_logits=True`, e o modelo treina seu roteador com uma perda de balanceamento de carga) -- Perda auxiliar de balanceamento de carga para os módulos esparsos. Modelos que equilibram seus especialistas com um viés de roteador em vez disso (DeepSeek-V3 e as arquiteturas derivadas dele) retornam `None` aqui, mas ainda retornam `router_logits`.
- **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.output_router_logits=True`) -- Tupla de `torch.Tensor` (um para cada camada esparsa) com forma `(batch_size * sequence_length, num_experts)`.

  Logits brutos do roteador calculados pelos roteadores MoE. Podem ser usados para calcular uma perda de balanceamento de carga ou para inspecionar como os tokens são distribuídos entre os especialistas.
- **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/v5.23.0/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.

## Qwen3OmniMoePreTrainedModel[[transformers.Qwen3OmniMoePreTrainedModel]]

#### transformers.Qwen3OmniMoePreTrainedModel[[transformers.Qwen3OmniMoePreTrainedModel]]

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L113)

**Parâmetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig)) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.

## Qwen3OmniMoePreTrainedModelForConditionalGeneration[[transformers.Qwen3OmniMoePreTrainedModelForConditionalGeneration]]

#### transformers.Qwen3OmniMoePreTrainedModelForConditionalGeneration[[transformers.Qwen3OmniMoePreTrainedModelForConditionalGeneration]]

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L159)

#### get_chunked_index[[transformers.Qwen3OmniMoePreTrainedModelForConditionalGeneration.get_chunked_index]]

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L182)

**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.Qwen3OmniMoePreTrainedModelForConditionalGeneration.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/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L219)

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

## Qwen3OmniMoeTalkerModel[[transformers.Qwen3OmniMoeTalkerModel]]

#### transformers.Qwen3OmniMoeTalkerModel[[transformers.Qwen3OmniMoeTalkerModel]]

```python
transformers.Qwen3OmniMoeTalkerModel(config: Qwen3OmniMoeTalkerTextConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2958)

**Parâmetros:**

config ([Qwen3OmniMoeTalkerTextConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerTextConfig)) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Parte textual do Qwen3OmniMoe, não um modelo puramente de texto, pois o DeepStack integra recursos visuais nos estados ocultos iniciais.

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Qwen3OmniMoeTalkerModel.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, visual_pos_masks: typing.Optional[torch.Tensor] = None, deepstack_visual_embeds: list[torch.Tensor] | None = None, **kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2983)

**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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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/v5.23.0/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/v5.23.0/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`).

visual_pos_masks (`torch.Tensor` de forma `(batch_size, seqlen)`, *opcional*) : A máscara das posições visuais.

deepstack_visual_embeds (`list[torch.Tensor]`, *opcional*) : Os embeddings visuais deepstack. A forma é (num_layers, visual_seqlen, embed_dim). O recurso é extraído das diferentes camadas do codificador visual e alimentado nos estados ocultos do decodificador. Ele vem do paper DeepStack(https://arxiv.org/abs/2406.04334).

**Retorna:** `MoeModelOutputWithPast` ou `tuple(torch.Tensor)`

Um `MoeModelOutputWithPast` 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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward do [Qwen3OmniMoeTalkerModel](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerModel) 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.
- **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/v5.23.0/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.
- **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_probs=True` e `config.add_router_probs=True` são passados ou quando `config.output_router_probs=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, sequence_length, num_experts)`.

  Logits brutos do roteador (pós-softmax) calculados pelos roteadores de MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts.

## Qwen3OmniMoeThinkerTextPreTrainedModel[[transformers.Qwen3OmniMoeThinkerTextPreTrainedModel]]

#### transformers.Qwen3OmniMoeThinkerTextPreTrainedModel[[transformers.Qwen3OmniMoeThinkerTextPreTrainedModel]]

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L1567)

**Parâmetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/pt/main_classes/configuration#transformers.PreTrainedConfig)) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.

## Qwen3OmniMoeProcessor[[transformers.Qwen3OmniMoeProcessor]]

#### transformers.Qwen3OmniMoeProcessor[[transformers.Qwen3OmniMoeProcessor]]

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

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/processing_qwen3_omni_moe.py#L128)

**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 Qwen3OmniMoeProcessor que encapsula um processador de imagem, um processador de vídeo, um extrator de características e um tokenizador em um único processador.

[Qwen3OmniMoeProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeProcessor) oferece todas as funcionalidades de [Qwen2VLImageProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor), [WhisperFeatureExtractor](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) e [Qwen2Tokenizer](/docs/transformers/v5.23.0/pt/model_doc/qwen2#transformers.Qwen2Tokenizer). Consulte [~Qwen2VLImageProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [~Qwen2VLVideoProcessor](/docs/transformers/v5.23.0/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor), [~WhisperFeatureExtractor](/docs/transformers/v5.23.0/pt/model_doc/whisper#transformers.WhisperFeatureExtractor) e [~Qwen2Tokenizer](/docs/transformers/v5.23.0/pt/model_doc/qwen2#transformers.Qwen2Tokenizer) para mais informações.

#### __call__[[transformers.Qwen3OmniMoeProcessor.__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'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.qwen3_omni_moe.processing_qwen3_omni_moe.Qwen3OmniMoeProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/processing_qwen3_omni_moe.py#L164)

**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, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.

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`) : Descontinuado, use `Qwen3OmniMoeProcessorKwargs.load_audio_from_video` em vez disso. 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.

load_audio_from_video (`bool`, *kwargs*, *opcional*, padrão `False`) : Descontinuado, use `Qwen3OmniMoeProcessorKwargs.load_audio_from_video` em vez disso. 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`) : Obsoleto, use `Qwen3OmniMoeProcessorKwargs.seconds_per_chunk` em vez disso. 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`) : Descontinuado, use `Qwen3OmniMoeProcessorKwargs.position_id_per_seconds` em vez disso. 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_mm_token_type_ids (`bool`, *kwargs*) : Se deve retornar ids de tipo de token multimodal indicando as posições dos tokens de espaço reservado multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Se deve retornar os deslocamentos de caracteres para cada placeholder multimodal e sua substituição.

load_audio_from_video (`bool`, *kwargs*) : Se deve carregar a trilha de áudio dos vídeos de entrada. Os tokens de áudio são intercalados com os tokens de vídeo, se o modelo suportar.

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 `13.0`) : 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 `load_audio_from_video=True`.

n_window (`int`, *kwargs*, *opcional*, padrão `50`) : O tamanho da janela do codificador de áudio. Isso deve corresponder a `n_window` na configuração do modelo.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/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/v5.23.0/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.

## Qwen3OmniMoeCode2Wav[[transformers.Qwen3OmniMoeCode2Wav]]

#### transformers.Qwen3OmniMoeCode2Wav[[transformers.Qwen3OmniMoeCode2Wav]]

```python
transformers.Qwen3OmniMoeCode2Wav(config: Qwen3OmniMoeCode2WavConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L3886)

## Qwen3OmniMoeCode2WavDecoderBlock[[transformers.Qwen3OmniMoeCode2WavDecoderBlock]]

#### transformers.Qwen3OmniMoeCode2WavDecoderBlock[[transformers.Qwen3OmniMoeCode2WavDecoderBlock]]

```python
transformers.Qwen3OmniMoeCode2WavDecoderBlock(config: Qwen3OmniMoeCode2WavConfig, layer_idx)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L3859)

## Qwen3OmniMoeCode2WavTransformerModel[[transformers.Qwen3OmniMoeCode2WavTransformerModel]]

#### transformers.Qwen3OmniMoeCode2WavTransformerModel[[transformers.Qwen3OmniMoeCode2WavTransformerModel]]

```python
transformers.Qwen3OmniMoeCode2WavTransformerModel(config: Qwen3OmniMoeCode2WavConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L3701)

**Parâmetros:**

config (`Qwen3OmniMoeCode2WavConfig`) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Qwen3 Omni Moe puro, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Qwen3OmniMoeCode2WavTransformerModel.forward]]

```python
forward(input_ids = None, attention_mask = None, position_ids = None, past_key_values = None, inputs_embeds = None, use_cache = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L3722)

**Parâmetros:**

input_ids (`` of shape `(batch_size, sequence_length)`) : Í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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`` of shape `(batch_size, sequence_length)`) : Mask to avoid performing attention on padding token indices. Mask values selected in `[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 (`` of shape `(batch_size, sequence_length)`) : Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (``) : Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.  Only [Cache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.Cache) instance is allowed as input, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache). If no `past_key_values` are passed, [DynamicCache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.DynamicCache) will be initialized by default.  The model will output the same cache format that is fed as input.  If `past_key_values` are used, the user is expected to input only unprocessed `input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, unprocessed_length)` instead of all `input_ids` of shape `(batch_size, sequence_length)`.

inputs_embeds (`` of shape `(batch_size, sequence_length, hidden_size)`) : Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model's internal embedding lookup matrix.

use_cache (``) : If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`).

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

Um [BaseModelOutputWithPast](/docs/transformers/v5.23.0/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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward do [Qwen3OmniMoeCode2WavTransformerModel](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeCode2WavTransformerModel) 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/v5.23.0/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.

## Qwen3OmniMoeTalkerCodePredictorModel[[transformers.Qwen3OmniMoeTalkerCodePredictorModel]]

#### transformers.Qwen3OmniMoeTalkerCodePredictorModel[[transformers.Qwen3OmniMoeTalkerCodePredictorModel]]

```python
transformers.Qwen3OmniMoeTalkerCodePredictorModel(config: Qwen3OmniMoeTalkerCodePredictorConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2614)

**Parâmetros:**

config ([Qwen3OmniMoeTalkerCodePredictorConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerCodePredictorConfig)) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Qwen3 Omni Moe puro, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Qwen3OmniMoeTalkerCodePredictorModel.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.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2643)

**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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/v5.23.0/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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward do [Qwen3OmniMoeTalkerCodePredictorModel](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerCodePredictorModel) 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/v5.23.0/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.

## Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration[[transformers.Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration]]

#### transformers.Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration[[transformers.Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration]]

```python
transformers.Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration(config: Qwen3OmniMoeTalkerCodePredictorConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2703)

**Parâmetros:**

config ([Qwen3OmniMoeTalkerCodePredictorConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerCodePredictorConfig)) : 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/v5.23.0/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O Modelo Qwen3 Omni Moe para geração de tokens condicionada a outras modalidades (por exemplo, geração de texto a partir de imagem e texto).

Este modelo herda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration.forward]]

```python
forward(input_ids = None, attention_mask = None, position_ids = None, past_key_values = None, inputs_embeds = None, labels = None, use_cache = None, generation_steps = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/qwen3_omni_moe/modeling_qwen3_omni_moe.py#L2726)

**Parâmetros:**

input_ids (`` of shape `(batch_size, sequence_length)`) : Í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/v5.23.0/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`` of shape `(batch_size, sequence_length)`) : Mask to avoid performing attention on padding token indices. Mask values selected in `[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 (`` of shape `(batch_size, sequence_length)`) : Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (``) : Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.  Only [Cache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.Cache) instance is allowed as input, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache). If no `past_key_values` are passed, [DynamicCache](/docs/transformers/v5.23.0/pt/internal/generation_utils#transformers.DynamicCache) will be initialized by default.  The model will output the same cache format that is fed as input.  If `past_key_values` are used, the user is expected to input only unprocessed `input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, unprocessed_length)` instead of all `input_ids` of shape `(batch_size, sequence_length)`.

inputs_embeds (`` of shape `(batch_size, sequence_length, hidden_size)`) : Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model's internal embedding lookup matrix.

labels (`` of shape `(batch_size, sequence_length)`) : Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]

use_cache (``) : If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`).

generation_steps (`int`) : etapa de geração do preditor de código, 0..num_code_groups-1

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

Um [CausalLMOutputWithPast](/docs/transformers/v5.23.0/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 ([Qwen3OmniMoeConfig](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeConfig)) e das entradas.

O método forward do [Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration](/docs/transformers/v5.23.0/pt/model_doc/qwen3_omni_moe#transformers.Qwen3OmniMoeTalkerCodePredictorModelForConditionalGeneration) 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/v5.23.0/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.

