# Geração Multimodal

Multimodal Modelos (any-to-any) são modelos de linguagem capazes de processar diversos tipos de dados de entrada (por exemplo, texto, imagens, áudio ou vídeo) e gerar saídas em qualquer uma dessas modalidades. Diferentemente dos modelos unimodais ou de modalidade fixa tradicionais, eles permitem combinações flexíveis de entrada e saída, habilitando um único sistema a lidar com uma ampla variedade de tarefas: desde a geração de texto para imagem até a transcrição de áudio para texto, a legendação de imagens, a compreensão de vídeo, entre outras. Esta tarefa compartilha muitas semelhanças com a tarefa de imagem-texto-para-texto, mas suporta uma gama mais ampla de modalidades de entrada e saída.

Neste guia, fornecemos uma visão geral dos modelos any-to-any e mostramos como usá-los com o Transformers para inferência. Diferentemente dos Vision LLMs, que geralmente são limitados a tarefas de visão e linguagem, os modelos omni-modais podem aceitar qualquer combinação de modalidades (por exemplo, texto, imagens, áudio, vídeo) como entrada e gerar saídas em diferentes modalidades, como texto ou imagens.

Vamos começar instalando as dependências:

```bash
pip install -q transformers accelerate flash_attn
```

Vamos inicializar o modelo e o processador.

```python
from transformers import AutoProcessor, AutoModelForMultimodalLM, infer_device
import torch

device = torch.device(infer_device())
model = AutoModelForMultimodalLM.from_pretrained(
    "Qwen/Qwen2.5-Omni-3B",
    dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
).to(device)

processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-Omni-3B")
```

Esses modelos geralmente incluem um [chat template](../chat_templating) para estruturar conversas entre modalidades. As entradas podem misturar imagens, texto, áudio ou outros formatos suportados em uma única interação. As saídas também podem variar (por exemplo, geração de texto ou geração de áudio), dependendo da configuração.

Abaixo está um exemplo que fornece uma entrada de "texto + áudio" e solicita uma resposta em texto.

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "url": "https://huggingface.co/datasets/raushan-testing-hf/audio-test/resolve/main/f2641_0_throatclearing.wav"},
            {"type": "text", "text": "What do you hear in this audio?"},
        ]
    },
]
```

Agora, chamaremos o método [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) dos processadores para pré-processar sua saída junto com as entradas de imagem.

```python
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
)
```

Agora podemos passar as entradas pré-processadas para o modelo.

```python
with torch.no_grad():
    generated_ids = model.generate(**inputs, max_new_tokens=100)
generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
print(generated_texts)
```

## Pipeline

A maneira mais rápida de começar é usar a API [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline). Especifique a tarefa `"any-to-any"` e o modelo que deseja usar.

```python
from transformers import pipeline
pipe = pipeline("any-to-any", model="mistralai/Voxtral-Mini-3B-2507")
```

O exemplo abaixo usa templates de chat para formatar as entradas de texto e utiliza a modalidade de áudio como dados multimodais.

```python
messages = [
     {
         "role": "user",
         "content": [
             {
                 "type": "audio",
                 "url": "https://huggingface.co/datasets/raushan-testing-hf/audio-test/resolve/main/glass-breaking-151256.mp3",
             },
             {"type": "text", "text": "What do you hear in this audio?"},
         ],
     },
 ]
```

Passe o texto formatado com o chat template e a imagem para o [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) e defina `return_full_text=False` para remover a entrada da saída gerada.

```python
outputs = pipe(text=messages, max_new_tokens=20, return_full_text=False)
outputs[0]["generated_text"]
```

O pipeline any-to-any também suporta a geração de áudio ou imagens com modelos any-to-any. Para isso, é necessário definir o parâmetro `generation_mode`. Não se esqueça de definir a amostragem de vídeo para o FPS desejado, caso contrário, o vídeo inteiro será carregado sem amostragem. Aqui está um exemplo de código:

```python
import soundfile as sf
pipe = pipeline("any-to-any", model="Qwen/Qwen2.5-Omni-3B")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "path": "https://huggingface.co/datasets/raushan-testing-hf/videos-test/resolve/main/Cooking_cake.mp4"},
            {"type": "text", "text": "Describe this video."},
        ],
    },
]
output = pipe(text=messages, fps=1, load_audio_from_video=True, max_new_tokens=20, generation_mode="audio")
sf.write("generated_audio.wav", out[0]["generated_audio"])
```