Pipeline IA multimodale locale 2026 : combiner voix, vision et texte hors ligne

Faits rapides

• VRAM totale pour le stack complet : ~15 Go (Whisper 3 Go + LLaVA 7B 6 Go + Llama 3.1 8B 6 Go). Piper tourne sur CPU.
• Stack simplifié (Llama 3.2 Vision 11B) : ~8 Go VRAM — gère vision et raisonnement textuel en un seul modèle.
• Latence vocale (Whisper small, RTX 4070) : ~200–500 ms STT. 500–1500 ms premier token LLM. 100 ms Piper TTS.
• Latence traitement image (LLaVA 7B, RTX 4070) : ~2–5 secondes par image selon résolution et prompt.
• Pas de vidéo temps réel : Les VLMs traitent des images individuelles, pas des flux vidéo continus. Pour la vidéo, extraire des images à 1 FPS et traiter chacune.
• Même instance Ollama pour VLM + LLM : Ollama peut servir Llama 3.2 Vision comme modèle de vision et modèle textuel, économisant la VRAM.
• Tous les composants sous licence MIT ou Apache 2.0 (whisper.cpp MIT, LLaVA MIT, Llama 3.1 8B Llama 3 Community License, Piper MIT).

Qu'est-ce qu'un pipeline IA multimodal ?

• Approche cloud (GPT-4o) : Un modèle géant entraîné simultanément sur toutes les modalités. Le raisonnement cross-modal est appris à l'entraînement — le modèle peut raisonner nativement sur la relation entre contenu image et requêtes vocales.
• Approche locale (ce guide) : Modèles spécialisés séparés pour chaque modalité, connectés par un orchestrateur. Plus modulaire et moins coûteux à exécuter, mais produit des « coutures » — la sortie du modèle de vision est sérialisée en texte avant d'être transmise au LLM.
• Pourquoi construire localement : Confidentialité (images médicales, documents propriétaires, captures d'écran confidentielles), coût (zéro frais par requête), capacité hors ligne (aucun Internet requis après téléchargement du modèle), personnalisation (échange de tout composant).
• Avantage modulaire : Vous pouvez mettre à niveau n'importe quel composant indépendamment. Quand un meilleur modèle STT local sort, remplacez uniquement la couche STT.

Coût : Pipeline locale vs APIs cloud (mensuel)

Vue d'ensemble de l'architecture

• Types d'entrée : Audio microphone (voix), image caméra ou fichier (vision), texte clavier (texte).
• Logique de routage : Détecter le type d'entrée à la frontière. Audio → modèle STT. Image → VLM. Texte → LLM directement. Si audio et image arrivent ensemble, traiter en parallèle et combiner.
• Registre de modèles : Chaque type d'entrée est mappé à une fonction handler qui appelle le modèle approprié et retourne une description texte/transcription.
• Orchestrateur : Collecte toutes les sorties de modèles, les combine en un seul prompt pour le LLM textuel, obtient la réponse LLM et la route vers TTS pour la sortie vocale ou vers l'écran en texte.
• Types de sortie : Réponse vocale (Piper TTS), texte à l'écran, ou données structurées (JSON) pour intégration avec d'autres systèmes.
• Traitement parallèle : STT et VLM peuvent traiter simultanément — une requête audio sur une image peut avoir les deux traités en parallèle, réduisant la latence totale de 40–60 % vs. traitement séquentiel.

Le stack de composants

Niveaux matériels pour le multimodal

Cas d'usage 1 : Analyseur de documents par commande vocale

• Exemple : Photographiez une facture et dites « Quel est le montant total dû et quelle est la date limite de paiement ? »
• Pipeline : Whisper transcrit la question → image envoyée à LLaVA ou Llama 3.2 Vision → VLM extrait texte et structure de la facture → LLM combine question + sortie VLM → Piper lit la réponse à voix haute.
• Prompt : « Voici une image : [description VLM]. L'utilisateur demande : [transcription]. Répondez à la question basée sur le contenu de l'image. »
• Meilleur VLM : MiniCPM-V 2.6 ou Llama 3.2 Vision 11B pour la précision OCR facture/document.
• Valeur confidentialité : Dossiers médicaux, documents juridiques, relevés financiers — traités entièrement localement sans aucune donnée quittant la machine.

Cas d'usage 2 : Assistant Q&A visuel

• Applications : Inventaire d'entrepôt, inspection de terrain, accessibilité pour malvoyants.
• Implémentation : Capturer une image caméra (OpenCV), sauvegarder en JPEG, passer au VLM avec la transcription Whisper.
• Meilleurs modèles : LLaVA 1.6 7B ou Llama 3.2 Vision 11B pour la compréhension générale d'objets/scènes.
• Latence : 3–6 secondes pour capture image + traitement VLM + LLM + TTS sur RTX 4070.

Cas d'usage 3 : Transcription de réunion + Analyse de diapositives

• STT : Exécuter faster-whisper en mode streaming pendant la réunion.
• Vision : À chaque nouvelle diapositive, capturer un screenshot et le passer à LLaVA pour description.
• Combinaison : En fin de réunion, passer transcription + descriptions de diapositives à Llama 3.1 8B pour résumé et points d'action.
• Sortie : Résumé lu à voix haute (Piper TTS) + fichier texte sauvegardé localement.
• Valeur RGPD : Traitement complet de la réunion en local. Aucun audio, transcription ou diapositive envoyé à un service cloud.

Cas d'usage 4 : Outil d'accessibilité local

• Lecteur d'écran : Capturer un screenshot toutes les 2 secondes → LLaVA décrit ce qui est à l'écran → Piper le lit à voix haute.
• Navigation vocale : Whisper transcrit les commandes vocales → LLM interprète l'intention → exécuter actions clavier/souris via pyautogui.
• Bénéfice confidentialité : Les utilisateurs handicapés utilisent souvent des outils d'accessibilité dans des contextes sensibles. Un outil local garantit qu'aucun contenu d'écran n'est transmis à des tiers.
• Choix de modèle pour l'accessibilité : Moondream 2 pour des descriptions d'écran rapides (2 Go VRAM). LLaVA 7B pour des descriptions plus riches (6 Go VRAM).

Cas d'usage 5 : Analyse locale de caméra de sécurité

• Capture d'image : Utiliser OpenCV pour capturer une image toutes les 5–10 secondes depuis une caméra IP via RTSP.
• Détection de mouvement : Calculer la différence entre images consécutives. Ignorer les images sous le seuil de mouvement.
• Analyse VLM : Quand un mouvement est détecté, envoyer l'image au VLM : « Décrivez ce qui se passe. Y a-t-il une personne ? »
• Sortie alerte : Si une personne est détectée, déclencher une notification de bureau locale et une annonce Piper TTS.
• Avantage confidentialité : Ring et Nest envoient la vidéo vers AWS et les serveurs Google respectivement. Cette configuration garde toutes les images sur votre matériel.
• Meilleur VLM pour la vitesse : Moondream 2 (~1 seconde par image, ~2 Go VRAM) ou LLaVA 7B (~3 secondes, ~6 Go VRAM).

Construire l'orchestrateur Python

#!/usr/bin/env python3
"""Local multimodal orchestrator: voice + vision + text, all offline."""

import asyncio
import base64
import subprocess
import tempfile
import sounddevice as sd
import soundfile as sf
import numpy as np
import requests

OLLAMA_URL = "http://localhost:11434/api/generate"
WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-small.bin"
VISION_MODEL = "llava:7b"
TEXT_MODEL = "llama3.1:8b"
PIPER_VOICE = "voices/en_US-lessac-medium.onnx"
SAMPLE_RATE = 16000

async def transcribe_audio(audio: np.ndarray) -> str:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        sf.write(f.name, audio, SAMPLE_RATE)
        loop = asyncio.get_event_loop()
        result = await loop.run_in_executor(None, lambda: subprocess.run(
            [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", f.name, "--no-timestamps", "--no-prints"],
            capture_output=True, text=True
        ))
    return result.stdout.strip()

async def describe_image(image_path: str) -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, lambda: requests.post(
        OLLAMA_URL,
        json={"model": VISION_MODEL, "prompt": "Describe the content of this image in detail.", "images": [image_b64], "stream": False},
    ))
    return response.json()["response"]

async def reason(transcript: str, image_description: str | None = None) -> str:
    if image_description:
        prompt = f"The user asked (via voice): {transcript}\n\nThe image shows: {image_description}\n\nAnswer based on the image. Be concise."
    else:
        prompt = transcript
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, lambda: requests.post(
        OLLAMA_URL, json={"model": TEXT_MODEL, "prompt": prompt, "stream": False},
    ))
    return response.json()["response"]

async def speak(text: str) -> None:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        await asyncio.get_event_loop().run_in_executor(None, lambda: subprocess.run(
            f'echo "{text}" | piper --model {PIPER_VOICE} --output_file {f.name}', shell=True, check=True
        ))
        data, sr = sf.read(f.name)
        sd.play(data, sr)
        sd.wait()

async def process_query(audio: np.ndarray, image_path: str | None = None) -> None:
    if image_path:
        transcript, image_desc = await asyncio.gather(transcribe_audio(audio), describe_image(image_path))
    else:
        transcript = await transcribe_audio(audio)
        image_desc = None
    if not transcript or len(transcript) < 3:
        return
    response = await reason(transcript, image_desc)
    await speak(response)

async def main():
    while True:
        audio = sd.rec(int(5 * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype="int16")
        sd.wait()
        await process_query(audio)

if __name__ == "__main__":
    asyncio.run(main())

Optimisation des performances

• STT + VLM parallèles : Utiliser asyncio.gather(transcribe_audio(), describe_image()) pour exécuter les deux simultanément. Économise 0,3–2 secondes.
• Garder les modèles chauds : Ollama garde automatiquement les modèles en VRAM entre les requêtes. Ne jamais recharger entre les requêtes.
• Streamer LLM → TTS : Détecter les limites de phrases dans la sortie LLM. Passer chaque phrase complète à Piper pendant que le LLM continue de générer.
• Gestion VRAM : Si la VRAM est serrée, décharger le VLM après traitement image avant de charger le LLM textuel. Ajoute ~2–3 secondes mais permet à un GPU 8 Go de gérer le stack complet.
• Utiliser Llama 3.2 Vision comme VLM + LLM combiné : Élimine l'overhead de commutation de modèle — un modèle gère vision et raisonnement textuel.
• Cible premier audio TTS : Piper génère le premier audio en 50–100 ms. Streamer une phrase à la fois pour une latence TTS perçue inférieure à une seconde.

Limitations et évaluation honnête

• Coutures modales : La sortie vision est sérialisée en texte avant d'être transmise au LLM textuel. Le LLM ne peut pas raisonner directement sur les features visuelles — il raisonne sur une description texte de l'image.
• Pas de vidéo temps réel : Les VLMs locaux traitent des images individuelles, pas de vidéo continue. Pour la vidéo, extraire des images à 0,5–2 FPS et traiter séquentiellement.
• Écart de qualité VLM : Les modèles de vision locaux (LLaVA 7B, Llama 3.2 Vision 11B) sont en retrait par rapport à GPT-4o Vision sur les infographies complexes, le texte manuscrit et les scènes ambiguës.
• Pression VRAM : Exécuter trois modèles simultanément sur un seul GPU nécessite une gestion VRAM soigneuse. Sur les GPU 12 Go, les tailles de modèles doivent être choisies avec soin.
• Latence vs. cloud : Un appel multimodal cloud (GPT-4o) prend 1–3 secondes. Un pipeline local prend 3–8 secondes sur du matériel comparable.
• Cohérence : Les modèles locaux produisent une qualité de sortie plus variable que les modèles cloud. Des hallucinations occasionnelles sont à prévoir.

Questions fréquemment posées

Sources

• Ollama — Orchestration locale LLM, supporte modèles vision et APIs chat.
• whisper.cpp sur GitHub — Speech-to-text rapide CPU, accélération Metal/CUDA.
• LLaVA sur Hugging Face — Modèle Vision-Language open source.
• Llama 3.2 Vision — LLM multimodal, 11B.
• Piper TTS sur GitHub — Text-to-speech local rapide.

Lecture complémentaire

• Reconnaissance vocale locale 2026 : Whisper.cpp vs faster-whisper — Analyse approfondie du composant STT.
• Modèles de vision locaux 2026 : LLaVA, Llama 3.2 Vision et Ollama — Analyse approfondie du composant vision.
• TTS local et clonage vocal 2026 — Analyse approfondie du composant TTS.
• Construire un assistant vocal 100 % hors ligne en 2026 — La version voix uniquement (plus simple, sans vision).
• Guide matériel pour LLMs locaux 2026 — Sélection du matériel pour les pipelines multi-modèles.