Labeln mit dem Modell im Kreislauf: Vorlabels und erneutes Training

Neu in v2.14.0

Dieses Tutorial führt eine Sentiment-Studie einmal durch den Kreislauf mit dem Modell im Loop. Ein Modell trainiert auf den ersten Labels, die Vorhersagen des Modells erscheinen den Annotatoren als Vorlabels, Reviewer korrigieren die Vorlabels mit der geringsten Konfidenz, und die Korrekturen fließen in den nächsten Lauf. Das Tutorial richtet sich an Studienverantwortliche, die wie in Dein erstes Modell trainieren ein erstes Modell trainiert haben und nun möchten, dass Annotatoren mit dem Modell zusammenarbeiten. Jeder Schritt außer einem läuft mit sklearn-text auf einem Laptop. Der Schritt zur Acquisition trainiert einen kleinen Transformer und dauert auf einer CPU einige Minuten.

Das Sentiment-Projekt

Das Projekt ist das Modelltraining-Beispiel von Potato, 160 synthetische Produktrezensionen mit einem radio-Schema namens sentiment. Ein Vorlabel ist ein Label, das ein Modell für ein Item vorgeschlagen hat, bevor eine Person das Item gelabelt hat. Das Zurückschreiben ist der Schritt, der die Vorhersagen eines Trainingslaufs zu Vorlabels auf der Annotationsseite macht. Am Ende des Tutorials trainiert das Projekt einen Klassifikator auf den ersten 120 Labels, veröffentlicht Vorlabels für die übrigen Rezensionen, liefert die Rezensionen mit der geringsten Konfidenz zuerst aus, trainiert neu, sobald neue Labels eintreffen, und hält einen zurückgehaltenen Split als Datensatzversion fest.

Vorlabels beschleunigen die Annotation und ziehen Annotatoren zugleich zur Antwort des Modells. Modellgestütztes Labeln mit einem auf deinen Labels trainierten Modell behandelt, wann sich dieser Tausch lohnt, und Prüfen von Durchwinken in vorgelabelten Daten unterscheiden behandelt Annotatoren, die Vorlabels ungelesen annehmen. Die folgende Konfiguration nimmt von Anfang an einen Teil der Annotatoren von jedem Vorlabel aus. Die zurückgehaltenen Antworten erlauben der Studie, den Sog zu messen.

Das Projekt einrichten

Installiere Potato. sklearn-text braucht nichts außer dem Basispaket:

pip install --upgrade potato-annotation

Kopiere examples/ai-assisted/model-training/ aus dem Potato-Repository in einen neuen Ordner. Der Ordner enthält data/reviews.json mit den 160 Rezensionen und data/gold.json, die Labels, aus denen der Simulator antwortet. Ersetze die config.yaml des Beispiels durch diese Konfiguration:

annotation_task_name: "Review Sentiment (model in the loop)"
 
data_files:
  - "data/reviews.json"
 
item_properties:
  id_key: "id"
  text_key: "text"
 
task_dir: "."
output_annotation_dir: "annotation_output"
 
require_password: false
admin_api_key: "demo-admin-key"
 
num_annotators_per_item: 1
assignment_strategy: llm_confidence
 
annotation_schemes:
  - annotation_type: "radio"
    name: "sentiment"
    description: "Is this review positive or negative?"
    labels:
      - "positive"
      - "negative"
    sequential_key_binding: true
 
ai_support:
  holdout:
    fraction: 0.2
    salt: "review-sentiment"
 
datasets:
  enabled: true
 
model_training:
  enabled: true
  writeback:
    schemas: ["sentiment"]
    include_unlabeled: true
    min_confidence: 0.6

Jeder Block, der zur Konfiguration des Beispiels hinzukommt, erfüllt eine Aufgabe:

• assignment_strategy: llm_confidence liefert jedes Item aus, das Vorlabel mit der geringsten Konfidenz zuerst. Items ohne Vorhersage kommen zuletzt, in der Reihenfolge der Warteschlange.
• ai_support.holdout hält bei 20 % der Paare aus Annotator und Item jede Form von KI-Unterstützung zurück, Vorlabels eingeschlossen. Lege den Holdout fest, bevor die Annotation beginnt, weil eine Änderung von fraction oder salt mitten in der Studie die Gruppen neu mischt.
• datasets.enabled erlaubt es, im letzten Schritt den Split eines Laufs als Datensatzversion zu speichern.
• writeback.schemas nennt die Schemas, deren Vorhersagen Annotatoren sehen. Die Liste ist standardmäßig leer, und das Einschalten des Trainings ändert auf der Annotationsseite nichts, bis die Liste ein Schema nennt.
• include_unlabeled: true lässt jeden Lauf auch für die Rezensionen vorhersagen, die noch niemand gelabelt hat. Ohne die Einstellung sagt ein Lauf nur für seine zurückgehaltenen Val- und Test-Items voraus. Diese Items tragen bereits menschliche Labels.
• min_confidence: 0.6 hält eine Vorhersage mit einer Konfidenz unter 0,6 aus dem Blick der Annotatoren. Potato speichert die Vorhersage trotzdem mit dem Lauf.

writeback.field behält den Standardwert predictions, das Item-Feld, in das die Vorlabels geschrieben werden. Mit dem Standard ist kein Block pre_annotation nötig. Prüfe die Konfiguration, bevor du den Server startest:

potato validate config.yaml
potato start config.yaml -p 8000

Eine Start-Menge labeln

Ein auf deinen Labels trainiertes Modell braucht zuerst Labels. sklearn-text verweigert das Anpassen mit weniger als 10 Items im Trainings-Split. Labele einige Rezensionen unter http://localhost:8000 oder lass drei simulierte Annotatoren je 40 Rezensionen aus der Gold-Datei labeln:

python -m potato.simulator --server http://localhost:8000 --users 3 \
  --strategy gold_standard --competence good=1.0 --max-annotations 40 \
  --gold-file data/gold.json --sequential --fast-mode --no-export

--competence good=1.0 gibt jedem simulierten Annotator das Profil good, das 80–90 % der Rezensionen richtig beantwortet. Mit num_annotators_per_item: 1 decken die drei Annotatoren 120 verschiedene Rezensionen ab und lassen 40 für das Modell ungelabelt.

Trainieren und den Bericht zum Zurückschreiben lesen

Öffne http://localhost:8000/admin/training mit dem Admin-Schlüssel, wähle sklearn-text und das Schema sentiment und klicke auf Train now. Derselbe Lauf startet von der Kommandozeile:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "sklearn-text", "schemas": ["sentiment"]}'

Der Lauf dauert einige Sekunden. Potato teilt die gelabelten Rezensionen in Train, Val und Test auf (standardmäßig 70 %, 15 % und 15 %), passt den Klassifikator auf Train an und bewertet ihn auf Val und Test. Die Status-Route meldet dann die Scores und den Bericht zum Zurückschreiben:

curl -H "X-API-Key: demo-admin-key" http://localhost:8000/admin/training/api/status

Ein Lauf dieses Tutorials lieferte Folgendes, gekürzt auf die Felder, die hier wichtig sind:

{
  "metrics": {
    "heldout_metric": "val macro_f1",
    "heldout_score": 0.7333,
    "n_train": 76.0,
    "val_n": 20.0,
    "test_n": 24.0,
    "test_macro_f1": 0.8222
  },
  "writeback": {
    "n_read": 84,
    "n_written": 78,
    "n_skipped_low_confidence": 6,
    "n_skipped_train_split": 0,
    "n_skipped_rejected": 0,
    "n_skipped_schema_not_enabled": 0,
    "summary": "Published 78 prediction(s) as prelabels."
  }
}

Der Lauf sagte für 84 Rezensionen voraus, die 44 Val- und Test-Rezensionen plus die 40, die niemand gelabelt hatte. Sechs Vorhersagen lagen unter der Schwelle von 0,6, und die übrigen 78 wurden zu Vorlabels. Deine Scores und Zahlen weichen von Lauf zu Lauf ab, weil die simulierten Annotatoren zufällige Fehler machen und andere Rezensionen labeln. Jeder Zähler für übersprungene Vorhersagen benennt eine der vier Prüfungen beim Zurückschreiben, die Konfiguration der Reihe nach auflistet.

Das Zurückschreiben ändert nie ein menschliches Label. Vorhersagen gehen in die Item-Daten, und Annotationen bleiben im eigenen Zustand jedes Annotators. Melde dich unter einem neuen Benutzernamen an, um das Ergebnis zu sehen. Die nächste Rezension kommt mit der ausgewählten Antwort des Modells:

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

Ein Vorlabel wird nicht gespeichert, solange der Annotator das Vorlabel nur ansieht. Das Vorlabel wird zur Antwort des Annotators, wenn der Annotator das Vorlabel bearbeitet oder zur nächsten Rezension weitergeht. Eine unbeantwortete Rezension zählt deshalb nicht als erledigt, und eine Antwort des Modells kehrt nicht als menschliches Label ins Training zurück.

Lies den Holdout-Score, bevor du Annotatoren Vorlabels zeigst. Ein Val-Score von 0,73 Macro-F1 auf 20 Rezensionen lässt viel Raum für falsche Vorlabels. Die Upstream-Referenz zum Zurückschreiben listet die übrigen Zähler für übersprungene Vorhersagen auf und zeigt, wie jeder Annotationstyp ein Vorlabel darstellt.

Die Vorlabels mit der geringsten Konfidenz prüfen

Unter llm_confidence bekommt der nächste Annotator die 40 ungelabelten Rezensionen nach der Konfidenz des veröffentlichten Vorlabels geordnet, die niedrigste zuerst. Eine zweite Strategie liefert Vorlabels zur Qualitätskontrolle statt zum Labeln aus. assignment_strategy: model_review liefert nur Items aus, die ein Vorlabel tragen, das mit der geringsten Konfidenz zuerst, und lässt Items ohne Vorhersage aus. Wechsle zu model_review für einen Prüfdurchgang über die Ausgabe des Modells und bleibe bei llm_confidence, solange jedes Item noch ein Label braucht. Die Upstream-Referenz zur Modellprüfung erklärt beide Warteschlangen.

Der Bericht zur Modellprüfung zeigt die Warteschlange und was das Modell ausgelassen hat:

curl -H "X-API-Key: demo-admin-key" http://localhost:8000/admin/model-review

Der Bericht des obigen Laufs, mit gekürzten Listen:

{
  "n_items": 160,
  "n_prelabelled": 78,
  "queue": ["review_062", "review_024", "review_044", "review_122", "..."],
  "worst_first": ["review_062", "review_024", "review_044", "..."],
  "n_empty": 82,
  "empty_prediction_ids": ["review_006", "review_007", "review_008", "..."],
  "provenance": {
    "review_062": {
      "sentiment": {
        "run_id": "20261104T043431-de5686",
        "trainer": "sklearn-text",
        "heldout_metric": "val macro_f1",
        "heldout_score": 0.7333
      }
    }
  }
}

Der Rang eines Items in queue ist die niedrigste Vorhersagekonfidenz des Items über alle Schemas. worst_first sind die 20 % der Warteschlange mit der geringsten Konfidenz, nie weniger als ein Item. empty_prediction_ids listet die Items ohne Vorlabel auf. In diesem Projekt sind die 82 leeren Items die 76 Trainingsrezensionen und die 6 Vorhersagen unter der Schwelle. Trainingsrezensionen bekommen nie ein Vorlabel.

provenance hält fest, woher jedes Vorlabel stammt. Für jedes Item in der Warteschlange, dessen Vorlabel ein Trainingslauf geschrieben hat, nennt der Eintrag den Lauf, den Trainer und den Holdout-Score des Laufs. Ein Vorlabel, das mit der Datendatei kam, hat keinen Eintrag. Sieht ein Vorlabel falsch aus, führt die Run-ID zur Lauf-Seite unter /admin/training/runs/<run_id>, die die Parameter und den Split jedes Items zeigt.

Urteile festhalten

Ein Urteil hält die Einschätzung eines Reviewers zu einem Vorlabel fest, getrennt von der Annotation des Reviewers. „Das Modell hatte recht“ und „eine Person hat dieses Label unabhängig gewählt“ sind verschiedene Fakten, und wer beide getrennt hält, hält die Präzision des Modells messbar. Potato nimmt Urteile über eine Route entgegen, vom Annotator, dem das Item zugewiesen ist, oder von einem Admin mit dem API-Schlüssel:

curl -X POST -H "Content-Type: application/json" -H "X-API-Key: demo-admin-key" \
  -d '{"instance_id": "review_062", "verdict": "correct", "schema_name": "sentiment"}' \
  http://localhost:8000/api/model-review/verdict

accept bedeutet, das Modell hatte recht, correct bedeutet, eine Person hat die Antwort geändert, und reject bedeutet, das Modell lag falsch. Ein reject nimmt das Vorlabel sofort vom Item, und spätere Läufe veröffentlichen für dieses Item und Schema keine Vorhersage mehr. Das reject zählt weiterhin gegen die Precision des Modells, und zwar als abgelehntes Vorlabel und nicht als ein Label, das das Modell verpasst hat, und dasselbe Urteil erneut zu senden ändert keine Zählung. Ein Urteil correct verschiebt das Item in den Train-Split jedes späteren Laufs, wie der Abschnitt zu Korrekturen unten beschreibt. Ein zweites Urteil zum selben Item ersetzt das erste, und ein unbekanntes Urteil wird mit HTTP 400 abgelehnt.

Die Warteschlange nach einem Acquisition-Score ordnen

Die Konfidenzordnung liefert zuerst die Items aus, bei denen die oberste Antwort des Modells am schwächsten ist. Eine Acquisition-Funktion im Active Learning ordnet ungelabelte Items danach, wie sehr ein Label für jedes Item dem nächsten Modell helfen würde. hf-text-classification und hf-image-classification nehmen einen Parameter acquisition, der einen solchen Score auf jede Vorhersage schreibt, und llm_confidence liefert dann den höchsten Score zuerst aus. Der Trainer braucht das Extra für Texttraining:

pip install "potato-annotation[train-text]"

Starte einen Lauf mit dem Parameter, über das Feld Parameters der Training-Seite oder über die API:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "hf-text-classification", "schemas": ["sentiment"],
       "params": {"acquisition": "margin"}}'

Der Parameter nimmt fünf Werte an:

Eine Vorhersage aus dem Margin-Lauf trägt den Score neben der Konfidenz:

{"label": "positive", "confidence": 0.5207,
 "probabilities": {"negative": 0.4793, "positive": 0.5207},
 "acquisition": 0.9586}

Unter llm_confidence kommen Items mit einem Acquisition-Score zuerst, dann Items mit nur einer Konfidenz, dann Items, deren Vorhersage keine Konfidenz hat, dann Items ohne Vorhersage. acquisition funktioniert bei Schemas mit einem einzelnen Label (radio, select, likert). Die Ordnung liest veröffentlichte Vorlabels, sodass das Schema in writeback.schemas stehen muss und include_unlabeled: true gesetzt sein muss, damit ungelabelte Items überhaupt einen Score bekommen. model_review ignoriert den Score und behält die Konfidenzordnung, weil ein Prüfdurchgang nach den falschen Antworten des Modells sucht. Der Upstream-Abschnitt zur Wahl der nächsten Frage enthält die Einzelheiten.

Vergleiche den Holdout-Score des neuen Laufs mit dem des sklearn-text-Laufs, bevor du die Vorlabels des Laufs behältst. Potato behält eine Vorhersage pro Item und Schema, und die Vorhersage eines neueren Laufs ersetzt die eines älteren. Wird die Vorhersage des neueren Laufs gespeichert, aber nicht angezeigt, z. B. unter min_confidence, geht auch das Vorlabel des älteren Laufs vom Item, wie die Konfiguration beschreibt. In einem Lauf dieses Tutorials auf einer CPU erreichten drei Epochen des Standardmodells (epochs: 3 in params) auf 84 Trainingsrezensionen 0,52 Test-Macro-F1, unter dem sklearn-text-Lauf auf denselben Labels, und der Lauf veröffentlichte 37 Vorlabels. Um die Vorlabels eines Laufs zurückzuziehen, lösche die Vorhersagen des Laufs:

curl -X DELETE -H "X-API-Key: demo-admin-key" \
  http://localhost:8000/admin/training/api/runs/<run_id>/predictions

Das Zurückziehen entfernt die gespeicherten Vorhersagen des Laufs und nimmt die Vorlabels des Laufs von den Items. Die Vorlabels eines früheren Laufs kommen nicht zurück, trainiere also erneut, um sie wieder zu veröffentlichen.

Automatisch neu trainieren

auto_retrain startet einen Lauf von selbst, wenn Annotationen eintreffen. Füge den Block zu model_training hinzu, sobald der Holdout-Score eines Laufs das Anzeigen von Vorlabels rechtfertigt:

model_training:
  enabled: true
  writeback:
    schemas: ["sentiment"]
    include_unlabeled: true
    min_confidence: 0.6
  auto_retrain:
    enabled: true
    trainer: sklearn-text
    schemas: ["sentiment"]
    update_frequency: 25
    min_interval_s: 600

Potato prüft nach jedem Speichern einer Annotation. Ein Lauf startet, sobald seit dem letzten automatischen Lauf 25 Annotationen eingetroffen sind und seit dem Ende des letzten Laufs 600 Sekunden vergangen sind. Beide Werte sind die Standardwerte, und trainer und schemas sind erforderlich. params übergibt Trainer-Parameter, wie es das Feld Parameters der Training-Seite tut.

Schalte auto_retrain nach dem ersten manuellen Lauf ein und nicht ab der ersten Annotation. Ein Projekt ohne bisherigen Lauf trainiert, sobald das Projekt update_frequency Annotationen hat. Mit update_frequency: 20 von Anfang an trainierte der erste automatische Lauf dieses Projekts auf 12 Rezensionen, erreichte einen Val-Macro-F1 von 1,0 auf 3 Rezensionen und veröffentlichte 72 Vorlabels. Ein Holdout-Score auf 3 Rezensionen sagt fast nichts über die nächsten 72 aus.

Entscheidet eine Prüfung, keinen Lauf zu starten, nennt skip_reason in /admin/training/api/status den Grund, etwa „waiting for 3 more annotation(s)“ oder „waiting 299 more second(s) since the last run“. Automatische Läufe reihen sich nicht in die Lauf-Warteschlange ein. Die nächste Annotation, die nach dem Leeren der Warteschlange gespeichert wird, löst eine neue Prüfung aus. Die Zähler liegen im Arbeitsspeicher, und nach einem Neustart zählt ein Projekt, das schon einmal trainiert hat, neue Annotationen ab dem Neustart. Ein Trainer, dessen Lizenz bestätigt werden muss (ultralytics-detect, ultralytics-segment, layoutlmv3), braucht außerdem accept_licence: true im Block, sonst wird jeder automatische Lauf übersprungen. Die vollständige Konfiguration mit beiden Blöcken besteht potato validate config.yaml --strict.

Korrigierte und angeheftete Items im Training

Zwei Arten von Items kommen in den Train-Split jedes späteren Laufs, unabhängig vom Platz des Items im stabilen Split. Die erste Art ist ein Item mit einem Urteil correct. Korrekturen kommen von den Items, bei denen das Modell am schlechtesten war, und in Val oder Test würden die Korrekturen das Modell an einer Stichprobe seiner eigenen Fehler bewerten. Urteile accept und reject verschieben ein Item nicht. Die zweite Art ist ein angeheftetes Item, das ein Admin von Hand ins Training schickt:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/pinned \
  -d '{"instance_ids": ["review_007", "review_008"]}'

Ein angeheftetes Item trainiert mit, sobald jemand das Item gelabelt hat, und bis dahin zählt jeder Lauf das Item als wartend. Mit curation: {enabled: true} heftet die Schaltfläche Train on these neben einem Slice auf der Katalog-Seite alles an, was der Slice erfasst, etwa den eingebauten Slice model-found-nothing. DELETE /admin/training/api/pinned hebt das Anheften auf.

Ein Lauf, der zurückgehaltene Items in Train verschoben hat, schreibt eine Warnung mit der Anzahl ins Log. Nach einem Urteil correct schrieb der nächste Lauf in diesem Tutorial Folgendes ins Log:

1 held-out item(s) moved to train (corrected: 1). Held-out scores are computed without them, so they are not directly comparable with a run that had them.

Die Zahlen stehen in der manifest.json des Run-Bundles unter stats.forced_train. Vergleiche Holdout-Scores über Läufe hinweg mit Blick auf die Warnung, denn die beiden Läufe bewerteten verschiedene Items.

Den Test-Split eines Laufs als Datensatz speichern

Ein Holdout-Score ändert sich mit den Splits, und erst eine feste Menge von Items macht zwei Modelle vergleichbar. Der Abschnitt Keep this split as a dataset auf der Lauf-Seite speichert die Val-, Test- oder Train-Items eines Laufs mit den vereinbarten menschlichen Labels der Items als neue Version eines Datensatzes. Wähle den Split, tippe einen Datensatznamen und klicke auf Save as dataset version. Die Route hinter der Schaltfläche nimmt dieselbe Anfrage von der Kommandozeile entgegen:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs/<run_id>/pin-split \
  -d '{"dataset": "sentiment-test", "split": "test"}'

Die Antwort nennt die neue Version und die Anzahl der Items, hier 23 Test-Rezensionen, gespeichert als Version v0001. Eine Version ändert sich nach dem Speichern nicht mehr, sodass spätere Modelle und LLM-Prompts im Experiment-Runner der Datensätze an genau diesen Items bewertet werden können. Das Speichern in einen Datensatz, der bereits Versionen hat, beginnt eine neue Version, die nur diesen Split enthält, sodass sich die Val-Items eines späteren Laufs nicht mit Items mischen können, auf denen der spätere Lauf trainiert hat. Die Eingaben jedes Beispiels lassen das Vorlabel-Feld aus, sodass eine Auswertung die Antwort des Modells nicht lesen kann. Die Route gibt HTTP 400 zurück, wenn datasets.enabled nicht gesetzt ist.

Annotatoren von Vorlabels ausnehmen

Der Block ai_support.holdout in der Konfiguration hält 20 % der Paare aus Annotator und Item ab der ersten Annotation frei von Unterstützung. Für ein zurückgehaltenes Paar zeigt die Annotationsseite kein Vorlabel, und die an den Browser gesendeten Item-Daten lassen sowohl das writeback.field (hier predictions) als auch das pre_annotation.field aus. Die Zuteilung ist ein gesalzener Hash pro Annotator und Item, sodass ein Paar bei jedem Besuch und nach einem Neustart in derselben Gruppe bleibt. Bei mehreren Annotatoren pro Rezension bekommen die meisten Rezensionen sowohl unterstützte als auch zurückgehaltene Annotatoren. Der Tab AI influence des Admin-Dashboards vergleicht die beiden Gruppen danach, wie oft Antworten mit dem Modell übereinstimmen, wie oft Antworten mit dem Gold übereinstimmen und wie groß die Übereinstimmung innerhalb jeder Gruppe ist. Mit num_annotators_per_item: 1 fällt jede Rezension nur in eine Gruppe, erhöhe den Wert für eine Studie, die den Effekt misst, also über 1. Modellgestütztes Labeln mit einem auf deinen Labels trainierten Modell erklärt, wie der Vergleich zu lesen ist.

Weiterführende Links

• Modelltraining erklärt den Trainingskreislauf und die Training-Seite.
• Konfiguration des Modelltrainings listet jeden Schlüssel von writeback und auto_retrain mit Standardwerten auf.
• Dein erstes Modell trainieren richtet dieses Projekt ein und führt einen ersten sklearn-text-Lauf aus.
• Detektions- und Segmentierungsmodelle auf Bildannotationen trainieren führt denselben Kreislauf mit einem Box-Detektor auf Bildern aus.
• Modellgestütztes Labeln mit einem auf deinen Labels trainierten Modell behandelt, wann Vorlabels Zeit sparen und wann Vorlabels Antworten verankern.
• Prüfen von Durchwinken in vorgelabelten Daten unterscheiden findet Annotatoren, die Vorlabels ungelesen annehmen.
• Active Learning behandelt die Wahl des nächsten Items, ohne die Antwort eines Modells zu zeigen.
• Die Upstream-Referenz zum Modelltraining nennt jede Prüfung und jede Route beim Zurückschreiben.

Literatur

• Houlsby, N., Huszár, F., Ghahramani, Z., and Lengyel, M. (2011). Bayesian Active Learning for Classification and Preference Learning. arXiv:1112.5745. https://arxiv.org/abs/1112.5745
• Sener, O., and Savarese, S. (2018). Active Learning for Convolutional Neural Networks: A Core-Set Approach. ICLR 2018. https://arxiv.org/abs/1708.00489