Entraîner des modèles sur vos propres annotations

Nouveauté de la v2.14.0

L'entraînement de modèles ajuste un modèle sur les étiquettes que vos annotateurs ont déjà données, l'évalue sur des items mis de côté avant l'entraînement et peut montrer ses réponses aux annotateurs sous forme de pré-étiquettes à confirmer ou à corriger. Cette page explique la boucle d'entraînement, la page Training de l'administration, les modules d'entraînement regroupés par tâche et la page ou le tutoriel qui traite chaque partie en détail. Elle s'adresse aux responsables d'étude et aux administrateurs qui font tourner un serveur Potato auto-hébergé. La page Training et le module sklearn-text font partie de Potato depuis la version 2.11. La version 2.14.0 ajoute 37 modules d'entraînement, l'entraînement à distance sur des serveurs GPU et des clusters SLURM, les scores sur items réservés dans le tableau Runs et la publication sur le Hugging Face Hub.

La boucle d'entraînement

Chaque tour de la boucle entraîne un modèle sur les étiquettes humaines recueillies jusque-là, puis donne au prochain annotateur les réponses du modèle comme point de départ. La boucle suit six étapes.

1. Annoter. Les annotateurs étiquettent les items comme d'habitude, et Potato résout les étiquettes de plusieurs annotateurs sur un même item en une seule étiquette, avec Dawid-Skene par défaut ou un vote majoritaire.
2. Entraîner. Une exécution répartit les items étiquetés entre des partitions train, val et test, puis ajuste le modèle dans un processus séparé. Chaque item garde la même partition d'une exécution à l'autre, car la partition est un hachage à graine fixe de l'identifiant de l'item.
3. Évaluer. L'exécution évalue le modèle sur les items réservés des partitions val et test.
4. Écrire en retour. Les prédictions de l'exécution sont inscrites dans les données de chaque item sous forme de pré-étiquettes, pour les schémas que vous choisissez. Les prédictions sous un seuil de confiance et les prédictions sur les items de la partition train sont écartées.
5. Corriger. L'annotateur suivant voit la réponse du modèle déjà remplie, puis la confirme ou la modifie. Un relecteur peut aussi consigner si le modèle avait raison.
6. Réentraîner. L'exécution suivante s'entraîne sur les nouvelles étiquettes, et chaque item qu'un relecteur a corrigé passe dans la partition train.

Activer l'entraînement

L'entraînement de modèles est désactivé par défaut, et une seule clé de configuration l'active. Ajoutez ce bloc à une configuration existante.

model_training:
  enabled: true

Redémarrez le serveur, puis ouvrez /admin/training avec une session d'administrateur ou la clé d'API d'administration. Sans enabled: true, les routes d'entraînement n'existent pas. Activer l'entraînement ne change rien pour les annotateurs, car les pré-étiquettes n'apparaissent que pour les schémas listés sous writeback.schemas, et cette liste est vide par défaut.

Le panneau Start a run, en haut de la page Training, contient toute la préparation d'une exécution. Schema liste les schémas d'annotation de l'étude, Trainer liste les modules d'entraînement adaptés au type et aux items du schéma choisi, et Runs on liste les endroits où une exécution peut tourner. Le champ Parameters attend du JSON et part de l'entrée du module choisi dans model_training.trainer_params. La note sous le champ nomme chaque paramètre que le module accepte. Train now lance l'exécution. Une exécution lancée pendant qu'une autre est en cours attend dans une file d'attente et apparaît dans le tableau Runs sous la forme waiting #N, avec un bouton Cancel run.

Deux exécutions de sklearn-text sur un schéma de sentiment, chacune avec un score mesuré sur des avis que le modèle n'a jamais vus à l'entraînement

Chaque identifiant d'exécution du tableau Runs ouvre la page de l'exécution à l'adresse /admin/training/runs/<run_id>. Cette page montre l'état de l'exécution, le module, le backend, la taille des partitions, le score sur items réservés et les paramètres, puis chaque métrique enregistrée et le journal de l'exécution. Une exécution en échec ajoute une section What went wrong. Depuis la page de l'exécution, vous pouvez aussi enregistrer les items val, test ou train de l'exécution comme version de jeu de données, et publier le modèle sur le Hugging Face Hub. Pour une première exécution complète sur un projet d'exemple sans GPU, suivez Entraîner votre premier modèle.

Les modules d'entraînement par tâche

Potato 2.14.0 compte 38 modules d'entraînement, chacun nommé dans le menu Trainer par son nom de registre. Le tableau regroupe les modules selon le type d'annotation dont chacun apprend.

Les cinq modules de la dernière ligne n'ajustent rien. Chacun envoie les items réservés à un modèle qui tourne ailleurs, et Potato évalue, écrit en retour et relit les réponses comme celles d'un modèle entraîné. sklearn-text ne demande rien de plus qu'une installation ordinaire de Potato, et pip install "potato-annotation[train]" installe ce dont les modules pour le texte, les images, l'audio et les LLM ont besoin. Un module non installé apparaît sur la page Training avec la mention « not installed » et la commande qui l'installe. Modules d'entraînement donne pour chaque module les types d'annotation, les types d'items, la commande d'installation et les paramètres.

Où tournent les exécutions

Une exécution tourne sur un backend, choisi pour chaque exécution dans le menu Runs on ou par défaut avec model_training.backend. Potato propose quatre sortes de backend.

• local entraîne sur le serveur Potato, dans un sous-processus. Avec device: auto, Potato prend CUDA en premier, puis Metal d'Apple, puis le processeur.
• ssh entraîne sur un serveur GPU que Potato atteint par ssh avec une clé. Potato copie le code source de Potato sur le serveur, y lance l'exécution et rapatrie le modèle après une exécution réussie.
• slurm se connecte de la même façon au nœud de connexion d'un cluster et soumet le travail d'entraînement à un nœud de calcul avec sbatch. Le backend n'appelle que sbatch, squeue, scancel et scontrol. Un cluster sans srun ni sacct fonctionne donc.
• agent dessert une machine que Potato ne peut pas joindre, comme un poste de travail derrière un NAT. La commande potato training agent, lancée sur cette machine, interroge le serveur pour obtenir des travaux, et les fichiers du modèle restent sur cette machine.

potato training check <backend> config.yaml teste un backend avant la première exécution, et le bouton Check de la page Training fait la même chose. Configuration liste chaque clé de backend, et Entraîner sur un serveur GPU ou un cluster met en place pas à pas les trois sortes de backend distant.

Scores sur items réservés

Chaque exécution évalue le modèle sur les items val et test, avec une métrique choisie selon le type d'annotation du schéma. Un classifieur à étiquette unique reçoit le macro-F1, un étiqueteur d'empans reçoit le F1 d'empans, un détecteur de boîtes reçoit le mAP à IoU 0,5, et un modèle de transcription reçoit 1 moins le taux d'erreur sur les mots. Le tableau Runs affiche un score principal par exécution, et la page de l'exécution liste chaque métrique, avec la partition dans le nom de la métrique, comme val_macro_f1 ou test_f1. Un item qui a une étiquette et aucune prédiction compte comme faux. Un module ne peut donc pas améliorer son score en sautant les items difficiles. Quand un module choisit le meilleur point de contrôle sur les items val, le score principal vient des items test, car le score val a déjà façonné le modèle. Un module qui ne choisit rien sur val, comme sklearn-text, prend son score principal sur les items val. Configuration donne les métriques de chaque type d'annotation.

Pré-étiquettes et file de relecture des modèles

Une pré-étiquette est la réponse d'un modèle, remplie sur la page d'annotation pour que l'annotateur la confirme ou la modifie. L'écriture en retour transforme les prédictions d'une exécution en pré-étiquettes pour les schémas listés sous writeback.schemas, sans qu'aucun bloc pre_annotation soit nécessaire. Ajoutez le bloc writeback sous model_training.

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

Avec ce bloc, une prédiction sentiment dont la confiance est inférieure à 0,6 est enregistrée mais pas affichée. include_unlabeled: true fait aussi prédire chaque exécution sur les items que personne n'a encore étiquetés. Sans ce réglage, une exécution ne prédit que sur les items réservés val et test. Les items de la partition train d'une exécution ne reçoivent jamais de pré-étiquette, et l'écriture en retour ne modifie jamais une étiquette humaine. Une pré-étiquette ne devient la réponse de l'annotateur que lorsque celui-ci la modifie ou passe à l'item suivant.

Un nouvel annotateur voit la réponse du modèle sélectionnée et la confirme ou la modifie

assignment_strategy: model_review sert aux relecteurs les items pré-étiquetés en commençant par les moins sûrs. Un relecteur consigne un verdict accept, correct ou reject sur chaque item. Une pré-étiquette rejetée est retirée de l'item et n'est plus montrée. Chaque exécution ultérieure s'entraîne sur un item au verdict correct et n'évalue jamais le modèle sur cet item. Les pré-étiquettes attirent les annotateurs vers la réponse du modèle. Activez include_unlabeled une fois que le score sur items réservés justifie le modèle, et utilisez Distinguer la relecture de la validation automatique dans des données pré-étiquetées pour repérer les annotateurs qui acceptent les pré-étiquettes sans les lire. Le modèle dans la boucle parcourt l'écriture en retour, la relecture et le réentraînement sur un seul projet.

Réentraîner à mesure que les annotations arrivent

auto_retrain lance des exécutions automatiquement au fil des annotations, et chaque nouvelle exécution remplace les pré-étiquettes de l'exécution précédente. Ajoutez le bloc sous model_training.

model_training:
  enabled: true
  auto_retrain:
    enabled: true
    trainer: sklearn-text
    schemas: [sentiment]
    update_frequency: 25
    min_interval_s: 600

Avec ces valeurs, une exécution démarre dès que 25 annotations sont arrivées depuis la dernière exécution automatique et que 600 secondes se sont écoulées depuis la fin de la dernière exécution. Configuration liste chaque clé de auto_retrain et les raisons pour lesquelles une vérification saute une exécution, et Le modèle dans la boucle montre quand activer le réentraînement.

Publier un modèle sur le Hugging Face Hub

Une exécution réussie dont le modèle se trouve sur le serveur Potato a, sur la page de l'exécution, un formulaire Publish to the Hugging Face Hub. L'envoi téléverse les poids du modèle, sa configuration et les fichiers de son tokenizer, ainsi qu'une fiche de modèle README.md rédigée à partir de l'exécution. La fiche nomme le module d'entraînement, le modèle de base, les schémas, les étiquettes, la taille des partitions et le score sur items réservés. Les prédictions de l'exécution et toute copie des données d'entraînement restent sur le serveur.

Vous saisissez deux fois le nom du dépôt, et l'envoi n'a lieu que si les deux noms correspondent. Private est coché par défaut, et le jeton Hugging Face vient d'une variable d'environnement du serveur (HF_TOKEN par défaut) et non de la page. Un modèle laissé sur un hôte distant ou sur la machine d'un agent ne peut pas être publié depuis la page de l'exécution. Configuration liste les fichiers envoyés et la route d'API, et Affiner un LLM sur vos annotations déroule un envoi du début à la fin.

Entraînement de modèles et moteur d'étiquetage

Le moteur d'étiquetage utilise les mêmes modules d'entraînement. Avec la distillation activée (features.distill), le moteur ajuste un modèle avec un module (sklearn-text par défaut) sur les étiquettes humaines du moteur et sur les étiquettes machine qu'un contrat a certifiées, puis place le modèle devant la cascade configurée comme source trained. Les items des partitions cert et audit du moteur n'entrent jamais dans le jeu d'entraînement de la distillation. Une source trained peut aussi charger un modèle issu d'une exécution d'entraînement, avec le répertoire du modèle de l'exécution comme artifact_dir. Configuration du moteur d'étiquetage liste les clés de la distillation.

Entraînement de modèles et apprentissage actif

La fonctionnalité d'apprentissage actif de Potato ajuste un modèle sur les étiquettes de l'étude dans un but plus étroit que l'entraînement de modèles. L'apprentissage actif ajuste un classifieur scikit-learn dans le processus du serveur toutes les update_frequency annotations et s'en sert pour réordonner la file, les items les plus incertains d'abord. Les annotateurs ne reçoivent la file réordonnée que sous assignment_strategy: active_learning. Le classifieur d'apprentissage actif est évalué sur les items sur lesquels il a été ajusté, et ses prédictions ne sont jamais montrées aux annotateurs.

L'entraînement de modèles fait tourner n'importe lequel des 38 modules d'entraînement dans un processus séparé ou sur une autre machine, évalue le modèle sur des items réservés et montre les réponses du modèle sous forme de pré-étiquettes. Il peut aussi ordonner la file. Sous assignment_strategy: llm_confidence, les items dont la pré-étiquette publiée est la moins sûre viennent en premier. Le paramètre acquisition de hf-text-classification et de hf-image-classification remplace cet ordre par un score de marge, d'entropie, de BALD ou de core-set. Utilisez l'apprentissage actif pour décider quels items les personnes étiquettent ensuite. Utilisez l'entraînement de modèles quand vous avez besoin d'un modèle évalué sur des items réservés, de pré-étiquettes pour les annotateurs ou d'un modèle à publier.

Tutoriels

Chaque tutoriel déroule une configuration de l'installation jusqu'à une exécution évaluée.

• Entraîner votre premier modèle à partir de vos annotations entraîne sklearn-text sur une étude de sentiment, sans GPU.
• Entraîner sur un serveur GPU, un cluster SLURM ou une machine derrière un NAT met en place un serveur GPU ssh, un cluster SLURM et un agent qui interroge le serveur.
• Étiquetage avec le modèle dans la boucle, pré-étiquettes et réentraînement couvre l'écriture en retour, la relecture, l'acquisition, auto_retrain et les versions de jeu de données.
• Affiner un LLM sur vos annotations entraîne des modèles SFT, DPO, de récompense et de récompense de processus, avec QLoRA et un envoi sur le Hub.
• Entraîner des modèles de détection et de segmentation sur des annotations d'images entraîne des détecteurs et des segmenteurs sur des images, des lames, de la microscopie et des cartes, ainsi que Cellpose, SAM, LayoutLMv3 et des modèles vision-langage.
• Entraîner des modèles de parole et d'audio sur vos annotations entraîne Whisper, la diarisation du locuteur, des détecteurs sur spectrogramme et des étiqueteurs audio, avec des fichiers RTTM.
• Entraîner des modèles sur des volumes, des nuages de points et de la vidéo entraîne volume-unet, external-3d et video-track.
• Entraîner des modèles sur des molécules, des spectres, des signaux et des épisodes de robots entraîne rdkit-property, peak-cnn, signal-cnn et episode-model.
• Pré-étiquettes et scores sur items réservés à partir d'un modèle que vous exécutez déjà connecte un modèle que vous servez déjà, par une passerelle d'inférence ou label-studio-ml.
• Affinage à confidentialité différentielle avec Opacus entraîne un classifieur avec le paramètre dp et Opacus.

Pour aller plus loin

• Modules d'entraînement - Les 38 modules, regroupés par tâche
• Configuration - Chaque clé model_training, chaque backend, chaque route et chaque chemin de stockage
• Apprentissage actif - Réordonner la file avec un classifieur scikit-learn
• Pré-annotation par LLM et par modèle de vision - Des pré-étiquettes issues d'un LLM ou d'un modèle de vision plutôt que d'un modèle entraîné
• Le moteur d'étiquetage - Des étiquettes machine testées contre un échantillon en aveugle d'étiquettes humaines
• Simulateur d'utilisateurs - Des annotateurs simulés pour essayer la boucle avant l'arrivée des vrais annotateurs

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