# Generación multimodal

Multimodal Los modelos (de cualquier cosa a cualquier cosa) son modelos de lenguaje capaces de procesar diversos tipos de datos de entrada (p. ej., texto, imágenes, audio o video) y generar salidas en cualquiera de estas modalidades. A diferencia de los modelos unimodales o de modalidad fija tradicionales, permiten combinaciones flexibles de entrada y salida, lo que habilita a un solo sistema para manejar una amplia gama de tareas: desde la generación de texto a imagen hasta la transcripción de audio a texto, la descripción de imágenes, la comprensión de video, y así sucesivamente. Esta tarea comparte muchas similitudes con la de imagen-texto a texto, pero soporta un rango más amplio de modalidades de entrada y salida.

En esta guía, ofrecemos una breve descripción general de los modelos any-to-any y mostramos cómo usarlos con Transformers para inferencia. A diferencia de los Vision LLM, que suelen estar limitados a tareas de visión y lenguaje, los modelos omni-modal pueden aceptar cualquier combinación de modalidades (p. ej., texto, imágenes, audio, video) como entrada y generar salidas en diferentes modalidades, como texto o imágenes.

Comencemos instalando las dependencias:

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

Iniciemos el modelo y el procesador.

```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")
```

Estos modelos suelen incluir una [plantilla de chat](../chat_templating) para estructurar las conversaciones entre modalidades. Las entradas pueden combinar imágenes, texto, audio u otros formatos admitidos en un solo turno. Las salidas también pueden variar (p. ej., generación de texto o generación de audio), según la configuración.

A continuación se muestra un ejemplo que proporciona una entrada de "texto + audio" y solicita una respuesta de 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?"},
        ]
    },
]
```

Ahora llamaremos al método [apply_chat_template()](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) de los procesadores para preprocesar su salida junto con las entradas de imagen.

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

Ahora podemos pasar las entradas preprocesadas al 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

La forma más rápida de empezar es utilizar la API [Pipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.Pipeline). Especifique la tarea `"any-to-any"` y el modelo que desea utilizar.

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

El ejemplo siguiente utiliza plantillas de chat para formatear las entradas de texto y usa la modalidad de audio como un dato multimodal.

```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?"},
         ],
     },
 ]
```

Pasa el texto y la imagen con el formato de plantilla de chat a [Pipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.Pipeline) y establece `return_full_text=False` para eliminar la entrada de la salida generada.

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

El pipeline any-to-any también permite generar audio o imágenes con modelos any-to-any. Para ello, es necesario establecer el parámetro `generation_mode`. No olvides configurar el muestreo de video al FPS deseado, de lo contrario se cargará el video completo sin muestreo. A continuación se muestra un ejemplo 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"])
```

