Utiliser l'IA visuelle pour accélérer l'annotation d'images et de vidéos

Potato 2.1 introduit le support de l'IA visuelle qui apporte l'assistance IA directement dans les flux de travail d'annotation d'images et de vidéos. Au lieu d'annoter chaque boîte englobante à partir de zéro, vous pouvez demander à YOLO de détecter automatiquement les objets puis réviser ses suggestions, ou demander à un modèle vision-langage de classifier les images et d'expliquer son raisonnement.

Ce guide vous accompagne dans la configuration de chaque endpoint d'IA visuelle, la configuration des différents modes d'assistance et la combinaison de l'IA visuelle avec les fonctionnalités d'IA textuelle de Potato.

Ce que vous apprendrez

Configurer YOLO pour une détection d'objets locale rapide
Exécuter des modèles Ollama Vision pour la compréhension d'images locale
Utiliser les API cloud de vision OpenAI et Anthropic
Configurer les modes de détection, pré-annotation, classification et indices
Combiner des endpoints d'IA visuelle et textuelle dans un seul projet
Le flux de travail accepter/rejeter pour examiner les suggestions IA

Prérequis

Vous aurez besoin de Potato 2.1.0 ou ultérieur :

bash

pip install --upgrade potato-annotation

Et selon l'endpoint que vous choisissez, vous aurez besoin de l'un de ces éléments :

YOLO : pip install ultralytics opencv-python
Ollama : installez depuis ollama.ai et téléchargez un modèle de vision
OpenAI : une clé API avec accès à GPT-4o
Anthropic : une clé API avec accès aux modèles de vision Claude

Option 1 : YOLO pour la détection d'objets

YOLO est le meilleur choix lorsque vous avez besoin d'une détection de boîtes englobantes rapide et précise s'exécutant entièrement sur votre machine locale. Il excelle dans la détection d'objets courants (personnes, voitures, animaux, meubles) et peut traiter des images en quelques millisecondes.

Installation

bash

pip install ultralytics opencv-python

Configuration

yaml

annotation_task_name: "Object Detection with YOLO"
 
data_files:
  - data/images.json
 
item_properties:
  id_key: id
  text_key: image_url
 
instance_display:
  fields:
    - key: image_url
      type: image
      display_options:
        max_width: 800
        zoomable: true
 
annotation_schemes:
  - annotation_type: image_annotation
    name: objects
    description: "Detect and label objects"
    source_field: "image_url"
    tools:
      - bbox
    labels:
      - name: "person"
        color: "#FF6B6B"
      - name: "car"
        color: "#4ECDC4"
      - name: "dog"
        color: "#45B7D1"
      - name: "cat"
        color: "#96CEB4"
 
    ai_support:
      enabled: true
      features:
        detection: true
        pre_annotate: true
        hint: true
 
ai_support:
  enabled: true
  endpoint_type: "yolo"
  ai_config:
    model: "yolov8m.pt"
    confidence_threshold: 0.5
    iou_threshold: 0.45
 
output_annotation_dir: "annotation_output/"
user_config:
  allow_all_users: true

Format des données

Créez data/images.json au format JSONL (un objet JSON par ligne) :

json

{"id": "img_001", "image_url": "images/street_scene_1.jpg"}
{"id": "img_002", "image_url": "images/park_photo.jpg"}
{"id": "img_003", "image_url": "https://example.com/images/office.jpg"}

Choisir un modèle YOLO

Modèle	Taille	Vitesse	Précision	Idéal pour
`yolov8n.pt`	6 Mo	Plus rapide	Plus faible	Prototypage rapide
`yolov8s.pt`	22 Mo	Rapide	Bonne	Charges de travail équilibrées
`yolov8m.pt`	50 Mo	Moyenne	Meilleure	Usage général
`yolov8l.pt`	84 Mo	Plus lente	Élevée	Quand la précision compte
`yolov8x.pt`	131 Mo	Plus lente	Maximale	Précision maximale

Pour détecter des objets absents des classes intégrées de YOLO, utilisez YOLO-World pour la détection à vocabulaire ouvert :

yaml

ai_config:
  model: "yolo-world"
  confidence_threshold: 0.3

Ajuster la détection

Si YOLO manque des objets, baissez le seuil de confiance :

yaml

ai_config:
  confidence_threshold: 0.3  # More detections, more false positives

Si vous obtenez trop de faux positifs, augmentez-le :

yaml

ai_config:
  confidence_threshold: 0.7  # Fewer detections, higher precision

Option 2 : Ollama Vision pour les VLLMs locaux

Ollama Vision vous donne la puissance des modèles vision-langage s'exécutant localement. Contrairement à YOLO, ces modèles peuvent comprendre le contexte de l'image, classifier les scènes et générer des explications textuelles -- le tout sans envoyer de données à une API cloud.

Installation

bash

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh
 
# Pull a vision model
ollama pull llava
 
# Or for better performance:
ollama pull qwen2.5-vl:7b

Configuration

yaml

annotation_task_name: "Image Classification with Ollama Vision"
 
data_files:
  - data/images.json
 
item_properties:
  id_key: id
  text_key: image_url
 
instance_display:
  fields:
    - key: image_url
      type: image
      display_options:
        max_width: 600
        zoomable: true
 
annotation_schemes:
  - annotation_type: radio
    name: scene_type
    description: "What type of scene is shown?"
    labels:
      - indoor
      - outdoor_urban
      - outdoor_nature
      - aerial
      - underwater
 
    ai_support:
      enabled: true
      features:
        hint: true
        classification: true
 
ai_support:
  enabled: true
  endpoint_type: "ollama_vision"
  ai_config:
    model: "llava:latest"
    base_url: "http://localhost:11434"
    max_tokens: 500
    temperature: 0.1
 
output_annotation_dir: "annotation_output/"
user_config:
  allow_all_users: true

Modèles supportés

Modèle	Paramètres	Points forts
`llava:7b`	7B	Rapide, bonne compréhension générale
`llava:13b`	13B	Meilleure précision
`llava-llama3`	8B	Raisonnement solide
`bakllava`	7B	Bons détails visuels
`llama3.2-vision:11b`	11B	Dernière version Llama vision
`qwen2.5-vl:7b`	7B	Fort en multilingue + vision
`moondream`	1.8B	Très rapide, léger

Option 3 : OpenAI Vision

OpenAI Vision fournit une compréhension d'images de haute qualité via GPT-4o. Idéal quand vous avez besoin du modèle de vision le plus performant et que les coûts d'API cloud ne sont pas un problème.

Configuration

yaml

ai_support:
  enabled: true
  endpoint_type: "openai_vision"
  ai_config:
    api_key: "${OPENAI_API_KEY}"
    model: "gpt-4o"
    max_tokens: 1000
    detail: "auto"  # "low" for faster/cheaper, "high" for detail

Définissez votre clé API :

bash

export OPENAI_API_KEY="sk-..."

Le paramètre detail contrôle la résolution d'image envoyée à l'API :

low -- Plus rapide et moins cher, bon pour la classification
high -- Résolution complète, meilleur pour trouver de petits objets
auto -- Laissez l'API décider

Option 4 : Anthropic Vision

Les capacités de vision de Claude sont fortes pour comprendre le contexte des images et fournir des explications détaillées.

Configuration

yaml

ai_support:
  enabled: true
  endpoint_type: "anthropic_vision"
  ai_config:
    api_key: "${ANTHROPIC_API_KEY}"
    model: "claude-sonnet-4-20250514"
    max_tokens: 1024

bash

export ANTHROPIC_API_KEY="sk-ant-..."

Modes d'assistance IA

Chaque endpoint d'IA visuelle supporte différents modes d'assistance. Activez uniquement ceux dont vous avez besoin par schéma d'annotation.

Mode détection

Trouve les objets correspondant à vos étiquettes configurées et les affiche en superposition de boîtes englobantes en pointillés :

yaml

ai_support:
  enabled: true
  features:
    detection: true

L'annotateur clique sur « Détecter », et les suggestions IA apparaissent en superpositions pointillées sur l'image. Double-cliquez pour accepter, clic droit pour rejeter.

Mode pré-annotation (Auto)

Détecte automatiquement tous les objets et crée des suggestions en une seule passe. Idéal pour amorcer de grands ensembles de données :

yaml

ai_support:
  enabled: true
  features:
    pre_annotate: true

Mode classification

Classifie une région sélectionnée ou l'image entière, retournant une étiquette suggérée avec un score de confiance :

yaml

ai_support:
  enabled: true
  features:
    classification: true

Mode indices

Fournit un texte de guidage sans donner la réponse. Bon pour former de nouveaux annotateurs :

yaml

ai_support:
  enabled: true
  features:
    hint: true

Le flux de travail accepter/rejeter

Quand un annotateur clique sur un bouton d'assistance IA, les suggestions apparaissent en superpositions pointillées :

Accepter une suggestion -- Double-cliquez sur la superposition pointillée pour la convertir en annotation réelle
Rejeter une suggestion -- Clic droit sur la superposition pour la rejeter
Tout accepter -- Cliquez sur « Tout accepter » dans la barre d'outils pour accepter toutes les suggestions d'un coup
Tout effacer -- Cliquez sur « Effacer » pour rejeter toutes les suggestions

Cela garde les annotateurs en contrôle tout en réduisant le travail manuel de dessin de boîtes à partir de zéro.

Annotation vidéo avec IA visuelle

L'IA visuelle fonctionne aussi avec les tâches d'annotation vidéo. Vous pouvez activer la détection de scènes, la détection d'images clés et le suivi d'objets :

yaml

annotation_schemes:
  - annotation_type: video_annotation
    name: scenes
    description: "Segment this video into scenes"
    mode: segment
    labels:
      - name: "intro"
        color: "#4ECDC4"
      - name: "main_content"
        color: "#FF6B6B"
      - name: "outro"
        color: "#45B7D1"
 
    ai_support:
      enabled: true
      features:
        scene_detection: true
        pre_annotate: true
        hint: true
 
ai_support:
  enabled: true
  endpoint_type: "ollama_vision"
  ai_config:
    model: "llava:latest"
    max_frames: 10  # Number of frames to sample

Le paramètre max_frames contrôle le nombre d'images que l'IA échantillonne de la vidéo pour l'analyse. Plus d'images signifie une meilleure précision mais un traitement plus lent.

Combiner les endpoints d'IA visuelle et textuelle

Si votre projet a à la fois de l'annotation textuelle et d'images, vous pouvez configurer des endpoints séparés pour chacun. Utilisez un modèle optimisé pour le texte pour les indices et les mots-clés, et un modèle de vision pour la détection :

yaml

ai_support:
  enabled: true
 
  # Text AI for radio buttons, text schemes, etc.
  endpoint_type: "ollama"
  ai_config:
    model: "llama3.2"
    include:
      all: true
 
  # Visual AI for image/video schemes
  visual_endpoint_type: "yolo"
  visual_ai_config:
    model: "yolov8m.pt"
    confidence_threshold: 0.5

Ou utilisez un modèle de vision cloud avec un modèle textuel local :

yaml

ai_support:
  enabled: true
  endpoint_type: "ollama"
  visual_endpoint_type: "openai_vision"
  ai_config:
    model: "llama3.2"
  visual_ai_config:
    api_key: "${OPENAI_API_KEY}"
    model: "gpt-4o"

Exemple complet : annotation de photos de produits

Voici une configuration prête pour la production pour annoter des photos de produits avec la détection YOLO et des indices IA textuels :

yaml

annotation_task_name: "Product Photo Annotation"
 
data_files:
  - data/product_photos.json
 
item_properties:
  id_key: sku
  text_key: photo_url
 
instance_display:
  layout:
    direction: horizontal
    gap: 24px
  fields:
    - key: photo_url
      type: image
      label: "Product Photo"
      display_options:
        max_width: 600
        zoomable: true
    - key: product_description
      type: text
      label: "Product Details"
 
annotation_schemes:
  - annotation_type: image_annotation
    name: product_regions
    description: "Draw boxes around products and defects"
    source_field: "photo_url"
    tools:
      - bbox
    labels:
      - name: "product"
        color: "#4ECDC4"
      - name: "defect"
        color: "#FF6B6B"
      - name: "label"
        color: "#45B7D1"
      - name: "packaging"
        color: "#96CEB4"
 
    ai_support:
      enabled: true
      features:
        detection: true
        pre_annotate: true
 
  - annotation_type: radio
    name: photo_quality
    description: "Is this photo suitable for the product listing?"
    labels:
      - Approved
      - Needs editing
      - Reshoot required
 
  - annotation_type: multiselect
    name: quality_issues
    description: "Select any issues present"
    labels:
      - Blurry
      - Poor lighting
      - Wrong angle
      - Background clutter
      - Color inaccurate
 
ai_support:
  enabled: true
  endpoint_type: "ollama"
  visual_endpoint_type: "yolo"
 
  ai_config:
    model: "llama3.2"
    include:
      all: true
 
  visual_ai_config:
    model: "yolov8m.pt"
    confidence_threshold: 0.5
 
output_annotation_dir: "annotation_output/"
output_annotation_format: "json"
user_config:
  allow_all_users: true

Données d'exemple (data/product_photos.json) :

json

{"sku": "SKU-001", "photo_url": "images/products/laptop_front.jpg", "product_description": "15-inch laptop, silver finish"}
{"sku": "SKU-002", "photo_url": "images/products/headphones_side.jpg", "product_description": "Over-ear wireless headphones, black"}
{"sku": "SKU-003", "photo_url": "images/products/backpack_full.jpg", "product_description": "40L hiking backpack, navy blue"}

Conseils pour l'annotation avec IA visuelle

Commencez par la pré-annotation pour les grands ensembles de données -- Utilisez le bouton Auto pour générer des suggestions pour tous les objets, puis demandez aux annotateurs de réviser et corriger plutôt que de dessiner à partir de zéro
Adaptez l'endpoint à votre tâche -- YOLO pour la détection précise, VLLMs pour la classification et la compréhension
Ajustez les seuils de confiance -- Commencez à 0,5 et ajustez en fonction du compromis faux positifs/faux négatifs observé
Utilisez les indices pour la formation des annotateurs -- Le mode indices guide les annotateurs sans les biaiser vers une réponse spécifique
Combinez les endpoints -- Un endpoint visuel YOLO pour la détection plus un endpoint textuel Ollama pour les indices vous donne le meilleur des deux mondes
Mettez en cache les résultats IA -- Activez la mise en cache sur disque pour éviter de relancer la détection sur les mêmes images

Dépannage

« No visual AI endpoint configured »

Assurez-vous que ai_support.enabled est true et que vous avez défini un endpoint_type qui supporte la vision : yolo, ollama_vision, openai_vision ou anthropic_vision.

YOLO ne détecte pas vos objets

Les classes intégrées de YOLO couvrent 80 objets courants. Si vos étiquettes ne correspondent pas aux noms de classes de YOLO, essayez YOLO-World pour la détection à vocabulaire ouvert, ou baissez le confidence_threshold.

Ollama retourne des erreurs

Vérifiez qu'Ollama est en cours d'exécution et que vous avez téléchargé un modèle de vision :

bash

curl http://localhost:11434/api/tags  # Check Ollama is running
ollama list                           # Check installed models

Réponse lente des API cloud

Activez la mise en cache pour que la même image ne soit pas analysée deux fois :

yaml

ai_support:
  cache_config:
    disk_cache:
      enabled: true
      path: "ai_cache/visual_cache.json"

Prochaines étapes

Lisez la documentation complète du support IA visuelle pour les détails de référence de l'API
Configurez l'affichage d'instances pour afficher des images à côté d'autres types de contenu
Explorez le support IA textuel pour les indices et la mise en surbrillance de mots-clés

Documentation complète sur /docs/features/visual-ai-support.