Modelle auf Volumen, Punktwolken und Video trainieren

Neu in v2.14.0

Dieses Tutorial trainiert drei Modelle auf 3D- und Bewegtdaten aus den eigenen Annotationen einer Potato-Studie. volume-unet trainiert ein 3D-U-Net, das CT- und MR-Volumen segmentiert, external-3d führt einen Lidar-Detektor aus, den du selbst baust und betreibst, und video-track trainiert einen Objekt-Tracker für Video. Die Seite richtet sich an Teams, die bereits Volumen, Punktwolken oder Videos in Potato annotieren und ein Modell wollen, das den Rest vorlabelt. Zu jedem Trainer behandelt die Seite das Schema, das die Trainingsdaten liefert, eine Konfiguration, die potato validate besteht, was ein Lauf tut, den Holdout-Score und den Weg der Vorhersagen zu den Annotatoren. Das Tutorial zum ersten Modell führt mit einem Textklassifikator ohne GPU durch die Training-Seite, und dieses Tutorial setzt diese Anleitung voraus.

Übersicht der Trainer

Alle drei Trainer passen pro Lauf ein Schema an, bewerten das Modell auf den zurückgehaltenen val- und test-Items des Laufs und schreiben Vorhersagen als Vorlabels zurück, die Annotatoren bearbeiten. volume-unet und die Detektoren hinter external-3d brauchen in der Praxis eine GPU, deshalb schicken die Konfigurationen für diese beiden Trainer Läufe per ssh an einen GPU-Server, wie das Tutorial zum Remote-Training es einrichtet.

Jeder Trainer liest Medien aus Dateien auf der Platte. Ein Medienpfad muss innerhalb des Aufgabenverzeichnisses oder von media_directory liegen, und Items, deren Medium eine http(s)-URL ist, bleiben bei Training und Vorhersage außen vor.

CT- und MR-Volumen mit volume-unet segmentieren

volume-unet lernt die Masken, die Annotatoren in einem volume_annotation-Schema malen, und malt Masken auf die Volumen, die noch niemand segmentiert hat. Das Schema zeigt eine NIfTI-Datei oder eine DICOM-Serie in drei verknüpften Ansichten (axial, koronal und sagittal), und Annotatoren malen jedes Label mit dem Pinsel oder indem sie ein Polygon schließen. Das Item-Feld, das source_field benennt, enthält relativ zu media_directory eine .nii- oder .nii.gz-Datei oder ein Verzeichnis mit einer DICOM-Serie. Eine auf einer Schicht gezeichnete Box hat keine Maske, deshalb ist eine Antwort, die nur aus Boxen besteht, kein Trainingsziel. Potato ist Forschungssoftware ohne klinische oder regulatorische Zulassung, und ein hier trainiertes Modell schlägt Masken vor, die Annotatoren korrigieren.

Die folgende Konfiguration segmentiert Milz und Leber, trainiert auf einem GPU-Server und vorlabelt jedes Volumen außerhalb des Train-Splits:

annotation_task_name: "Spleen segmentation"
task_dir: .
media_directory: media
data_files:
  - data/scans.jsonl
item_properties:
  id_key: id
  text_key: volume
output_annotation_dir: annotation_output
user_config:
  allow_all_users: true
 
annotation_schemes:
  - annotation_type: volume_annotation
    name: organs
    description: "Paint the spleen and the liver on every slice where each organ appears."
    source_field: volume
    labels:
      - {name: Spleen, color: "#e6553a", key_value: "1"}
      - {name: Liver, color: "#3a8ee6", key_value: "2"}
    tools: [brush, eraser, polygon]
    default_window: Soft tissue
 
model_training:
  enabled: true
  backend: gpu-server
  backends:
    gpu-server:
      type: ssh
      host: gpu.example.edu
      python: /opt/conda/bin/python3
      gpus: auto
      min_free_gpu_mb: 8000
  trainer_params:
    volume-unet:
      patch: 96
  writeback:
    schemas: [organs]
    min_confidence: 0.6
    include_unlabeled: true

Jede Datenzeile nennt ein Volumen:

{"id": "case_001", "volume": "case_001.nii.gz"}
{"id": "case_002", "volume": "case_002_ct"}

Der Wert patch legt die Kantenlänge des kubischen Patches fest, auf dem das Netz trainiert, und muss bei den standardmäßigen drei Ebenen ein Vielfaches von 4 sein (2 hoch levels minus 1). Ein Patch mit 96 Voxeln gibt dem Netz mehr Kontext um jedes Voxel als der Standard von 64 und braucht mehr GPU-Speicher. Mit min_free_gpu_mb: 8000 startet Potato einen Lauf nur auf einer GPU mit mindestens 8.000 MB freiem Speicher. Potato nimmt die mittlere Wahrscheinlichkeit des Modells innerhalb der Maske jedes gemalten Labels und meldet den niedrigsten dieser Mittelwerte als Konfidenz des Volumens. Mit min_confidence: 0.6 erhält ein Volumen, in dem irgendein Organ mit einer mittleren Wahrscheinlichkeit unter 0,6 gemalt wurde, kein Vorlabel.

Trainingsschritte eines volume-unet-Laufs

Ein Lauf liest jedes annotierte Volumen in der Voxelreihenfolge, in der das Widget malt, und macht aus den Masken ein Label pro Voxel. Wo sich zwei Labels überlappen, gewinnt das spätere Label in der Label-Reihenfolge des Bundles, wie beim NIfTI-Export. Die Intensitäten werden auf das 0,5- und das 99,5-Perzentil jedes Volumens beschnitten und standardisiert. Das Netz ist ein 3D-U-Net in reinem torch (drei Ebenen, Instance Norm), trainiert mit Kreuzentropie plus Soft Dice auf 100 zufälligen Patches pro Epoche. Die Hälfte der Patches ist auf ein gemaltes Voxel zentriert, damit kleine Strukturen im Training vorkommen. Nach jeder Epoche bewertet der Lauf den mittleren Dice-Wert auf den val-Volumen und behält die beste Epoche, und der Lauf endet nach 10 Epochen ohne bessere Bewertung. Die Vorhersage schiebt den Patch mit halber Überlappung über das ganze Volumen und mittelt die Wahrscheinlichkeiten.

Der Train-Split braucht mindestens drei annotierte Volumen (min_instances). Ein Volumen, dessen gemalte Form von der Form der Datei abweicht, bleibt mit einer Warnung im Lauf-Log außen vor, ebenso ein Volumen, dessen Datei fehlt. Bei mehreren Readern auf einem Volumen trainiert der Lauf auf den Masken des einen Readers, auf den aggregation auflöst, weil die Aggregatoren ganze Antworten vergleichen. Segment CT Volumes With Several Readers and STAPLE behandelt die Übereinstimmung der Reader und eine außerhalb von Potato gebildete Konsensmaske.

Holdout-Score für Volumen

Potato berechnet den Dice-Koeffizienten für jedes Label auf jedem zurückgehaltenen Volumen (dice_<label>) und meldet den Mittelwert über alle Volumen und Labels als mean_dice. Ein Label, das das Modell in einem Volumen mit diesem Label ausgelassen hat, erhält 0. Der Trainer wählt die beste Epoche auf val, deshalb nimmt die Runs-Tabelle den Hauptscore von test (test_mean_dice). Die vollständige Liste der Scores pro Label steht auf der Lauf-Seite.

Masken-Vorlabels in den Schichtansichten

Vorhergesagte Masken kommen in der eigenen Form des Widgets zurück, pro Label und axialer Schicht, mit der Markierung prefilled_from: model, und erscheinen in den Schichtansichten, wenn ein Annotator das Volumen öffnet. Der Annotator korrigiert die Masken mit Pinsel und Radierer, und die korrigierten Masken werden als Antwort dieses Annotators gespeichert. Items im Train-Split des Laufs erhalten nie ein Vorlabel. Ohne include_unlabeled sagt ein Lauf nur auf den val- und test-Volumen des Laufs voraus.

3D-Quader mit external-3d erkennen

external-3d übergibt die annotierten Scans an einen 3D-Detektor, den du auf dem Trainingshost installierst, führt deine Train- und Predict-Befehle aus und liest die vorhergesagten Boxen als Quader zurück. Potato bündelt keinen Punktwolken-Detektor. Die beiden Detektoren, für die der Trainer gebaut ist, OpenPCDet und MMDetection3D, brauchen CUDA-Operatoren, die auf dem GPU-Host kompiliert werden. Auf Potatos Seite braucht der Trainer nur numpy.

Die Trainingsdaten stammen aus einem spatial_annotation-Schema mit dem Tool cuboid_3d. Annotatoren setzen orientierte Boxen auf PCD-, PLY-, LAS- oder KITTI-.bin-Scans, gespeichert in Metern im eigenen Koordinatensystem des Scans (siehe 3D-Punktwolken und Quader). Quader sind die einzigen Ziele, deshalb werden Punkte, Polylinien und Punktsegmente im selben Schema ignoriert. Jedes Item ist ein Scan, und eine Folge von Frames mit Track-IDs ist kein Trainingsziel.

Für den Detektor geschriebener Datensatzordner

Bevor der Train-Befehl läuft, schreibt Potato die Scans nach {dataset}, einen Ordner namens dataset im Ordner des Laufs, im Custom-Dataset-Layout von OpenPCDet:

• points/<id>.npy enthält einen Scan als float32-Zeilen aus x y z intensity, mit Intensität 0, wenn die Datei keine hat.
• labels/<id>.txt enthält für die train- und val-Scans eine Zeile pro Quader, als x y z dx dy dz heading label. Der Heading-Wert ist die Rotation um +z im Bogenmaß, Pitch und Roll bleiben nicht erhalten. Ein Leerzeichen in einem Label-Namen wird zu einem Unterstrich.
• ImageSets/train.txt, val.txt und predict.txt listen die Scan-IDs auf. predict.txt listet die val- und test-Scans, dazu die ungelabelten Scans, wenn writeback.include_unlabeled eingeschaltet ist.

Jede <id> besteht aus den ersten 16 Hex-Zeichen des SHA-1 der Item-ID, weil Item-IDs Zeichen enthalten können, die ein Dateiname nicht verträgt. Die Labels von test-Scans werden nie in den Ordner geschrieben. Potato schreibt einen georeferenzierten Scan relativ zum Ursprung des Scans, weil georeferenzierte Koordinaten für float32 zu groß sind, und verschiebt die vorhergesagten Boxen um denselben Versatz zurück.

Vom Detektor zurückgelesene Vorhersagedateien

Der Predict-Befehl schreibt eine Datei pro Scan nach {predictions}/<id>.txt, eine Box pro Zeile, als x y z dx dy dz heading label score. Der Score ist optional. Potato lässt eine Zeile aus, die sich nicht parsen lässt, nan oder inf enthält, ein Label nennt, das das Schema nicht hat, oder eine Box ohne Größe beschreibt, und das Lauf-Log zählt die ausgelassenen Zeilen. Die übrigen Boxen kommen als cuboid_3d-Objekte mit der Markierung source: model zurück, und der Score jeder Box wird zur Konfidenz der Box. Potato setzt die Konfidenz eines Scans auf den niedrigsten Box-Score des Scans, und min_confidence gilt für diesen Wert.

Train- und Predict-Befehle

Beide Befehle werden als Trainer-Parameter gesetzt. Potato zerlegt jeden Befehl wie eine Shell in Wörter, ersetzt {dataset}, {workdir} (den Ordner des Laufs) und {predictions} durch die passenden Pfade und führt den Befehl ohne Shell im Ordner des Laufs aus. Andere geschweifte Klammern in einem Befehl bleiben wie geschrieben. Pipes, && und $VARIABLES erreichen das Programm als wörtliche Wörter, deshalb gehört mehrstufige Arbeit in ein Skript. Füge der Konfiguration der Punktwolken-Studie diesen Block hinzu:

model_training:
  enabled: true
  backend: gpu-server
  backends:
    gpu-server:
      type: ssh
      host: gpu.example.edu
      python: /opt/conda/envs/pcdet/bin/python
      gpus: auto
  trainer_params:
    external-3d:
      train_command: "/opt/pcdet-jobs/train.sh {dataset} {workdir}"
      predict_command: "/opt/conda/envs/pcdet/bin/python /opt/pcdet-jobs/predict.py {dataset} {workdir} {predictions}"
      timeout_s: 43200
  writeback:
    schemas: [objects]
    min_confidence: 0.3
    include_unlabeled: true

Die Pfade liegen auf dem Trainingshost, auf dem auch der Ordner des Laufs liegt. timeout_s begrenzt jeden Befehl, und 12 Stunden ersetzen hier den Standard von 24. Ein Train-Befehl, der mit einem Wert ungleich null endet, lässt den Lauf scheitern, und der Fehler des Laufs zeigt die letzten Zeilen der Ausgabe des Befehls.

train.sh ist dein eigenes Skript. Für OpenPCDet richtet das Skript die Custom-Dataset-Konfiguration von OpenPCDet auf {dataset}, baut die Info-Dateien mit python -m pcdet.datasets.custom.custom_dataset create_custom_infos <dataset config>, führt das Trainingsskript von OpenPCDet aus und speichert den Checkpoint unter {workdir}. Die Klassennamen in der Konfiguration des Detektors müssen mit den Label-Namen übereinstimmen, wie sie in labels/ stehen. Der Custom-Dataset-Leitfaden von MMDetection3D liest Punktwolken nur als .bin-Dateien, deshalb schreibt das Skript für MMDetection3D zuerst jede points/<id>.npy als .bin-Datei aus. Lass train_command leer, um das Training zu überspringen, und predict_command führt dann ein Modell aus, das du anderswo trainiert hast.

predict.py liest die IDs in predict.txt, führt den Detektor auf jedem Scan aus und schreibt die Boxen. Die Funktionen load_model und detect sind dein eigener Code um den Detektor, den du trainiert hast:

"""predict.py DATASET WORKDIR PREDICTIONS: one line per box, one file per scan."""
import os
import sys
 
import numpy as np
 
from my_detector import load_model, detect  # your code around OpenPCDet or MMDetection3D
 
dataset, workdir, out = sys.argv[1:4]
model = load_model(os.path.join(workdir, "output"))  # where train.sh saved the checkpoint
os.makedirs(out, exist_ok=True)
 
with open(os.path.join(dataset, "ImageSets", "predict.txt")) as fh:
    scan_ids = fh.read().split()
 
for scan_id in scan_ids:
    points = np.load(os.path.join(dataset, "points", scan_id + ".npy"))  # float32, (N, 4)
    with open(os.path.join(out, scan_id + ".txt"), "w") as fh:
        for x, y, z, dx, dy, dz, heading, label, score in detect(model, points):
            fh.write(f"{x} {y} {z} {dx} {dy} {dz} {heading} {label} {score}\n")

Ohne train_command ist der Predict-Befehl der ganze Lauf, und ein Predict-Befehl, der mit einem Wert ungleich null endet, lässt den Lauf scheitern. Ein Predict-Befehl, der mit 0 endet, aber für keinen Scan eine <id>.txt schreibt oder nur Zeilen schreibt, die Potato weglässt, zählt ebenfalls als fehlgeschlagen, weil ein Lauf, der auf dieser Ausgabe bewertet wird, wie ein Modell aussähe, das nichts gefunden hat. Eine leere Datei ist ein Scan ohne Objekte. Nach einem Train-Befehl lässt ein fehlschlagender Predict-Befehl den Lauf nicht scheitern. Der Lauf endet mit der Warnung „Prediction pass failed after 0 prediction(s)“ und den letzten Zeilen des Befehls, und der Lauf hat weder Vorhersagen noch einen Holdout-Score. Prüfe das Lauf-Log auf diese Warnung, wenn ein beendeter Lauf „not scored“ zeigt.

Holdout-Score für Quader

Potato berechnet die 3D-Average-Precision pro Label bei einer volumetrischen IoU von 0,5 (ap_3d_50_<label>). Die IoU ist für orientierte Quader bei jeder Rotation exakt. Potato meldet außerdem den Mittelwert über die Labels bei IoU 0,25 und 0,5 sowie Precision, Recall und F1 bei 0,5. Der Hauptscore ist map_3d_50. Mit einem train_command nimmt die Runs-Tabelle den Hauptscore zuerst von test, weil der Train-Befehl die val-Labels in {dataset} erhält und auf diesen Labels einen Checkpoint wählen kann. Ohne train_command hat das Modell die val-Items der Studie nie gesehen, und der Hauptscore stammt von val.

Quader-Vorlabels im Punktwolken-Viewer

Vorhergesagte Quader erscheinen im Punktwolken-Viewer als bearbeitbare Boxen, und eine bearbeitete Box wird als Antwort des Annotators gespeichert. Potato prüft jedes vorhergesagte Objekt, bevor der Viewer es zeichnet, und lässt ein Objekt aus, dessen Geometrie sich nicht parsen lässt, einen Quader ohne Größe und ein Label, das das Schema nicht hat. So annotieren Sie 3D-Punktwolken behandelt die Annotationsseite und die Übereinstimmung bei 3D-Boxen.

Objekte im Video mit video-track verfolgen

video-track lernt aus den Tracks, die Annotatoren in einem video_annotation-Schema im Modus tracking oder combined zeichnen, und sagt Tracks auf den Videos voraus, die noch niemand verfolgt hat. Ein Track ist ein Label und eine Box an jedem Keyframe, und das Widget interpoliert die Box zwischen den Keyframes. Ein video_annotation-Schema in einem anderen Modus speichert Segmente statt Tracks, und video-track wird für dieses Schema nicht angeboten.

annotation_task_name: "Pedestrian tracking"
task_dir: .
media_directory: media
data_files:
  - data/clips.jsonl
item_properties:
  id_key: id
  text_key: video
output_annotation_dir: annotation_output
user_config:
  allow_all_users: true
 
annotation_schemes:
  - annotation_type: video_annotation
    name: tracks
    description: "Track every pedestrian and cyclist with a box at each keyframe."
    source_field: video
    mode: tracking
    video_fps: 25
    labels:
      - {name: pedestrian, color: "#FF6B6B"}
      - {name: cyclist, color: "#45B7D1"}
    tracking_options:
      interpolation: linear
      auto_advance_frames: 5
    frame_stepping: true
 
model_training:
  enabled: true
  trainer_params:
    video-track:
      frame_fps: 2
      predict_fps: 5
      max_age: 4
  writeback:
    schemas: [tracks]
    include_unlabeled: true

Jede Datenzeile nennt einen Clip unter media_directory:

{"id": "clip_001", "video": "/media/clip_001.mp4"}
{"id": "clip_002", "video": "/media/clip_002.mp4"}

Setze video_fps auf die tatsächliche Bildrate der Clips. Keyframes sind nach Frame nummeriert, und der Trainer nummeriert die vorhergesagten Keyframes mit dem video_fps des Schemas (30, wenn nicht gesetzt). Der Trainer liest die Box auf einem abgetasteten Frame nach der eigenen interpolation-Einstellung jedes Tracks (linear, kubisch nach Catmull-Rom oder konstant). Die Boxen, aus denen das Modell lernt, folgen deshalb dem Verlauf, den die Annotatoren gesehen haben. Wie im Widget wird ein Track mit einem Keyframe auf jedem Frame gehalten, und ein Track, dem das Widget ein startFrame und ein endFrame gegeben hat, läuft zwischen diesen beiden Frames. Ein Keyframe außerhalb dieser beiden Frames erscheint trotzdem auf seinem eigenen Frame. predict_fps: 5 erkennt auf fünf Frames pro Sekunde statt auf zwei. Fünf Frames pro Sekunde geben einem schnell bewegten Objekt mehr Keyframes und kosten mehr Detektor-Durchläufe. Ein Track endet, wenn mehr als max_age abgetastete Frames ohne passende Detektion vergangen sind, deshalb lässt max_age: 4 bei 5 Frames pro Sekunde einen Track 0,8 Sekunden verpasste Detektionen überleben. Ein Fußgänger, der hinter einem Pfosten vorbeigeht, behält einen Track, wenn der Detektor den Fußgänger innerhalb von 0,8 Sekunden wiederfindet. Die Konfiguration trainiert auf der Maschine, auf der Potato läuft (dem Backend local), und das Backend gpu-server aus der Volumen-Konfiguration funktioniert auch für video-track.

Training und Track-Verknüpfung in einem video-track-Lauf

Ein Lauf tastet jedes annotierte Video mit frame_fps Frames pro Sekunde ab, vom Anfang bis zum letzten Keyframe, und liest jeden abgetasteten Frame mit OpenCV. Canvas-Pixel hängen vom Bildschirm des Annotators ab, deshalb liest der Trainer die Box jedes Tracks auf diesem Frame als Bruchteil des Bildes. Ein abgetasteter Frame ohne Track bleibt als Beispiel für eine leere Szene im Training. Der Lauf fine-tunt auf diesen Frames einen torchvision-Faster-R-CNN mit den Parametern und Standardwerten von torchvision-detect. Der Detektor startet mit den COCO-Gewichten von torchvision. Nach jeder Epoche bewertet der Lauf die Box-mAP bei IoU 0,5 auf den val-Frames (frame_map_50) und behält die beste Epoche.

Die Vorhersage tastet jedes Video mit predict_fps ab, erkennt auf jedem abgetasteten Frame und verknüpft die Detektionen zu Tracks. Die Detektionen jedes Frames werden eins zu eins mit den aktiven Tracks desselben Labels abgeglichen, nach der Überlappung mit der letzten Box jedes Tracks, und ein Treffer braucht eine IoU von mindestens match_iou (0,3). Eine nicht zugeordnete Detektion mit einem Score von mindestens new_track_score (0,5) startet einen neuen Track. Der Trainer verwirft vor dem Zurückschreiben und Bewerten einen vorhergesagten Track mit weniger als min_track_keyframes Detektionen (standardmäßig 2). Das Widget würde einen Track mit einer Detektion sonst auf jedem Frame halten. Jede Detektion wird zu einem Keyframe, deshalb interpoliert das Widget zwischen den Keyframes des Modells so, wie das Widget es zwischen denen eines Annotators tut.

Der Train-Split braucht mindestens zwei annotierte Videos (min_instances). Ein Video, das OpenCV nicht dekodieren kann, bleibt mit einer Warnung, die das Item nennt, außen vor, und der Lauf macht mit dem Rest weiter.

Holdout-Score für Tracks

Potato vergleicht die vorhergesagten Tracks mit den annotierten Tracks auf Frames, die mit 2 pro Sekunde über jedes zurückgehaltene Video abgetastet werden, plus jedem annotierten Keyframe. Die Scores sind MOTA, IDF1, ID-Wechsel, Fehlen und False Positives, wobei eine Box bei einer IoU von 0,5 als gefunden zählt. MOTA rechnet Fehlen, False Positives und Identitätswechsel gegen die Zahl der annotierten Boxen auf. IDF1 ist der F1-Wert der Boxen, die über das ganze Video der richtigen Identität zugeordnet sind, und IDF1 ist der Hauptscore (idf1). Der Trainer wählt die beste Epoche auf val, deshalb nimmt die Runs-Tabelle den Hauptscore von test.

Track-Vorlabels im Video-Widget

Die vorhergesagten Tracks füllen das Video-Widget als Tracks mit Keyframes, die als KI-Ausgabe markiert sind und den Score des Detektors tragen. Das Widget rechnet die Boxen beim Zeichnen der Tracks in die eigenen Canvas-Pixel um, und der Annotator korrigiert die Tracks wie jeden anderen Track. Die Konfidenz eines Videos ist der mittlere Score der Keyframes des Modells. Im Modus combined enthält ein Vorlabel nur Tracks, und der Annotator ergänzt die Segmente. How to Annotate Video Object Tracking behandelt die Annotationsseite, Verdeckung und zeitliche Übereinstimmung.

Einen Lauf starten und das Ergebnis prüfen

Starte den Server nach dem Hinzufügen von model_training neu, öffne /admin/training, wähle das Schema und den Trainer und klicke auf Train now. Die Seite bietet nur die Trainer an, die zu jedem Schema passen, und führt einen nicht installierten Trainer als „not installed“ mit dem Installationsbefehl auf. Um einen GPU-Server vor dem ersten Lauf zu prüfen, führe Folgendes aus:

potato training check gpu-server config.yaml

Die Prüfung meldet die Python-Version auf dem Remote-Rechner, jede GPU mit ihrem freien Speicher, die GPU, die ein Lauf erhielte, und die Trainingspakete, die dem Remote-Interpreter fehlen. Ein Lauf lässt sich auch über die API starten, mit Parametern pro Lauf, die trainer_params überschreiben:

curl -X POST -H "X-API-Key: $KEY" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "video-track", "schemas": ["tracks"], "params": {"predict_fps": 10}}'

Wenn der Lauf endet, führt die Runs-Tabelle den Holdout-Score auf, mit dem Split und der Metrik in einem Tooltip. Vorlabels verankern Annotatoren, deshalb schalte include_unlabeled in einer neuen Studie erst ein, wenn der Holdout-Score das Zeigen der Modellantworten stützt. Das Tutorial zum Modell im Kreislauf behandelt, wie die Vorlabels mit der geringsten Konfidenz zuerst ausgeliefert werden und wie auf Korrekturen neu trainiert wird, und Konfiguration und Routen des Modelltrainings listet jeden Schlüssel, die Backends und die Rückschreibe-Prüfungen auf.

Weiterführende Links

• Modelltraining auf den eigenen Annotationen
• Trainer in Potato, nach Aufgabe gruppiert
• Das Tutorial zu Vision-Modellen, für 2D-Detection und Segmentierung
• Video-Tracking und Maskenpropagation
• Video-Annotation
• Annotation medizinischer Bilder
• Maskenkonsens mit STAPLE
• Upstream-Referenz für volume-unet, external-3d und video-track

Referenzen

• Bernardin, K., and Stiefelhagen, R. (2008). Evaluating Multiple Object Tracking Performance: The CLEAR MOT Metrics. EURASIP Journal on Image and Video Processing. https://doi.org/10.1155/2008/246309
• Çiçek, Ö., Abdulkadir, A., Lienkamp, S. S., Brox, T., and Ronneberger, O. (2016). 3D U-Net: Learning Dense Volumetric Segmentation from Sparse Annotation. MICCAI 2016. https://arxiv.org/abs/1606.06650
• Ristani, E., Solera, F., Zou, R. S., Cucchiara, R., and Tomasi, C. (2016). Performance Measures and a Data Set for Multi-Target, Multi-Camera Tracking. ECCV 2016 Workshop on Benchmarking Multi-Target Tracking. https://arxiv.org/abs/1609.01775