Nouveautés

Cette page couvre les nouvelles fonctionnalités et améliorations des versions Potato v2.x.

Potato 2.11.1

Publié en octobre 2026

Potato 2.11.1 permet de nouveau à potato start config.yaml --debug de démarrer sur l'adresse par défaut, ajoute les classifieurs d'images à l'entraînement de modèles et corrige les pré-étiquettes qui se perdaient à chaque redémarrage.

pip install --upgrade potato-annotation

Mode debug

De la 2.8.2 à la 2.11.0, un serveur en mode debug sur l'adresse par défaut 0.0.0.0 refusait de démarrer sans --host 127.0.0.1. En 2.11.1, il démarre sur n'importe quelle adresse, et les autres machines du réseau peuvent l'atteindre. Le guide de débogage décrit ce que fait désormais le mode debug :

• La page de connexion reste en place, sauf si vous ajoutez --debug-phase. Avec --debug-phase, chaque visiteur est connecté sous le debug_user partagé ; ne l'utilisez donc pas pour une vraie étude.
• Les pages d'administration s'ouvrent sans clé uniquement pour les requêtes venant de la machine du serveur elle-même, c'est-à-dire d'une adresse de loopback sans en-tête X-Forwarded-For, X-Real-IP ni Forwarded. Cela vaut aussi pour un serveur lié à 127.0.0.1, où la 2.11.0 laissait passer toutes les requêtes, car un proxy ou un tunnel sur la même machine transmet à 127.0.0.1 les requêtes d'autres machines.
• Le débogueur interactif de Werkzeug ne fonctionne que sur un serveur lié à 127.0.0.1, car il exécute le code saisi dans le navigateur.

POTATO_ALLOW_REMOTE_DEBUG n'est plus lu. Une commande en mode debug avec --host 127.0.0.1 fonctionne toujours et donne toujours accès au débogueur interactif.

Classification d'images et pré-étiquettes

• L'entraînement de modèles ajuste des classifieurs d'images. Un schéma radio ou multiselect dont les items désignent des fichiers image est entraîné sur des embeddings CLIP, alors qu'il ajustait auparavant un TF-IDF sur les chemins des fichiers. Les images distantes ou manquantes sont écartées avec un avertissement.
• L'apprentissage actif sur images fonctionne comme le décrit la documentation. vectorizer: {name: image} construit le vectoriseur CLIP. Le gestionnaire ne savait pas construire un vectoriseur portant ce nom, si bien qu'une telle étude était classée par TF-IDF sur les chemins des fichiers.
• Le moteur d'étiquetage distille des classifieurs d'images dans une étude sur des images (labeling_engine.distill.modality).
• Des pré-étiquettes pour les items non étiquetés. model_training.writeback.include_unlabeled: true produit des prédictions pour les items que personne n'a encore étiquetés. Auparavant, une exécution ne prédisait que sur des items mis de côté et déjà étiquetés, si bien que la réécriture n'atteignait jamais les items auxquels une pré-étiquette est destinée.

La documentation de l'entraînement de modèles couvre les exécutions d'entraînement, la réécriture et la file de revue.

Corrections qui touchent les études antérieures

• Les pré-étiquettes ne survivaient pas à un redémarrage. Au démarrage, la relecture des prédictions enregistrées s'exécutait avant le chargement du moindre item, si bien que la file de revue du modèle se vidait à chaque redémarrage. Elle s'exécute désormais après le chargement des items et applique les mêmes vérifications que la réécriture.
• Un modèle de texte s'entraînait sur des URL. Pour les items dotés d'un champ url, path ou file_name, l'entraîneur recevait cette valeur au lieu du texte.
• Les réinitialisations de mot de passe échouaient avec le SSO. Avec method: oauth et allow_local_login, chaque réinitialisation levait une erreur. Les comptes locaux peuvent désormais être réinitialisés.
• ai_support refusait OpenRouter. endpoint_type: openrouter est désormais accepté.

Les notes de version donnent la liste complète.

Potato 2.11.0

Publié en octobre 2026

Potato 2.11.0 ajoute le moteur d'étiquetage, qui étiquette un jeu de données avec des modèles et s'appuie sur un échantillon aléatoire d'étiquettes humaines, recueillies en aveugle, pour mesurer à quelle fréquence les modèles se trompent. Vous indiquez ce que les étiquettes finales doivent respecter, par exemple « au plus 5 % des étiquettes machine acceptées sont fausses, avec une confiance de 90 % ». Le moteur accepte les étiquettes machine qu'un test statistique justifie, envoie le reste à des personnes et rédige un certificat qui consigne ce qui a été testé et sur combien d'étiquettes humaines. La page Le moteur d'étiquetage explique la mise en place.

Les sessions inactives sont désormais déconnectées, après 8 heures par défaut. Avant la 2.11.0, session_timeout_minutes n'avait aucun effet sur une application servie, car la vérification était enregistrée sur un objet application que potato start abandonne. Une session restée inactive plus longtemps que le réglage (480 minutes par défaut) est désormais effacée, et sa requête suivante mène à la page de connexion. Les bornes et les machines de laboratoire partagées qui restent connectées toute la nuit vont commencer à subir des déconnexions ; augmentez donc session_timeout_minutes là où cela compte.

pip install --upgrade potato-annotation

Le moteur d'étiquetage

Un bloc labeling_engine et assignment_strategy: engine activent le moteur. Ses sources sont des modèles, essayés dans l'ordre de la cascade, et un item passe à des personnes après la dernière source. Chaque contrat porte sur un schéma d'annotation et se teste sur des étiquettes humaines que le moteur demande au hasard et présente en aveugle, sans pré-annotation, verdict de juge ni aide de l'IA sur la page.

• Sources. LLM, modèles vision-langage, modèles de décision (Laya et tout serveur /v1/systemone), détecteurs YOLO, juges LLM avec permutation de l'ordre des étiquettes, jurys, modèles entraînés sur les propres étiquettes de l'étude, et étiquettes que vous avez déjà.
• Contrats. selective_risk borne la part des étiquettes machine acceptées qui sont fausses, à un niveau de confiance donné. ppi fournit des intervalles de prévalence ou de moyenne qui restent valides quelle que soit la qualité de la machine. no_worse_than_human exécute le test de l'annotateur alternatif, budget_first projette ce qu'un budget d'étiquettes humaines permet d'obtenir, et distributional compare les étiquettes de la machine à la façon dont les personnes se répartissent sur les items subjectifs.
• Modalités. Schémas à choix unique parmi N, ordinaux, numériques et multi-étiquettes, régions d'image, audio, vidéo, segments de temporal grounding et d'annotation à niveaux, objets 3D et étiquettes d'étapes dans les traces d'agents. Les régions, segments, objets 3D et traces sont évalués avec les mesures qu'utilise le rapport d'accord.
• Audits. Une part des étiquettes machine acceptées repart vers des personnes, en aveugle. Quand les audits montrent un taux d'erreur supérieur à la cible, le moteur cesse d'accepter des étiquettes machine sur ce schéma (avec features.drift, activé par défaut), et une nouvelle certification rétablit l'acceptation.
• Interfaces. potato label run|status|certify|certificate|export|calls|distill|optimize|migrate-config, une REST API sous /api/engine/v1, cinq outils MCP engine_*, un Python SDK et une page d'administration à /admin/labeling-engine.

Un contrat respecté est un énoncé statistique sur l'accord avec les personnes qui ont étiqueté l'échantillon. Le moteur ne vérifie pas que ces personnes ont raison, si bien qu'un contrat testé sur des annotateurs peu fiables certifie l'accord avec des annotateurs peu fiables. La page Contrats du moteur d'étiquetage indique ce que teste chaque contrat et quand il échoue.

icl_labeling, judge_calibration et pre_annotation continuent de fonctionner, et chacun affiche au démarrage une note qui nomme son équivalent dans le moteur. potato label migrate-config écrit le bloc labeling_engine équivalent. Le mode solo et l'alignement des juges ne sont pas dépréciés. La page Migrer vers le moteur d'étiquetage donne la table de correspondance.

Accord

• /admin/iaa couvre davantage de schémas. spatial_annotation, temporal_grounding, tiered_annotation et les schémas de traces d'agents (process_reward, trajectory_eval, tool_call_review, failure_attribution, gui_trajectory) étaient ignorés comme non pris en charge et sont désormais évalués.
• /admin/api/agreement ne rend plus compte des schémas structurés. Réduits à des noms d'étiquettes, les traces d'agents, segments, régions et objets 3D affichaient un accord parfait entre toutes les paires d'annotateurs. La route renvoie désormais vers /admin/iaa, qui compare les structures.
• Deux segments identiques de longueur nulle sont désormais en accord. Ils étaient auparavant comptés comme un désaccord total.
• Les annotateurs machine restent hors des chiffres publiés. La publication et le Mode article excluent les annotateurs machine des étiquettes de référence et des chiffres d'accord.

Mode solo

• Suggestions en aveugle. solo_mode.suggestions retient l'étiquette du LLM sur tous les items ou sur un échantillon, et le passage de relais s'appuie sur l'accord mesuré sur les items en aveugle, car une suggestion affichée à l'écran influence la personne qui la vérifie.
• Un plafond de dépense et un cache des réponses. ai_budget.cap_usd est vérifié avant le début de l'étiquetage et avant chaque lot, et solo_mode.cache réutilise la réponse à un appel répété.
• Modèles de décision. Les points de terminaison systemone et laya étiquettent les schémas à choix fixe en un seul passage avant, comme premier niveau rapide. La page Mode solo en donne une configuration.
• Jeu de référence, jury et curriculum. solo_mode.gold évalue un prompt sur des étiquettes connues avant l'exécution complète, solo_mode.jury fait voter plusieurs modèles sur chaque item, et instance_selection.curriculum vous fait commencer par les items que le LLM a trouvés les plus faciles. Une vérification de la sensibilité au prompt est également nouvelle.

Corrections qui touchent les études sous 2.10

• Une page d'image enregistrait d'elle-même une réponse préremplie. Sur un schéma image_annotation avec pre_annotation, le canevas enregistrait les formes préremplies comme réponse de l'annotateur lorsqu'il recalculait sa mise en page après le chargement, si bien qu'un item jamais modifié comptait comme répondu. Seule une modification enregistre désormais. Dans une étude d'images sous 2.10 avec pré-annotations, certains items comptés comme répondus n'ont peut-être jamais été touchés.
• Les images d'hôtes sans en-têtes CORS ne se chargeaient pas. Un hôte qui n'envoie pas d'en-tête Access-Control-Allow-Origin, comme cocodataset.org, refusait la requête du canevas, et la page affichait « Failed to load image ». La page charge désormais une telle image sans CORS. Le dessin fonctionne, et le remplissage de région, SAM et la segmentation par prompt textuel, qui lisent les pixels de l'image, expliquent pourquoi ils ne peuvent pas s'exécuter.
• Une forme pré-annotée sans color était ignorée. L'item affichait « Annotations: 0 » sans avertissement ; la forme prend désormais la couleur de son étiquette.
• « Generate prompt » du mode solo n'appelait jamais de modèle. Il demande désormais au modèle de révision d'écrire le premier prompt. Sans modèle de révision, il se rabat sur la description de la tâche et le signale.
• Les refus via potato mcp connect ressemblaient à des succès. Un appel d'outil refusé revenait avec isError: false ; il revient désormais comme une erreur d'outil qui porte le message du serveur.
• L'exemple de squelette d'étude complète contenait une clé morte. Potato ne lit aucune clé training.feedback.enabled, donc l'exemple définit désormais feedback.show_explanations.
• Les sessions inactives n'étaient jamais déconnectées, comme décrit au début de cette entrée.
• L'arbitrage comptait les annotateurs machine. Des annotateurs machine pouvaient envoyer un item en arbitrage, min_human_annotations était ignoré, et un score d'accord manquant faisait planter la mise en forme.
• La mise à l'échelle automatique de Prolific comptait les annotations machine et ignorait les plafonds par item. Le nombre de places à ouvrir ne compte désormais que les annotations humaines, rapportées au plafond de chaque item.
• La découverte de cas limites ne faisait rien sur vLLM. Le décodage guidé sur vLLM ne renvoyait jamais les champs de cas limites, qui font désormais partie du schéma de réponse.

Les notes de version donnent la liste complète.

Potato 2.10.3

Publié en octobre 2026

Potato 2.10.3 corrige trois bugs trouvés dans la 2.10.2 après sa publication.

pip install --upgrade potato-annotation

• L'accord sur des données unanimes. Quand tous les annotateurs donnaient la même réponse pour chaque item, /admin/api/agreement renvoyait le schéma sous la forme {"error": "float division by zero"}. L'accord dû au hasard vaut alors 1, donc l'alpha et les deux kappas ne sont pas définis. La route les signale désormais comme null, avec percent_agreement à 1,0 et la même note que celle de /admin/iaa, et la moyenne globale laisse le schéma de côté.
• potato deploy button --dry-run reste hors ligne. Sans --hf-backup-repo, l'exécution à blanc demandait à HuggingFace à qui appartenait le jeton, et un jeton invalide se terminait par une trace d'erreur. L'exécution à blanc utilise désormais l'espace réservé <hf-account>/<name>-annotations, comme le fait potato deploy up --dry-run, et une exécution réelle signale un jeton refusé par un message d'erreur.
• Importer Potato ne hache plus de mot de passe. Potato calculait un hachage PBKDF2 à l'import, si bien que chaque processus dépensait 100 000 itérations au démarrage, outils en ligne de commande compris. Le hachage est désormais calculé la première fois qu'un nom d'utilisateur inconnu tente de se connecter. L'import fonctionne aussi de nouveau sous Pyodide, dont le hashlib n'a pas de pbkdf2_hmac.

Les notes de version donnent la liste complète.

Potato 2.10.2

Publié en octobre 2026

Potato 2.10.2 corrige des fonctionnalités qui ne marchaient pas après une installation par pip ni dans l'image Docker, ferme des moyens de se connecter sous l'identité d'un autre utilisateur, fait fonctionner le backend MySQL et corrige les statistiques d'accord. Si vous avez publié des valeurs d'accord calculées avec une version antérieure, recalculez-les.

pip install --upgrade potato-annotation

• Les comptes SSO acceptaient n'importe quel mot de passe. Dans une tâche avec OAuth, le formulaire de mot de passe connectait n'importe qui à un compte qu'un fournisseur avait enregistré. Les identités SSO ne s'authentifient plus par mot de passe, et dans une étude sur MySQL un inconnu ne peut plus enregistrer le nom d'utilisateur d'un annotateur existant et hériter de son travail.
• ai_support et les instruments d'enquête échouaient après une installation par pip. Le wheel omettait les prompts d'IA et les instruments d'enquête, si bien qu'une étude qui utilisait l'un ou l'autre s'arrêtait au démarrage. Les conteneurs et les cibles de potato deploy sautaient aussi dix sous-systèmes, dont le support de chat.
• Le backend MySQL ne s'activait jamais. Une configuration qui le désignait stockait les annotations sur disque. Installez le pilote avec pip install 'potato-annotation[mysql]' ; l'export, les sauvegardes et potato deploy pull lisent désormais la base de données.
• 59 corrections des statistiques d'accord, chacune vérifiée par rapport à une implémentation de référence comme scipy, sklearn ou le paquet krippendorff. Un coefficient indéfini est signalé comme indéfini et non plus comme 1,0, l'alpha ordinal utilise la métrique ordinale de Krippendorff, MACE estime la compétence des spammeurs purs à environ 0,01 au lieu de 0,35, les résultats ne changent plus après un redémarrage, et plackett_luce ajuste la vraisemblance best-worst au lieu de répéter Bradley-Terry.
• Les nuages de points en coordonnées cartographiques gardent leur précision. Un fichier LAS en coordonnées UTM était dessiné sur une grille dont le pas pouvait atteindre 0,5 m. Potato le sert désormais par rapport à une origine locale et enregistre les annotations dans les coordonnées propres du fichier.

Les notes de version donnent la liste complète.

Potato 2.10.1

Publié en octobre 2026

Potato 2.10.1 corrige cinq problèmes de potato deploy et de la sauvegarde découverts après la 2.10.0. Mettez à jour avant de vous fier à une exécution à blanc.

pip install --upgrade potato-annotation

• Une exécution à blanc réussissait pour des déploiements que up refusait ensuite. Heroku ou ECS Express sans --backup, Render ou Railway sans stockage de sauvegarde vers lequel téléverser le projet, et Fly avec un projet trop volumineux pour être envoyé inline affichaient tous un plan sans erreur. Le plan et up exécutent désormais la même vérification, et tous deux affichent REFUSED: <reason> et se terminent avec le code de sortie 2.
• --demo était proposé là où il ne peut pas fonctionner. Render, Railway et ECS Express téléversent votre projet vers le stockage de la sauvegarde, et ont donc besoin de --backup hf ou --backup s3, même pour une étude jetable. L'avertissement de la vérification préalable ne propose désormais --demo que pour Heroku et HuggingFace.
• --cloud jetstream2 planifiait le mauvais gabarit (flavor). L'exécution à blanc affichait m1.small, alors que up créait un m3.small.
• Deux prix étaient faux. potato deploy providers indiquait environ $16 par mois pour aws-ec2 et environ $7 pour fly. Les plans calculent $18.31 et $5.85, et les résumés indiquent désormais environ $18 et environ $6.
• backup: {enabled: false} ne désactivait pas la sauvegarde quand la configuration contenait encore un bloc huggingface_backup. Le nouveau bloc l'emporte désormais.

Les notes de version donnent la liste complète.

Potato 2.10.0

Publié en octobre 2026

Potato 2.10.0 ajoute huit plateformes d'hébergement à potato deploy, sauvegarde les annotations sur les hébergeurs dont le disque ne survit pas à un redémarrage, et ajoute text_as_image, qui affiche le texte de chaque élément sous forme d'image pour que les annotateurs ne puissent pas le coller dans un chatbot. Exécuter Potato en local ou dans le cloud indique quel hébergeur convient à quelle étude.

Potato déclare désormais Python 3.9 ou une version ultérieure. Une dépendance centrale l'exigeait déjà, si bien que les versions précédentes ne pouvaient pas non plus s'installer sur 3.7 ou 3.8, et pip le signale maintenant avant d'installer quoi que ce soit.

pip install --upgrade potato-annotation

Déploiement

• AWS, de trois façons. --provider aws crée une instance Lightsail à un prix forfaitaire de $12 par mois, qui ne demande que les permissions lightsail:*. aws-ec2 est destiné aux comptes où Lightsail est désactivé, et aws-ecs exécute le conteneur sur ECS Express Mode derrière une adresse HTTPS gérée par AWS, pour un coût plus élevé et avec une sauvegarde obligatoire.
• Heroku, sur un seul dyno Basic. Heroku efface le disque chaque jour, donc Potato refuse d'y déployer sans --backup ou --demo.
• Fly et Railway, chacun avec un volume persistant.
• Hetzner, Vultr et Linode, sous forme de VM configurées de la même façon que DigitalOcean, avec un certificat Let's Encrypt pour l'adresse IP.
• OpenStack, avec un préréglage Jetstream2. Jetstream2 donne à chaque instance un nom DNS, si bien que la tâche obtient un certificat ordinaire. Les clouds OpenStack des campus et EGI fonctionnent aussi.
• Boutons de déploiement. potato deploy button config.yaml --target heroku|render|aws|railway écrit dans votre dépôt les fichiers d'un bouton « Deploy to Heroku », « Deploy to Render » ou AWS « Launch Stack », pour que d'autres personnes puissent exécuter la tâche dans leurs propres comptes.

Les nouveaux extras deploy-aws et deploy-openstack installent les clients AWS et OpenStack.

Sauvegarde et restauration

Un nouveau bloc backup copie toutes les cinq minutes la sortie des annotations et des instantanés des bases de données SQLite vers un dataset HuggingFace, un bucket compatible S3, ou les deux. Quand un serveur démarre avec un répertoire de tâche vide et que la sauvegarde contient des données, Potato les restaure avant de charger quoi que ce soit, si bien que les annotateurs reprennent là où ils s'étaient arrêtés après un redémarrage. Passez --backup hf, --backup s3 ou --backup hf,s3 à potato deploy up. L'ancien bloc huggingface_backup est lu comme un bloc backup avec une seule destination et la restauration désactivée, si bien que les déploiements existants se comportent comme avant.

Texte sous forme d'image

text_as_image: true convertit le texte de chaque élément en PNG sur le serveur et retire les mots de la page, de l'enregistrement de l'élément intégré à la page et des points de terminaison JSON, si bien qu'un annotateur n'a rien à sélectionner, copier ou coller. La fonctionnalité rend plus coûteux le fait de coller un élément dans un chatbot, et un annotateur peut toujours retaper le texte ou lancer un OCR sur une capture d'écran. Un lecteur d'écran ne tire rien de l'image, donc la fonctionnalité ne convient pas à une étude dont certains annotateurs en utilisent un. Potato refuse de démarrer quand text_as_image est combiné avec un schéma de segments, un schéma qui lit le champ de texte de l'élément, le mode poche (Pocket Mode) ou les salles multijoueur. Contribution de @Eyecatch3r dans la PR #169.

Corrections qui touchent les données collectées

• Un redémarrage sur un hébergeur sans disque persistant faisait perdre le travail antérieur. Le serveur démarrait vide, et le nouvel état d'un annotateur qui revenait écrasait la copie sauvegardée. La restauration au démarrage corrige ce problème.
• DigitalOcean avec --volume-gb conservait les annotations sur le disque racine plutôt que sur le volume. La sortie et les bases de données SQLite se trouvent désormais sur /data.
• La sauvegarde HuggingFace ne faisait rien dans l'image publiée, qui n'incluait pas huggingface_hub, et sur Render et DigitalOcean, --hf-token définissait une variable que rien ne lisait. L'image installe désormais le nouvel extra hosting.
• Les déploiements Render démarraient sans le projet, et le conteneur s'arrêtait avec « config file not found ». Le conteneur télécharge désormais le projet au démarrage et vérifie son sha256.

Les notes de version donnent la liste complète.

Potato 2.9.2 à 2.9.4

Publié en septembre 2026

Passez à la version 2.9.4 ou ultérieure si des personnes en qui vous n'avez pas confiance peuvent atteindre votre serveur. Avant la 2.9.4, le formulaire /forgot-password créait un jeton de réinitialisation pour tout nom d'utilisateur soumis et affichait le lien de réinitialisation sur la page, si bien que quiconque pouvait atteindre le serveur pouvait prendre le contrôle de n'importe quel compte à mot de passe, comptes administrateur compris (GHSA-43v4-43pw-4rp2). Le formulaire ne crée plus aucun jeton. Les liens de réinitialisation proviennent uniquement de POST /admin/create_reset_token et de la commande potato reset-password. Signalé, avec un correctif, par HDEF.

• Téléphones (2.9.4). Sur les écrans tactiles, les contrôles mesurent au moins 44 px de haut, l'en-tête occupe deux lignes au lieu de trois, multirate devient une liste de lignes étiquetées, et le surlignage de segments fonctionne par appui long.
• Annotateurs machines (2.9.4). Un bloc machine_annotators déclare des évaluateurs qui sont des programmes, comme des détecteurs ou des LLM. /admin/iaa rapporte alors l'accord humain-humain, l'accord machine-machine et l'accord combiné, avec des chiffres principaux calculés sur les seuls humains, et les exports csv, tsv et parquet gagnent une colonne annotator_origin dès qu'un enregistrement provient d'une machine.
• Cookies de session derrière un préfixe d'URL (2.9.4). Deux études servies sous /app1 et /app2 sur un même hôte partageaient un seul cookie de session, si bien que se connecter à l'une déconnectait de l'autre. Le cookie est désormais limité au préfixe. Corrigé par @Eyecatch3r dans la PR #172.
• Navigation plus rapide (2.9.2). Les scripts et les feuilles de style restent en cache d'un élément à l'autre, et Next demande moins d'allers-retours. Sur une liaison avec des allers-retours de 80 ms, Next sur une tâche à boutons radio est passé d'environ 2,6 s à environ 0,8 s.
• Modifications de texte juste avant Next (2.9.2). Vider une zone de texte et appuyer sur Next en moins d'une seconde conservait l'ancien texte. Chaque sauvegarde applique désormais d'abord les modifications en attente.

Potato 2.9.0

Publié en septembre 2026

Potato importe des projets depuis brat, doccano, Prodigy, CoNLL et REFI-QDA, et transcrit et diarise l'audio en local. Les exports indiquent si une forme sur une image a été dessinée par une personne, proposée par un modèle ou importée, et dans quelle salle un vote a été émis. L'essentiel de la version consiste en corrections de bugs.

Lancez potato validate --strict sur chaque configuration avant la mise à jour. Plusieurs changements peuvent empêcher une étude 2.8.2 qui fonctionnait de démarrer, ou modifier son comportement. Les noms de schéma en double dans une même phase sont refusés, min_annotators_per_instance est devenu un alias du plafond par élément, require_fully_annotated: true est appliqué, une phase qui échoue au chargement interrompt le démarrage, et les décalages de segments sont exprimés en points de code et non plus en unités UTF-16. Les valeurs d'accord des schémas à valeurs d'ensemble, à valeurs d'ordre, matriciels et ordinaux étiquetés changent et doivent être recalculées. Les notes de version donnent la liste complète.

pip install --upgrade potato-annotation

Import et export

• Importateurs pour brat, doccano, Prodigy, CoNLL-2003/CoNLL-U et REFI-QDA .qdpx, ainsi qu'un exportateur .qdpx. Voir Importer un projet.
• Provenance dans les exports. Chaque forme sur une image indique si une personne l'a dessinée ou si un modèle l'a proposée (source, ai_model, confidence, edited, carried_over, import_format). Les votes émis dans une salle multijoueur portent la salle, le rôle, le vote initial, le fait qu'il a changé ou non après la révélation, et le nombre de votants.
• Les exports de segments en csv, jsonl et parquet incluent le texte couvert.
• python -m potato.export --format adjudication est nouveau, et chaque type de schéma dispose désormais d'un contrôle d'arbitrage « adopter une réponse » (seuls radio et likert en avaient un).

Audio, vidéo et transcriptions

• Transcription et diarisation des locuteurs en local avec faster-whisper et sherpa-onnx, sans PyTorch ni jeton Hugging Face. Installez potato-annotation[transcribe], puis lancez potato transcripts <dir> --transcribe --diarize --num-speakers N -o out.json. Voir Formats de transcription.
• segment_schemes affiche n'importe quel type d'annotation à l'intérieur d'un segment audio ou vidéo. Auparavant, la clé était acceptée puis ignorée.

Accord, qualité et IA

• L'accord au fil du temps, mis en regard des révisions du livre de codes, avec un déclencheur de recalibration sur /admin/iaa.
• Un mode de revue des sorties de modèle qui inclut la tranche des prédictions vides, ce qui permet de calculer le rappel.
• ai_budget.cap_usd refuse de lancer une exécution que le budget ne couvre pas, et ai_budget.prices fixe les tarifs par modèle dans la configuration.
• ai_support enregistre final_annotation et pre_annotation_seeds, ce qui permet de mesurer les taux d'acceptation sur vos propres données.

Déploiement et interface

• Prise en charge des proxys inverses et des préfixes de chemin sur chaque page (#168, Aldo Costa). Voir Proxy inverse.
• card_sort fonctionne sans souris, et les déplacements sont annoncés aux lecteurs d'écran.
• resizable, max_height et min_height fonctionnent sur chaque type d'affichage.

Corrections qui modifient les résultats

• /admin/api/agreement ne produisait jamais de nombre et comparait les valeurs stockées plutôt que les noms d'étiquettes, si bien que chaque schéma catégoriel affichait un accord parfait.
• Dans une étude à deux annotateurs par élément, le second annotateur était envoyé vers la page de fin, et toutes les réponses qu'il donnait ensuite étaient perdues.
• Les suggestions d'IA portaient sur le mauvais élément avec toutes les stratégies d'attribution sauf fixed_order.
• Les inscriptions n'étaient jamais enregistrées avec la configuration en mémoire par défaut, si bien qu'après un redémarrage n'importe qui pouvait revendiquer un nom d'utilisateur existant.

Merci à Aldo Costa (@Eyecatch3r) pour #168 et #171, et à @ruthenian8 pour avoir signalé et diagnostiqué #170.

Potato 2.8.2

Publié en août 2026

La version 2.8.1 ne contenait pas deux des cinq correctifs de sécurité décrits dans ses notes de version, à savoir le correctif SSRF des points de terminaison média (GHSA-9394-85jj-2mhj) et le durcissement du mode debug (GHSA-r4ww-vc5h-35qf). La version 2.8.2 livre les deux. Si vous êtes passé à 2.8.1 pour l'un ou l'autre de ces problèmes, mettez à jour une nouvelle fois. Voir les notes de version 2.8.2.

Potato 2.8.1

Publié en août 2026

Une version de sécurité. Elle corrigeait une exécution de code à distance via l'agent de codage en direct (GHSA-cm4p-5rfv-x252), une configuration d'administration lisible sans la clé d'administration, et un webhook d'ingestion de traces qui acceptait toutes les requêtes. Mettez à jour si vous faites tourner Potato ailleurs que sur localhost, et passez directement à 2.8.2, qui contient les deux correctifs absents de 2.8.1.

Potato 2.8.0

Publié en août 2026

Potato était une plateforme d'annotation de texte dotée d'un mode image. Il couvre désormais les images, la vidéo, les numérisations gigapixel, les nuages de points 3D, les cartes de profondeur, les épisodes robotiques, les déroulés de vidéo générative et l'ancrage vision-langage. Pour chacun d'eux, il rapporte un accord corrigé du hasard.

Mettez à jour si vous avez installé Potato depuis PyPI. Jusqu'à 2.7.1, les wheels déclaraient les données du paquet avec un motif glob à un seul niveau, si bien que 27 gabarits situés dans des sous-répertoires manquaient dans chaque wheel. Les routes de configuration du mode solo, les pages d'administration, la calibration des juges et la carte du corpus étaient toutes cassées pour quiconque avait lancé pip install. Qui travaillait depuis un checkout git n'a jamais rencontré le problème. Corrigé dans la PR #164 par @0x6362.

pip install --upgrade potato-annotation

Accord sur la géométrie et le temps

• Accord corrigé du hasard pour les étiquettes spatiales, décomposé en détection (les annotateurs ont-ils trouvé les mêmes objets), classification (les ont-ils nommés de la même façon) et localisation (les ont-ils placés au même endroit, rapportée en σ par rapport à une ligne de base empirique du hasard, avec un test KS).
• STAPLE pour le consensus sur les masques. Il estime une frontière latente ainsi qu'une sensibilité et une spécificité pour chaque annotateur. Sur un corpus où deux annotateurs soigneux sont en minorité, trois contre deux, face à des annotateurs bruités, le vote majoritaire obtient un Dice de 0,846 par rapport à la vérité et STAPLE obtient 1,000.
• IoU 3D exact avec rotation, pour que l'accord sur les cuboïdes soit correct sur les données de drone, de caméra tenue à la main et d'intérieur, et pas seulement pour des boîtes à plat.
• Accord temporel rapporté sous forme de balayage sur plusieurs tolérances d'appariement, parce qu'un accord à 0,25 s n'affirme pas la même chose qu'un accord à 2 s.
• Les valeurs indéfinies s'expliquent d'elles-mêmes. α est réellement indéfini sur un corpus unanime, et un NaN nu se lit comme un calcul cassé.

Cette version corrige aussi un bug. L'arbitrage comparait les clés d'une annotation, et les schémas d'image stockent tout sous une seule clé nommée _data. Chaque paire d'images obtenait donc un accord de 1,0, si bien que deux annotateurs qui ne s'accordaient sur rien paraissaient unanimes et qu'aucune image n'était jamais envoyée en revue.

Vision

• Primitives géométriques. Polylignes, ellipses, cuboïdes 2D, ensembles de points clés avec topologie de squelette et indicateurs de visibilité COCO, et masques au pinceau indexés par instance.
• Segmentation par clic dans le navigateur. MobileSAM sous ONNX Runtime Web, environ 132 ms par clic, sans GPU et sans appel réseau à chaque clic.
• Invites textuelles à vocabulaire ouvert. Tapez une expression, et chaque correspondance est encadrée. Grounding DINO, sous licence Apache-2.0, fonctionne lui aussi dans le navigateur.
• Propagation de masques vidéo avec les modules de mémoire de SAM 2, mesurée à 0,974–0,979 d'IoU par image, sans dégradation au fil de la séquence. Celle-ci s'exécute côté serveur, par conception. Le navigateur dispose d'un chemin de report distinct, plus léger.
• Zoom profond pour les images gigapixel, servies à la fois en DZI et en IIIF Image API 3.0, avec des masques au pinceau à la pleine résolution de la source.
• Ingestion de médias. TIFF 16 bits multipage, HEIC, RAW d'appareil photo, et ProRes/MKV/MOV via un proxy côté serveur avec cache.
• 15 formats d'import et 29 formats d'export, dont 11 en aller-retour. Darwin fonctionne dans les deux sens.

Les raccourcis clavier d'annotation d'images suivent désormais par défaut les conventions de V7, avec b pour le pinceau, r pour le rectangle, f pour le remplissage, k pour le point clé et v pour la sélection. Définissez keybinding_profile: legacy sur le schéma pour rétablir les anciens raccourcis d'une étude déjà sur le terrain.

3D, profondeur et robotique

• spatial_annotation pour les nuages PCD, PLY, LAS, KITTI .bin et .xyz, avec cuboïdes 3D, points, polylignes et segments par point, niveau de détail par octree et panneaux en tranche orthographique. La rotation est stockée sous forme de quaternion, si bien que l'inclinaison de montage, qu'un champ limité au lacet écarterait sans rien signaler, survit à un aller-retour KITTI.
• Cartes de profondeur en PNG/TIFF 16 bits, NPY, PFM et EXR, avec fenêtrage, palettes de couleurs, lecture en mètres sous le curseur et déprojection dans le même visualiseur 3D.
• Projection tenant compte de l'étalonnage, pour qu'un cuboïde dessiné en 3D apparaisse dans chaque image de caméra et puisse être vérifié en 2D.
• episode_annotation place N flux vidéo synchronisés et M pistes de séries temporelles du robot sur une même chronologie, avec segmentation en phases, résultats par phase et courbes de récompense denses. Importe LeRobot v2, RLDS/TFDS et HDF5. Le sous-échantillonnage des pistes préserve les minima et les maxima, si bien qu'un pic de force d'une seule image survit au passage vers une piste de 300 pixels.

Évaluation

• rollout_evaluation affiche de 2 à N vidéos générées sur une même horloge et demande à l'annotateur de marquer l'image à partir de laquelle le monde cesse d'avoir un sens, puis d'indiquer quelle propriété physique ou causale a cédé. Les panneaux peuvent être présentés à l'aveugle et mélangés de façon stable pour chaque annotateur.
• grounding_eval et region_caption évaluent l'ancrage par l'IoU à quatre seuils et le pointage par le taux de points tombant dans la région, parce qu'un point n'a pas d'aire et que l'IoU calculée contre un point vaut toujours zéro. L'absence d'ancrage est comptée à part.

Tout le reste

• Conversations en fils. L'affichage dialogue restitue la structure des réponses à partir du champ reply_to de chaque tour. potato convokit importe n'importe quel corpus ConvoKit et --format convokit réexporte vers ce format, sans dépendance à convokit.
• Télémétrie du dessin. Temps par forme, dynamique des tracés, nombre de révisions et délai d'acceptation des suggestions d'IA. Des pré-étiquettes acceptées en bloc font monter l'accord sans que l'exactitude suive, car des annotateurs qui acceptent la même suggestion sont unanimes par construction. Le chronométrage est un signal de processus qui distingue la relecture de l'approbation machinale là où les étiquettes n'y parviennent pas.
• Ingestion en direct depuis une base de données. Les lignes créées après le démarrage deviennent annotables dans un délai de poll_interval_seconds, sans redémarrage (#166).
• Spécifications lisibles par machine. Un JSON Schema couvrant 159 clés de configuration, 61 types d'annotation et 24 types d'affichage, ainsi qu'un document OpenAPI de 419 chemins. Les deux sont générés à partir du code et la CI échoue dès que l'un d'eux dérive, si bien qu'un éditeur ou un agent de codage peut vérifier une configuration sans inventer d'options.
• Aucune requête sortante. Chaque feuille de style, script, police et icône est désormais servi depuis l'installation, dans les 14 gabarits. styles.css commençait par un @import de Google Fonts, qui envoyait l'adresse IP de chaque annotateur à un tiers au chargement de la page, et la page de connexion portait une favicon tierce. Les deux ont disparu.
• L'onglet Instances de l'administration est passé d'un coût quadratique à un coût linéaire. Pour 2000 éléments, son temps est tombé de 15,1 s à 23 ms.

Potato 2.7.2

Publié en août 2026

Journalisation des frappes pour les champs de texte libre. Potato enregistre le rythme derrière une réponse et jamais les caractères, ce qui suffit à distinguer la frappe du collage.

• Journalisation des frappes, une capture aveugle au contenu des pauses, des rafales, des révisions et des collages sur chaque champ de texte libre, avec une quarantaine de caractéristiques de synthèse calculées par réponse. Désactivée par défaut.
• Détection du processus de rédaction, six règles nommées, à seuils explicites, qui indiquent les valeurs de caractéristiques derrière chaque signalement. Les seuils peuvent être réajustés à votre propre projet, et une voie supervisée existe si vous disposez d'étiquettes.
• Repères éthiques, avec un exemple de formulation du consentement, la conservation et la suppression, le problème du taux de base, et les raisons pour lesquelles un signalement invite à regarder plutôt qu'il ne constitue une conclusion.
• Exports optionnels. export_include_typing_dynamics écrit un fichier annexe de synthèse, et --format keystrokes écrit les flux bruts en Parquet. Aucun des deux n'est actif par défaut, si bien que les données comportementales ne se retrouvent jamais par accident dans une publication de jeu de données.

La divulgation aux annotateurs est activée par défaut, et la désactiver inscrit un avertissement au démarrage.

Potato 2.7.1

Publié en juillet 2026

L'ingestion de transcriptions, en partant du principe que la transcription existe déjà. Quelqu'un a lancé Whisper, ou téléchargé des sous-titres, ou reçu un corpus, et l'étape suivante ne devrait pas consister à écrire un script de conversion.

• 21 formats de transcription et de sous-titres, contre 6 auparavant. Whisper, WhisperX, whisper.cpp, AWS Transcribe, Deepgram, AssemblyAI, Rev.ai, SPoRC, SubRip, WebVTT, SubStation Alpha, TTML/DFXP, YouTube json3 et srv1/srv2/srv3, NIST CTM, Praat TextGrid et ELAN EAF. La détection se fait sur le contenu du fichier, pas sur l'extension.
• Fichiers de transcription annexes. Un fichier de données peut pointer vers media/int_001.srt sur le disque au lieu d'intégrer la transcription. Les chemins sont résolus sous task_dir par le contrôle de sécurité des chemins habituel, si bien que vos transcriptions restent des fichiers que vous pouvez comparer et réexporter.
• potato transcripts, un convertisseur qui transforme un dossier de sorties ASR en fichier de données prêt à annoter, en appariant transcriptions et médias par nom de base. --dry-run indique ce qui a été détecté avant d'écrire quoi que ce soit, et --emit-config affiche une configuration correspondante.
• Un seul vocabulaire de formats pour quatre schémas. speech_transcript, voice_interaction et tiered_annotation acceptent désormais tout ce qu'accepte l'affichage audio_dialogue. Auparavant, seul l'affichage le faisait.
• Comment annoter des transcriptions Whisper et Comment annoter des sous-titres YouTube déroulent les deux points de départ de bout en bout.

Dans la version 2.7.1, l'ASR et la diarisation s'exécutent en amont et Potato lit leur sortie. Potato 2.9 a ajouté la transcription et la diarisation en local via potato transcripts --transcribe --diarize, et le mode Think-Aloud transcrit en local la parole des annotateurs eux-mêmes depuis la version 2.7.0.

Potato 2.7.0

Publié en juillet 2026

Potato 2.7 repose sur une idée : un outil d'annotation devrait mesurer comment les jugements se forment, et pas seulement enregistrer ce qu'ils étaient. Cela vaut pour les deux sortes de juges, les humains qui annotent et les modèles d'IA que l'on évalue.

Mesurer la façon dont les humains étiquettent

Sept fonctionnalités optionnelles, dont aucune ne demande de LLM.

• Moteur psychométrique, une couche de théorie de la réponse à l'item calculée en direct, qui donne à chaque étiquette une probabilité a posteriori et un intervalle de sensibilité (p = 0.94 [0.88–0.97]) plutôt qu'un simple vote majoritaire. Elle estime la compétence des annotateurs et la difficulté des items à partir des seuls profils d'accord, oriente chaque item vers l'annotateur dont le jugement apporte le plus d'information, et signale les défauts probables du livre de codes.
• Salles multijoueur, la réunion de calibration que votre équipe organise déjà par partage d'écran, intégrée à l'outil et instrumentée (vote à l'aveugle, révélation par l'animateur, discussion, nouveau vote), avec un indicateur d'alpha de Krippendorff en direct qui montre ce que la séance a rapporté.
• Laboratoire de frontières de décision, des sondes contrefactuelles après chaque étiquette (« cela tiendrait-il encore ? ») qui transforment une annotation ordinaire en jeux de contrastes et repèrent les annotateurs incohérents sans glisser d'items étalons.
• Truth Serum, un score de prédiction par les pairs fondé sur la réponse « étonnamment populaire », qui l'emporte sur le vote majoritaire là où l'annotation est difficile, sans étiquettes de référence.
• Mode Think-Aloud. Les annotateurs parlent pendant qu'ils travaillent, la reconnaissance vocale tourne entièrement en local et la transcription mot à mot devient la justification.
• Mode article. Une commande transforme un projet en rapport de jeu de données LaTeX compilable, statistiques d'accord et citations comprises.
• Mode poche, l'annotation mobile de plein droit, avec une pile de cartes à balayer, la synchronisation hors ligne et l'installation en PWA.

Évaluer les agents d'IA

La suite d'évaluation d'agents couvre désormais la structure des équipes et les agents multimodaux. Elle comprend un graphe d'interaction entre agents cliquable, l'attribution des défaillances entre agents, la revue des passages de relais, des fiches de score par agent et par équipe, des chronologies de contention sur les outils et l'étiquetage des comportements émergents, ainsi que les trajectoires d'usage d'interface graphique et d'ordinateur, les chronologies vocales en duplex intégral, l'ancrage temporel dans la vidéo et la structure des tableaux de documents.

Partout ailleurs

Annotation d'événements inter-documents, annotation au niveau du tour de parole, un livre de codes tenu comme un document vivant avec un éditeur pleine page, liaison entre pages d'un PDF avec OCR facultatif, rôles RBAC avec schémas par cohorte, tableaux de bord administrateur et annotateur en 10 langues, et une installation bien plus légère. Les SDK d'IA se chargent désormais à la demande, ce qui fait passer le temps de démarrage d'environ 2,0 s à 0,7 s.

Potato 2.6.0

Publié en juin 2026

Potato 2.6 entre dans l'analyse de données qualitatives et étoffe la panoplie d'évaluation d'agents. Elle ajoute le mode QDA, un flux de calibration et d'alignement du LLM juge avec une file de triage fondée sur un signal, et des schémas d'édition de trajectoires qui produisent des données d'entraînement SFT et DPO. Potato passe également sous licence GPL-3.0-or-later (auparavant PolyForm Shield).

Mode QDA

Le mode qda_mode, optionnel, transforme Potato en atelier collaboratif de codage qualitatif. Son activation compose un livre de codes vivant, le codage in vivo, les mémos d'analyse, les cas et la recherche plein texte, avec des réglages par défaut pensés pour un analyste qui code un corpus entier.

qda_mode:
  enabled: true            # codebook + memos + cases + search
codebook_invivo_key: i     # mint a code from a text selection
search:
  enabled: true
  annotator_claim: true

En savoir plus sur le mode QDA →

Calibration et alignement du LLM juge

Étiquetez automatiquement vos données avec un ou plusieurs LLM juges, puis lancez une passe de calibration humaine à l'aveugle pour mesurer l'exactitude, l'accord et l'erreur de calibration. Un flux distinct d'alignement à juge unique suit le kappa de Cohen face à vos étiquettes de référence humaines à mesure que vous affinez la grille, avec un verdict en ligne facultatif pendant l'annotation.

En savoir plus sur la calibration du juge → · Alignement du juge →

File de triage fondée sur un signal

Priorisez la file d'annotation selon un signal de qualité propre à chaque élément (une erreur d'agent, un pouce vers le bas en production, un score bas, ou n'importe quel champ personnalisé), pour que les relecteurs voient d'abord les éléments les plus suspects plutôt que de les voir dans l'ordre d'arrivée.

triage:
  enabled: true
  signal_field: quality_score
  invert_signal: true
assignment_strategy: priority

En savoir plus sur la file de triage →

Édition de trajectoires pour le SFT/DPO

Les nouveaux schémas trajectory_edit et trajectory_correction permettent aux annotateurs de réécrire les étapes d'une trace d'agent. L'exportateur transforme chaque paire original/corrigé en cibles d'affinage supervisé (trajectory_sft.jsonl) et en paires de préférence DPO (trajectory_dpo.jsonl).

En savoir plus sur l'édition de trajectoires →

Affichage eval_trace

Un affichage de trace d'agent à trois volets (Raisonnement, Appels de fonctions et Réponse finale), conçu pour l'évaluation continue, où les traces arrivent par un webhook, un collecteur Langfuse ou un répertoire surveillé, et sont jugées au fil de leur arrivée.

En savoir plus sur eval_trace →

Flux de travail et attribution

• Couverture hétérogène. Plafonds d'annotateurs par élément, rapport d'accord inter-annotateurs et routage vers l'arbitrage pour les tâches dont les éléments demandent un nombre d'annotateurs différent.
• Récupération des attributions abandonnées. Récupérez les attributions laissées par des travailleurs Prolific ou bloqués par le contrôle qualité, avec une durée de rétention configurable et une récupération idempotente.
• Stratégie d'attribution par lots personnalisés. Attribuez des lots d'éléments prédéfinis à des annotateurs précis.
• Préfixes d'URL pour proxy inverse. Servez Potato sous un sous-chemin derrière un proxy inverse.

Licence

Potato est désormais publié sous GPL-3.0-or-later, en remplacement de PolyForm Shield. Vous pouvez l'utiliser, le modifier et le redistribuer, y compris à des fins commerciales, tant que les œuvres dérivées restent sous GPL. Voir la page À propos pour les détails.

Performances et stabilité

• Démarrage environ 3× plus rapide. La pile ML n'est plus chargée d'emblée au démarrage. Le temps d'import est passé d'environ 6,5 s à 2 s, le démarrage sur 50 000 éléments d'environ 10 s à 5,7 s, et la mémoire résidente d'environ 750 Mo à 365 Mo.
• Renommage de schéma. annotation_type: highlight devient span, avec une migration en place. Mettez à jour les anciennes configurations en renommant le type ; les configurations span existantes ne sont pas touchées.
• Une large vague de durcissement QA a touché l'enregistrement des routes, les phases d'entraînement, Prolific, la persistance, l'export et le traitement des enquêtes, les webhooks, le mode solo et l'apprentissage actif.

Potato 2.5.0

Publié en 2026

Une vague consacrée au codage qualitatif, qui rend Potato crédible pour les flux de recherche qualitative à côté de ses usages d'annotation en NLP et en ML.

• Accord inter-annotateurs. Kappa de Cohen (par paires) et kappa de Fleiss (N évaluateurs) en plus de l'alpha de Krippendorff, exposés par l'API d'accord d'administration. Voir le guide sur l'accord inter-annotateurs.
• Nouveaux exportateurs. codebook (un CSV par schéma avec hiérarchie des codes, couleur, description et nombre d'usages) et quotation_report (un CSV par segment avec le texte, les décalages, le document source et le codeur).
• Analyse des codes. Points de terminaison d'administration pour la cooccurrence de codes deux à deux et un tableau croisé codes × attribut sur les métadonnées d'instance existantes.

Potato 2.4.5

Publié en 2026

Une version de stabilisation et d'outillage.

• Raffinement validé. Un cadre modulaire pour améliorer par itérations les consignes d'annotation du mode solo, avec des garde-fous contre les contradictions entre consignes et les fuites de métadonnées.
• Validateur de configuration. Une nouvelle commande python -m potato.validate_cli qui vérifie les clés de configuration par rapport au schéma des clés de configuration connues.
• Sécurité. Correction d'un contournement par préfixe frère dans la validation des chemins, qui permettait une traversée de répertoires (GHSA-q9m2-fhv9-3jcf).
• Corrections sur la synchronisation d'état entre enregistrement et navigation, l'intégration Prolific, la navigation multi-phases et les retours du contrôle qualité.

Potato 2.3.0

Publié le 9 mars 2026

Potato 2.3 est la plus grande version de l'histoire de Potato. Elle introduit l'annotation agentique, le mode solo, l'échelle du meilleur et du pire, l'authentification SSO/OAuth, l'export Parquet, 15 nouveaux projets de démonstration et un durcissement de la sécurité.

Annotation agentique

Un système complet pour évaluer les agents d'IA par annotation humaine. Il comprend 12 convertisseurs de format de trace, 3 types d'affichage spécialisés et 9 schémas d'annotation prêts à l'emploi.

12 convertisseurs de format de trace. Importez des traces d'agents depuis OpenAI, Anthropic, SWE-bench, OpenTelemetry, MCP, CrewAI/AutoGen/LangGraph, LangChain, LangFuse, ReAct, WebArena/VisualWebArena, ATIF et des enregistrements de navigateur bruts. La détection automatique est disponible.

La conversion s'exécute en ligne de commande, comme une étape préalable au démarrage du serveur :

python -m potato.trace_converter \
  --input traces.json \
  --input-format react \
  --output data/traces.jsonl

Le fichier converti est ensuite un fichier de données ordinaire, affiché par l'un des types d'affichage d'agent :

data_files:
  - "data/traces.jsonl"
 
instance_display:
  fields:
    - key: steps
      type: agent_trace
      label: "Agent trajectory"

3 types d'affichage :

• Affichage de trace d'agent. Cartes d'étapes à code couleur, observations repliables, mise en forme du JSON et chronologie latérale, pour les agents qui utilisent des outils
• Affichage de trace d'agent web. Captures d'écran complètes avec calques SVG montrant les cibles de clic, les saisies de texte et les défilements, et navigation en pellicule, pour les agents de navigation
• Affichage de conversation interactive. Mode conversation en direct (l'annotateur interagit avec l'agent via un proxy) et mode relecture de trace, pour les agents conversationnels

Notations par tour. Notez chaque étape en plus de la trace globale, pour une évaluation à grain fin.

9 schémas prêts à l'emploi : 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.

Système de proxy d'agent. Proxys OpenAI, HTTP et echo pour l'évaluation d'agents en direct.

En savoir plus sur l'annotation agentique →

Mode solo

Un flux de travail dans lequel un seul annotateur humain collabore avec un LLM pour étiqueter un jeu de données entier. Il atteint plus de 95 % d'accord avec les chaînes multi-annotateurs tout en ne demandant que 10 à 15 % du total des étiquettes humaines.

Le mode solo fonctionne comme une machine à états de phases plutôt que comme une séquence fixe. Il passe par la configuration, la revue de l'invite, une boucle facultative sur les cas limites, l'annotation en parallèle, la résolution des désaccords, l'annotation active avec revue périodique et revue des règles, l'étiquetage autonome et la validation finale. Cinq de ces phases peuvent revenir à la revue de l'invite quand l'invite s'avère être le problème, et la validation finale revient à l'annotation active quand l'échantillon ne franchit pas le seuil.

solo_mode:
  enabled: true
  labeling_models:
    - endpoint_type: openai
      model: "gpt-4o"
      api_key: ${OPENAI_API_KEY}
  thresholds:
    end_human_annotation_agreement: 0.92
    minimum_validation_sample: 50
  state_dir: "solo_state"

Priorisation des instances à signaux multiples. instance_selection pondère sept signaux (faible confiance, diversité, prédiction du LLM, désaccord, aléatoire, cartographie, règle de cas limite) pour choisir ce que l'humain voit ensuite.

En savoir plus sur le mode solo →

Échelle du meilleur et du pire

Une annotation comparative efficace, où les annotateurs choisissent le meilleur et le pire élément de chaque n-uplet. Génération automatique des n-uplets par plans en blocs incomplets équilibrés et trois méthodes de scoring (comptage, Bradley-Terry, Plackett-Luce).

annotation_schemes:
  - annotation_type: bws
    name: fluency
    description: "Which sentence reads most fluently?"
    tuple_size: 4
    best_description: "Most Fluent"
    worst_description: "Least Fluent"

En savoir plus sur l'échelle du meilleur et du pire →

Authentification SSO et OAuth

Une authentification prête pour la production avec Google OAuth (restriction par domaine), GitHub OAuth (restriction par organisation) et OIDC générique (Okta, Azure AD, Auth0, Keycloak). Prend en charge l'inscription automatique, le mode mixte et la gestion des sessions.

authentication:
  method: "oauth"
  providers:
    google:
      client_id: ${GOOGLE_CLIENT_ID}
      client_secret: ${GOOGLE_CLIENT_SECRET}
      allowed_domain: "umich.edu"
  user_identity_field: "email"
  auto_register: true
 
secret_key: ${POTATO_SECRET_KEY}

En savoir plus sur le SSO et OAuth →

Export Parquet

Exportez les annotations au format Apache Parquet, sous la forme de trois fichiers structurés : annotations.parquet, spans.parquet et items.parquet. Prend en charge les compressions snappy, gzip, zstd, lz4 et brotli, l'export incrémental et le partitionnement par date ou par annotateur. Compatible avec pandas, DuckDB, PyArrow, Polars et Hugging Face Datasets.

export_annotation_format:
  - parquet

En savoir plus sur l'export Parquet →

15 nouveaux projets de démonstration

De nouvelles démos dans project-hub/ couvrent l'annotation agentique (5 démos), le mode solo (3 démos), l'échelle du meilleur et du pire (3 démos), l'authentification (2 démos) et les flux d'export (2 démos). Lancez n'importe quelle démo avec potato start config.yaml.

Durcissement de la sécurité

• Jetons de session cryptographiquement sûrs, avec expiration configurable
• Protection CSRF activée par défaut
• Limitation de débit sur les points de terminaison d'authentification
• Assainissement des entrées pour les contenus fournis par les utilisateurs
• Audit des dépendances, avec tous les paquets mis à jour
• En-têtes Content Security Policy

Autres améliorations

• Convertisseurs de trace personnalisés pour les frameworks d'agents non pris en charge
• Mode solo hybride avec échantillonnage de vérification multi-annotateurs
• Onglet BWS du tableau de bord d'administration, avec courbes de convergence des scores
• Export Parquet incrémental avec partitionnement par date

Comparaison v2.2 / v2.3

Potato 2.2.0

Publié le 20 février 2026

Potato 2.2 est une version majeure avec 9 nouveaux schémas d'annotation, un système d'export modulaire, l'estimation de compétence MACE, 55 instruments d'enquête validés et des sources de données distantes.

Nouveaux schémas d'annotation (9)

Annotation d'événements. Structures d'événements N-aires avec segments déclencheurs et rôles d'arguments typés. Annotez des événements comme ATTACK, HIRE et TRAVEL avec des arguments d'entités contraints et une visualisation en arcs en étoile.

annotation_schemes:
  - annotation_type: event_annotation
    name: events
    description: "Mark the event triggers and their arguments"
    span_schema: entities
    event_types:
      - type: "ATTACK"
        trigger_labels: ["EVENT_TRIGGER"]
        arguments:
          - role: "attacker"
            entity_types: ["PERSON", "ORGANIZATION"]
            required: true

En savoir plus sur l'annotation d'événements →

Liaison d'entités. Liez les annotations de segments à des bases de connaissances externes (Wikidata, UMLS, API REST personnalisées). Ajoutez un bloc entity_linking: à n'importe quel schéma de segments pour activer la recherche et la liaison dans une base de connaissances.

En savoir plus sur la liaison d'entités →

Triage. Interface d'acceptation, de rejet et de passage à la manière de Prodigy, pour le filtrage rapide des données. Étiquettes personnalisables, raccourcis clavier et avancement automatique pour une annotation à haut débit.

En savoir plus sur le triage →

Comparaison par paires. Comparez deux éléments en mode binaire (clic sur la tuile préférée) ou en mode échelle (curseur). Prend en charge items_key, allow_tie et un bloc scale: avec une plage configurable.

En savoir plus sur la comparaison par paires →

Arbres de conversation. Annotez des structures de conversation hiérarchiques avec des évaluations par nœud, la sélection de chemins et la comparaison de branches.

En savoir plus sur les arbres de conversation →

Chaînes de coréférence. Regroupez les mentions coréférentes en chaînes avec des indicateurs visuels. Prend en charge les types d'entités, le contrôle des singletons et plusieurs modes de surlignage.

En savoir plus sur les chaînes de coréférence →

Masques de segmentation. Nouveaux outils fill, eraser et brush pour la segmentation d'images au niveau du pixel.

Boîtes englobantes pour PDF et documents. Dessinez des boîtes sur les pages PDF pour les tâches d'annotation de documents.

Segments discontinus. allow_discontinuous: true permet de sélectionner des segments de texte non contigus comme un seul segment.

Annotation intelligente

Estimation de compétence MACE. Algorithme EM bayésien variationnel qui estime conjointement les vraies étiquettes et les scores de compétence des annotateurs (0,0-1,0). Fonctionne avec les schémas radio, likert, select et multiselect.

mace:
  enabled: true
  trigger_every_n: 10
  min_annotations_per_item: 3

En savoir plus sur MACE →

Mise en évidence des options. Mise en évidence, par un LLM, des options probablement correctes pour les tâches d'annotation discrètes. Met en évidence les k meilleures options avec un indicateur en étoile et atténue les options moins probables.

ai_support:
  option_highlighting:
    enabled: true
    top_k: 3
    dim_opacity: 0.4

En savoir plus sur la mise en évidence des options →

Ordonnancement par diversité. Clustering fondé sur les embeddings et échantillonnage en tourniquet, pour que les annotateurs voient des contenus variés plutôt que des éléments similaires à la suite.

assignment_strategy: diversity_clustering
diversity_ordering:
  enabled: true
  prefill_count: 100

En savoir plus sur l'ordonnancement par diversité →

Système d'export

Un nouveau CLI d'export modulaire (python -m potato.export) convertit les annotations vers 6 formats standards du secteur : COCO, YOLO, Pascal VOC, CoNLL-2003, CoNLL-U et masques de segmentation.

python -m potato.export --config config.yaml --format coco --output ./export/

En savoir plus sur les formats d'export →

Sources de données distantes

Chargez des données d'annotation depuis des URL, S3, Google Drive, Dropbox, Hugging Face, Google Sheets et des bases de données SQL via le nouveau bloc de configuration data_sources:. Inclut le chargement partiel, la mise en cache et la gestion des identifiants.

En savoir plus sur les sources de données distantes →

Instruments d'enquête

55 questionnaires validés répartis en 8 catégories (Personnalité, Santé mentale, Affect, Concept de soi, Attitudes sociales, Style de réponse, Format court, Démographie). Utilisez-les dans les phases pré-étude et post-étude avec instrument: "tipi".

En savoir plus sur les instruments d'enquête →

Autres améliorations

• Suivi d'objets vidéo avec interpolation entre images clés
• Prise en charge de fichiers de configuration IA externes
• Améliorations de la grille de mise en page des formulaires
• Gestionnaires de formats pour PDF, Word, code et tableurs

Potato 2.1.0

Publié le 5 février 2026

Potato 2.1 introduit le système d'affichage des instances, la prise en charge de l'IA visuelle, la liaison de segments, l'annotation de segments multi-champs et la personnalisation de la mise en page.

Système d'affichage des instances

Un nouveau bloc de configuration instance_display qui sépare l'affichage du contenu de l'annotation. Affichez n'importe quelle combinaison d'images, de vidéos, d'audio, de texte et de dialogues à côté de n'importe quels schémas d'annotation.

instance_display:
  fields:
    - key: image_url
      type: image
      display_options:
        max_width: 600
        zoomable: true
    - key: description
      type: text
 
annotation_schemes:
  - annotation_type: radio
    name: category
    description: "What category best describes this image?"
    labels: [nature, urban, people]

Prend en charge 24 types d'affichage, dont text, html, image, video, audio, depth_map, dialogue, conversation_tree, pairwise, code, spreadsheet, document, pdf, gallery et cinq affichages de traces d'agent.

En savoir plus sur l'affichage des instances →

Annotation de segments multi-champs

Les schémas d'annotation de segments prennent désormais en charge une option target_field pour annoter sur plusieurs champs de texte d'une même instance.

annotation_schemes:
  - annotation_type: span
    name: source_entities
    description: "Label the entities in the source document"
    labels: [PERSON, ORGANIZATION]
 
  - annotation_type: span
    name: summary_entities
    description: "Label the entities in the summary"
    labels: [PERSON, ORGANIZATION]

En savoir plus sur l'annotation de segments →

Liaison de segments

Un nouveau type d'annotation span_link pour créer des relations typées entre des segments annotés. Prend en charge les liens orientés et non orientés, les relations N-aires, l'affichage visuel en arcs et les contraintes d'étiquettes.

annotation_schemes:
  - annotation_type: span
    name: entities
    description: "Highlight the named entities in the text"
    labels:
      - name: "PERSON"
        color: "#3b82f6"
      - name: "ORGANIZATION"
        color: "#22c55e"
 
  - annotation_type: span_link
    name: relations
    description: "Link the entities that stand in a relation"
    span_schema: entities
    link_types:
      - name: "WORKS_FOR"
        directed: true
        allowed_source_labels: ["PERSON"]
        allowed_target_labels: ["ORGANIZATION"]
        color: "#dc2626"

En savoir plus sur la liaison de segments →

Prise en charge de l'IA visuelle

Quatre nouveaux points d'accès de vision pour l'assistance par IA à l'annotation d'images et de vidéos :

• YOLO, détection d'objets locale et rapide
• Ollama Vision, modèles vision-langage locaux (LLaVA, Qwen-VL)
• OpenAI Vision, vision GPT-4o dans le cloud
• Anthropic Vision, Claude avec la vision

Les fonctionnalités comprennent la détection d'objets, la pré-annotation, la classification, les indices, la détection de scènes, la détection d'images clés et le suivi d'objets.

En savoir plus sur la prise en charge de l'IA visuelle →

Personnalisation de la mise en page

Créez des mises en page visuelles personnalisées élaborées à l'aide de gabarits HTML et de CSS. Potato génère un fichier de mise en page modifiable, ou vous pouvez fournir un gabarit entièrement personnalisé avec des grilles, des options à code couleur et un style par section.

task_layout: layouts/custom_task_layout.html

Trois exemples de mise en page sont fournis : modération de contenu, QA de dialogue et revue médicale.

En savoir plus sur la personnalisation de la mise en page →

Justifications des étiquettes

Une quatrième capacité d'IA, qui génère des explications équilibrées sur les raisons pour lesquelles chaque étiquette pourrait s'appliquer, afin d'aider les annotateurs à comprendre les différentes perspectives de classification.

ai_support:
  features:
    rationales:
      enabled: true

En savoir plus sur l'assistance par IA →

Autres améliorations

• Plus de 50 nouveaux tests pour une meilleure fiabilité
• Améliorations du design responsive
• Meilleure organisation du project-hub, avec des exemples de mise en page
• Corrections de bugs sur les types d'annotation

Comparaison v2.0 / v2.1

Potato 2.0

Potato 2.0 est une version majeure qui ajoute l'assistance par IA, l'apprentissage actif, les phases d'entraînement, les flux de travail multi-phases et un backend MySQL.

Assistance par IA

Intégrez des grands modèles de langage pour aider les annotateurs avec des indices, le surlignage de mots-clés et des suggestions d'étiquettes.

Fournisseurs pris en charge :

• OpenAI (GPT-4, GPT-3.5)
• Anthropic (Claude 3, Claude 3.5)
• Google (Gemini)
• Ollama (modèles locaux)
• vLLM (auto-hébergé)

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

En savoir plus sur l'assistance par IA →

Annotation audio

Annotation audio complète avec visualisation de la forme d'onde assurée par Peaks.js. Créez des segments, étiquetez des régions temporelles et annotez la parole avec des raccourcis clavier.

Fonctionnalités clés :

• Visualisation de la forme d'onde
• Création et étiquetage de segments
• Questions d'annotation par segment
• Plus de 15 raccourcis clavier
• Mise en cache côté serveur des formes d'onde

annotation_schemes:
  - annotation_type: audio_annotation
    name: speakers
    description: "Mark each speaker turn in the audio"
    mode: label
    labels:
      - Speaker A
      - Speaker B

En savoir plus sur l'annotation audio →

Apprentissage actif

Priorisez automatiquement les instances d'annotation en fonction de l'incertitude du modèle. Entraînez des classifieurs sur les annotations existantes et concentrez les annotateurs sur les exemples les plus informatifs.

Capacités :

• Plusieurs classifieurs au choix (LogisticRegression, RandomForest, SVC, MultinomialNB)
• Divers vectoriseurs (TF-IDF, Count, Hashing)
• Persistance du modèle entre les redémarrages
• Sélection améliorée par LLM
• Prise en charge de plusieurs schémas

active_learning:
  enabled: true
  schema_names:
    - sentiment
  min_instances_for_training: 30
  update_frequency: 50
  classifier:
    type: LogisticRegression

En savoir plus sur l'apprentissage actif →

Phase d'entraînement

Qualifiez les annotateurs avec des questions d'entraînement avant la tâche principale. Donnez un retour immédiat et garantissez la qualité grâce à des critères de réussite configurables.

Fonctionnalités :

• Questions d'entraînement avec réponses connues
• Retour immédiat et explications
• Critères de réussite configurables
• Possibilité de nouvelles tentatives
• Suivi de la progression dans le tableau de bord administrateur

phases:
  training:
    enabled: true
    data_file: "data/training.json"
    passing_criteria:
      min_correct: 8
      total_questions: 10

En savoir plus sur la phase d'entraînement →

Tableau de bord administrateur amélioré

Une interface complète de suivi et de gestion des tâches d'annotation.

Onglets du tableau de bord :

• Vue d'ensemble. Métriques globales et taux de complétion
• Annotateurs. Suivi des performances, analyse des temps
• Instances. Parcours des données avec scores de désaccord
• Configuration. Ajustement des paramètres en temps réel

admin_api_key: ${ADMIN_API_KEY}

En savoir plus sur le tableau de bord administrateur →

Backend de base de données

Prise en charge de MySQL pour les déploiements à grande échelle, avec pool de connexions et prise en charge des transactions.

database:
  type: mysql
  host: localhost
  database: potato_db
  username: ${DB_USER}
  password: ${DB_PASSWORD}

Potato crée automatiquement les tables nécessaires au premier démarrage.

Historique des annotations

Suivi complet de toutes les modifications d'annotation, avec horodatages, identifiants d'utilisateur et types d'action. Permet l'audit et l'analyse comportementale.

{
  "history": [
    {
      "timestamp": "2024-01-15T10:30:00Z",
      "user": "annotator_1",
      "action": "create",
      "schema": "sentiment",
      "value": "Positive"
    }
  ]
}

Flux de travail multi-phases

Construisez des flux de travail d'annotation complexes avec plusieurs phases successives :

1. Consentement - Recueil du consentement éclairé
2. Pré-étude - Données démographiques et sélection
3. Instructions - Consignes de la tâche
4. Entraînement - Questions d'entraînement
5. Annotation - Tâche principale
6. Post-étude - Questionnaires de retour

phases:
  consent:
    enabled: true
    data_file: "data/consent.json"
  prestudy:
    enabled: true
    data_file: "data/demographics.json"
  training:
    enabled: true
    data_file: "data/training.json"
  poststudy:
    enabled: true
    data_file: "data/feedback.json"

En savoir plus sur les flux de travail multi-phases →

Changements de configuration v2.0

Nouvelle structure de configuration

Potato 2.0 utilise un format de configuration plus propre :

v1 (ancien) :

data_files:
  - data.json
id_key: id
text_key: text
output_file: annotations.json

v2 (nouveau) :

data_files:
  - "data/data.json"
 
item_properties:
  id_key: id
  text_key: text
 
output_annotation_dir: "output/"
export_annotation_format: "jsonl"

Exigence de sécurité

Les fichiers de configuration doivent désormais se trouver dans le task_dir :

Lorsque la configuration se trouve à côté des données, le répertoire de la tâche est le répertoire courant :

task_dir: "."

Lorsque la configuration se trouve dans un sous-répertoire, indiquez le répertoire du projet auquel elle appartient :

task_dir: "my_project/"

Comparaison rapide

Guide de migration

Mettre à jour votre configuration (v1 vers v2)

1. Configuration des données

   yamlCopier

   # Old
   id_key: id
   text_key: text
    
   # New
   item_properties:
     id_key: id
     text_key: text

2. Configuration de la sortie

   yamlCopier

   # Old
   output_file: annotations.json
    
   # New
   output_annotation_dir: "output/"
   export_annotation_format: "jsonl"

3. Emplacement du fichier de configuration Assurez-vous que votre fichier de configuration se trouve dans le répertoire du projet.

Démarrer le serveur

# v2 command
python -m potato start config.yaml -p 8000
 
# Or shorthand
potato start config.yaml

Pour commencer

Prêt à essayer Potato ? Commencez par le guide de démarrage rapide ou explorez des fonctionnalités précises :

Fonctionnalités v2.3 :

• Annotation agentique - Évaluer des agents d'IA avec des convertisseurs de traces et des affichages au niveau de l'étape
• Mode solo - Étiquetage collaboratif entre un humain et un LLM
• Échelle du meilleur et du pire - Annotation comparative avec calcul de scores
• SSO et OAuth - Authentification Google, GitHub et OIDC
• Export Parquet - Export de données en colonnes

Fonctionnalités v2.2 :

• Annotation d'événements - Structures d'événements N-aires
• Liaison d'entités - Liaison à des bases de connaissances
• Triage - Filtrage rapide des données
• Chaînes de coréférence - Coréférence d'entités
• Arbres de conversation - Annotation de dialogues hiérarchiques
• MACE - Estimation de la compétence des annotateurs
• Mise en évidence des options - Orientation vers les options, assistée par IA
• Ordonnancement par diversité - Ordonnancement des éléments par embeddings
• Formats d'export - CLI d'export avec 6 formats
• Sources de données distantes - Chargement de données depuis le cloud
• Instruments d'enquête - 55 questionnaires validés

Fonctionnalités v2.1 :

• Affichage des instances - Affichage de contenus multimodaux
• Prise en charge de l'IA visuelle - IA pour l'annotation d'images et de vidéos
• Liaison de segments - Annotation de relations entre entités

Fonctionnalités principales :

• Assistance par IA - Aide intelligente à l'annotation
• Apprentissage actif - Priorisation intelligente des instances
• Annotation audio - Annotation fondée sur la forme d'onde
• Phase d'entraînement - Qualification des annotateurs
• Tableau de bord administrateur - Suivi et gestion