Llama 3.2 Vision

Exécutez Llama 3.2 Vision de Meta pour la compréhension d'images sur Clore.ai

Exécutez les modèles multimodaux Llama 3.2 Vision de Meta pour la compréhension d'images sur les GPU de CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Pourquoi Llama 3.2 Vision ?

• Multimodal - Comprend à la fois le texte et les images

• Plusieurs tailles - Versions à 11B et 90B de paramètres

• Polyvalent - OCR, réponse visuelle aux questions, légende d'image, analyse de documents

• Poids ouverts - Entièrement open source par Meta

• Écosystème Llama - Compatible avec Ollama, vLLM, transformers

Variantes de modèle

Modèle	Paramètres	VRAM (FP16)	Contexte	Idéal pour
Llama-3.2-11B-Vision	11B	24GB	128K	Usage général, GPU unique
Llama-3.2-90B-Vision	90B	180GB	128K	Qualité maximale
Llama-3.2-11B-Vision-Instruct	11B	24GB	128K	Discussion/assistant
Llama-3.2-90B-Vision-Instruct	90B	180GB	128K	Production

Déploiement rapide sur CLORE.AI

Image Docker :

vllm/vllm-openai:latest

Ports :

22/tcp
8000/http

Commande :

python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.2-11B-Vision-Instruct \\
    --host 0.0.0.0 \
    --port 8000 \\
    --max-model-len 8192

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Configuration matérielle requise

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Modèle	GPU minimum	Recommandé	Optimal
Vision 11B	RTX 4090 24 Go	A100 40 Go	A100 80 Go
Vision 90B	4x A100 40 Go	4x A100 80 Go	8x H100

Installation

Avec Ollama (le plus simple)

# Télécharger le modèle
ollama pull llama3.2-vision:11b

# Exécution interactive
ollama run llama3.2-vision:11b

Avec vLLM

pip install vllm

python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.2-11B-Vision-Instruct \\
    --host 0.0.0.0 \
    --port 8000

Utilisation de Transformers

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained(model_id)

Utilisation de base

Compréhension d’images

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image
import requests

model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained(model_id)

# Charger l’image
url = "https://example.com/image.jpg"
image = Image.open(requests.get(url, stream=True).raw)

# Créer le prompt
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Qu'y a-t-il dans cette image ? Décrivez-la en détail."}
        ]
    }
]

input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=500)
print(processor.decode(output[0], skip_special_tokens=True))

Avec Ollama

# Décrire une image
ollama run llama3.2-vision:11b "Décrivez cette image : /path/to/image.jpg"

# Ou utiliser l'API
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2-vision:11b",
  "prompt": "Qu'y a-t-il dans cette image ?",
  "images": ["base64_encoded_image_here"]
}'

Avec l'API vLLM

from openai import OpenAI
import base64

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

# Encoder l'image en base64
with open("image.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="meta-llama/Llama-3.2-11B-Vision-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Qu'y a-t-il dans cette image ?"},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}
                }
            ]
        }
    ],
    max_tokens=500
)

print(response.choices[0].message.content)

Cas d’usage

OCR / Extraction de texte

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Extrayez tout le texte de cette image. Formatez-le en Markdown."}
        ]
    }
]

Analyse de document

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Analysez ce document. Résumez les points clés."}
        ]
    }
]

Réponse visuelle aux questions

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Combien de personnes y a-t-il sur cette photo ? Que font-elles ?"}
        ]
    }
]

Légendage d’images

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Rédigez une légende détaillée pour cette image, adaptée aux réseaux sociaux."}
        ]
    }
]

Code à partir de captures d'écran

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Convertissez cette capture d'écran d'interface utilisateur en code HTML/CSS."}
        ]
    }
]

Images multiples

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "image"},
            {"type": "text", "text": "Comparez ces deux images. Quelles sont les différences ?"}
        ]
    }
]

# Traiter avec plusieurs images
inputs = processor(
    images=[image1, image2],
    text=input_text,
    return_tensors="pt"
).to(model.device)

Traitement par lots

import os
from PIL import Image

def process_images(image_paths, prompt):
    results = []

    for path in image_paths:
        image = Image.open(path)

        messages = [
            {
                "role": "user",
                "content": [
                    {"type": "image"},
                    {"type": "text", "text": prompt}
                ]
            }
        ]

        input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
        inputs = processor(image, input_text, return_tensors="pt").to(model.device)

        output = model.generate(**inputs, max_new_tokens=300)
        result = processor.decode(output[0], skip_special_tokens=True)

        results.append({"file": path, "description": result})

        # Vider le cache entre les images
        torch.cuda.empty_cache()

    return results

# Traiter le dossier
images = [f"./images/{f}" for f in os.listdir("./images") if f.endswith(('.jpg', '.png'))]
results = process_images(images, "Décrivez cette image en un paragraphe.")

Interface Gradio

import gradio as gr
import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image

model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"
model = MllamaForConditionalGeneration.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto"
)
processor = AutoProcessor.from_pretrained(model_id)

def analyze_image(image, question):
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image"},
                {"type": "text", "text": question}
            ]
        }
    ]

    input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
    inputs = processor(image, input_text, return_tensors="pt").to(model.device)

    output = model.generate(**inputs, max_new_tokens=500)
    return processor.decode(output[0], skip_special_tokens=True)

demo = gr.Interface(
    fn=analyze_image,
    inputs=[
        gr.Image(type="pil", label="Téléverser une image"),
        gr.Textbox(label="Question", placeholder="Qu'y a-t-il dans cette image ?")
    ],
    outputs=gr.Textbox(label="Réponse"),
    title="Llama 3.2 Vision - Analyse d'image",
    description="Téléversez une image et posez-lui des questions. Fonctionne sur CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Performances

Tâche	Modèle	GPU	Temps
Description d'une seule image	11B	RTX 4090	~3 s
Description d'une seule image	11B	A100 40 Go	~2 s
OCR (1 page)	11B	RTX 4090	~5 s
Analyse de document	11B	A100 40 Go	~8 s
Lot (10 images)	11B	A100 40 Go	~25 s

Quantification

4 bits avec bitsandbytes

from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16
)

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

GGUF avec Ollama

# Quantifié en 4 bits (tient dans 8 Go de VRAM)
ollama pull llama3.2-vision:11b-q4_K_M

# Quantifié en 8 bits
ollama pull llama3.2-vision:11b-q8_0

Estimation des coûts

Tarifs habituels de la place de marché CLORE.AI :

GPU	Tarif horaire	Idéal pour
RTX 4090 24 Go	~$0.10	Modèle 11B
A100 40 Go	~$0.17	11B avec contexte long
A100 80 Go	~$0.25	11B optimal
4x A100 80 Go	~$1.00	Modèle 90B

Les prix varient. Consultez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot commandes pour le traitement par lots

• Payez avec CLORE jetons

• Utilisez des modèles quantifiés (4 bits) pour le développement

Dépannage

Mémoire insuffisante

# Utiliser une quantification 4 bits
model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    load_in_4bit=True,
    device_map="auto"
)

# Ou réduire max_new_tokens
output = model.generate(**inputs, max_new_tokens=256)

Génération lente

• Assurez-vous que le GPU est utilisé (vérifiez nvidia-smi)

• Utilisez bfloat16 au lieu de float32

• Réduisez la résolution de l'image avant le traitement

• Utilisez vLLM pour un meilleur débit

L'image ne se charge pas

from PIL import Image
import requests
from io import BytesIO

# Depuis une URL
response = requests.get(url)
image = Image.open(BytesIO(response.content)).convert("RGB")

# Depuis un fichier
image = Image.open("path/to/image.jpg").convert("RGB")

# Redimensionner si trop grande
max_size = 1024
if max(image.size) > max_size:
    image.thumbnail((max_size, max_size))

Jeton HuggingFace requis

# Définir le jeton pour les modèles à accès restreint
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx

# Ou se connecter
huggingface-cli login

Llama Vision vs les autres

Fonctionnalité	Llama 3.2 Vision	LLaVA 1.6	GPT-4V
Paramètres	11B / 90B	7B / 34B	Inconnu
Open source	Oui	Oui	Non
Qualité de l'OCR	Excellente	Bon	Excellente
Contexte	128K	32K	128K
Multi-image	Oui	Limité	Oui
Licence	Llama 3.2	Apache 2.0	Propriétaire

Utilisez Llama 3.2 Vision lorsque :

• Besoin d'un modèle multimodal open source

• OCR et analyse de documents

• Intégration à l'écosystème Llama

• Compréhension de longs contextes

Étapes suivantes

• LLaVA - Modèle de vision alternatif

• Florence-2 - Modèle de vision de Microsoft

• Ollama - Déploiement facile

• vLLM - Diffusion en production