Skip to content

Support IA

Branchez OpenAI, Claude, Gemini, Ollama, HuggingFace, vLLM et OpenRouter sur Potato pour obtenir des suggestions d'étiquettes, de la pré-annotation et un surlignage de mots-clés assisté par IA.

Potato 2.0 intègre nativement les grands modèles de langage (LLM) pour aider les annotateurs : indices contextuels, surlignage de mots-clés et suggestions d'étiquettes.

Fournisseurs pris en charge

Potato fonctionne avec plusieurs fournisseurs de LLM :

Fournisseurs cloud :

  • OpenAI (GPT-4, GPT-4 Turbo, GPT-3.5)
  • Anthropic (Claude 3, Claude 3.5)
  • Google (Gemini 1.5 Pro, Gemini 2.0 Flash)
  • Hugging Face
  • OpenRouter

Local / auto-hébergé :

  • Ollama (exécution des modèles en local)
  • vLLM (inférence auto-hébergée haute performance)

Configuration

Configuration de base

Ajoutez une section ai_support à votre fichier de configuration :

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
    temperature: 0.3
    max_tokens: 500

Configuration par fournisseur

OpenAI

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4o
    api_key: ${OPENAI_API_KEY}
    temperature: 0.3
    max_tokens: 500

Anthropic Claude

yaml
ai_support:
  enabled: true
  endpoint_type: anthropic
 
  ai_config:
    model: claude-3-sonnet-20240229
    api_key: ${ANTHROPIC_API_KEY}
    temperature: 0.3
    max_tokens: 500

Google Gemini

yaml
ai_support:
  enabled: true
  endpoint_type: google
 
  ai_config:
    model: gemini-1.5-pro
    api_key: ${GOOGLE_API_KEY}

Ollama en local

yaml
ai_support:
  enabled: true
  endpoint_type: ollama
 
  ai_config:
    model: llama2
    base_url: http://localhost:11434

vLLM (auto-hébergé)

yaml
ai_support:
  enabled: true
  endpoint_type: vllm
 
  ai_config:
    model: meta-llama/Llama-2-7b-chat-hf
    base_url: http://localhost:8000/v1

Points de terminaison IA pour le visuel

Nouveau dans la v2.1.0

Pour les tâches d'annotation d'images et de vidéos, Potato propose des points de terminaison de vision dédiés : YOLO, Ollama Vision, OpenAI Vision et Anthropic Vision. Ils permettent la détection d'objets, la pré-annotation et la classification visuelle.

Voir Support IA pour le visuel pour la configuration complète.

Fonctionnalités IA

Le support IA de Potato couvre cinq usages principaux :

1. Indices contextuels

Donner des repères aux annotateurs sans leur souffler la réponse :

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
 
  # Hints appear as tooltips or sidebars
  features:
    hints:
      enabled: true

2. Surlignage de mots-clés

Surligner automatiquement les mots-clés pertinents dans le texte :

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
 
  features:
    keyword_highlighting:
      enabled: true
      # Highlights are rendered as box overlays on the text

3. Suggestions d'étiquettes

Proposer des étiquettes à l'annotateur, accompagnées d'un indicateur de confiance :

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
 
  features:
    label_suggestions:
      enabled: true
      show_confidence: true

4. Justifications des étiquettes

Nouveau dans la v2.1.0

Produire, pour chaque étiquette, une explication équilibrée de ce qui plaide en sa faveur, afin que les annotateurs comprennent le raisonnement derrière les différentes classifications :

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
 
  features:
    rationales:
      enabled: true

Les justifications apparaissent dans une infobulle qui liste chaque étiquette disponible avec l'explication correspondante. C'est utile pour former les annotateurs ou pour les décisions d'annotation difficiles.

5. Surlignage des options

Nouveau dans la v2.2.0

Mise en avant, par l'IA, des options les plus vraisemblables pour les tâches d'annotation discrètes (radio, multiselect, likert, select). Le système analyse le contenu, met en avant les k options les plus probables et atténue les autres, toutes restant cliquables.

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4o-mini
    api_key: ${OPENAI_API_KEY}
 
  option_highlighting:
    enabled: true
    top_k: 3
    dim_opacity: 0.4
    auto_apply: true

Voir Surlignage des options pour la configuration complète.

En complément : ordonnancement par diversité

Nouveau dans la v2.2.0

Ce n'est pas à proprement parler une fonctionnalité d'IA, mais l'ordonnancement par diversité utilise des plongements sentence-transformer pour regrouper les éléments et les présenter dans un ordre varié, ce qui limite la fatigue des annotateurs et améliore la couverture. Il s'articule avec le support IA en préchargeant automatiquement les indices IA des éléments réordonnés.

Cache et performances

Les réponses de l'IA peuvent être mises en cache pour gagner en réactivité et réduire les coûts d'API :

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
 
  cache_config:
    disk_cache:
      enabled: true
      path: "ai_cache/cache.json"
 
    # Pre-generate hints on startup and prefetch upcoming
    prefetch:
      warm_up_page_count: 100
      on_next: 5
      on_prev: 2

Stratégies de mise en cache

  1. Préchauffage : génère à l'avance les indices IA d'un premier lot d'instances au démarrage du serveur (warm_up_page_count)
  2. Préchargement : génère les indices des instances à venir au fur et à mesure que les annotateurs avancent (on_next) ou reculent (on_prev)
  3. Persistance sur disque : les caches sont écrits sur disque et survivent aux redémarrages du serveur

Prompts personnalisés

Potato fournit un prompt par défaut pour chaque type d'annotation, dans potato/ai/prompt/. Vous pouvez les adapter à votre tâche :

Type d'annotationFichier de prompt
Boutons radioradio_prompt.txt
Échelles de Likertlikert_prompt.txt
Cases à cochercheckbox_prompt.txt
Annotation d'empansspan_prompt.txt
Curseursslider_prompt.txt
Listes déroulantesdropdown_prompt.txt
Saisie numériquenumber_prompt.txt
Saisie de textetext_prompt.txt

Les prompts acceptent des variables de substitution :

  • {text} - Le texte du document
  • {labels} - Les étiquettes disponibles pour le schéma
  • {description} - La description du schéma

Plusieurs schémas

Pour les tâches comportant plusieurs schémas d'annotation, le support IA peut être activé de façon sélective :

yaml
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
    model: gpt-4
    api_key: ${OPENAI_API_KEY}
 
  # Only enable for specific schemes
  special_include:
    - page: 1
      schema: sentiment
    - page: 1
      schema: topics

Exemple complet

Configuration complète pour une analyse de sentiment assistée par IA :

yaml
annotation_task_name: "AI-Assisted Sentiment Analysis"
task_dir: "."
port: 8000
 
data_files:
  - "data/reviews.json"
 
item_properties:
  id_key: id
  text_key: text
 
annotation_schemes:
  - annotation_type: radio
    name: sentiment
    description: "What is the sentiment of this review?"
    labels:
      - Positive
      - Negative
      - Neutral
 
ai_support:
  enabled: true
  endpoint_type: openai
 
  ai_config:
 
  features:
 
  cache_config:
 
output_annotation_dir: "output/"
export_annotation_format: "json"
user_config:
  allow_all_users: true

Variables d'environnement

Conservez vos clés d'API dans des variables d'environnement :

bash
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GOOGLE_API_KEY="..."

Référencez-les dans la configuration avec la syntaxe ${VARIABLE_NAME}.

Maîtrise des coûts

  • Par défaut, un appel à l'IA est fait par instance
  • Activez le cache pour éviter de répéter les mêmes appels
  • Servez-vous du préchauffage et du préchargement pour générer les indices à l'avance
  • Envisagez des modèles plus petits ou moins chers pour les tâches simples
  • Les fournisseurs locaux (Ollama, vLLM) ne coûtent rien en API

Bonnes pratiques

  1. L'IA assiste, elle ne remplace pas - La décision finale revient à l'annotateur
  2. Activez le cache en production - Moins de latence et moins de coûts
  3. Testez vos prompts sérieusement - Un prompt personnalisé doit être validé
  4. Surveillez les coûts d'API - Suivez la consommation, surtout chez les fournisseurs cloud
  5. Pensez aux fournisseurs locaux - Ollama ou vLLM pour l'annotation à gros volume
  6. Protégez vos identifiants d'API - Passez par des variables d'environnement, ne versionnez jamais une clé

Pour aller plus loin

Pour les détails d'implémentation et les modèles de prompts personnalisés, consultez la documentation source.