Video-texto-a-texto

Los modelos de lenguaje de video, también conocidos como modelos de video-texto-a-texto, son modelos que pueden procesar video y generar texto como salida. Estos modelos pueden abordar diversas tareas, desde la respuesta a preguntas sobre videos hasta la generación de descripciones de videos.

Estos modelos tienen una arquitectura casi idéntica a la de los modelos de imagen y texto a texto, con algunas modificaciones para aceptar datos de video, ya que los datos de video son esencialmente fotogramas de imagen con dependencias temporales. Algunos modelos de imagen y texto a texto aceptan múltiples imágenes, pero esto por sí solo no es suficiente para que un modelo acepte videos.

Además, los modelos de video-texto a texto suelen entrenarse con todas las modalidades visuales. Cada ejemplo puede tener videos, múltiples videos, imágenes y múltiples imágenes. Algunos de estos modelos también pueden aceptar entradas intercaladas. Por ejemplo, puede hacer referencia a un video específico dentro de una cadena de texto añadiendo un token de video en el texto, como “¿Qué está pasando en este video? <video>”.

Tenga en cuenta que estos modelos procesan videos sin audio. Por otro lado, los modelos Any-to-any pueden procesar videos con audio.

En esta guía, ofrecemos una breve descripción general de los LMs de video y mostramos cómo usarlos con Transformers para inferencia.

Para empezar, existen varios tipos de LMs de video:

modelos base utilizados para el ajuste fino
modelos de chat afinados para conversación
modelos ajustados con instrucciones

Esta guía se centra en la inferencia con un modelo ajustado por instrucciones, llava-hf/llava-onevision-qwen2-0.5b-ov-hf, que puede aceptar datos intercalados. Alternativamente, puedes probar llava-interleave-qwen-0.5b-hf si tu hardware no permite ejecutar un modelo de 7B.

Comencemos instalando las dependencias.

pip install -q transformers accelerate flash_attn torchcodec

Iniciemos el modelo y el procesador.

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)

Inferiremos con dos videos, ambos con gatos.

Los videos son series de fotogramas de imagen. Dependiendo de las limitaciones del hardware, se requiere un submuestreo. Si el número de fotogramas submuestreados es demasiado bajo, las predicciones serán de baja calidad.

Los modelos de video-texto-a-texto tienen procesadores con un procesador de video abstraído en ellos. Puede pasar argumentos relacionados con la inferencia de video a la función apply_chat_template().

Puedes obtener más información sobre los procesadores de video aquí.

Podemos definir nuestro historial de chat, pasando un video con una URL como se muestra a continuación.

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

Puede preprocesar los videos pasando mensajes, estableciendo do_sample_frames en True y pasando num_frames. Aquí se muestrean 10 fotogramas.

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)

Las entradas contienen input_ids para el texto tokenizado, pixel_values_videos para 10 fotogramas y attention_mask para los tokens.

Ahora podemos realizar la inferencia con nuestras entradas preprocesadas y decodificarlas.

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"

También puede alternar varios videos con texto directamente en la plantilla de chat, como se muestra a continuación.

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

La inferencia permanece igual que en el ejemplo anterior.

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