Modèles de vision locaux 2026 : LLaVA, Llama 3.2 Vision, Qwen2-VL & configuration Ollama

Faits rapides

• Ce que font les VLM : Entrée image + texte → sortie texte. Pas des générateurs d'images — ces modèles *comprennent* les images.
• Support Ollama : Tous les modèles de cette comparaison ont une intégration Ollama officielle ou communautaire (mai 2026).
• Plus petit modèle utilisable : Moondream 2 à 1,9B paramètres, ~2 Go de VRAM.
• Plus grand modèle local pratique : Llama 3.2 Vision 90B avec ~64 Go de mémoire unifiée (Apple M-Series ou multi-GPU).
• Format d'entrée image : JPEG, PNG, WebP. Résolution maximale variable selon le modèle (1024×1024 à 4096×4096).
• Précision OCR : Qwen2-VL 7B ≈ MiniCPM-V 2.6 > Llama 3.2 Vision 11B > LLaVA 1.6 13B > LLaVA 1.6 7B > Moondream 2.
• Multimodal = plus lent : Les VLM ajoutent un encodeur visuel au LLM — ~30–60 % plus lent qu'un modèle texte seul de même taille.

Qu'est-ce qu'un modèle vision-langage (VLM) ?

• Différence avec les générateurs d'images : Stable Diffusion, FLUX et DALL-E 3 génèrent des images à partir de texte. Les VLM sont des modèles image-vers-texte — ils décrivent, analysent et répondent à des questions sur les images.
• Différence avec l'OCR classique : L'OCR traditionnel (Tesseract) extrait du texte par reconnaissance de motifs. Les VLM comprennent le contexte — ils peuvent expliquer une table, répondre à des questions sur un graphique.
• Pourquoi les exécuter localement : Documents privés (dossiers médicaux, scans juridiques, relevés financiers), captures d'écran propriétaires, ou workflows où l'envoi d'images à des API cloud soulève des problèmes de conformité.
• Ce qu'ils ne peuvent pas faire : Générer des images, exécuter du code visible dans les captures d'écran, ou accéder à internet.

Modèles de vision locaux disponibles — Tableau comparatif

Test de précision : extraction de facture

Support multi-images

• MiniCPM-V 2.6 accepte jusqu'à 4 images par prompt ; Qwen2-VL jusqu'à 8. LLaVA et Moondream n'acceptent qu'une image à la fois.
• Quand le multi-images est utile : Envoyer toutes les pages d'un PDF multi-pages, comparer deux photos de produit, analyser des captures avant/après dans un seul prompt.

Configuration via Ollama — étape par étape

• Étape 1 — Installer Ollama : Téléchargez depuis ollama.com pour macOS, Linux ou Windows. Installation en moins de 2 minutes.
• Étape 2 — Télécharger un modèle : ollama pull llama3.2-vision (11B, ~8 Go) ou ollama pull moondream (1,9B, ~2 Go) pour les configs limitées en VRAM.
• Étape 3 — Utiliser via CLI : ollama run llama3.2-vision "Qu'y a-t-il dans cette image ?" --image /chemin/photo.jpg
• Étape 4 — Utiliser l'API HTTP : POST vers http://localhost:11434/api/generate avec l'image encodée en base64 dans le tableau images.
• Étape 5 — Exemple Python : Utiliser la bibliothèque requests avec l'encodage base64 — voir le bloc de code ci-dessous.

import base64
import requests

def ask_vision_model(image_path: str, prompt: str, model: str = "llama3.2-vision") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

# Exemple d'utilisation
result = ask_vision_model("facture.png", "Extraire toutes les lignes et les montants totaux de cette facture.")
print(result)

Cas d'usage 1 : OCR et extraction de documents

• Ce qui fonctionne bien : Factures scannées, captures de PDF, notes manuscrites en lettres d'imprimerie, tableaux avec bordures claires.
• Ce qui fonctionne moins bien : Écriture cursive, scans sous 150 DPI, JPEG très compressés, textes superposés.
• Meilleurs modèles pour l'OCR : MiniCPM-V 2.6 (précision maximale dans la classe 6 Go), Llama 3.2 Vision 11B (meilleur sur les types de documents mixtes).
• Prompt engineering pour l'OCR : « Extraire tout le texte de ce document tel qu'il est écrit. » Ou : « Retourner le contenu de cette facture en JSON avec les champs : fournisseur, date, lignes[], total. »
• Vs OCR classique : Les VLM sont plus lents mais plus sémantiques. Tesseract est plus rapide pour l'extraction de texte brut. Utiliser les VLM pour l'extraction de données structurées.

Cas d'usage 2 : Questions-réponses sur images

• Description de scènes : « Qu'y a-t-il sur cette photo ? » — objets, personnes, activités, décor.
• Catalogage de produits : Traiter des photos avec un template : « Décrire couleur, forme, matière, état. » Utile pour l'inventaire e-commerce sans API cloud.
• Accessibilité : Générer des textes alternatifs pour les images à grande échelle.
• Meilleurs modèles : LLaVA 1.6 13B ou Llama 3.2 Vision 11B pour les Q&A sur photos. LLaVA 1.6 7B pour le traitement en volume.
• Vitesse : Sur un GPU 6 Go, Llama 3.2 Vision 11B Q4 génère ~8–12 tokens/sec — 100 images prennent ~2–5 minutes.

Cas d'usage 3 : Analyse de captures d'écran et UI

• Workflows développeur : Envoyer des captures de messages d'erreur : « Qu'est-ce qui ne va pas dans cette capture et comment le corriger ? »
• Génération de rapports de bugs : Créer automatiquement des descriptions de bugs à partir de captures d'écran.
• Monitoring de tableaux de bord : Analyser des captures pour détecter des anomalies.
• Tests d'accessibilité : Comparer des captures avant et après des modifications UI.
• Meilleurs modèles : InternVL 2.5 8B (meilleure compréhension UI), MiniCPM-V 2.6 (deuxième, avec support Ollama).

Cas d'usage 4 : Lecture de graphiques

• Ce qui fonctionne : Lire les étiquettes d'axes, identifier les tendances, comparer des hauteurs de barres.
• Ce qui est peu fiable : Extraction numérique précise sur des graphiques continus, pourcentages de diagrammes circulaires sans étiquettes.
• Stratégie de prompt : « Décris la tendance » fonctionne mieux que « Quelle est la valeur exacte en mars 2026 ? »
• Meilleurs modèles : InternVL 2.5 (meilleure compréhension des graphiques), Llama 3.2 Vision 11B (bon sur les graphiques bien étiquetés).
• Limite : Aucun VLM local n'extrait de façon fiable des valeurs précises de graphiques complexes en 2026.

Cas d'usage 5 : Analyse d'images vidéo

• Extraction d'images : ffmpeg -i video.mp4 -vf fps=1 frames/frame_%04d.jpg
• Analyse image par image : Envoyer chaque image au modèle avec un prompt cohérent.
• Résumé global : Collecter toutes les descriptions et les envoyer à un LLM texte.
• Cas d'usage : Revue de caméras de sécurité, analyse d'enregistrements de cours, inspection qualité en fabrication.
• Meilleurs modèles : Llama 3.2 Vision 11B pour la qualité, LLaVA 1.6 7B pour la vitesse.
• Réalité des performances : Une vidéo de 10 minutes prend ~20–30 minutes à traiter complètement.

import base64
import subprocess
import os
import requests

def extract_frames(video_path: str, output_dir: str, fps: int = 1) -> list[str]:
    os.makedirs(output_dir, exist_ok=True)
    subprocess.run([
        "ffmpeg", "-i", video_path,
        "-vf", f"fps={fps}",
        f"{output_dir}/frame_%04d.jpg",
        "-y"
    ], check=True)
    return sorted([
        os.path.join(output_dir, f)
        for f in os.listdir(output_dir)
        if f.endswith(".jpg")
    ])

def analyze_frame(image_path: str, model: str = "llama3.2-vision") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": "Describe what is happening in this frame in one sentence.",
            "images": [image_b64],
            "stream": False,
        },
    )
    return response.json()["response"]

frames = extract_frames("cours.mp4", "frames/", fps=1)
descriptions = [analyze_frame(f) for f in frames]
print("\n".join(f"[{i+1}s] {d}" for i, d in enumerate(descriptions)))

VRAM et réalité des performances

Modèles de vision locaux vs GPT-4o Vision

• Documents structurés (factures, formulaires) : Modèles locaux à 80–90 % de la qualité GPT-4o — suffisant pour la production.
• Scènes complexes, images ambiguës : Modèles locaux à 50–70 % de GPT-4o — écart de qualité notable.
• Reconnaissance de l'écriture manuscrite : Modèles locaux nettement plus faibles, surtout pour le cursif.
• Extraction de données de graphiques : Peu fiable sur les deux, mais GPT-4o plus précis sur les valeurs numériques.
• Coût : GPT-4o Vision à 0,01–0,03 $ par image vs 0 $ en local. 10 000 images/mois = 100–300 $ économisés.
• Confidentialité : Traitement local — aucune image n'est envoyée aux serveurs OpenAI. La CNIL recommande le traitement local pour les données professionnelles sensibles.
• Vitesse : Modèles locaux à 10–20 tokens/sec vs GPT-4o à 30–80 tokens/sec, mais sans latence réseau pour le traitement par lots.

LLaVA en détail

• Architecture : Encodeur visuel CLIP ViT-L/14 + décodeur texte Llama-2 ou Mistral, reliés par une couche de projection linéaire.
• LLaVA 1.5 vs 1.6 : La version 1.6 (début 2024) a ajouté le support haute résolution via le découpage dynamique, améliorant significativement l'OCR et la lecture de graphiques.
• Entraînement : Instruction-tuning sur LLaVA-Instruct-150K — conversations visuelles générées à partir de légendes d'images.
• Points forts : Large base de connaissances, bien documenté, grande communauté, intégration Ollama étendue.
• Points faibles : OCR moins précis que MiniCPM-V 2.6, analyse UI moins bonne qu'InternVL 2.5.
• Pourquoi toujours recommandé : La plus grande communauté, le plus de tutoriels et d'exemples de prompts de tous les VLM locaux.

Qwen2-VL — Meilleure OCR multilingue

• Architecture : Résolution dynamique jusqu'à 4096×4096 — bien supérieure à LLaVA 1.6 (672×672) ou Llama 3.2 Vision (1120×1120).
• OCR multilingue : Meilleure classe pour le chinois, japonais, coréen et anglais. Données d'entraînement multilingues étendues.
• 7B vs 72B : Le 7B tient dans ~6 Go de VRAM (Q4), compétitif avec Llama 3.2 Vision 11B. Le 72B (~48 Go) domine les benchmarks open-source.
• Installation Ollama : ollama pull qwen2-vl:7b
• Multi-images : Jusqu'à 8 images par requête — capacité maximale de cette comparaison.
• Page du modèle : Qwen2-VL 7B sur Hugging Face

Choisir son modèle de vision

• Moins de 4 Go de VRAM : Moondream 2 (1,9B) à 2 Go. PaliGemma 2 (3B) et SmolVLM (2,2B) comme alternatives — PaliGemma 2 avec une meilleure compréhension documentaire (~3 Go). Aucun adapté à l'OCR de texte dense.
• 6 Go de VRAM : MiniCPM-V 2.6 pour l'OCR de documents. LLaVA 1.6 7B pour les questions-réponses générales sur photos. Qwen2-VL 7B pour l'OCR multilingue.
• 8–16 Go de VRAM : Llama 3.2 Vision 11B — recommandation claire, meilleure qualité globale, large support Ollama.
• 16+ Go de VRAM : LLaVA 1.6 13B pour les scènes complexes. InternVL 2.5 8B pour les captures d'écran UI/code.
• 64+ Go de mémoire unifiée : Llama 3.2 Vision 90B pour la meilleure qualité locale. Qwen2-VL 72B comme alternative avec les meilleurs scores de benchmarks.
• Toujours vérifier les chiffres : Croiser toute valeur numérique extraite de graphiques avec les données source.

FAQ

Sources

• Page du projet LLaVA — Fiches modèles LLaVA 1.5 et 1.6, détails d'architecture et description du jeu de données.
• Llama 3.2 Vision sur Hugging Face — Fiche modèle officielle Meta et benchmarks.
• MiniCPM-V 2.6 sur Hugging Face — Fiche modèle OpenBMB, benchmarks OCR et instructions de fine-tuning.
• Moondream sur GitHub — Description de l'architecture et scripts d'inférence.
• InternVL 2.5 sur Hugging Face — Fiche modèle OpenGVLab et benchmarks UI.
• Documentation Ollama — Support des modèles vision, référence API et bibliothèque de modèles.
• Qwen2-VL sur Hugging Face — Fiche modèle Qwen2-VL d'Alibaba et benchmarks OCR multilingues.
• PaliGemma 2 sur Hugging Face — Fiche modèle PaliGemma 2 3B de Google.
• SmolVLM sur Hugging Face — Fiche modèle SmolVLM de HuggingFace.

Lectures complémentaires

• Pipeline IA multimodale locale 2026 — Combiner modèles de vision, STT et TTS en une stack locale complète.
• Reconnaissance vocale locale 2026 : Whisper.cpp vs faster-whisper — Ajouter la saisie vocale en complément de la vision.
• TTS local et clonage vocal 2026 — Ajouter la synthèse vocale pour lire les réponses VLM.
• Installer Ollama — Prérequis : configuration et paramétrage d'Ollama.
• Guide matériel LLM local 2026 — Exigences VRAM et RAM pour l'inférence de modèles vision.