Skip to content

Étiquetage ICL

Servez-vous de l'apprentissage en contexte dans Potato pour faire pré-étiqueter les instances par un LLM, puis renvoyez les cas ambigus à une vérification humaine — l'annotation passe à l'échelle avec l'IA dans la boucle.

L'étiquetage ICL (In-Context Learning, apprentissage en contexte) de Potato permet une annotation assistée par IA : les annotations humaines les plus sûres servent d'exemples en contexte pour guider un LLM qui étiquette le reste des données. Le système suit la confiance du LLM et renvoie les prédictions aux humains pour vérification.

Vue d'ensemble

Le système d'étiquetage ICL :

  1. Recueille les exemples fiables : repère les instances sur lesquelles les annotateurs s'accordent (par exemple 80 % d'accord ou plus)
  2. Étiquette avec le LLM : utilise ces exemples dans le prompt pour faire étiqueter les instances restantes
  3. Suit la confiance : enregistre le score de confiance du LLM pour chaque prédiction
  4. Vérifie la justesse : envoie un échantillon des instances étiquetées par le LLM à des humains, en vérification à l'aveugle
  5. Publie les métriques : calcule et affiche la justesse du LLM d'après les résultats de vérification

Fonctionnalités

Collecte automatique des exemples

Le système repère de lui-même les exemples fiables, ceux sur lesquels plusieurs annotateurs sont d'accord :

  • Seuil d'accord configurable (par défaut : 80 %)
  • Nombre minimal d'annotateurs requis (par défaut : 2)
  • Rafraîchissement automatique à intervalle configurable
  • Un vivier d'exemples par schéma

Étiquetage par le LLM, avec des limites

Pour favoriser l'amélioration progressive plutôt que l'étiquetage en masse :

  • Nombre total d'étiquettes : plafonne le nombre de prédictions du LLM
  • Proportion maximale de non étiquetés : n'étiqueter qu'un pourcentage des données restantes
  • Mise en pause si la justesse baisse : suspension automatique quand la justesse passe sous le seuil

Vérification à l'aveugle

La vérification se fait « à l'aveugle » : l'annotateur voit l'instance comme une tâche ordinaire, sans connaître la prédiction du LLM.

  • Taux d'échantillonnage configurable (par défaut : 20 % des étiquettes du LLM)
  • Plusieurs stratégies de sélection : low_confidence, random, mixed
  • Les tâches de vérification se mêlent naturellement aux attributions habituelles

Configuration

L'étiquetage ICL suppose que ai_support soit activé :

yaml
# AI endpoint configuration (required)
ai_support:
  enabled: true
  endpoint_type: "openai"
  ai_config:
    model: "gpt-4o-mini"
    api_key: "${OPENAI_API_KEY}"
 
# ICL labeling configuration
icl_labeling:
  enabled: true
 
  # Example selection settings
  example_selection:
    min_agreement_threshold: 0.8      # 80% annotators must agree
    min_annotators_per_instance: 2    # Minimum annotations for consensus
    max_examples_per_schema: 10       # Max examples per schema in prompt
    refresh_interval_seconds: 300     # How often to refresh examples
 
  # LLM labeling settings
  llm_labeling:
    batch_size: 20
    trigger_threshold: 5              # Min examples before LLM labeling starts
    confidence_threshold: 0.7         # Min confidence to accept prediction
    batch_interval_seconds: 600
    max_total_labels: 100             # Max instances to label total
    max_unlabeled_ratio: 0.5          # Max portion of unlabeled to label
    pause_on_low_accuracy: true
    min_accuracy_threshold: 0.7
 
  # Human verification settings
  verification:
    enabled: true
    sample_rate: 0.2                  # 20% of LLM labels verified
    selection_strategy: "low_confidence"
    mix_with_regular_assignments: true
    assignment_mix_rate: 0.2

Stratégies de sélection

  • low_confidence : fait vérifier en priorité les prédictions les moins sûres du LLM
  • random : tirage aléatoire parmi toutes les prédictions
  • mixed : 50 % de faible confiance et 50 % d'aléatoire

API d'administration

Point de terminaison d'état

http
GET /admin/api/icl/status

Renvoie l'état général de l'étiqueteur ICL : exemples par schéma, prédictions produites, taille de la file de vérification et métriques de justesse.

Point de terminaison des exemples

http
GET /admin/api/icl/examples?schema=sentiment

Renvoie les exemples fiables, éventuellement filtrés par schéma.

Point de terminaison de justesse

http
GET /admin/api/icl/accuracy?schema=sentiment

Renvoie les métriques de justesse calculées à partir des vérifications humaines.

Point de terminaison de déclenchement manuel

http
POST /admin/api/icl/trigger
Content-Type: application/json
 
{"schema_name": "sentiment"}

Lance manuellement l'étiquetage par lot pour un schéma donné.

Déroulement type

1. Configurer le projet

yaml
ai_support:
  enabled: true
  endpoint_type: "openai"
  ai_config:
    model: "gpt-4o-mini"
    api_key: "${OPENAI_API_KEY}"
 
icl_labeling:
  enabled: true
  example_selection:
    min_agreement_threshold: 0.8
  llm_labeling:
    max_total_labels: 50  # Start small
  verification:
    enabled: true
    sample_rate: 0.3  # Verify 30% initially

2. Recueillir des annotations humaines

Faites annoter les données normalement. Dès qu'un consensus se dégage (80 % d'accord ou plus), les instances concernées deviennent disponibles comme exemples.

3. Suivre l'avancement

bash
curl http://localhost:8000/admin/api/icl/status

4. Examiner la justesse

bash
curl http://localhost:8000/admin/api/icl/accuracy

5. Itérer

Selon la justesse observée :

  • Si elle est élevée (>80 %), augmentez max_total_labels
  • Si elle est faible, ajoutez des exemples humains avant de poursuivre

Bonnes pratiques

  1. Commencez petit : partez de limites prudentes (max_total_labels: 50) pour jauger la justesse avant de monter en charge

  2. Vérifiez tôt : utilisez au départ un sample_rate élevé (0.3 à 0.5) pour obtenir des estimations de justesse fiables

  3. Surveillez activement : consultez régulièrement les métriques de justesse via l'API d'administration

  4. Ajustez les seuils : si la justesse du LLM est faible :

    • Augmentez min_agreement_threshold pour des exemples plus propres
    • Augmentez trigger_threshold pour disposer de plus d'exemples avant d'étiqueter
    • Abaissez confidence_threshold pour écarter les prédictions incertaines

  5. Exploitez les stratégies de sélection :

    • low_confidence : le meilleur choix pour repérer les catégories problématiques
    • random : le meilleur choix pour une estimation non biaisée de la justesse
    • mixed : un compromis entre les deux

Dépannage

Le LLM n'étiquette rien

  1. Vérifiez que ai_support est correctement configuré
  2. Vérifiez qu'il existe assez d'exemples fiables
  3. Vérifiez que l'étiquetage n'est pas en pause à cause des limites ou d'une justesse trop basse

Justesse trop faible

  1. Augmentez min_agreement_threshold pour des exemples plus propres
  2. Étoffez les consignes d'annotation
  3. Passez en revue les exemples utilisés (/admin/api/icl/examples)

Les tâches de vérification n'apparaissent pas

  1. Vérifiez que verification.enabled vaut true
  2. Vérifiez que mix_with_regular_assignments vaut true
  3. Vérifiez qu'il y a bien des vérifications en attente dans la file

Pour aller plus loin

Pour les détails d'implémentation, consultez la documentation source.