Potato 2.14 : entraîner des modèles sur vos propres annotations

Potato 2.14 entraîne des modèles sur les annotations propres d'une étude. Une exécution ajuste l'un des 38 modules d'entraînement sur les étiquettes que les annotateurs ont données, évalue le modèle sur des items mis de côté avant l'entraînement et écrit les prédictions du modèle sur les items sous forme de pré-étiquettes que les annotateurs confirment ou corrigent. La version 2.13.1 n'avait qu'un seul module, sklearn-text. La version importe aussi des fichiers de diarisation RTTM, exporte les tours de parole corrigés, exécute WhisperX pour la transcription locale et corrige plusieurs bogues qui modifiaient des chiffres d'accord et des exports, si bien qu'il faut lire les notes de mise à niveau avant d'installer.

pip install --upgrade potato-annotation

Notes de mise à niveau

Lancez d'abord potato validate config.yaml --strict sur chaque configuration. Les changements suivants peuvent modifier ce que fait une étude 2.13 qui fonctionnait.

• assignment_strategy: llm_confidence ordonne désormais la file. La stratégie sert d'abord la pré-étiquette la moins sûre, puis les items sans pré-étiquette. Les versions précédentes acceptaient la valeur et attribuaient les items au hasard.
• model_training est vérifié à la validation et au démarrage. Une clé inconnue sous writeback ou auto_retrain, une partition nommée autrement que train, val ou test, et une entrée de writeback.schemas qui n'est pas un schéma sont des erreurs qui arrêtent le serveur.
• La page Training rapporte un score sur items réservés. La colonne du score affichait auparavant l'exactitude d'entraînement. Le score d'une exécution 2.13 n'est pas comparable à un score sur items réservés de la 2.14.
• Les liens, les chaînes et les événements apparaissent dans les exports. Les réponses span_link, coreference et event_annotation manquaient dans tous les exports, et CSV et TSV ajoutent désormais les colonnes <scheme>._links et <scheme>._events.
• Potato ne liste plus ujson dans install_requires. Un script à vous qui importe ujson depuis l'environnement de Potato a besoin de pip install ujson.

Entraînement de modèles

L'entraînement de modèles convient à une étude qui compte plus d'items que les annotateurs n'en étiquetteront, et où un modèle entraîné sur les premières étiquettes peut proposer le reste. La boucle comporte trois étapes. D'abord, une exécution résout les étiquettes de chaque item en une seule réponse et répartit les items entre train, val et test. Ensuite, le module ajuste un modèle sur la partition train dans un processus séparé, et l'exécution évalue le modèle sur les items val et test. Enfin, l'écriture en retour montre les prédictions du modèle aux annotateurs sous forme de pré-étiquettes, et les réponses que les annotateurs enregistrent deviennent les étiquettes de l'exécution suivante.

Pour activer la boucle sur une étude dotée d'un schéma sentiment, ajoutez ce bloc à la configuration de l'étude.

model_training:
  enabled: true
  writeback:
    schemas: [sentiment]
    include_unlabeled: true
    min_confidence: 0.6

Les annotateurs ne voient rien d'une exécution tant qu'un schéma n'est pas nommé sous writeback.schemas. include_unlabeled: true prédit sur les items que personne n'a étiquetés, et min_confidence garde hors de la page les prédictions inférieures à 0,6. Redémarrez le serveur, ouvrez /admin/training avec la clé d'administration, choisissez un module et un schéma, puis cliquez sur Train now.

Le projet d'exemple de Potato dans examples/ai-assisted/model-training/ contient 160 avis de produits et exécute sklearn-text, qui n'a besoin d'aucun GPU ni de rien de plus qu'une installation ordinaire. La documentation de l'entraînement de modèles rapporte une exécution sur ce projet, sur 120 avis étiquetés, qui a obtenu un macro-F1 de 0,84 sur les avis de validation et a écrit 80 pré-étiquettes. Un nouvel annotateur voit alors chacun de ces avis avec la réponse du modèle déjà sélectionnée.

Entraîner votre premier modèle déroule l'exemple pas à pas.

Des modules pour chaque type d'annotation

La page Training ne propose pour chaque schéma que les modules qui lui conviennent. Le catalogue des modules liste les 38 modules avec leurs commandes d'installation, et la liste ci-dessous nomme les principaux groupes.

• Texte. hf-text-classification, setfit et sklearn-text classent des items. hf-token-classification étiquette des empans, hf-relation relie des empans en relations, événements et chaînes de coréférence, et byt5-gloss segmente et glose des mots pour la glose interlinéaire.
• Images. torchvision-detect et ultralytics-detect entraînent des détecteurs, et torchvision-segment, ultralytics-segment et cellpose entraînent des segmenteurs. Les exécutions de détection et de segmentation découpent en tuiles les lames entières et les grandes images, et s'entraînent sur des plans de microscopie et des cartes GeoTIFF. volume-unet segmente des volumes 3D, layoutlmv3 étiquette des mises en page, et vlm-sft affine un modèle vision-langage sur des légendes, de l'ancrage et des étapes d'interface.
• Audio et vidéo. whisper-asr affine Whisper sur des tours de transcription corrigés, diarization entraîne un modèle de locuteurs sur des tours de parole, hf-audio-tagger étiquette des segments audio, et video-track suit des objets d'une image à l'autre.
• LLM et agents. llm-sft affine sur des réponses en texte libre, llm-dpo sur des préférences par paires, reward-model sur des réponses par paires, des classements et des réponses meilleur-pire, et prm-reward sur des notes d'étapes de traces d'agent.
• Sciences. rdkit-property prédit des réponses sur des molécules, peak-cnn prédit des positions de pics sur des spectres, signal-cnn étiquette des intervalles de signaux de séries temporelles, et episode-model étiquette des épisodes de robots.

Les modules ultralytics sont sous AGPL-3.0, et les poids de LayoutLMv3 sont sous CC BY-NC-SA 4.0. Une exécution de l'un ou de l'autre vous demande d'abord d'accepter la licence. pip install "potato-annotation[train]" installe ce dont les modules pour le texte, les images, l'audio et les LLM ont besoin, et le catalogue nomme les installations séparées.

Scores sur items réservés et pré-étiquettes

Chaque exécution évalue ses prédictions sur les items val et test avec une métrique adaptée au schéma, comme le macro-F1 pour les étiquettes, le mAP50 pour les boîtes, le taux d'erreur sur les mots pour les transcriptions et le Dice pour les volumes. Un item qui a une étiquette et aucune prédiction compte comme faux, et un chiffre de couverture indique la part des items qui ont reçu une prédiction. Les items de la partition train ne reçoivent jamais de pré-étiquette, et un item qu'un relecteur a corrigé va toujours dans la partition train des exécutions suivantes.

Une pré-étiquette ne devient la réponse de l'annotateur que lorsque celui-ci la modifie ou passe à la suite, et l'écriture en retour ne modifie jamais une étiquette humaine. La file de relecture des modèles sert les pré-étiquettes en commençant par les moins sûres, et le rapport de relecture nomme l'exécution derrière chaque pré-étiquette. Le modèle dans la boucle couvre le processus de relecture.

Entraîner sur un serveur GPU ou un cluster

Une exécution tourne sur un backend. Le backend local entraîne sur le serveur Potato et choisit CUDA, Metal d'Apple ou le processeur. Un backend ssh lance l'exécution sur un serveur GPU que Potato peut joindre et rapatrie en flux la progression et le modèle. Un backend slurm soumet l'exécution à un nœud de calcul avec sbatch depuis le nœud de connexion, et n'a besoin que de sbatch, squeue et scancel. Un backend agent dessert une machine que Potato ne peut pas joindre, qui lance potato training agent et interroge le serveur pour obtenir des travaux. Avant une exécution sur un backend ssh, potato training check <backend> config.yaml rapporte le Python distant, les GPU distants et les paquets d'entraînement manquants. Entraîner sur un serveur GPU, un cluster SLURM ou une machine derrière un NAT met en place chaque backend.

Choisir ce qu'il faut demander ensuite

hf-text-classification et hf-image-classification acceptent un paramètre acquisition qui écrit un score sur chaque prédiction, par marge, entropie, BALD ou distance de core-set. assignment_strategy: llm_confidence sert alors d'abord le score le plus élevé. auto_retrain lance par défaut une nouvelle exécution après chaque série de 25 nouvelles annotations, et chaque exécution réévalue les items non étiquetés. L'apprentissage actif compare cette boucle avec le bloc active_learning de Potato.

Des modèles que vous avez déjà

Cinq modules n'ajustent rien et évaluent un modèle qui tourne ailleurs : label-studio-ml pour un backend ML de Label Studio, openai-vlm-boxes pour un modèle vision-langage derrière une API compatible OpenAI, hf-inference pour un Hugging Face Inference Endpoint, roboflow, et cvat-nuclio pour une fonction serverless CVAT. Les prédictions de ces modèles reçoivent le même score sur items réservés, la même écriture en retour et la même relecture que celles d'un modèle entraîné. Pré-étiquettes et scores sur items réservés à partir d'un modèle que vous exécutez déjà couvre chaque passerelle.

Publier un modèle

La page d'une exécution envoie le modèle vers le Hugging Face Hub avec une fiche de modèle qui nomme le module, le modèle de base, les schémas, la taille des partitions et le score sur items réservés. Vous saisissez deux fois le nom du dépôt, le dépôt est privé par défaut, et le jeton vient d'une variable d'environnement du serveur. Les prédictions et les données d'entraînement restent sur le serveur. La même page conserve la partition d'une exécution et ses étiquettes humaines comme version de jeu de données, pour comparer des modèles ultérieurs sur les mêmes items.

Transcriptions, import et export

• WhisperX. potato transcripts --transcribe utilise WhisperX quand il est installé, avec des temps de mots issus de l'alignement forcé sous --asr-word-timestamps, et se rabat sinon sur faster-whisper. Une exécution whisper-asr écrit une copie CTranslate2 du modèle affiné que --asr-model charge.
• Import RTTM. potato import -f rttm transforme un fichier de diarisation, ou un dossier de fichiers de diarisation, en un item par enregistrement avec les tours de parole à corriger. --speaker-map renomme les locuteurs.
• Export segments. Le format écrit une ligne JSONL par segment audio ou vidéo et un fichier RTTM par annotateur.
• Dépendances CoNLL-U. HEAD et DEPREL viennent d'un schéma span_link orienté sur les empans exportés. Les deux colonnes valaient toujours _ auparavant.

Corrections qui touchent les résultats

Le journal des modifications liste chaque correction. Les corrections ci-dessous pouvaient avoir changé des chiffres que vous aviez rapportés.

• Une égalité de classement écrite B,D=A,C était lue comme un seul item nommé D=A, si bien que le tau de Kendall et la distance de Spearman laissaient de côté les deux items à égalité.
• Les pré-étiquettes de curseur, d'étiquette douce et d'échelle par paires étaient enregistrées comme réponse de l'annotateur au chargement de la page, si bien qu'un item comptait comme fait avant que quiconque réponde. Ouvrir un item grounding_eval enregistrait l'item de la même façon.
• /admin/iaa listait la coréférence, les liens d'empans et les événements comme des empans sans score. Le rapport note désormais ces trois types par le F1 moyen sur les paires.
• Fusionner ou scinder un code du livre de codes ne repointait aucun codage, car rien ne reliait les annotations enregistrées aux identifiants de codes.
• Les manifestes d'instantanés figeaient des chiffres d'accord nuls, et enregistrent désormais le kappa et le pourcentage d'accord.
• La relecture des modèles comptait un verdict reject comme un échec plutôt que contre la pré-étiquette que le verdict retirait, et la précision du rapport de relecture sortait fausse. Une paire annotateur-item réservée gardait aussi le champ d'écriture en retour dans les données de l'item quand writeback.field différait de pre_annotation.field, et les données d'item d'une telle paire omettent désormais les deux champs.

Installer la 2.14

Mettez à niveau, validez chaque configuration et installez les modules dont vous avez besoin.

pip install --upgrade potato-annotation
potato validate config.yaml --strict
pip install "potato-annotation[train]"

L'entraînement de modèles est le point de départ, et Nouveautés liste le reste de la version.