Transformers documentation

Vidéo-texte-vers-texte

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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, à 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 entrelacé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 « 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, 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é par instructions, llava-hf/llava-onevision-qwen2-0.5b-ov-hf, qui peut traiter des données entrelacées. Sinon, vous pouvez essayer 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.

pip install -q transformers accelerate flash_attn torchcodec

Initialisons le modèle et le processeur.

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().

Vous pouvez en savoir plus sur les processeurs vidéo ici.

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

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.

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.

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.

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.

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. ']
Update on GitHub