Was kommt als Nächstes?

Jede Familie nutzt standardmäßig die Erkennung. Eine andere Aufgabe wählst du auf eine von drei Arten aus, die in dieser Prioritätsreihenfolge ausgewertet werden:

Da die öffentliche Factory LibreYOLO(...) eine echte Gewichtsdatei erwartet, beginnst du eine dieser Aufgaben am saubersten von Grund auf neu, indem du die Familienklasse direkt erstellst und task= übergibst. Trainierte Checkpoints werden wieder über die einheitliche Factory geladen und erkennen ihre Aufgabe automatisch.

1
from libreyolo import LibreYOLO, LibreYOLO9, LibreRFDETR
2
3
# Start a task from scratch via the family class
4
m = LibreYOLO9(None, size="t", task="classify", nb_classes=10)
5
6
# Load a trained checkpoint via the unified factory (task auto-detected)
7
m = LibreYOLO("LibreYOLO9t-obb.pt")

Die Klassifikation gibt ein einziges Label für ein ganzes Bild aus. YOLO9 behält sein Backbone und ergänzt einen leichtgewichtigen Klassifikations-Head. RF-DETR verwendet seinen DINOv2-Encoder erneut und fügt einen gepoolten linearen Head hinzu. Beide arbeiten mit 224 mal 224.

Inferenz und das Probs-Ergebnis

Die Vorhersage gibt ein Results-Objekt zurück, dessen Feld probs einen Softmax über die Klassen enthält.

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreYOLO9t-cls.pt")
4
r = model.predict("cat.jpg")
5
6
print(r.probs.top1)        # class id of the argmax
7
print(r.probs.top1conf)    # its probability
8
print(r.probs.top5)        # [id, id, id, id, id]
9
print(model.names[r.probs.top1])  # human-readable label

Datensatzformat und Training

Die Klassifikation nutzt ein ImageFolder-Layout statt einer YAML-Datei. Die Klassennamen entsprechen den sortierten Namen der Unterordner und werden anhand des Trainingssplits festgelegt.

1
dataset/
2
  train/
3
    cat/   img001.jpg ...
4
    dog/   img104.jpg ...
5
  val/
6
    cat/   ...
7
    dog/   ...

Das Argument data= akzeptiert einen Ordner, eine .zip-URL oder einen bekannten Namen für den automatischen Download (imagenette160 und imagenet10). Der Head wird automatisch neu aufgebaut, damit er zur Klassenanzahl des Datensatzes passt.

1
from libreyolo import LibreYOLO9
2
3
model = LibreYOLO9(None, size="t", task="classify", nb_classes=10)
4
result = model.train(
5
    data="imagenette160",   # folder, .zip URL, or known name
6
    epochs=10, batch=64, imgsz=224,
7
    optimizer="adamw", lr0=1e-3,
8
)
9
# Validation reports metrics/accuracy_top1 and metrics/accuracy_top5

Orientierte Boxen enthalten einen Drehwinkel, wie ihn Luftbilder, Dokumente und dicht gepackte Szenen benötigen. YOLO9 fügt seinem Erkennungs-Head einen Winkelzweig hinzu. RF-DETR ergänzt seinen Decoder um ein lernbares Winkel-Embedding.

Inferenz und das OBB-Ergebnis

Results stellen ein Feld obb bereit. Winkel werden im Bogenmaß angegeben.

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreYOLO9t-obb.pt")
4
r = model.predict("aerial.jpg")
5
6
for i in range(len(r.obb.cls)):
7
    cx, cy, w, h, angle = r.obb.xywhr[i]  # angle in radians
8
    corners = r.obb.xyxyxyxy[i]           # 4 (x, y) corner points
9
    conf, cls = r.obb.conf[i], r.obb.cls[i]

Datensatzformat und Training

OBB verwendet eine Standard-Daten-YAML im Erkennungsstil, die Labels sind jedoch YOLO-OBB-Textdateien mit genau neun Feldern pro Zeile: Auf eine Klassen-ID folgen vier normalisierte Eckpunkte. Der Winkel wird aus den Ecken abgeleitet und nicht gespeichert.

1
# class_id  x1 y1  x2 y2  x3 y3  x4 y4   (all normalized to [0, 1])
2
0  0.51 0.32  0.66 0.38  0.62 0.55  0.47 0.49
3
2  0.10 0.71  0.18 0.69  0.20 0.80  0.12 0.82

Ein gewöhnlicher Erkennungs-Checkpoint kann nicht direkt in ein OBB-Modell geladen werden. Der Wechsel von Erkennung zu OBB ist nur als Warmstart des Trainings erlaubt: Übergib pretrained=True (YOLO9) oder das explizite Transfer-Flag bei RF-DETR. Mosaic und Mixup sind für OBB deaktiviert, bis eine eckenbewusste Augmentierung verfügbar ist. Gekachelte Inferenz wird nicht unterstützt.

1
from libreyolo import LibreYOLO9
2
3
model = LibreYOLO9(None, size="t", task="obb")
4
# Warm-start the backbone from a same-family detect checkpoint
5
result = model.train(data="dota8.yaml", pretrained=True, epochs=100, imgsz=640)
6
7
# CLI equivalent
8
# libreyolo train model=LibreYOLO9t.pt data=dota8.yaml --task obb

Die Validierung verwendet AP mit gedrehter IoU und meldet mAP50 und mAP50-95 unter der OBB-Metrikgruppe.

Die Pose-Schätzung sagt Keypoints pro erkannter Instanz vorher. Das Standardlayout besteht aus COCO-17-Keypoints für Personen. In ihrer ersten Version sind YOLO9 pose und RF-DETR pose Einzelklassenmodelle ausschließlich für Personen. YOLO-NAS pose und EdgeCrafter pose sind im Codebaum bereits verfügbar.

Inferenz und das Keypoints-Ergebnis

Results stellen ein Feld keypoints mit der Form (N, K, 3) bereit. Der letzte Kanal enthält Sichtbarkeit oder Confidence, angegeben in Pixelkoordinaten des Originalbilds.

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreYOLO9t-pose.pt")
4
r = model.predict("athletes.jpg")
5
6
kp = r.keypoints
7
print(kp.xy.shape)   # (N, 17, 2) pixel coordinates
8
print(kp.conf)       # (N, 17)    per-keypoint visibility / confidence
9
print(kp.xyn)        # normalized coordinates
10
print(r.boxes.xyxy)  # person boxes still come along

Datensatzformat und Training

Pose verwendet eine Daten-YAML, die kpt_shape: [K, 2|3] und für die Augmentierung durch horizontales Spiegeln einen flip_idx deklarieren muss. Labels sind YOLO-pose-Textzeilen: eine Klassen-ID, eine normalisierte Box und anschließend K Keypoint-Tripel (x, y, v) mit der Sichtbarkeit v aus {0, 1, 2}.

1
path: coco8-pose
2
train: images/train
3
val: images/val
4
nc: 1
5
names:
6
  0: person
7
kpt_shape: [17, 3]
8
flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]

1
from libreyolo import LibreYOLO9
2
3
# Warm-start from a detection checkpoint; the keypoint head is reinitialized
4
model = LibreYOLO9("LibreYOLO9t.pt", size="t", task="pose")
5
model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
6
7
# Validation reports OKS-based AP via the pose validator

YOLO9-P2 ist YOLOv9 mit einer vierten Erkennungsskala bei Stride 4. Das serienmäßige YOLOv9 erkennt bei Strides von 8/16/32, deshalb fallen Objekte unter etwa 16 px durch sein feinmaschigstes Raster. Der P2-Head erfasst den Bereich von 4-16 px, der Luft- und Drohnenaufnahmen dominiert.

In einem kontrollierten A/B-Test auf VisDrone mit demselben Rezept, derselben Auflösung und derselben Initialisierung, bei dem nur der P2-Head geändert wurde, verbesserte sich die AP für kleine Objekte gegenüber dem serienmäßigen YOLOv9 derselben Größe um +49 %. Eine höhere Trainingsauflösung und die größere Größe s verdoppelten die AP für kleine Objekte im gesamten Projekt ungefähr:

VisDrone2019-DET val (548 Bilder), pycocotools, ein Seed. Betrachte ±1 Punkt als Rauschen.

VisDrone-Forschungsvorschau

Ein trainierter Checkpoint wird als LibreYOLO9P2s-visdrone veröffentlicht. Die Familie wurde in dev zusammengeführt, ist aber noch nicht Teil eines PyPI-Releases. Installiere sie bis zum nächsten Release aus dem Quellcode.

1
from libreyolo import LibreYOLO
2
3
# Auto-downloads from the LibreYOLO Hugging Face org
4
model = LibreYOLO("LibreYOLO9P2s-visdrone.pt")
5
6
# Evaluate/predict at 768 - the resolution it was trained at
7
results = model.predict("aerial.jpg", imgsz=768, conf=0.25)

Wann du das Modell verwenden solltest und wann nicht

Passe die Architektur an das Einsatzgebiet an. Bei COCO-ähnlichen Daten, bei denen „klein“ 16-32 px bedeutet, hilft der P2-Head nicht. Das serienmäßige YOLOv9 ist dort die bessere Wahl. Nutze YOLO9-P2, wenn deine Objekte kleiner als etwa 16 px sind: in Drohnen- und Luftaufnahmen, entfernter Videoüberwachung oder Satellitenkacheln. Die zusätzliche Skala verdoppelt Rechenaufwand und Anchor-Anzahl ungefähr. Das ist der Preis des Stride-4-Rasters.

Training eines eigenen Modells

YOLO9-P2 wird per Transfer aus serienmäßigen YOLOv9-Erkennungs-Checkpoints initialisiert: Das Backbone, das gemeinsam genutzte Neck und die vorhandenen Head-Türme werden geladen. Die neuen P2-Module beginnen frisch. Das Rezept unten bildet ab, was wir auf die harte Tour über Daten mit winzigen Objekten gelernt haben:

1
from libreyolo import LibreYOLO9P2
2
3
model = LibreYOLO9P2(None, size="s")
4
model.train(
5
    data="/abs/path/tiny_objects.yaml",
6
    imgsz=768,                # resolution is the biggest lever for tiny objects
7
    lr0=0.005,                # the family default 0.01 diverges on transfer init
8
    mosaic_prob=0.0,          # mosaic tiling shrinks tiny objects below detectability
9
    mixup_prob=0.0,
10
    hsv_prob=1.0, flip_prob=0.5,
11
    max_labels=600,           # dense aerial frames exceed the default 100-box cap
12
    pretrained="LibreYOLO9s.pt",  # transfer init from stock YOLOv9
13
    epochs=60,
14
)

Adapter im LoRA-Stil ermöglichen das Fine-Tuning des Transformer-Backbones von RF-DETR. Dabei wird ein kleiner Satz von Low-Rank-Matrizen trainiert, während die Basisgewichte eingefroren bleiben. Das reduziert den Speicherbedarf für Optimizer und Gradienten und eignet sich ideal, um einen starken Checkpoint auf bescheidener Hardware an eine neue Domäne anzupassen.

Aktivierung

Die gesamte öffentliche API besteht aus einem einzigen Flag für train(). Rang, Alpha und Zielmodule können nicht angepasst werden. Das Rezept ist auf eine gut getestete Konfiguration festgelegt. Intern verwendet die Implementierung DoRA (gewichtszersetztes LoRA, Rang 16) für die Query-, Key- und Value-Projektionen der DINOv2-Attention.

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("rf-detr-nano.pth")   # sizes n, s, m, l
4
result = model.train(
5
    data="data.yaml",
6
    lora=True,        # DoRA on the frozen DINOv2 backbone
7
    epochs=100, batch_size=4, lr=1e-4,
8
)
9
10
# Resume: LoRA is auto-detected from the checkpoint, no need to repeat the flag
11
model.train(data="data.yaml", resume=True)

1
# CLI equivalent
2
libreyolo train --model rf-detr-nano.pth --data data.yaml --lora

Checkpoints und Export

• Trainings-Checkpoints behalten die Adapter-Tensoren, und die Konfiguration zeichnet die Verwendung von LoRA auf. Dadurch wird der Adaptergraph beim Laden und Fortsetzen automatisch neu aufgebaut.
• Der Erkennungs-Head bleibt immer trainierbar, deshalb kannst du weiterhin auf eine neue Klassenanzahl anpassen.
• export() führt die Adapter wieder mit dichten Gewichten zusammen. Exportierte Modelle sind eigenständig und haben keine Abhängigkeit von peft.
• LoRA ist ausschließlich für RF-DETR verfügbar. Die Übergabe von lora=True an andere Familien löst einen eindeutigen Fehler aus.

Der heutige Stand jeder Funktion. Alles hier ist experimentell. Diese Tabelle zeigt den tatsächlichen Status.