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

Ce modèle a été publié dans HF papers le 2024-08-06 et contribué à Hugging Face Transformers le 2024-09-05.

LLaVA-OneVision

Aperçu

Le modèle LLaVA-OneVision a été proposé dans LLaVA-OneVision: Easy Visual Task Transfer par Bo Li, Yuanhan Zhang, Dong Guo, Renrui Zhang, Feng Li, Hao Zhang, Kaichen Zhang, Yanwei Li, Ziwei Liu, Chunyuan Li

LLaVA-OneVision est un modèle Vision-Language capable de générer du texte conditionné par une ou plusieurs images/vidéos. Le modèle est composé d'un encodeur visuel SigLIP et d'un socle linguistique Qwen2. Les images sont traitées avec la technique anyres-9, où l'image est divisée en 9 patches pour mieux traiter les images haute résolution et capturer un maximum de détails. En revanche, les vidéos sont regroupées pour atteindre une longueur de séquence totale de 196 tokens par image, afin d'optimiser l'efficacité mémoire des calculs. LLaVA-OneVision est disponible en trois tailles : 0,5B, 7B et 72B, et atteint des performances remarquables sur les évaluations de référence.

L'abstract de l'article est le suivant :

Nous présentons LLaVA-OneVision, une famille de grands modèles multimodaux ouverts (LMM) développée en consolidant nos connaissances sur les données, les modèles et les représentations visuelles issues de la série de blogs LLaVA-NeXT. Nos résultats expérimentaux démontrent que LLaVA-OneVision est le premier modèle unique capable de repousser simultanément les limites de performance des LMM ouverts dans trois scénarios importants de la vision par ordinateur : les scénarios à image unique, à images multiples et vidéo. Il est important de noter que la conception de LLaVAOneVision permet un fort apprentissage par transfert entre différentes modalités/scénarios, ce qui engendre de nouvelles capacités émergentes. En particulier, une compréhension vidéo robuste et des capacités inter-scénarios sont démontrées par le transfert de tâches des images vers les vidéos.

LLaVA-OneVision architecture. Taken from the original paper.

Astuces :

Nous recommandons aux utilisateurs d'utiliser padding_side="left" lors du calcul de la génération par lots, car cela conduit à des résultats plus précis. Assurez-vous simplement d'appeler processor.tokenizer.padding_side = "left" avant de générer.

Llava-OneVision utilise un nombre de patches différent pour les images et doit donc effectuer un bourrage des entrées dans le code de modélisation, en plus du bourrage réalisé lors du traitement des entrées. Le réglage par défaut est le « bourrage à gauche » si le modèle est en mode eval(), sinon le « bourrage à droite ».

Mise en forme des prompts avec des modèles de chat

Chaque checkpoint est entraîné avec un format de prompt spécifique, en fonction du modèle de langage de grande taille sous-jacent. Pour garantir un formatage correct, utilisez la méthode apply_chat_template du processeur.

Important :

Vous devez construire un historique de conversation — passer une simple chaîne de caractères ne fonctionnera pas.
Chaque message doit être un dictionnaire avec les clés "role" et "content".
Le "content" doit être une liste de dictionnaires pour différentes modalités comme "text" et "image".

Voici un exemple de la structure à donner à votre entrée. Nous utiliserons llava-onevision-qwen2-7b-si-hf et un historique de conversation contenant du texte et une image. Chaque champ de contenu doit être une liste de dictionnaires, comme suit :

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 vous utilisez transformers>=4.49.0, vous pouvez également obtenir une sortie vectorisée à partir de apply_chat_template. Consultez les Exemples d'utilisation ci-dessous pour plus de détails sur son utilisation.

Ce modèle a été contribué par RaushanTurganbay. Le code d'origine peut être trouvé ici.

Exemple d'utilisation

Inférence sur une image unique

Voici comment charger le modèle et effectuer une inférence en demi-précision (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'

Inférence multi-image

LLaVa-OneVision peut effectuer de l'inférence avec plusieurs images en entrée, où les images appartiennent soit au même prompt, soit à des prompts différents (dans le cas d'une inférence par lots). Pour cela, vous devez utiliser des points de contrôle avec un suffixe « ov ». Pour les cas multi-images, nous recommandons d'utiliser une liste imbriquée d'images en entrée. Sinon, chaque image sera patchifiée et consommera beaucoup de mémoire. Voici comment faire :

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

Inférence vidéo

LLaVa-OneVision peut également effectuer de l'inférence avec des vidéos en entrée, où les images de la vidéo sont traitées comme plusieurs images. Voici comment faire :

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

Optimisation des modèles

Quantification à l'aide de bitsandbytes

Le modèle peut être chargé en 8 ou 4 bits, réduisant considérablement les besoins en mémoire tout en conservant les performances du modèle d'origine. Assurez-vous d'abord d'installer bitsandbytes, pip install bitsandbytes, et de disposer d'un GPU/accélérateur pris en charge par la bibliothèque.

bitsandbytes est en cours de refonte pour prendre en charge plusieurs backends au-delà de CUDA. Actuellement, les implémentations ROCm (GPU AMD) et Intel CPU sont matures, l'Intel XPU est en cours de développement et la prise en charge d'Apple Silicon est attendue pour le T4/T1. Pour les instructions d'installation et les dernières mises à jour des backends, consultez ce lien.

Nous valorisons vos retours pour aider à identifier les bugs avant la sortie complète ! Consultez ces documents pour plus de détails et les liens de retour.

Il suffit de remplacer l'extrait ci-dessus par :

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

Utiliser Flash-Attention 2 pour accélérer encore davantage la génération

Commencez par vous assurer d'installer flash-attn. Reportez-vous au dépôt original de Flash Attention pour les instructions d'installation de ce package. Remplacez simplement l'extrait de code ci-dessus par :

from transformers import LlavaOnevisionForConditionalGeneration


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

Transformers

LLaVA-OneVision

Aperçu

Mise en forme des prompts avec des modèles de chat

Exemple d'utilisation

Inférence sur une image unique

Inférence multi-image

Inférence vidéo

Optimisation des modèles

Quantification à l'aide de bitsandbytes

Utiliser Flash-Attention 2 pour accélérer encore davantage la génération

LlavaOnevisionConfig

classe transformers.LlavaOnevisionConfig

LlavaOnevisionProcessor

classe transformers.LlavaOnevisionProcessor

__call__

LlavaOnevisionImageProcessor

classe transformers.LlavaOnevisionImageProcessor

prétraiter

LlavaOnevisionImageProcessorPil

classe transformers.LlavaOnevisionImageProcessorPil

prétraiter

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