Transformers documentation

LLaVA-OneVision

Transformers

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo foi publicado em HF papers em 2024-08-06 e contribuído para Hugging Face Transformers em 2024-09-05.

LLaVA-OneVision

Visão geral

O modelo LLaVA-OneVision foi proposto em LLaVA-OneVision: Easy Visual Task Transfer por Bo Li, Yuanhan Zhang, Dong Guo, Renrui Zhang, Feng Li, Hao Zhang, Kaichen Zhang, Yanwei Li, Ziwei Liu, Chunyuan Li

LLaVA-OneVision é um Vision-Language Model capaz de gerar texto condicionado em uma ou várias imagens/vídeos. O modelo consiste em um codificador de visão SigLIP e um backbone de linguagem Qwen2. As imagens são processadas com a técnica anyres-9, na qual a imagem é dividida em 9 patches para processar melhor imagens de alta resolução e capturar o máximo de detalhes possível. No entanto, os vídeos são agregados para um comprimento total de sequência de 196 tokens por quadro, visando um cálculo mais eficiente em termos de memória. O LLaVA-OneVision está disponível em três tamanhos: 0.5B, 7B e 72B, e alcança desempenho notável em avaliações de benchmark.

O resumo do artigo é o seguinte:

Apresentamos o LLaVA-OneVision, uma família de grandes modelos multimodais abertos (LMMs) desenvolvida ao consolidar nossos insights sobre dados, modelos e representações visuais na série de blogs LLaVA-NeXT. Nossos resultados experimentais demonstram que o LLaVA-OneVision é o primeiro modelo único capaz de simultaneamente expandir os limites de desempenho dos LMMs abertos em três cenários importantes de visão computacional: imagens únicas, múltiplas imagens e vídeos. Importantly, o design do LLaVAOneVision permite um forte aprendizado de transferência entre diferentes modalidades/cenários, resultando em novas capacidades emergentes. Em particular, a forte compreensão de vídeo e as capacidades entre cenários são demonstradas por meio da transferência de tarefas de imagens para vídeos.

LLaVA-OneVision architecture. Taken from the original paper.

Dicas:

Recomendamos que os usuários utilizem padding_side="left" ao realizar a geração em lote, pois isso resulta em resultados mais precisos. Basta garantir que você chame processor.tokenizer.padding_side = "left" antes de gerar.

Llava-OneVision usa um número diferente de patches para imagens e, portanto, precisa fazer padding dos inputs dentro do código de modelagem, além do padding realizado ao processar os inputs. A configuração padrão é “left-padding” se o modelo estiver em modo eval(), caso contrário, “right-padding”.

Formatando prompts com modelos de chat

Cada checkpoint é treinado com um formato de prompt específico, dependendo do backbone do grande modelo de linguagem subjacente. Para garantir o formato correto, use o método apply_chat_template do processador.

Importante:

Você deve construir um histórico de conversa — passar uma string simples não funcionará.
Cada mensagem deve ser um dicionário com as chaves "role" e "content".
O "content" deve ser uma lista de dicionários para diferentes modalidades, como "text" e "image".

Aqui está um exemplo de como estruturar sua entrada. Vamos usar llava-onevision-qwen2-7b-si-hf e um histórico de conversa de texto e imagem. Cada campo de conteúdo deve ser uma lista de dicts, conforme mostrado a seguir:

from transformers import AutoProcessor


processor = AutoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-7b-si-hf")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "What’s shown in this image?"},
        ],
    },
    {
        "role": "assistant",
        "content": [{"type": "text", "text": "This image shows a red stop sign."},]
    },
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Describe the image in more details."},
        ],
    },
]

text_prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)

# Note that the template simply formats your prompt, you still have to tokenize it and obtain pixel values for your images
print(text_prompt)
'<|im_start|>user\n<image>What is shown in this image?<|im_end|>\n<|im_start|>assistant\nPage showing the list of options.<|im_end|>'

🚀 Bônus: Se você estiver usando transformers>=4.49.0, também pode obter uma saída vetorizada de apply_chat_template. Consulte os Exemplos de uso abaixo para mais detalhes sobre como usá-lo.

Este modelo foi contribuído por RaushanTurganbay. O código original pode ser encontrado aqui.

Exemplo de uso

Inferência de uma única imagem

Aqui está como carregar o modelo e executar inferência em meia precisão (torch.float16):

import torch

from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration


processor = AutoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-7b-ov-hf")
model = LlavaOnevisionForConditionalGeneration.from_pretrained(
    "llava-hf/llava-onevision-qwen2-7b-ov-hf",
    device_map="auto"
)

# prepare image and text prompt, using the appropriate prompt template
url = "https://github.com/haotian-liu/LLaVA/blob/1a91fc274d7c35a9b50b3cb29c4247ae5837ce39/images/llava_v1_5_radar.jpg?raw=true"
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": url},
            {"type": "text", "text": "What is shown in this image?"},
        ],
    },
]
inputs = processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)
inputs = inputs.to(model.device, torch.float16)

# autoregressively complete prompt
output = model.generate(**inputs, max_new_tokens=100)
print(processor.decode(output[0], skip_special_tokens=True))
'user\n\nWhat is shown in this image?\nassistant\nThe image shows a radar chart, also known as a spider chart or a star chart, which is used to compare multiple quantitative variables. Each axis represents a different variable, and the chart is filled with'

Inferência com múltiplas imagens

LLaVa-OneVision pode realizar inferência com múltiplas imagens como entrada, em que as imagens pertencem ao mesmo prompt ou a prompts diferentes (em inferência em lote). Para isso, é necessário usar checkpoints com o sufixo “ov”. Para casos de múltiplas imagens, recomendamos usar uma lista aninhada de imagens como entrada. Caso contrário, cada imagem será patchificada e consumirá muita memória. Veja como fazer:

import torch

from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration


# Load the model in half-precision
model = LlavaOnevisionForConditionalGeneration.from_pretrained("llava-hf/llava-onevision-qwen2-7b-ov-hf", device_map="auto")
processor = AutoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-7b-ov-hf")

# Prepare a batch of two prompts, where the first one is a multi-turn conversation and the second is not
conversation_1 = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"},
            {"type": "text", "text": "What is shown in this image?"},
        ],
    },
    {
        "role": "assistant",
        "content": [
            {"type": "text", "text": "There is a red stop sign in the image."},
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "http://images.cocodataset.org/val2017/000000039769.jpg"},
            {"type": "text", "text": "What about this image? How many cats do you see?"},
        ],
    },
]

conversation_2 = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"},
            {"type": "text", "text": "What is shown in this image?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    [conversation_1, conversation_2],
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    padding=True,
    padding_side="left",
    return_tensors="pt",
).to(model.device, torch.float16)

# Generate
generate_ids = model.generate(**inputs, max_new_tokens=30)
processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
['user\n\nWhat is shown in this image?\nassistant\nThere is a red stop sign in the image.\nuser\n\nWhat about this image? How many cats do you see?\nassistant\ntwo', 'user\n\nWhat is shown in this image?\nassistant\nThe image shows a whimsical scene of a snowman sitting by a campfire. The snowman is anthropomorphized, wearing a hat and']

Inferência de vídeo

O LLaVa-OneVision também pode realizar inferência com vídeos como entrada, em que os quadros do vídeo são tratados como múltiplas imagens. Veja como fazer isso:

from huggingface_hub import hf_hub_download
import torch
from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration

# Load the model in half-precision
model = LlavaOnevisionForConditionalGeneration.from_pretrained("llava-hf/llava-onevision-qwen2-7b-ov-hf", device_map="auto")
processor = AutoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-7b-ov-hf")

video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")
conversation = [
    {

        "role": "user",
        "content": [
            {"type": "video", "path": video_path},
            {"type": "text", "text": "Why is this video funny?"},
            ],
    },
]

inputs = processor.apply_chat_template(
    conversation,
    num_frames=8
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt"
).to(model.device, torch.float16)

out = model.generate(**inputs, max_new_tokens=60)
processor.batch_decode(out, skip_special_tokens=True, clean_up_tokenization_spaces=True)
["user\n\nWhy is this video funny?\nassistant\nThe video appears to be humorous because it shows a young child, who is wearing glasses and holding a book, seemingly reading with a serious and focused expression. The child's glasses are a bit oversized for their face, which adds a comical touch, as it's a common trope to see children wearing"]

Otimização de modelos

Quantização usando bitsandbytes

O modelo pode ser carregado em 8 ou 4 bits, reduzindo significativamente os requisitos de memória enquanto mantém o desempenho do modelo original. Primeiro, certifique-se de instalar o bitsandbytes, pip install bitsandbytes e de ter acesso a uma GPU/acelerador suportado pela biblioteca.

bitsandbytes está sendo refatorado para suportar múltiplos backends além do CUDA. Atualmente, as implementações para ROCm (GPU AMD) e CPU Intel estão maduras, com o Intel XPU em andamento e o suporte a Apple Silicon esperado para o Q4/Q1. Para instruções de instalação e as atualizações mais recentes dos backends, visite este link.

Valorizamos seu feedback para ajudar a identificar bugs antes do lançamento completo! Consulte esses documentos para mais detalhes e links de feedback.

Basta alterar o trecho acima com:

from transformers import BitsAndBytesConfig, LlavaOnevisionForConditionalGeneration


# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
)

model = LlavaOnevisionForConditionalGeneration.from_pretrained(model_id, quantization_config=quantization_config, device_map="auto")

Use o Flash-Attention 2 para acelerar ainda mais a geração

Primeiro, certifique-se de instalar o flash-attn. Consulte o repositório original do Flash Attention para obter informações sobre a instalação desse pacote. Basta alterar o trecho acima para:

from transformers import LlavaOnevisionForConditionalGeneration


model = LlavaOnevisionForConditionalGeneration.from_pretrained(
    model_id,
    use_flash_attention_2=True
).to(0, device_map="auto")

Transformers

LLaVA-OneVision

Visão geral

Formatando prompts com modelos de chat

Exemplo de uso

Inferência de uma única imagem

Inferência com múltiplas imagens

Inferência de vídeo

Otimização de modelos

Quantização usando bitsandbytes

Use o Flash-Attention 2 para acelerar ainda mais a geração

LlavaOnevisionConfig

classe transformers.LlavaOnevisionConfig

LlavaOnevisionProcessor

classe transformers.LlavaOnevisionProcessor

__call__

LlavaOnevisionImageProcessor

classe transformers.LlavaOnevisionImageProcessor

pré-processamento

LlavaOnevisionImageProcessorPil

classe transformers.LlavaOnevisionImageProcessorPil

pré-processamento

LlavaOnevisionVideoProcessor

classe transformers.LlavaOnevisionVideoProcessor

LlavaOnevisionModel

classe transformers.LlavaOnevisionModel

forward

get_image_features

get_placeholder_mask

get_video_features

pack_image_features

LlavaOnevisionForConditionalGeneration

classe transformers.LlavaOnevisionForConditionalGeneration

forward

get_image_features

get_video_features

call