Potato 2.3 : Annotation agentique, Solo Mode et l'avenir de l'évaluation humaine

Nous sommes ravis d'annoncer Potato 2.3.0, la plus grande version de l'histoire de Potato. Cette mise à jour introduit deux nouveaux systèmes majeurs -- l'annotation agentique et le Solo Mode -- aux côtés du Best-Worst Scaling, de l'authentification SSO/OAuth, de l'export Parquet et de 15 nouveaux projets de démonstration.

Le thème de cette version est simple : les choses que nous devons annoter ont changé, et nos outils doivent suivre. Les chercheurs ne se contentent plus d'étiqueter le sentiment de textes et les entités nommées. Ils évaluent des traces d'agents IA multi-étapes, comparent des sorties de LLM à grande échelle et construisent des ensembles de données pour des tâches de plus en plus complexes. Potato 2.3 est conçu pour cette nouvelle réalité.

Annotation agentique

La fonctionnalité phare de Potato 2.3 est un système complet pour évaluer les agents IA par l'annotation humaine.

Les agents IA -- des systèmes qui exécutent des actions multi-étapes pour accomplir des tâches -- prolifèrent rapidement. Mais les évaluer est difficile. Une seule exécution d'agent peut impliquer des dizaines d'appels d'outils, d'étapes de raisonnement, de navigations de pages web et de sorties intermédiaires. Les outils d'annotation existants affichent les sorties des agents comme du texte brut, perdant la structure riche dont les évaluateurs ont besoin.

Le système d'annotation agentique de Potato résout ce problème avec trois composants.

12 convertisseurs de formats de traces

Les traces d'agents se présentent dans différents formats selon le framework. Potato les normalise tous en une représentation unifiée :

La configuration est simple :

agentic:
  enabled: true
  trace_converter: react
  trace_file: "data/agent_traces.jsonl"

La détection automatique est disponible pour les projets qui doivent ingérer des traces de sources multiples :

agentic:
  enabled: true
  trace_converter: auto

Trois types d'affichage

Différentes modalités d'agents nécessitent différentes visualisations.

L'affichage de traces d'agent rend les traces d'agents utilisant des outils sous forme de cartes d'étapes codées par couleur avec des observations réductibles, un formatage JSON et une barre latérale chronologique :

agentic:
  display_type: agent_trace
  agent_trace_display:
    colors:
      thought: "#6E56CF"
      action: "#3b82f6"
      observation: "#22c55e"
      error: "#ef4444"
    collapse_observations: true
    show_step_numbers: true

L'affichage de traces d'agent web rend les traces d'agents de navigation avec des captures d'écran complètes, des superpositions SVG montrant les cibles de clic et les champs de saisie, et une pellicule pour une navigation rapide :

agentic:
  display_type: web_agent
  web_agent_display:
    screenshot_max_width: 900
    overlay:
      enabled: true
      click_marker: "circle"
      click_color: "#ef4444"
    filmstrip:
      enabled: true

L'affichage de chat interactif supporte à la fois la revue de traces (évaluation d'une conversation enregistrée) et le chat en direct (les annotateurs interagissent avec un agent en temps réel, puis évaluent la conversation) :

agentic:
  display_type: interactive_chat
  interactive_chat_display:
    mode: trace_review
    trace_review:
      show_token_counts: true
      show_latency: true

Notations par tour

Pour tout type d'affichage, les annotateurs peuvent noter les étapes individuelles en plus de la trace globale :

annotation_schemes:
  - annotation_type: likert
    name: overall_quality
    min: 1
    max: 5
 
  - annotation_type: per_turn_rating
    name: step_correctness
    target: agentic_steps
    rating_type: radio
    labels:
      - "Correct"
      - "Partially Correct"
      - "Incorrect"

Schémas pré-construits

Neuf schémas d'annotation couvrent les dimensions courantes d'évaluation d'agents prêts à l'emploi :

annotation_schemes:
  - preset: agent_task_success
  - preset: agent_step_correctness
  - preset: agent_error_taxonomy
  - preset: agent_safety

Presets disponibles : agent_task_success, agent_step_correctness, agent_error_taxonomy, agent_safety, agent_efficiency, agent_instruction_following, agent_explanation_quality, agent_web_action_correctness, agent_conversation_quality.

Lire la documentation de l'annotation agentique →

Solo Mode

La deuxième fonctionnalité majeure de Potato 2.3 est le Solo Mode : un flux de travail en 12 phases qui remplace le paradigme traditionnel multi-annotateurs par un seul expert humain collaborant avec un LLM.

Le problème

L'annotation traditionnelle nécessite plusieurs annotateurs pour la fiabilité. Mais recruter, former et coordonner une équipe est coûteux et lent. Pour de nombreux projets de recherche, le goulot d'étranglement de l'annotation n'est pas l'interface -- c'est la logistique.

La solution

Le Solo Mode permet à un seul expert du domaine d'étiqueter un sous-ensemble stratégiquement sélectionné des données. Un LLM apprend de ces étiquettes, propose des étiquettes pour les instances restantes, et l'humain ne révise que les cas où le LLM a des difficultés. Un flux de travail en 12 phases orchestre tout cela automatiquement.

Dans les benchmarks internes, le Solo Mode a atteint un accord de plus de 95% avec les pipelines multi-annotateurs complets tout en ne nécessitant que 10 à 15% du total des étiquettes humaines.

Les 12 phases

1. Annotation initiale -- l'humain étiquette 50 instances diversifiées
2. Calibration initiale du LLM -- le LLM étiquette un lot de calibration en utilisant les exemples initiaux
3. Analyse de confusion -- identifier les schémas de désaccord systématiques humain-LLM
4. Affinement des directives -- le LLM propose des directives améliorées ; l'humain approuve
5. Génération de fonctions d'étiquetage -- règles programmatiques inspirées d'ALCHEmist pour les instances faciles
6. Étiquetage actif -- l'humain étiquette les instances restantes les plus informatives
7. Boucle de raffinement automatisée -- ré-étiquetage itératif avec des directives mises à jour
8. Exploration des désaccords -- l'humain résout les cas où le LLM et les fonctions d'étiquetage sont en conflit
9. Synthèse de cas limites -- le LLM génère des exemples synthétiques ambigus pour l'étiquetage humain
10. Escalade de confiance en cascade -- l'humain révise les étiquettes LLM à plus faible confiance
11. Optimisation de prompt -- recherche automatisée de prompts inspirée de DSPy
12. Validation finale -- revue d'un échantillon aléatoire ; réussite ou retour en arrière

Démarrage rapide

solo_mode:
  enabled: true
  llm:
    endpoint_type: openai
    model: "gpt-4o"
    api_key: ${OPENAI_API_KEY}
  seed_count: 50
  accuracy_threshold: 0.92
  confidence_threshold: 0.85
 
annotation_schemes:
  - annotation_type: radio
    name: sentiment
    labels: [Positive, Neutral, Negative]

Priorisation multi-signaux des instances

Le Solo Mode utilise six pools pondérés pour sélectionner les instances les plus précieuses pour l'étiquetage humain :

solo_mode:
  prioritization:
    pools:
      - name: uncertain
        weight: 0.30
      - name: disagreement
        weight: 0.25
      - name: boundary
        weight: 0.20
      - name: novel
        weight: 0.10
      - name: error_pattern
        weight: 0.10
      - name: random
        weight: 0.05

Lire la documentation du Solo Mode →

Best-Worst Scaling

Potato 2.3 ajoute le Best-Worst Scaling (BWS), également connu sous le nom de Maximum Difference Scaling. Les annotateurs voient un tuple d'éléments (généralement 4) et sélectionnent le meilleur et le pire selon un critère. Le BWS produit des scores scalaires fiables à partir de simples jugements binaires, nécessitant beaucoup moins d'annotations que les échelles de Likert pour la même puissance statistique.

annotation_schemes:
  - annotation_type: best_worst_scaling
    name: fluency
    description: "Select the BEST and WORST translation"
    items_key: "translations"
    tuple_size: 4
    best_label: "Most Fluent"
    worst_label: "Least Fluent"
    randomize_order: true
 
    tuple_generation:
      method: balanced_incomplete
      tuples_per_item: 5
 
    scoring:
      method: bradley_terry
      auto_compute: true
      include_confidence: true

Trois méthodes de scoring sont disponibles :

• Comptage -- simple (nombre_meilleur - nombre_pire) / apparitions
• Bradley-Terry -- modèle de comparaison par paires (défaut recommandé)
• Plackett-Luce -- modèle de classement complet pour une efficacité maximale des données

Scoring depuis le CLI :

python -m potato.bws score --config config.yaml --method bradley_terry --output scores.csv

Le tableau de bord d'administration inclut un onglet BWS avec les distributions de scores, les graphiques de convergence et les métriques de fiabilité split-half.

Lire la documentation du Best-Worst Scaling →

Authentification SSO et OAuth

Les déploiements d'annotation en production nécessitent une authentification appropriée. Potato 2.3 supporte trois méthodes OAuth :

Google OAuth

authentication:
  method: google_oauth
  google_oauth:
    client_id: ${GOOGLE_CLIENT_ID}
    client_secret: ${GOOGLE_CLIENT_SECRET}
    redirect_uri: "https://annotation.example.com/auth/google/callback"
    allowed_domains:
      - "umich.edu"
    auto_register: true

GitHub OAuth avec restriction d'organisation

authentication:
  method: github_oauth
  github_oauth:
    client_id: ${GITHUB_CLIENT_ID}
    client_secret: ${GITHUB_CLIENT_SECRET}
    redirect_uri: "https://annotation.example.com/auth/github/callback"
    allowed_organizations:
      - "my-research-lab"
    scopes:
      - "read:user"
      - "read:org"

OIDC générique

Connectez-vous à Okta, Azure AD, Auth0, Keycloak ou tout fournisseur compatible OIDC :

authentication:
  method: oidc
  oidc:
    discovery_url: "https://accounts.example.com/.well-known/openid-configuration"
    client_id: ${OIDC_CLIENT_ID}
    client_secret: ${OIDC_CLIENT_SECRET}
    redirect_uri: "https://annotation.example.com/auth/oidc/callback"

Toutes les méthodes supportent la restriction de domaine, l'inscription automatique et le mode mixte (plusieurs méthodes d'authentification sur une seule page de connexion).

Lire la documentation SSO et OAuth →

Export Parquet

Les données d'annotation sont de plus en plus consommées par des outils de science des données qui attendent des formats en colonnes. Potato 2.3 peut exporter les annotations directement en Apache Parquet, produisant trois fichiers structurés :

• annotations.parquet -- une ligne par (instance, annotateur, schéma) avec valeurs, horodatages et durées
• spans.parquet -- une ligne par span annoté avec offsets, étiquettes et liens
• items.parquet -- métadonnées des instances avec nombre d'annotations et statut

parquet_export:
  enabled: true
  output_dir: "output/parquet/"
  compression: zstd
  auto_export: true

Chargez directement dans pandas, DuckDB, PyArrow, Polars ou HuggingFace Datasets :

import pandas as pd
annotations = pd.read_parquet("output/parquet/annotations.parquet")
 
# Or with DuckDB for SQL queries
import duckdb
duckdb.sql("""
  SELECT instance_id, value, COUNT(*) as n
  FROM 'output/parquet/annotations.parquet'
  WHERE schema_name = 'sentiment'
  GROUP BY instance_id, value
""")

Supporte les compressions snappy, gzip, zstd, lz4 et brotli, l'export incrémental avec partitionnement par date/annotateur et l'encodage dictionnaire pour les colonnes de chaînes.

Lire la documentation de l'export Parquet →

15 nouveaux projets de démonstration

Potato 2.3 est livré avec 15 nouveaux projets de démonstration dans le répertoire project-hub/, couvrant les nouvelles fonctionnalités :

Démonstrations d'annotation agentique

1. react-agent-eval -- Évaluer des traces d'agents ReAct avec des notations au niveau des étapes
2. web-agent-eval -- Évaluation de traces WebArena avec superpositions de captures d'écran
3. chatbot-eval -- Évaluation de chat interactif avec proxy d'agent en direct
4. multi-agent-eval -- Évaluer des systèmes multi-agents CrewAI
5. swebench-eval -- Évaluation de traces SWE-bench pour les agents de programmation

Démonstrations Solo Mode

6. solo-sentiment -- Classification de sentiment Solo Mode sur des avis de produits
7. solo-ner -- Reconnaissance d'entités nommées en Solo Mode
8. solo-toxicity -- Détection de toxicité Solo Mode avec synthèse de cas limites

Démonstrations Best-Worst Scaling

9. bws-translation -- Classement de qualité de traduction automatique
10. bws-summarization -- Comparaison de qualité de résumés
11. bws-image-quality -- Classement de qualité de génération d'images

Démonstrations d'authentification

12. google-oauth-demo -- Exemple de configuration Google OAuth
13. github-oauth-demo -- GitHub OAuth avec restriction d'organisation

Démonstrations d'export

14. parquet-export-demo -- Export Parquet avec script d'analyse DuckDB
15. huggingface-upload -- Export en Parquet et envoi vers HuggingFace Hub

Chaque démonstration inclut un config.yaml complet, des données d'exemple et un README avec des instructions d'installation. Démarrez n'importe quelle démonstration avec :

cd project-hub/react-agent-eval
potato start config.yaml

Renforcement de la sécurité

Potato 2.3 inclut plusieurs améliorations de sécurité :

• Les jetons de session utilisent une génération aléatoire cryptographiquement sûre avec expiration configurable
• La protection CSRF est activée par défaut pour toutes les soumissions de formulaires
• La limitation de débit sur les endpoints d'authentification (configurable, 10 tentatives par minute par défaut)
• L'assainissement des entrées pour tout contenu fourni par l'utilisateur affiché dans l'interface d'annotation
• L'audit des dépendances -- toutes les dépendances Python et JavaScript mises à jour vers les dernières versions sécurisées
• Les en-têtes Content Security Policy ajoutés pour prévenir le XSS

security:
  csrf_protection: true
  rate_limiting:
    auth_attempts: 10            # per minute
    api_requests: 100            # per minute
  session:
    token_length: 64
    lifetime_hours: 24
  content_security_policy: true

Mise à niveau

Depuis Potato 2.2.x

pip install --upgrade potato-annotation

Toutes les configurations v2.2 sont entièrement rétrocompatibles. Aucune modification des configurations existantes n'est requise.

Nouvelles dépendances

L'export Parquet nécessite PyArrow :

pip install potato-annotation[parquet]

Le Solo Mode nécessite un SDK de fournisseur LLM :

pip install potato-annotation[solo]    # installs openai + anthropic SDKs

Ou installez tout :

pip install potato-annotation[all]

Et ensuite

Potato 2.3 représente une expansion significative de ce que les outils d'annotation peuvent faire. Nous travaillons déjà sur le prochain ensemble de fonctionnalités :

• Comparaison d'annotations -- comparer les annotations entre les tours et les annotateurs avec des diffs visuels
• Annotation fédérée -- coordonner l'annotation entre plusieurs instances Potato
• Sources de données en streaming -- annoter des données depuis Kafka, Pub/Sub et d'autres systèmes de streaming
• Interface optimisée pour mobile -- annotation responsive pour tablettes et téléphones

Nous serions ravis d'avoir vos retours. Créez des issues sur GitHub, participez aux discussions sur GitHub Discussions ou contactez l'équipe directement.

Liens

• Guide d'installation
• Nouveautés de la v2.3
• Annotation agentique
• Solo Mode
• Best-Worst Scaling
• SSO et OAuth
• Export Parquet
• Dépôt GitHub
• Package PyPI