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, 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 sequência 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 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 se concentra na inferência com um modelo ajustado por instruções, llava-hf/llava-onevision-qwen2-0.5b-ov-hf, que pode receber dados intercalados. Alternativamente, você pode tentar llava-interleave-qwen-0.5b-hf se o seu hardware não permitir a execução de um modelo de 7B.

Vamos começar a instalar as dependências.

pip install -q transformers accelerate flash_attn torchcodec

Vamos inicializar o modelo e o processador.

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

Você pode saber mais sobre processadores de vídeo aqui.

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

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.

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.

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.

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.

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