# Vidéo-texte-vers-texte

Les modèles vidéo-texte-vers-texte, également appelés modèles de langage vidéo, sont des modèles capables de traiter des vidéos et de produire du texte. Ces modèles peuvent s’attaquer à diverses tâches, allant de la réponse à des questions sur des vidéos à la génération de légendes vidéo.

Ces modèles présentent une architecture quasi identique à celle des modèles [image-texte-vers-texte](./image_text_to_text), à l’exception de quelques modifications permettant d’accepter des données vidéo, car les données vidéo correspondent essentiellement à des images avec des dépendances temporelles. Certains modèles image-texte-vers-texte acceptent plusieurs images, mais cela seul est insuffisant pour qu’un modèle puisse accepter des vidéos.

De plus, les modèles vidéo-texte-vers-texte sont souvent entraînés avec toutes les modalités visuelles. Chaque exemple peut contenir des vidéos, plusieurs vidéos, des images et plusieurs images. Certains de ces modèles peuvent également accepter des entrées alternées. Par exemple, vous pouvez faire référence à une vidéo spécifique dans une chaîne de texte en ajoutant un jeton vidéo dans le texte, comme dans « Que se passe-t-il dans cette vidéo ? `<video>` ».

Notez que ces modèles traitent des vidéos sans audio. Les modèles [Any-to-any](./any_to_any), en revanche, peuvent traiter des vidéos avec de l’audio.

Dans ce guide, nous présentons un bref aperçu des LM vidéo et montrons comment les utiliser avec Transformers pour l'inférence.

Pour commencer, il existe plusieurs types de LM vidéo :

- modèles de base utilisés pour le fine-tuning
- Modèles de chat affinés pour la conversation
- modèles affinés par instruction

Ce guide se concentre sur l’inférence avec un modèle ajusté sur des instructions, [llava-hf/llava-onevision-qwen2-0.5b-ov-hf](https://huggingface.co/llava-hf/llava-interleave-qwen-7b-hf), qui peut traiter des données entrelacées. Vous pouvez également essayer [llava-interleave-qwen-0.5b-hf](https://huggingface.co/llava-hf/llava-interleave-qwen-0.5b-hf) si votre matériel ne permet pas d’exécuter un modèle de 7B.

Commençons par installer les dépendances.

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

Initialisons le modèle et le processeur.

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

Nous effectuerons l’inférence sur deux vidéos, toutes deux mettant en scène des chats.

  
    
      
    
  

  
    
      
    
  

Les vidéos sont des séries d'images. En fonction des limitations matérielles, un sous-échantillonnage est nécessaire. Si le nombre d'images sous-échantillonnées est trop faible, la qualité des prédictions sera médiocre.

Les modèles vidéo-texte-vers-texte disposent de processeurs dans lesquels le processeur vidéo est abstrait. Vous pouvez passer des arguments liés à l'inférence vidéo à la fonction [apply_chat_template()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.apply_chat_template).

> [!WARNING]
> Vous pouvez en savoir plus sur les processeurs vidéo [ici](../main_classes/video_processor).

Nous pouvons définir notre historique de chat en passant une vidéo avec une URL comme ci-dessous.

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

Vous pouvez prétraiter les vidéos en transmettant des messages, en définissant `do_sample_frames` sur True et en transmettant `num_frames`. Ici, nous échantillonnons 10 images.

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

Les entrées contiennent `input_ids` pour le texte tokenisé, `pixel_values_videos` pour 10 images et `attention_mask` pour les tokens.

Nous pouvons maintenant effectuer l'inférence avec nos entrées prétraitées et les décoder.

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

Vous pouvez également alterner plusieurs vidéos et du texte directement dans le modèle de chat, comme ci-dessous.

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

L'inférence reste identique à celle de l'exemple précédent.

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

