La suite

Chaque famille utilise la détection par défaut. Vous sélectionnez une autre tâche de l'une des trois manières suivantes, selon cet ordre de priorité :

Comme la factory publique LibreYOLO(...) attend un véritable fichier de poids, le moyen le plus simple de démarrer l'une de ces tâches à partir de zéro consiste à construire directement la classe de la famille et à transmettre task=. Les checkpoints entraînés se rechargent dans la factory unifiée, qui détecte automatiquement leur tâche.

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")

La classification attribue une étiquette unique à une image entière. YOLO9 conserve son backbone et lui ajoute une tête de classification légère ; RF-DETR réutilise son encodeur DINOv2 et ajoute une tête linéaire après pooling. Les deux s'exécutent en 224 par 224.

Inférence et résultat Probs

La prédiction renvoie un objet Results dont le champ probs contient un softmax sur les classes.

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

Format du dataset et entraînement

La classification utilise une structure ImageFolder, pas un fichier YAML. Les noms de classes sont ceux des sous-dossiers triés, fixés à partir du split d'entraînement.

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

L'argument data= accepte un dossier, une URL .zip ou un nom connu avec téléchargement automatique (imagenette160 et imagenet10). La tête est reconstruite automatiquement pour correspondre au nombre de classes du dataset.

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

Les boîtes orientées comportent un angle de rotation, nécessaire pour les images aériennes, les documents et les scènes très denses. YOLO9 ajoute une branche d'angle à sa tête de détection ; RF-DETR ajoute un embedding d'angle apprenable à son décodeur.

Inférence et résultat OBB

L'objet Results expose un champ obb. Les angles sont exprimés en radians.

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]

Format du dataset et entraînement

OBB utilise un fichier YAML de données standard au format détection, mais les étiquettes sont des fichiers texte YOLO-OBB contenant exactement neuf champs par ligne : un identifiant de classe suivi de quatre sommets normalisés. L'angle est déduit des sommets, pas enregistré.

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

Un checkpoint de détection standard ne peut pas être chargé directement dans un modèle OBB. Le passage de la détection à OBB n'est autorisé que pour initialiser un entraînement : transmettez pretrained=True (YOLO9) ou le flag de transfert explicite sur RF-DETR. Mosaic et mixup sont désactivés pour OBB tant qu'une augmentation tenant compte des sommets n'est pas disponible, et l'inférence par tuiles n'est pas prise en charge.

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

La validation utilise l'AP avec IoU rotative, indiquée sous les noms mAP50 et mAP50-95 dans le groupe de métriques OBB.

L'estimation de pose prédit des points clés pour chaque instance détectée. La structure par défaut utilise les points clés de personne COCO-17. Les premières versions de la pose YOLO9 et RF-DETR sont limitées à une seule classe, la personne ; les poses YOLO-NAS et EdgeCrafter sont déjà disponibles dans l'arborescence.

Inférence et résultat Keypoints

L'objet Results expose un champ keypoints de forme (N, K, 3), dont le dernier canal représente la visibilité ou la confiance, dans les coordonnées en pixels de l'image d'origine.

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

Format du dataset et entraînement

La pose utilise un fichier YAML de données qui doit déclarer kpt_shape: [K, 2|3] et, pour l'augmentation par retournement horizontal, un flip_idx. Les étiquettes sont des lignes texte YOLO-pose : un identifiant de classe, une boîte normalisée, puis K triplets de points clés (x, y, v), avec la visibilité v dans {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 est YOLOv9 avec une quatrième échelle de détection à stride 4. Le YOLOv9 standard détecte aux strides 8/16/32, de sorte que les objets de moins de ~16 px passent sous sa grille la plus fine ; la tête P2 couvre la plage 4-16 px qui domine les images aériennes et de drones.

Dans un test A/B contrôlé sur VisDrone (même recette, même résolution, même initialisation ; la seule différence était la tête P2), l'AP des petits objets a progressé de +49% par rapport au YOLOv9 standard de même taille. L'ajout d'une résolution d'entraînement plus élevée et de la plus grande taille s a approximativement doublé l'AP des petits objets dans le projet :

Validation VisDrone2019-DET (548 images), pycocotools, une seule seed ; considérez ±1 point comme du bruit.

Aperçu de recherche VisDrone

Un checkpoint entraîné est publié sous le nom LibreYOLO9P2s-visdrone. La famille est fusionnée sur dev, mais n'est pas encore disponible dans une version PyPI : installez-la depuis les sources jusqu'à la prochaine version.

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)

Quand l'utiliser (ou non)

Adaptez l'architecture au terrain. Sur des données proches de COCO (« petit » signifie 16-32 px), la tête P2 n'apporte aucun gain ; le YOLOv9 standard est alors préférable. Choisissez YOLO9-P2 lorsque vos objets font moins de ~16 px : vidéos de drones et images aériennes, vidéosurveillance distante, tuiles satellite. L'échelle supplémentaire double approximativement le calcul et le nombre d'ancres. C'est le prix de la grille à stride 4.

Entraîner votre propre modèle

YOLO9-P2 s'initialise par transfert depuis des checkpoints de détection YOLOv9 standard : le backbone, le neck partagé et les tours de tête existantes sont chargés ; les nouveaux modules P2 partent de zéro. La recette ci-dessous reprend ce que nous avons appris à nos dépens sur les données de petits objets :

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
)

Les adaptateurs de type LoRA vous permettent de faire du fine-tuning sur le backbone transformer de RF-DETR en entraînant un petit ensemble de matrices de faible rang, tandis que les poids de base restent gelés. Cela réduit la mémoire consacrée à l'optimiseur et aux gradients, ce qui est idéal pour adapter un checkpoint performant à un nouveau domaine sur du matériel modeste.

L'activer

Toute l'API publique se résume à un seul flag dans train(). Aucun réglage de rang, alpha ou module cible n'est à ajuster ; la recette utilise une configuration fixe et éprouvée. En interne, l'implémentation utilise DoRA (LoRA avec décomposition des poids, rang 16), appliqué aux projections query, key et value de l'attention DINOv2.

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 et export

• Les checkpoints d'entraînement conservent les tenseurs des adaptateurs, et la configuration indique que LoRA a été utilisé afin que le chargement et la reprise reconstruisent automatiquement le graphe des adaptateurs.
• La tête de détection reste toujours entraînable, ce qui vous permet de l'adapter à un nouveau nombre de classes.
• export() fusionne les adaptateurs dans des poids denses. Les modèles exportés sont ordinaires et n'ont aucune dépendance à peft.
• LoRA est réservé à RF-DETR ; transmettre lora=True à d'autres familles déclenche une erreur explicite.

État actuel de chaque fonctionnalité. Tout est expérimental ici ; ce tableau en donne une vue fidèle.