Transformers documentation

Vídeo-texto-para-texto

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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