# Vídeo-texto-para-texto

Video-text-to-text, também conhecido como modelos de linguagem de vídeo, são modelos que podem processar vídeo e gerar texto como saída. Esses modelos podem lidar com diversas tarefas, desde a resposta a perguntas sobre vídeos até a criação de legendas para vídeos.

Esses modelos possuem uma arquitetura quase idêntica à dos modelos [imagem-texto-para-texto](./image_text_to_text), exceto por algumas alterações para aceitar dados de vídeo, já que os dados de vídeo são essencialmente quadros de imagem com dependências temporais. Alguns modelos de imagem-texto-para-texto aceitam múltiplas imagens, mas isso, por si só, é insuficiente para que um modelo aceite vídeos.

Além disso, os modelos de vídeo-texto-para-texto são frequentemente treinados com todas as modalidades visuais. Cada exemplo pode ter vídeos, múltiplos vídeos, imagens e múltiplas imagens. Alguns desses modelos também podem aceitar entradas intercaladas. Por exemplo, você pode se referir a um vídeo específico dentro de uma string de texto adicionando um token de vídeo no texto, como "What is happening in this video? `<video>`".

Observe que esses modelos processam vídeos sem áudio. Por outro lado, os modelos [Any-to-any](./any_to_any) podem processar vídeos com áudio.

Neste guia, fornecemos uma visão geral breve dos LMs de vídeo e mostramos como usá-los com o Transformers para inferência.

Para começar, existem vários tipos de LMs de vídeo:

- modelos base usados para ajuste fino
- modelos de chat ajustados finamente para conversação
- modelos ajustados finamente por instrução

Este guia foca na inferência com um modelo ajustado por instruções, [llava-hf/llava-onevision-qwen2-0.5b-ov-hf](https://huggingface.co/llava-hf/llava-interleave-qwen-7b-hf), que pode receber dados intercalados. Alternativamente, você pode tentar [llava-interleave-qwen-0.5b-hf](https://huggingface.co/llava-hf/llava-interleave-qwen-0.5b-hf) se o seu hardware não permitir a execução de um modelo de 7B.

Vamos começar instalando as dependências.

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

Vamos inicializar o modelo e o processador.

```python
from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration
import torch
model_id = "llava-hf/llava-onevision-qwen2-0.5b-ov-hf"

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
processor = AutoProcessor.from_pretrained(model_id, device=device)

model = LlavaForConditionalGeneration.from_pretrained(model_id, device_map="auto", dtype=torch.float16)
```

Vamos inferir com dois vídeos, ambos com gatos.

  
    
      
    
  

  
    
      
    
  

Vídeos são séries de quadros de imagem. Dependendo das limitações de hardware, é necessário realizar o downsampling. Se o número de quadros após o downsampling for muito baixo, as previsões terão baixa qualidade.

Os modelos de vídeo-para-texto possuem processadores com o processador de vídeo abstraído neles. Você pode passar argumentos relacionados à inferência de vídeo para a função [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template).

> [!WARNING]
> Você pode saber mais sobre processadores de vídeo [aqui](../main_classes/video_processor).

Podemos definir nosso histórico de chat, passando um vídeo com uma URL, como abaixo.

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "https://huggingface.co/spaces/merve/llava-interleave/resolve/main/cats_1.mp4"},
            {"type": "text", "text": "Describe what is happening in this video."},
        ],
    }
]
```

Você pode pré-processar os vídeos passando mensagens, definindo `do_sample_frames` como True e passando `num_frames`. Aqui, amostramos 10 quadros.

```python
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
    num_frames=10,
    do_sample_frames=True
)
inputs.to(model.device)
```

As entradas contêm `input_ids` para o texto tokenizado, `pixel_values_videos` para 10 quadros e `attention_mask` para os tokens.

Agora podemos inferir com as entradas pré-processadas e decodificá-las.

```python
generated_ids = model.generate(**inputs, max_new_tokens=128)
input_length = len(inputs["input_ids"][0])
output_text = processor.batch_decode(
    generated_ids[:, input_length:], skip_special_tokens=True, clean_up_tokenization_spaces=False
)
output_text = processor.batch_decode(
    generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text[0])

#"The video features a fluffy, long-haired cat with a mix of brown and white fur, lying on a beige carpeted floor. The cat's eyes are wide open, and its whiskers are prominently visible. The cat appears to be in a relaxed state, with its head slightly"
```

Você também pode intercalar vários vídeos com texto diretamente no modelo de chat, como mostrado abaixo.

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Here's a video."},
            {"type": "video", "video": "https://huggingface.co/spaces/merve/llava-interleave/resolve/main/cats_1.mp4"},
            {"type": "text", "text": "Here's another video."},
            {"type": "video", "video": "https://huggingface.co/spaces/merve/llava-interleave/resolve/main/cats_2.mp4"},
            {"type": "text", "text": "Describe similarities in these videos."},
        ],
    }
]
```

A inferência permanece a mesma do exemplo anterior.

```python
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
    num_frames=100,
    do_sample_frames=True
)
inputs.to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=50)
input_length = len(inputs["input_ids"][0])
output_text = processor.batch_decode(
    generated_ids[:, input_length:], skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)
#['Both videos feature a cat with a similar appearance, characterized by a fluffy white coat with black markings, a pink nose, and a pink tongue. The cat\'s eyes are wide open, and it appears to be in a state of alertness or excitement. ']
```