Detection- und Segmentierungsmodelle auf Bildannotationen trainieren

Neu in v2.14.0

Dieses Tutorial trainiert einen Objektdetektor auf den eigenen Bounding Boxes einer Studie und zeigt die Boxen des Detektors den nächsten Annotatoren als Vorlabels zum Korrigieren. Das Tutorial richtet sich an Studienverantwortliche mit einem image_annotation-Schema, die Das erste Modell trainieren gelesen haben oder mit der Admin-Seite Training vertraut sind. Die erste Hälfte durchläuft einen vollständigen Kreislauf mit torchvision-detect (Boxen auf Bildern, ein Trainingslauf, Rückschreiben, Korrekturen und ein zweiter Lauf), und jeder Schritt dort lief auf einer Laptop-CPU. Die zweite Hälfte passt den Kreislauf an YOLO, Umrisse, SAM-Verfeinerung, Klassen für ganze Bilder, ganze Slides, Mikroskopie, Karten, Zellen, Dokumentseiten und Vision-Language-Modelle an, jeweils in einem eigenen Abschnitt.

Die Vision-Trainer installieren

torchvision-detect fine-tunt einen torchvision-Faster-R-CNN-Detektor. Der Trainer braucht torch und torchvision. Potato lässt beide in der Standardinstallation weg, weil torch ein Download von mehreren Gigabyte ist. Das Vision-Extra wird auf der Maschine installiert, die trainiert:

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

Dasselbe Extra deckt torchvision-segment, hf-image-classification, sam-finetune, layoutlmv3 und vlm-sft ab. Ein Trainer, dessen Pakete fehlen, erscheint auf der Training-Seite als „not installed“, zusammen mit dem Befehl, der die Pakete installiert.

Für das kleine Projekt unten ist eine GPU optional. Auf einem Mac mit Apple Silicon trainieren torchvision-detect und torchvision-segment auf der CPU statt auf Metal (mps), und das Lauf-Log hält den Wechsel mit der Warnung „torchvision-detect does not run on Apple's Metal (mps) with this torch; using the CPU“ fest. In den Messungen des Potato-Teams dauerte ein Metal-Trainingsschritt bei der Standard-Bildgröße länger als eine ganze CPU-Epoche. Für größere Bilder oder eine größere Studie wird auf einem GPU-Server trainiert, wie Remote-Training beschreibt.

Ein Bildprojekt aufsetzen

Das Projekt braucht drei Dinge: die Bilder, eine Datendatei, die die Bilder aufführt, und eine Konfiguration. Die Bilder kommen in einen Ordner namens media im Projektordner, denn Potato liefert <task_dir>/media/ standardmäßig unter dem URL-Pfad /media/ aus. Ein anderer Ordner funktioniert, wenn die Konfiguration den Ordner mit media_directory nennt.

shapes/
  config.yaml
  data/images.jsonl
  media/img_001.png
  media/img_002.png
  ...

Jede Zeile von data/images.jsonl ist ein Item mit einer ID und dem URL-Pfad des Bildes:

{"id": "img_001", "image_url": "/media/img_001.png"}

Die Konfiguration definiert ein image_annotation-Schema mit dem bbox-Tool und zwei Labels und schaltet das Modelltraining mit Rückschreiben ein. Die Konfiguration besteht python -m potato.validate_cli --strict:

annotation_task_name: "Shape detection (model training)"
task_dir: "."
data_files:
  - "data/images.jsonl"
item_properties:
  id_key: "id"
  text_key: "image_url"
output_annotation_dir: "annotation_output"
 
require_password: false
admin_api_key: "demo-admin-key"
num_annotators_per_item: 1
 
annotation_schemes:
  - annotation_type: "image_annotation"
    name: "objects"
    description: "Draw a box around every circle and every square."
    source_field: "image_url"
    tools: ["bbox"]
    labels:
      - name: "circle"
        color: "#e6194b"
      - name: "square"
        color: "#4363d8"
 
model_training:
  enabled: true
  writeback:
    schemas: ["objects"]
    include_unlabeled: true
    min_confidence: 0.5

Vier Einstellungen prägen den Kreislauf:

• source_field: "image_url" sagt dem Bild-Widget und dem Trainer, welches Item-Feld das Bild enthält.
• num_annotators_per_item: 1 gibt jedem Bild einen Annotator, sodass die Seed-Labels möglichst viele verschiedene Bilder abdecken.
• writeback.include_unlabeled: true lässt jeden Lauf auf den Bildern vorhersagen, die noch niemand gelabelt hat. Ohne die Einstellung sagt ein Lauf nur auf den zurückgehaltenen Val- und Test-Bildern voraus, und diese Bilder haben bereits menschliche Boxen.
• writeback.min_confidence: 0.5 hält die Vorhersage für ein Bild zurück, wenn der mittlere Score der Boxen des Bildes unter 0,5 liegt. Die Schwelle gilt für das ganze Bild, daher sehen Annotatoren nie die Hälfte der Boxen eines Bildes.

Der Server wird aus dem Projektordner heraus gestartet:

potato start config.yaml -p 8000

Ein Seed-Set labeln

torchvision-detect verweigert das Fitten mit weniger als 20 annotierten Bildern im Train-Split, und der Standard-Split legt 70 % der gelabelten Bilder in Train. Es sind mindestens 30 Bilder zu labeln, mehr, wenn die Objekte variieren. Die Boxen werden von Hand unter http://localhost:8000 gezeichnet. Ein Bild ohne Boxen bleibt beim Training außen vor, denn ein Detektor kann ein Bild ohne Objekte nicht von einem Bild unterscheiden, das niemand fertig bearbeitet hat. Auf jedem Bild, das abgeschickt wird, sind alle Objekte einzuzeichnen.

Um den Kreislauf auszuprobieren, bevor irgendjemand labelt, kann der Nutzersimulator Boxen aus einer Gold-Datei zeichnen. Jeder Gold-Eintrag gibt die Bild-ID und die Formen des Schemas in normalisierten Koordinaten an:

[
  {"id": "img_001", "objects": [
    {"type": "bbox", "label": "circle",
     "coordinates": {"x": 0.158, "y": 0.849, "width": 0.106, "height": 0.146}}
  ]}
]

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

Der Simulator zeichnet jede Gold-Box mit einigen Pixeln Jitter neu, und auf dem Niveau good übersieht oder vertauscht der Simulator auch einige Objekte, wie es ein sorgfältiger Annotator manchmal tut. In unserem Test mit 80 synthetischen Bildern labelten drei simulierte Annotatoren 60 Bilder in etwa einer Sekunde.

torchvision-detect trainieren

http://localhost:8000/admin öffnen, den Admin-Schlüssel demo-admin-key eingeben und http://localhost:8000/admin/training öffnen. objects als Schema und torchvision-detect als Trainer wählen, Parameters leer lassen und auf Train now klicken. Derselbe Lauf startet aus einem Skript mit:

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

Der Lauf startet mit den COCO-Gewichten von torchvision und setzt dem Detektor einen neuen Box-Head für die zwei Labels des Schemas auf. Torch lädt die COCO-Gewichte beim ersten Lauf in den Cache von torch herunter. Die Standardwerte sind die kleine Architektur fasterrcnn_mobilenet_v3_large_fpn, 15 Epochen, 4 Bilder pro Schritt und Early Stopping nach 4 Epochen ohne besseres Val-mAP. Jede Form trainiert als ihre Bounding Box, sodass eine Studie, deren Annotatoren Polygone gezeichnet haben, trotzdem einen Box-Detektor trainiert. Bei mehreren Annotatoren pro Bild trainiert der Lauf auf der einen vollständigen Antwort, die model_training.aggregation für das Bild wählt, denn die Boxen zweier Personen stimmen selten exakt überein.

Auf der Apple-M4-Pro-CPU, die wir verwendeten, trainierten 37 Trainingsbilder von 320 mal 240 Pixeln in etwa 106 Sekunden, und der Lauf stoppte nach 5 Epochen. Die Dateien des Laufs landen in annotation_output/training/runs/<run_id>/, mit dem gefitteten Detektor unter artifacts/model/detector.pt. Die Einstellungen des Laufs und das verwendete Gerät stehen in artifacts/model_card.json.

Den Holdout-Score lesen

Jeder Lauf bewertet den Detektor an den Bildern, auf denen der Detektor nie trainiert hat. Der Hauptscore für ein image_annotation-Schema ist map_50, die COCO-Mean-Average-Precision, bei der eine vorhergesagte Box als Treffer zählt, wenn sie die Bounding Box eines annotierten Objekts mit einer IoU von mindestens 0,5 überlappt. Die Lauf-Seite hält außerdem map_50_95 fest, den Durchschnitt über IoU-Schwellen von 0,5 bis 0,95. Die Boxen zweier Annotatoren für ein Objekt überlappen selten mit einer IoU von 0,9, daher messen die strengeren Schwellen teilweise, wie konsistent Menschen zeichnen. Potato führt deshalb mit der Schwelle 0,5. Übereinstimmung bei Bounding Boxes messen zeigt, wie sich diese Konsistenz direkt prüfen lässt.

Der Detektor behält den Checkpoint der Epoche mit dem besten Val-Score, sodass der Hauptscore aus dem Test-Split stammt, wenn der Test-Split Bilder hat. Die Runs-Tabelle zeigt den Hauptscore in der Spalte Held-out score. Die Lauf-Seite listet n_train, n_boxes, Größe und Abdeckung jedes Splits sowie die Zahl der annotierten und vorhergesagten Objekte auf Val und Test. In unserem Testlauf mit den 80 synthetischen Bildern farbiger Kreise und Quadrate erzielte der Detektor 0,99 bei Test-map_50. Synthetische Formen sind weit leichter zu finden als echte Objekte, daher ist der Score an den eigenen Bildern zu beurteilen.

Die Vorlabels prüfen

Nach einem erfolgreichen Lauf schreibt Potato die Boxen des Detektors in das Feld predictions jedes berechtigten Bildes. GET /admin/training/api/status meldet das Ergebnis im Feld writeback der Antwort, mit n_written für die Bilder, die Vorlabels erhielten, und einer Zahl für jeden Grund, aus dem ein Bild zurückgehalten wurde, z. B. n_skipped_low_confidence unterhalb von min_confidence und n_skipped_train_split für Bilder, auf denen der Lauf trainiert hat. Bilder im Train-Split erhalten nie Vorlabels, denn die Konfidenz eines Modells auf den eigenen Trainingsdaten sagt nichts über neue Bilder.

Unter http://localhost:8000 mit einem neuen Benutzernamen anmelden. Jedes ungelabelte Bild, das die Rückschreibe-Prüfungen bestanden hat, öffnet sich mit den bereits eingezeichneten Boxen des Detektors. Jede Box wird mit source: ai und dem Score des Detektors als confidence gespeichert. Der Annotator verschiebt oder skaliert eine Box, ändert ein Label, löscht eine falsche Detektion und zeichnet jedes Objekt ein, das der Detektor übersehen hat. Die Boxen werden zur Antwort des Annotators, wenn der Annotator die Boxen bearbeitet oder zum nächsten Bild weitergeht. Ein Vorlabel wird nie gespeichert, solange der Annotator das Bild nur ansieht. Die Warteschlange zur Modellprüfung liefert vorgelabelte Bilder mit der geringsten Konfidenz zuerst aus, und ein correct-Urteil eines Reviewers legt das Bild in den Train-Split aller späteren Läufe.

Auf den korrigierten Boxen neu trainieren

Jedes korrigierte Bild wird zum menschlichen Label für den nächsten Lauf. Ein weiterer torchvision-detect-Lauf wird von der Training-Seite gestartet, sobald Annotatoren einen Stapel vorgelabelter Bilder durchgearbeitet haben. Ein neuer Lauf ersetzt die Vorhersage des vorigen Laufs auf jedem Bild, und ein Vorlabel auf einem Bild, auf dem der neue Lauf trainiert, wird entfernt.

Um ohne Klicken neu zu trainieren, wird ein auto_retrain-Block hinzugefügt. Dieses Fragment erweitert den obigen model_training-Block und startet nach jeweils 25 neuen Annotationen einen Lauf, höchstens einmal alle 10 Minuten:

model_training:
  enabled: true
  auto_retrain:
    enabled: true
    trainer: torchvision-detect
    schemas: [objects]
    update_frequency: 25
    min_interval_s: 600
  writeback:
    schemas: [objects]
    include_unlabeled: true
    min_confidence: 0.5

Vorlabels verankern Annotatoren an den Boxen des Modells. Das Rückschreiben für Annotatoren sollte erst eingeschaltet werden, wenn der Holdout-Score die Vorlabels stützt, und Vorgelabelte Durchwinker-Annotationen erkennen zeigt einen Weg zu prüfen, ob Annotatoren Boxen ungesehen akzeptieren.

Schnellere Detektion mit Ultralytics YOLO

ultralytics-detect trainiert einen Ultralytics-YOLO-Detektor aus einem auf COCO vortrainierten Checkpoint (standardmäßig yolo11n.pt) auf denselben Boxen. YOLO trainiert und sagt schneller voraus als torchvision-detect, und die Vorlabels sind dieselben editierbaren Boxen. Ultralytics steht unter der Lizenz AGPL-3.0, und ein mit Ultralytics trainiertes und verbreitetes Modell unterliegt den Bedingungen der AGPL. Ultralytics verkauft für die geschlossene Nutzung eine separate Enterprise-Lizenz. Die Extras von Potato lassen Ultralytics weg, daher ist das Paket selbst zu installieren:

pip install ultralytics

Potato verlangt vor jedem Lauf eine Bestätigung der Lizenz. Die Training-Seite zeigt eine Bestätigung, ein API-Lauf braucht "accept_licence": true im Request-Body, und ein automatisches Neutraining braucht auto_retrain.accept_licence: true. Ohne die Bestätigung lehnt die API den Lauf mit HTTP 400, needs_licence_ack: true und der Meldung „ultralytics-detect is licensed AGPL-3.0“ ab. Die folgende Anfrage bestätigt die Lizenz und startet den Lauf:

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

Während eines Laufs schaltet der Trainer die Nutzungsanalytik von Ultralytics, Ultralytics HUB, die Integrationen von Experiment-Trackern und automatische Paketinstallationen ab. Die Änderungen gelten im Speicher für den Prozess des Laufs, und die Ultralytics-Einstellungsdatei bleibt unverändert. Checkpoints werden nach ~/.cache/potato/ultralytics heruntergeladen. Die Standardwerte sind 50 Epochen bei 640 Pixeln mit Early Stopping nach 10 Epochen.

Umrisse statt Boxen

torchvision-segment trainiert ein torchvision-Mask-R-CNN auf Umrissen aus Polygonen, Ellipsen, Freihandformen und Pinselmasken. Boxen bleiben beim Segmentierungstraining außen vor, denn eine Box sagt nicht, welche Pixel zum Objekt gehören. Annotatoren erhalten ein Umriss-Tool wie polygon oder brush. Bildsegmentierungsmasken annotieren behandelt, wann welches Tool passt.

Jede vorhergesagte Maske wird in ein Polygon mit höchstens 64 Eckpunkten nachgezeichnet, sodass der Annotator das Vorlabel Punkt für Punkt korrigiert. Zerfällt eine Maske in Teile, bleibt das größte Teil erhalten. Der Standardwert von score_threshold ist 0,5 statt der 0,25 des Detektors. Die zweiten Vermutungen von Mask R-CNN für ein Objekt erreichen Scores zwischen 0,25 und 0,6, und jede Vermutung wäre eine weitere Form, die der Annotator löschen müsste. Holdout-Scores vergleichen die vorhergesagten Polygone mit den annotierten Umrissen. Auf einem Mac trainiert torchvision-segment auf der CPU. Mit torch 2.8 maß das Potato-Team einen Trainingsschritt auf einem Bild mit 256 Pixeln mit 57 Sekunden auf Metal und 2,3 Sekunden auf der CPU. Für echte Studien ist ein GPU-Server zu verwenden. ultralytics-segment ist das YOLO-Gegenstück (yolo11n-seg.pt), mit denselben Polygonen mit 64 Eckpunkten und derselben AGPL-3.0-Lizenzbestätigung.

Boxen in Umrisse verwandeln mit sam-finetune

Boxen sind schnell gezeichnet, Umrisse langsam. sam-finetune fine-tunt den Maskendecoder von Segment Anything (SAM), damit aus einer Box der Umriss wird, den die Annotatoren zeichnen würden. Der Bild-Encoder bleibt eingefroren, und das Embedding jedes Bildes wird einmal berechnet, sodass eine Epoche wenig kostet. Das Training promptet jeden annotierten Umriss mit seiner Bounding Box. Der Lauf verschiebt und skaliert jede Prompt-Box um bis zu box_jitter (standardmäßig 5 %), sodass der Decoder von Boxen lernt, die so locker sind wie die eines Detektors.

sam-finetune verfeinert Boxen und braucht Boxen als Ausgangspunkt. Die übliche Abfolge auf einem Schema besteht aus zwei Läufen:

1. torchvision-detect oder ultralytics-detect mit writeback.include_unlabeled: true ausführen, sodass die ungelabelten Bilder Box-Vorlabels tragen.
2. sam-finetune auf demselben Schema ausführen. Jedes Box-Vorlabel wird zu einem Polygon-Vorlabel, und die Polygone ersetzen die Boxen.

Das Schema braucht Umrisse, aus denen SAM lernt, daher erhalten Annotatoren neben bbox ein Umriss-Tool. Auf zurückgehaltenen Bildern sind die eigenen Boxen der Annotatoren die Prompts, sodass val_mask_iou die mittlere IoU des Umrisses meldet, wenn die Box stimmt. Diese Vorhersagen auf zurückgehaltenen Bildern werden bewertet, aber nie gespeichert oder veröffentlicht, denn die Vorhersagen entstehen aus der Antwort eines anderen Annotators. Der Rückschreibe-Bericht zählt die Vorhersagen auf zurückgehaltenen Bildern in n_skipped_heldout_only. Der Standard-Checkpoint ist facebook/sam-vit-base (Apache-2.0). Der gefine-tunte Decoder liefert nur Vorlabels. Das Click-to-Segment des Bild-Tools führt separate ONNX-Gewichte im Browser aus, und ein sam-finetune-Lauf ersetzt diese Gewichte nicht.

Ganze Bilder klassifizieren

Für eine Frage zum ganzen Bild, z. B. ein radio-Schema, das fragt, welches Tier ein Foto zeigt, wird ein Klassifikator statt eines Detektors verwendet. hf-image-classification fine-tunt jedes Modell, das AutoModelForImageClassification von Hugging Face lädt, etwa ViT, DeiT, BEiT, ConvNeXt, Swin oder DINOv2. Das Standardmodell ist google/vit-base-patch16-224-in21k. Der Trainer spiegelt Trainingsbilder standardmäßig zufällig. In Parameters wird flip auf false gesetzt, wenn ein Spiegeln das Label ändert, etwa bei Text im Bild oder bei links und rechts. lora: true trainiert einen LoRA-Adapter und den Klassifikationskopf statt aller Gewichte.

Ein Choice-Schema gilt als Bildkorpus, wenn mindestens 80 % der gelabelten Items des Schemas einen Bildpfad tragen, der auf .jpg, .jpeg, .png, .bmp, .webp, .tif, .tiff oder .gif endet. Auf einem solchen Korpus fittet sklearn-text ohne benannten Vektorisierer einen linearen Klassifikator auf CLIP-Bild-Embeddings. Die CLIP-Baseline braucht keine GPU, nur pip install "potato-annotation[embeddings]" pillow.

Bildpfade und Remote-Bilder

Die Bildtrainer lesen das Feld, das source_field des Schemas nennt. Ohne source_field nimmt ein Trainer das erste nichtleere Item-Feld aus image_url, image, image_path, file_name, url, path und den Audio- und Video-Entsprechungen. Bilder müssen lokale Dateien im Projekt sein:

• Ein relativer Pfad wird gegen task_dir aufgelöst oder gegen media_directory, wenn die Datei unter task_dir nicht gefunden wird.
• Ein URL-Pfad wie /media/img_001.jpg wird gegen media_directory aufgelöst. Die Annotationsseite lädt das Bild vom selben Ort.
• Eine Datei, die ein absoluter Pfad, ../ oder ein symbolischer Link außerhalb des Task-Verzeichnisses und von media_directory platziert, bleibt mit einer Warnung außen vor.
• Remote-Bilder über http(s) werden nie heruntergeladen. Ein Lauf lässt jedes Item aus, dessen Bild remote ist oder fehlt, das Lauf-Log nennt die Zahl, und diese Items erhalten keine Vorhersage.

Um auf Remote-Bildern zu trainieren, werden sie in media_directory heruntergeladen. Die Seite zu Vision-Formaten und potato import behandeln, wie sich vorhandene Bilddatensätze in ein Projekt holen lassen.

Ganze Slides und andere große Bilder

Die Detection- und Segmentierungstrainer skalieren jedes Bild auf einige hundert Pixel, und die Objekte auf einem Pathologie-Slide mit 100.000 Pixeln oder einer Satellitenszene verschwinden bei dieser Größe. Bei einem image_annotation-, microscopy- oder geo_annotation-Schema schneidet Potato große Bilder daher in Kacheln, wenn die Trainingsdaten des Laufs gebaut werden. Das Kacheln geschieht automatisch für Slide-Formate (.svs, .ndpi, .mrxs, .scn und andere) und für Bilder, deren längere Seite 4.096 Pixel oder mehr misst. Slides brauchen openslide:

pip install "potato-annotation[wsi]"

Das Training nutzt die Kacheln, die ein annotiertes Objekt enthalten, plus eine Stichprobe leerer Kacheln, und jedes Objekt wird auf seine Kachel zugeschnitten. Die Vorhersage deckt jede Kachel über Gewebe ab, bis zu max_predict_tiles pro Bild. Der Split jedes Bildes wird entschieden, bevor das Bild zerschnitten wird, sodass Kacheln eines Slides nie in zwei Splits landen. Kachelvorhersagen werden auf das ganze Bild zurückgeführt, und ein Objekt, das zwei überlappende Kacheln fanden, bleibt einmal erhalten. Die Vorlabels nutzen die Koordinaten des ganzen Bildes, dieselben Koordinaten, die der Deep-Zoom-Viewer speichert. Holdout-Scores werden auf ganzen Bildern berechnet. Ein Remote-Backend lädt die Kacheln herunter statt des Slides.

Die Einstellungen liegen unter model_training.tiling. Dieses Fragment trainiert einen 40x-Slide bei 20x auf Kacheln mit 1.024 Pixeln:

model_training:
  enabled: true
  tiling:
    tile_size: 1024
    overlap: 128
    downsample: 2

overlap sollte mindestens so groß sein wie die Objekte, denn ein größeres Objekt wird in Teilen gefunden, eines pro Kachel. Für einen Slide, der seine Auflösung festhält, legt mpp die Mikrometer pro Kachelpixel fest und überschreibt downsample. Zwei Einstellungen brauchen bei manchen Slides Sorgfalt. Die leeren Trainingskacheln setzen voraus, dass jedes Objekt auf einem annotierten Bild gezeichnet wurde, daher wird background: 0 gesetzt, wenn Annotatoren nur einige Regionen eines Slides gezeichnet haben. Gewebe wird per Otsu-Schwelle auf dem Slide-Thumbnail erkannt, sodass ein Slide ohne freies Glas seine hellere Hälfte verliert, und tissue_threshold: 0 sagt auf jeder Kachel voraus. Die Tabelle tiling listet jeden Schlüssel und Standardwert.

Mikroskopie und Karten

Die ROIs eines microscopy-Schemas trainieren torchvision-detect, ultralytics-detect, torchvision-segment, ultralytics-segment und cellpose. Jede z-Ebene und jeder Zeitpunkt mit ROIs wird mit den Standardkanälen und dem Standardkontrast des Schemas gerendert und wird zu einem eigenen Trainingsbild. Der Renderer ist der Compositor, den auch der Viewer verwendet. Für ein Bild, auf dem noch nichts gezeichnet ist, wird auf der mittleren z-Ebene und beim ersten Zeitpunkt vorhergesagt, wo sich der Viewer öffnet. Die Vorhersagen kommen als Mikroskopie-ROIs mit z und t jeder ROI zurück. Zellklassifikationen verweisen auf ein Label-Bild statt auf eine Form, und die Trainer überspringen Zellklassifikationen.

Die Features eines geo_annotation-Schemas trainieren dieselben Detection- und Segmentierungstrainer auf der Raster-Basiskarte des Items. Ein GeoTIFF wird anhand der Transformation und des EPSG-Codes in den eigenen Tags der Datei platziert und bei projizierten Daten mit pyproj umprojiziert. Ein einfaches Bild mit einer Ausdehnung wird in Längen- und Breitengrad platziert. Polygone, Rechtecke, Linien und Punkte werden zu Formen auf dem Raster, wobei Polygonlöcher gefüllt werden. Die Vorhersagen kommen als GeoJSON-Features in EPSG:4326 mit source: model zurück. Die Karte bietet die Features als Vorschläge an, und die Vorschläge zählen erst als Antwort, wenn der Annotator einen bearbeitet oder akzeptiert. Eine Karte, deren Basiskarte ein Tile-Server oder ein GeoJSON-Umriss ist, hat kein Raster zum Trainieren, und der Lauf lässt diese Items mit einer Warnung aus.

Zellen mit cellpose

cellpose fine-tunt Cellpose auf Zell- oder Zellkernumrissen in einem image_annotation- oder microscopy-Schema. Cellpose 3 oder 4 wird separat installiert:

pip install cellpose

Das Standard-Basismodell ist cyto3. nuclei und cyto2 funktionieren ebenfalls mit Cellpose 3, und cpsam mit Cellpose 4. diameter wird auf den typischen Zelldurchmesser in Pixeln gesetzt, wenn die eigene Schätzung von Cellpose danebenliegt. Cellpose segmentiert ohne Klassen, daher erhält jede vorhergesagte Zelle den Parameter label oder das häufigste Label des Schemas, wenn label nicht gesetzt ist. Pro Label wird ein Modell trainiert, wenn die Klassen unterschiedlich aussehen. Jede vorhergesagte Maske kommt als Polygon zurück, mit der mittleren Wahrscheinlichkeit der Zelle als Konfidenz des Vorlabels. cellpose braucht nur 5 annotierte Bilder im Train-Split, gegenüber 20 bei den Detektoren. Der Code von Cellpose steht unter BSD-3-Clause, und die Gewichte stammen von den Cellpose-Autoren zu deren Bedingungen.

Spektrogramme

Die Boxen eines spectrogram_annotation-Schemas trainieren torchvision-detect und ultralytics-detect auf jeder Aufnahme, die als Spektrogrammbild gerendert wird. Das Tutorial zu Audiomodellen behandelt die Spektrogramm-Detektion von Anfang bis Ende, mit den Render-Einstellungen und den Aufnahmeformaten, die die Trainer lesen.

Dokumentlayout mit layoutlmv3

layoutlmv3 fine-tunt LayoutLMv3, um die Regionen zu finden, die Annotatoren auf Seitenbildern zeichnen, anhand der Wörter der Seite und deren Positionen. Eine Region ist jeder gelabelte Block, z. B. ein Titel, eine Tabelle oder eine Summe. Potato führt keine OCR aus, daher trägt jedes Item die Wörter der Seite mit Boxen in Pixeln des Seitenbildes oder von 0 bis 1:

{"id": "page_001", "image": "pages/page_001.png",
 "words": [{"text": "INVOICE", "bbox": [40, 52, 180, 82]},
           {"text": "Total", "bbox": [300, 700, 380, 730]}]}

Ein PAGE-XML-Import im Modus regions füllt words aus den Word-Elementen der Datei. Wörter aus der Textebene eines PDFs oder aus einem anderen OCR-Tool funktionieren genauso. Jedes Wort wird mit der Region gelabelt, in die der Mittelpunkt des Wortes fällt, vorhergesagte Wörter werden wieder zu Regionen zusammengeführt, und jede Region wird zu einem Box-Vorlabel um die Wörter der Region. Holdout-Scores sind Box-mAP. Eine vorhergesagte Box endet an den Wörtern der Region, daher erzielen Regionen, die deutlich größer als die Wörter gezeichnet wurden, weniger, als die Boxen verdienen.

Die LayoutLMv3-Gewichte stehen unter CC BY-NC-SA 4.0 und sind nicht für die kommerzielle Nutzung bestimmt. Wie bei den YOLO-Trainern fragt die Training-Seite vor einem Lauf nach einer Bestätigung, ein API-Lauf braucht accept_licence: true, und ein automatisches Neutraining braucht auto_retrain.accept_licence: true.

Vision-Language-Modelle mit vlm-sft

vlm-sft fine-tunt ein Vision-Language-Modell auf den Antworten von Annotatoren zu Bildern, standardmäßig mit einem LoRA-Adapter und Qwen/Qwen2.5-VL-3B-Instruct als Standardmodell. Der Trainer lernt aus vier Schemas:

Koordinaten liegen auf einem Raster von 0 bis 1.000 des Bildes, sodass jeder Checkpoint das Format aus den Beispielen lernen kann. Ein Text-Lauf veröffentlicht die generierte Antwort als Text-Vorlabel. Ein Grounding-Lauf veröffentlicht für jeden Ausdruck eine Region oder ein Fehlen, und VLM-Grounding behandelt das Schema grounding_eval. Ein GUI-Trajectory-Lauf schlägt für jeden Schritt ein Urteil vor, abhängig davon, wo das Modell klicken würde, und Computer-Use-Agenten evaluieren behandelt GUI-Traces. Ein Beschriftungs-Lauf wird mit Token-F1 und BLEU-4 bewertet, aber nie veröffentlicht, denn die beschrifteten Regionen sind die Antwort eines Annotators.

Echte Checkpoints brauchen eine GPU. Das Potato-Team trainierte zwei Epochen Qwen/Qwen3-VL-2B-Instruct mit LoRA über 26 Bilder in 46 Sekunden auf der Metal-GPU eines Macs. {"lora": {"quantize": "4bit"}} in Parameters trainiert einen QLoRA-Adapter über 4-Bit-Basisgewichte. Die Lizenz des gewählten Modells ist zu prüfen. Qwen2.5-VL-3B trägt die Qwen-Forschungslizenz, und das 7B-Modell steht unter Apache-2.0. Das Tutorial zum LLM-Fine-Tuning behandelt LoRA, QLoRA und das Veröffentlichen eines Modells auf dem Hugging Face Hub.

Weiterführende Links

• Übersicht zum Modelltraining, für den Kreislauf und die Training-Seite
• Trainer, für jeden Trainer nach Aufgabe gruppiert
• Konfiguration, für jeden Schlüssel, Holdout-Scores, das Rückschreiben und die Routen
• Labeln mit dem Modell im Kreislauf, für Prüfung, Acquisition und automatisches Neutraining
• Remote-Training, für ssh-GPU-Server, SLURM und den Polling-Agent
• Bildannotation, für die Tools und Optionen des Schemas
• Model Zoo und Lizenzen, für die Vision-Modelle, die im Browser und auf dem Server laufen
• Upstream-Referenz zu Bild-Items, ganzen Slides, torchvision-detect, sam-finetune und vlm-sft, mit jeder Parametertabelle

Literatur

• Ren, S., He, K., Girshick, R., and Sun, J. (2017). Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 39, 1137–1149. doi:10.1109/TPAMI.2016.2577031
• He, K., Gkioxari, G., Dollár, P., and Girshick, R. (2017). Mask R-CNN. 2017 IEEE International Conference on Computer Vision (ICCV), 2980–2988. doi:10.1109/ICCV.2017.322
• Kirillov, A., Mintun, E., Ravi, N., Mao, H., Rolland, C., Gustafson, L., Xiao, T., Whitehead, S., Berg, A. C., Lo, W.-Y., Dollár, P., and Girshick, R. (2023). Segment Anything. 2023 IEEE/CVF International Conference on Computer Vision (ICCV), 3992–4003. doi:10.1109/ICCV51070.2023.00371
• Stringer, C., Wang, T., Michaelos, M., and Pachitariu, M. (2021). Cellpose: a generalist algorithm for cellular segmentation. Nature Methods, 18, 100–106. doi:10.1038/s41592-020-01018-x
• Huang, Y., Lv, T., Cui, L., Lu, Y., and Wei, F. (2022). LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking. Proceedings of the 30th ACM International Conference on Multimedia, 4083–4091. doi:10.1145/3503161.3548112