Transformers documentation

LLaVA-OneVision

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

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 se publicó en HF papers el 2024-08-06 y se contribuyó a Hugging Face Transformers el 2024-09-05.

LLaVA-OneVision

Resumen

El modelo LLaVA-OneVision fue propuesto en 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 es un modelo de visión-lenguaje que puede generar texto condicionado por una o varias imágenes/videos. El modelo consta de un codificador de visión SigLIP y un backbone de lenguaje Qwen2. Las imágenes se procesan con la técnica anyres-9, donde la imagen se divide en 9 parches para procesar mejor las imágenes de alta resolución y capturar el máximo detalle posible. Sin embargo, los videos se agrupan a una longitud de secuencia total de 196 tokens por cuadro para un cálculo más eficiente en memoria. LLaVA-OneVision está disponible en tres tamaños: 0.5B, 7B y 72B, y logra un rendimiento notable en las evaluaciones de benchmark.

El resumen del artículo es el siguiente:

Presentamos LLaVA-OneVision, una familia de grandes modelos multimodales abiertos (LMM) desarrollados al consolidar nuestros conocimientos sobre datos, modelos y representaciones visuales en la serie de blogs LLaVA-NeXT. Nuestros resultados experimentales demuestran que LLaVA-OneVision es el primer modelo único capaz de ampliar simultáneamente los límites de rendimiento de los LMM abiertos en tres escenarios importantes de visión por computadora: imágenes individuales, múltiples imágenes y video. Es importante destacar que el diseño de LLaVAOneVision permite un fuerte aprendizaje de transferencia entre diferentes modalidades/escenarios, lo que genera nuevas capacidades emergentes. En particular, se demuestra una fuerte comprensión de video y capacidades entre escenarios a través de la transferencia de tareas de imágenes a videos.

LLaVA-OneVision architecture. Taken from the original paper.

Consejos:

Recomendamos a los usuarios que utilicen padding_side="left" al calcular la generación por lotes, ya que esto conduce a resultados más precisos. Simplemente asegúrese de llamar a processor.tokenizer.padding_side = "left" antes de generar.

Llava-OneVision utiliza un número diferente de parches para las imágenes y, por lo tanto, debe rellenar las entradas dentro del código de modelado, además del relleno realizado al procesar las entradas. La configuración predeterminada es “left-padding” si el modelo está en modo eval(), de lo contrario es “right-padding”.

Formateo de prompts con plantillas de chat

Cada checkpoint se entrena con un formato de prompt específico, dependiendo del modelo de lenguaje de gran escala subyacente. Para garantizar un formato correcto, utiliza el método apply_chat_template del procesador.

Importante:

Debes construir un historial de conversación; pasar una cadena de texto simple no funcionará.
Cada mensaje debe ser un diccionario con las claves "role" y "content".
El "content" debe ser una lista de diccionarios para diferentes modalidades como "text" y "image".

A continuación se muestra un ejemplo de cómo estructurar la entrada. Utilizaremos llava-onevision-qwen2-7b-si-hf y un historial de conversación de texto e imagen. Cada campo de contenido debe ser una lista de diccionarios, de la siguiente manera:

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|>'

🚀 Bonus: Si estás usando transformers>=4.49.0, también puedes obtener una salida vectorizada de apply_chat_template. Consulta los Ejemplos de uso a continuación para más detalles sobre cómo utilizarla.

Este modelo fue aportado por RaushanTurganbay. El código original se puede encontrar aquí.

Ejemplo de uso

Inferencia de una sola imagen

Así es como se carga el modelo y se realiza la inferencia en media precisión (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'

Inferencia con múltiples imágenes

LLaVa-OneVision puede realizar inferencia con múltiples imágenes como entrada, donde las imágenes pertenecen al mismo prompt o a prompts diferentes (en inferencia por lotes). Para ello, debes usar checkpoints con el sufijo “ov”. Para los casos de múltiples imágenes, recomendamos usar una lista anidada de imágenes como entrada. De lo contrario, cada imagen se convertirá en parches y consumirá mucha memoria. Así es como puedes hacerlo:

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']

Inferencia de video

LLaVa-OneVision también puede realizar inferencia con videos como entrada, donde los fotogramas del video se tratan como múltiples imágenes. Así es como puedes hacerlo:

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"]

Optimización de modelos

Cuantización usando bitsandbytes

El modelo se puede cargar en 8 o 4 bits, lo que reduce considerablemente los requisitos de memoria mientras mantiene el rendimiento del modelo original. Primero, asegúrate de instalar bitsandbytes, pip install bitsandbytes y de tener acceso a una GPU/acelerador compatible con la biblioteca.

bitsandbytes se está refactorizando para admitir múltiples backends además de CUDA. Actualmente, las implementaciones de ROCm (GPU de AMD) y CPU de Intel están maduras, la de Intel XPU está en curso y se espera el soporte para Apple Silicon para el Q4/Q1. Para obtener instrucciones de instalación y las últimas actualizaciones de backends, visita este enlace.

¡Valoramos tu feedback para ayudar a identificar errores antes del lanzamiento completo! Consulta estos documentos para más detalles y enlaces de feedback.

Simplemente cambia el fragmento anterior por:

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 Flash-Attention 2 para acelerar aún más la generación

Primero, asegúrate de instalar flash-attn. Consulta el repositorio original de Flash Attention para obtener información sobre la instalación de ese paquete. Simplemente cambia el fragmento anterior por:

from transformers import LlavaOnevisionForConditionalGeneration


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

Transformers

LLaVA-OneVision

Resumen

Formateo de prompts con plantillas de chat

Ejemplo de uso

Inferencia de una sola imagen

Inferencia con múltiples imágenes

Inferencia de video

Optimización de modelos

Cuantización usando bitsandbytes

Use Flash-Attention 2 para acelerar aún más la generación

LlavaOnevisionConfig

clase transformers.LlavaOnevisionConfig

LlavaOnevisionProcessor

clase transformers.LlavaOnevisionProcessor

__call__

LlavaOnevisionImageProcessor

clase transformers.LlavaOnevisionImageProcessor

preprocesar

LlavaOnevisionImageProcessorPil

clase transformers.LlavaOnevisionImageProcessorPil

preprocesar

LlavaOnevisionVideoProcessor

clase transformers.LlavaOnevisionVideoProcessor

LlavaOnevisionModel

clase transformers.LlavaOnevisionModel

forward

get_image_features

get_placeholder_mask

get_video_features

pack_image_features

LlavaOnevisionForConditionalGeneration

clase transformers.LlavaOnevisionForConditionalGeneration

forward

get_image_features

get_video_features

call