Modelltraining auf den eigenen Annotationen

Neu in v2.14.0

Beim Modelltraining wird ein Modell auf den Labels trainiert, die Annotatoren bereits vergeben haben. Das Modell wird an Items bewertet, die vom Training zurückgehalten wurden, und seine Antworten können Annotatoren als Vorlabels angezeigt werden, die sie bestätigen oder korrigieren. Diese Seite erklärt den Trainingskreislauf, die Admin-Seite Training, die nach Aufgabe gruppierten Trainer und die Seite oder das Tutorial, das jeden Teil im Detail behandelt. Die Seite richtet sich an Studienverantwortliche und Admins, die einen selbst gehosteten Potato-Server betreiben. Die Training-Seite und der Trainer sklearn-text gehören seit 2.11 zu Potato. Version 2.14.0 bringt 37 Trainer, Remote-Training auf GPU-Servern und SLURM-Clustern, Holdout-Scores in der Runs-Tabelle und die Veröffentlichung auf dem Hugging Face Hub.

Der Trainingskreislauf

Jede Runde des Kreislaufs trainiert ein Modell auf den bisher gesammelten menschlichen Labels und gibt dem nächsten Annotator die Antworten des Modells als Ausgangspunkt. Der Kreislauf läuft in sechs Schritten ab:

1. Annotieren. Annotatoren labeln Items wie gewohnt, und Potato löst die Labels mehrerer Annotatoren zu einem Item zu einem Label auf, standardmäßig mit Dawid-Skene oder per Mehrheitsentscheid.
2. Trainieren. Ein Lauf teilt die gelabelten Items in Train-, Val- und Test-Items auf und trainiert das Modell in einem eigenen Prozess. Jedes Item behält von Lauf zu Lauf denselben Split, weil der Split ein Hash der Item-ID mit festem Seed ist.
3. Bewerten. Der Lauf bewertet das Modell an den zurückgehaltenen Val- und Test-Items.
4. Zurückschreiben. Die Vorhersagen des Laufs gehen als Vorlabels für die von dir gewählten Schemas in die Daten jedes Items. Vorhersagen unterhalb einer Konfidenzschwelle und Vorhersagen für Items im Train-Split bleiben außen vor.
5. Korrigieren. Der nächste Annotator sieht die Antwort des Modells bereits ausgefüllt und bestätigt oder ändert sie. Ein Reviewer kann außerdem festhalten, ob das Modell recht hatte.
6. Neu trainieren. Der nächste Lauf trainiert auf den neuen Labels, und jedes Item, das ein Reviewer korrigiert hat, kommt in den Train-Split.

Das Training einschalten

Modelltraining ist standardmäßig aus, und ein einziger Konfigurationsschlüssel schaltet das Training ein. Füge diesen Block zu einer bestehenden Konfiguration hinzu:

model_training:
  enabled: true

Starte den Server neu und öffne /admin/training mit einer Admin-Sitzung oder dem Admin-API-Schlüssel. Ohne enabled: true gibt es die Training-Routen nicht. Das Einschalten des Trainings ändert nichts für Annotatoren, denn Vorlabels erscheinen nur für die Schemas unter writeback.schemas, und diese Liste ist standardmäßig leer.

Das Panel Start a run oben auf der Training-Seite enthält das gesamte Setup für einen Lauf. Schema listet die Annotationsschemas der Studie, Trainer listet die Trainer, die zum Typ und zu den Items des gewählten Schemas passen, und Runs on listet die Orte, an denen ein Lauf ausgeführt werden kann. Das Feld Parameters nimmt JSON entgegen und beginnt mit dem Eintrag des gewählten Trainers in model_training.trainer_params. Der Hinweis unter dem Feld nennt jeden Parameter, den der Trainer akzeptiert. Train now startet den Lauf. Ein Lauf, der gestartet wird, während ein anderer Lauf läuft, wartet in einer Warteschlange und steht in der Runs-Tabelle als waiting #N mit einer Schaltfläche Cancel run.

Zwei sklearn-text-Läufe auf einem Sentiment-Schema, jeweils mit einem Score an Rezensionen, die das Modell nie im Training gesehen hat

Jede Run-ID in der Runs-Tabelle öffnet die Lauf-Seite unter /admin/training/runs/<run_id>. Die Lauf-Seite zeigt Status, Trainer, Backend, Split-Größen, Holdout-Score und Parameter des Laufs, danach jede aufgezeichnete Metrik und das Log des Laufs. Ein fehlgeschlagener Lauf erhält zusätzlich den Abschnitt What went wrong. Von der Lauf-Seite aus kannst du außerdem die Val-, Test- oder Train-Items des Laufs als Datensatzversion speichern und das Modell auf dem Hugging Face Hub veröffentlichen. Für einen vollständigen ersten Lauf auf einem Beispielprojekt ohne GPU folge Dein erstes Modell trainieren.

Trainer nach Aufgabe

Potato 2.14.0 hat 38 Trainer, die im Menü Trainer jeweils mit ihrem Registry-Namen erscheinen. Die Tabelle gruppiert die Trainer nach der Art von Annotation, aus der jeder Trainer lernt:

Die fünf Trainer in der letzten Zeile trainieren nichts. Jeder von ihnen schickt die zurückgehaltenen Items an ein Modell, das anderswo läuft, und Potato bewertet, schreibt zurück und prüft die Antworten wie die eines trainierten Modells. sklearn-text braucht nichts außer einer einfachen Potato-Installation, und pip install "potato-annotation[train]" installiert, was die Text-, Bild-, Audio- und LLM-Trainer brauchen. Ein Trainer, der nicht installiert ist, erscheint auf der Training-Seite als „not installed“, zusammen mit dem Befehl, der den Trainer installiert. Trainer nennt für jeden Trainer die Annotationstypen, Item-Typen, den Installationsbefehl und die Parameter.

Wo Läufe ausgeführt werden

Ein Lauf wird auf einem Backend ausgeführt, das pro Lauf im Menü Runs on oder standardmäßig über model_training.backend gewählt wird. Potato kennt vier Arten von Backends:

• local trainiert auf dem Potato-Server in einem Subprozess. device: auto nimmt zuerst CUDA, dann Apples Metal, dann die CPU.
• ssh trainiert auf einem GPU-Server, den Potato per schlüsselbasiertem ssh erreicht. Potato kopiert den Potato-Quellcode auf den Server, startet den Lauf dort und kopiert nach einem erfolgreichen Lauf das Modell zurück.
• slurm verbindet sich auf dieselbe Weise mit dem Login-Knoten eines Clusters und reicht den Trainingsjob mit sbatch bei einem Rechenknoten ein. Das Backend ruft nur sbatch, squeue, scancel und scontrol auf. Ein Cluster ohne srun oder sacct funktioniert deshalb.
• agent bedient eine Maschine, die Potato nicht erreichen kann, etwa eine Workstation hinter NAT. potato training agent auf dieser Maschine fragt den Server regelmäßig nach Jobs ab, und die Modelldateien bleiben auf dieser Maschine.

potato training check <backend> config.yaml testet ein Backend vor dem ersten Lauf, und die Schaltfläche Check auf der Training-Seite macht dasselbe. Konfiguration listet jeden Backend-Schlüssel, und Training auf einem GPU-Server oder Cluster richtet die drei Remote-Arten Schritt für Schritt ein.

Holdout-Scores

Jeder Lauf bewertet das Modell an den Val- und Test-Items, mit einer Metrik, die zum Annotationstyp des Schemas passt. Ein Klassifikator mit einem Label pro Item erhält Macro-F1, ein Span-Tagger Span-F1, ein Box-Detektor mAP bei IoU 0,5 und ein Transkriptionsmodell 1 minus die Wortfehlerrate. Die Runs-Tabelle zeigt pro Lauf einen Hauptscore, und die Lauf-Seite listet jede Metrik mit dem Split im Metriknamen, etwa val_macro_f1 oder test_f1. Ein Item mit einem Label und ohne Vorhersage zählt als falsch. Ein Trainer kann den Score deshalb nicht erhöhen, indem er schwierige Items auslässt. Wählt ein Trainer den besten Checkpoint anhand der Val-Items, stammt der Hauptscore von den Test-Items, weil der Val-Score das Modell bereits geprägt hat. Ein Trainer, der auf Val nichts auswählt, etwa sklearn-text, nimmt den Hauptscore von den Val-Items. Konfiguration nennt die Metriken für jeden Annotationstyp.

Vorlabels und die Warteschlange zur Modellprüfung

Ein Vorlabel ist die Antwort eines Modells, die auf der Annotationsseite ausgefüllt erscheint und die der Annotator bestätigt oder ändert. Das Rückschreiben macht aus den Vorhersagen eines Laufs Vorlabels für die Schemas unter writeback.schemas, ohne dass ein pre_annotation-Block nötig ist. Füge den Block writeback unter model_training hinzu:

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

Mit diesem Block wird eine sentiment-Vorhersage mit einer Konfidenz unter 0,6 gespeichert und nicht angezeigt. include_unlabeled: true sorgt dafür, dass jeder Lauf auch auf Items vorhersagt, die noch niemand gelabelt hat. Ohne diese Einstellung sagt ein Lauf nur an den zurückgehaltenen Val- und Test-Items voraus. Items im Train-Split eines Laufs erhalten nie ein Vorlabel, und das Rückschreiben ändert nie ein menschliches Label. Ein Vorlabel wird erst dann zur Antwort des Annotators, wenn der Annotator das Vorlabel bearbeitet oder zum nächsten Item weitergeht.

Ein neuer Annotator sieht die Antwort des Modells ausgewählt und bestätigt oder ändert sie

assignment_strategy: model_review liefert vorgelabelte Items an Reviewer aus, die unsichersten zuerst. Ein Reviewer hält zu jedem Item ein Urteil fest, entweder accept, correct oder reject. Ein abgelehntes Vorlabel wird vom Item entfernt und nicht erneut angezeigt. Jeder spätere Lauf trainiert auf einem Item mit dem Urteil correct und bewertet das Modell nie an diesem Item. Vorlabels ziehen Annotatoren zur Antwort des Modells hin. Schalte include_unlabeled erst ein, wenn der Holdout-Score das Modell trägt, und nutze Wie man Prüfung von Durchwinken bei vorgelabelten Daten unterscheidet, um Annotatoren zu finden, die Vorlabels ungelesen akzeptieren. Das Modell im Kreislauf führt an einem Projekt durch Rückschreiben, Prüfung und erneutes Training.

Neu trainieren, während Annotationen eintreffen

auto_retrain startet automatisch Läufe, sobald Annotationen eintreffen, und jeder neue Lauf ersetzt die Vorlabels des vorigen Laufs. Füge den Block unter model_training hinzu:

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

Mit diesen Werten startet ein Lauf, sobald seit dem letzten automatischen Lauf 25 Annotationen eingetroffen sind und seit dem Ende des letzten Laufs 600 Sekunden vergangen sind. Konfiguration listet jeden auto_retrain-Schlüssel und die Gründe, aus denen eine Prüfung einen Lauf überspringt, und Das Modell im Kreislauf zeigt, wann sich das erneute Training lohnt.

Ein Modell auf dem Hugging Face Hub veröffentlichen

Ein erfolgreicher Lauf, dessen Modell auf dem Potato-Server liegt, hat auf der Lauf-Seite ein Formular Publish to the Hugging Face Hub. Der Push lädt die Gewichte, die Konfiguration und die Tokenizer-Dateien des Modells hoch, dazu eine README.md als Modellkarte, die aus dem Lauf erzeugt wird. Die Modellkarte nennt Trainer, Basismodell, Schemas, Labels, Split-Größen und Holdout-Score. Die Vorhersagen des Laufs und jede Kopie der Trainingsdaten bleiben auf dem Server.

Du tippst den Repository-Namen zweimal ein, und der Push läuft nur, wenn beide Namen übereinstimmen. Private ist standardmäßig angehakt, und das Hugging-Face-Token kommt aus einer Umgebungsvariable auf dem Server (standardmäßig HF_TOKEN) und nicht von der Seite. Ein Modell, das auf einem Remote-Host oder auf einer Agent-Maschine liegt, lässt sich nicht von der Lauf-Seite pushen. Konfiguration listet, welche Dateien hochgeladen werden, und die API-Route, und Ein LLM auf den eigenen Annotationen fine-tunen führt einen Push von Anfang bis Ende vor.

Modelltraining und die Labeling Engine

Die Labeling Engine nutzt dieselben Trainer. Bei eingeschalteter Distillation (features.distill) trainiert die Engine mit einem Trainer (standardmäßig sklearn-text) ein Modell auf den menschlichen Labels der Engine und auf den Maschinenlabels, die ein Vertrag zertifiziert hat, und stellt das Modell als Quelle trained vor die konfigurierte Kaskade. Items in den Cert- und Audit-Splits der Engine gehen nie in den Trainingssatz der Distillation ein. Eine Quelle trained kann auch ein Modell aus einem Trainingslauf laden, wobei das Modellverzeichnis des Laufs als artifact_dir dient. Konfiguration der Labeling Engine listet die Distillation-Schlüssel.

Modelltraining und Active Learning

Das Active Learning von Potato trainiert ein Modell auf den Labels der Studie, und zwar für einen engeren Zweck als das Modelltraining. Active Learning trainiert alle update_frequency Annotationen einen scikit-learn-Klassifikator im Serverprozess und ordnet damit die Warteschlange um, die unsichersten Items zuerst. Annotatoren erhalten die umgeordnete Warteschlange nur unter assignment_strategy: active_learning. Der Klassifikator des Active Learning wird an den Items bewertet, auf denen er trainiert wurde, und seine Vorhersagen werden Annotatoren nie angezeigt.

Das Modelltraining führt jeden der 38 Trainer in einem eigenen Prozess oder auf einer anderen Maschine aus, bewertet das Modell an zurückgehaltenen Items und zeigt die Antworten des Modells als Vorlabels. Auch das Modelltraining kann die Warteschlange ordnen. Unter assignment_strategy: llm_confidence kommen die Items zuerst, deren veröffentlichtes Vorlabel am wenigsten sicher ist. Der Parameter acquisition von hf-text-classification und hf-image-classification ersetzt diese Reihenfolge durch einen Margin-, Entropie-, BALD- oder Core-Set-Score. Nutze Active Learning, um zu entscheiden, welche Items Menschen als Nächstes labeln. Nutze das Modelltraining, wenn du ein an zurückgehaltenen Items bewertetes Modell, Vorlabels für Annotatoren oder ein Modell zum Veröffentlichen brauchst.

Tutorials

Jedes Tutorial führt ein Setup von der Installation bis zu einem bewerteten Lauf:

• Dein erstes Modell aus den eigenen Annotationen trainieren trainiert sklearn-text auf einer Sentiment-Studie, ohne GPU.
• Auf einem GPU-Server, SLURM-Cluster oder einer Maschine hinter NAT trainieren richtet einen ssh-GPU-Server, einen SLURM-Cluster und einen abfragenden Agent ein.
• Labeln mit Modell im Kreislauf: Vorlabels und erneutes Training behandelt Rückschreiben, Prüfung, Acquisition, auto_retrain und Datensatzversionen.
• Ein LLM auf den eigenen Annotationen fine-tunen trainiert SFT-, DPO-, Reward- und Process-Reward-Modelle, mit QLoRA und einem Hub-Push.
• Detektions- und Segmentierungsmodelle auf Bildannotationen trainieren trainiert Detektoren und Segmentierer auf Bildern, Slides, Mikroskopie und Karten, dazu Cellpose, SAM, LayoutLMv3 und Vision-Language-Modelle.
• Sprach- und Audiomodelle auf den eigenen Annotationen trainieren trainiert Whisper, Sprecherdiarisierung, Spektrogramm-Detektoren und Audio-Tagger, mit RTTM-Dateien.
• Modelle auf Volumen, Punktwolken und Video trainieren trainiert volume-unet, external-3d und video-track.
• Modelle auf Molekülen, Spektren, Signalen und Roboter-Episoden trainieren trainiert rdkit-property, peak-cnn, signal-cnn und episode-model.
• Vorlabels und Holdout-Scores von einem Modell, das du bereits betreibst bindet ein Modell, das du schon bereitstellst, über eine Inference-Bridge oder label-studio-ml an.
• Differentially Private Fine-Tuning mit Opacus trainiert einen Klassifikator mit dem Parameter dp und Opacus.

Weiterführende Lektüre

• Trainer - Alle 38 Trainer, nach Aufgabe gruppiert
• Konfiguration - Jeder model_training-Schlüssel, jedes Backend, jede Route und jeder Speicherpfad
• Active Learning - Umordnen der Warteschlange mit einem scikit-learn-Klassifikator
• Vorannotation mit LLMs und Vision-Modellen - Vorlabels aus einem LLM oder einem Vision-Modell statt aus einem trainierten
• Die Labeling Engine - Maschinenlabels, die gegen eine verblindete Stichprobe menschlicher Labels getestet werden
• Annotator-Simulator - Simulierte Annotatoren, um den Kreislauf auszuprobieren, bevor echte Annotatoren beginnen

Für Implementierungsdetails siehe die Quelldokumentation.