1
pip install libreyolo

1
git clone https://github.com/LibreYOLO/libreyolo.git
2
cd libreyolo
3
pip install -e .

1
# ONNX export and inference
2
pip install libreyolo[onnx]
3
# or: pip install onnx onnxsim onnxscript onnxruntime
4
5
# RT-DETR support
6
pip install libreyolo[rtdetr]
7
# or: pip install transformers timm
8
9
# RF-DETR support
10
pip install libreyolo[rfdetr]
11
# or: pip install rfdetr transformers timm supervision
12
13
# TensorRT export and inference (NVIDIA GPU)
14
pip install libreyolo[tensorrt]
15
# Note: TensorRT itself requires manual installation (depends on CUDA version)
16
17
# OpenVINO export and inference (Intel CPU/GPU/VPU)
18
pip install libreyolo[openvino]
19
# INT8 export also needs: pip install nncf
20
21
# NCNN export and inference
22
pip install libreyolo[ncnn]
23
# or: pip install pnnx ncnn

1
# ONNX environment
2
uv venv .venv-onnx
3
uv pip install --python .venv-onnx/bin/python -e '.[onnx]'
4
5
# RT-DETR environment
6
uv venv .venv-rtdetr
7
uv pip install --python .venv-rtdetr/bin/python -e '.[rtdetr]'
8
9
# Repeat with .[rfdetr], .[openvino], .[ncnn], or .[tensorrt] as needed

1
from libreyolo import LibreYOLO
2
3
# Auto-detects architecture and size from the weights file
4
model = LibreYOLO("LibreYOLO9c.pt")
5
6
# Run on a single image
7
result = model("photo.jpg")
8
9
print(f"Found {len(result)} objects")
10
print(result.boxes.xyxy)   # bounding boxes (N, 4)
11
print(result.boxes.conf)   # confidence scores (N,)
12
print(result.boxes.cls)    # class IDs (N,)

1
result = model("photo.jpg", save=True)
2
# Saved under runs/detect/predict*/photo.jpg by default

1
results = model("images/", save=True, batch=4)
2
for r in results:
3
    print(f"{r.path}: {len(r)} detections")

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreYOLO9t.pt")
4
# model = LibreYOLO("LibreYOLO9s.pt")
5
# model = LibreYOLO("LibreYOLO9m.pt")
6
# model = LibreYOLO("LibreYOLO9c.pt")

1
from libreyolo import LibreRFDETR
2
3
model = LibreRFDETR(size="s")

1
from libreyolo import LibreYOLO
2
3
# Auto-detects: YOLOX, size=s, 80 classes
4
model = LibreYOLO("LibreYOLOXs.pt")
5
6
# Auto-detects: YOLO9, size=c, 80 classes
7
model = LibreYOLO("LibreYOLO9c.pt")
8
9
# Auto-detects: RT-DETR
10
model = LibreYOLO("LibreRTDETRr50.pt")
11
12
# RF-DETR checkpoints also work when you point at an actual checkpoint file
13
model = LibreYOLO("/path/to/checkpoint_best_regular.pth")
14
15
# ONNX models work too
16
model = LibreYOLO("model.onnx")
17
18
# TensorRT engines
19
model = LibreYOLO("model.engine")
20
21
# OpenVINO models (directory with model.xml)
22
model = LibreYOLO("model_openvino/")
23
24
# NCNN models (directory with model.ncnn.param + model.ncnn.bin)
25
model = LibreYOLO("model_ncnn/")

1
result = model("image.jpg")

1
result = model(
2
    "image.jpg",
3
    conf=0.25,            # confidence threshold (default: 0.25)
4
    iou=0.45,             # NMS IoU threshold (default: 0.45)
5
    imgsz=640,            # input size override (default: model's native)
6
    classes=[0, 2, 5],    # filter to specific class IDs (default: all)
7
    max_det=300,          # max detections per image (default: 300)
8
    save=True,            # save annotated image (default: False)
9
    output_path="out/",   # where to save (default: runs/detect/predict*/)
10
    color_format="auto",  # "auto", "rgb", or "bgr"
11
    output_file_format="png",  # output format: "jpg", "png", "webp"
12
)

1
# File path (string or pathlib.Path)
2
result = model("photo.jpg")
3
result = model(Path("photo.jpg"))
4
5
# URL
6
result = model("https://example.com/image.jpg")
7
8
# PIL Image
9
from PIL import Image
10
img = Image.open("photo.jpg")
11
result = model(img)
12
13
# NumPy array (HWC or CHW, RGB or BGR, uint8 or float32)
14
import numpy as np
15
arr = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
16
result = model(arr)
17
18
# OpenCV (BGR) — specify color_format
19
import cv2
20
frame = cv2.imread("photo.jpg")
21
result = model(frame, color_format="bgr")
22
23
# PyTorch tensor (CHW or NCHW)
24
import torch
25
tensor = torch.randn(3, 640, 640)
26
result = model(tensor)
27
28
# Raw bytes
29
with open("photo.jpg", "rb") as f:
30
    result = model(f.read())
31
32
# Directory of images
33
results = model("images/", batch=4)

1
result = model("image.jpg")
2
3
# Number of detections
4
len(result)  # e.g., 5
5
6
# Bounding boxes in xyxy format (x1, y1, x2, y2)
7
result.boxes.xyxy        # tensor of shape (N, 4)
8
9
# Bounding boxes in xywh format (center_x, center_y, width, height)
10
result.boxes.xywh        # tensor of shape (N, 4)
11
12
# Confidence scores
13
result.boxes.conf        # tensor of shape (N,)
14
15
# Class IDs
16
result.boxes.cls         # tensor of shape (N,)
17
18
# Combined data: [x1, y1, x2, y2, conf, cls]
19
result.boxes.data        # tensor of shape (N, 6)
20
21
# Metadata
22
result.orig_shape        # (height, width) of original image
23
result.path              # source file path (or None)
24
result.names             # {0: "person", 1: "bicycle", ...}
25
26
# Move to CPU / convert to numpy
27
result_cpu = result.cpu()
28
boxes_np = result.boxes.numpy()

1
# Only detect people (class 0) and cars (class 2)
2
result = model("image.jpg", classes=[0, 2])

1
result = model(
2
    "large_aerial_image.jpg",
3
    tiling=True,
4
    overlap_ratio=0.2,   # 20% overlap between tiles (default)
5
    save=True,
6
)
7
8
# Extra metadata on tiled results
9
result.tiled           # True
10
result.num_tiles       # number of tiles used
11
result.saved_path      # output directory when save=True
12
result.tiles_path      # directory containing per-tile crops
13
result.grid_path       # grid visualization image

1
from libreyolo import LibreYOLOX
2
3
model = LibreYOLOX(size="s")
4
5
results = model.train(
6
    data="coco128.yaml",     # path to data.yaml (required)
7
8
    # Training parameters
9
    epochs=100,              # default: 100
10
    batch=16,
11
    imgsz=640,
12
13
    # Optimizer
14
    lr0=0.01,                # initial learning rate
15
    optimizer="SGD",         # "SGD", "Adam", "AdamW"
16
17
    # System
18
    device="0",              # GPU device ("", "cpu", "cuda", "0", "0,1")
19
    workers=8,
20
    seed=0,
21
22
    # Output
23
    project="runs/train",
24
    name="exp",
25
    exist_ok=False,
26
27
    # Training features
28
    amp=True,                # automatic mixed precision
29
    patience=50,             # early stopping patience
30
    resume=False,            # resume from loaded checkpoint
31
)
32
33
print(f"Best mAP50-95: {results['best_mAP50_95']:.3f}")
34
print(f"Best checkpoint: {results['best_checkpoint']}")

1
{
2
    "final_loss": 2.31,
3
    "best_mAP50": 0.682,
4
    "best_mAP50_95": 0.451,
5
    "best_epoch": 87,
6
    "save_dir": "runs/train/exp",
7
    "best_checkpoint": "runs/train/exp/weights/best.pt",
8
    "last_checkpoint": "runs/train/exp/weights/last.pt",
9
}

1
model = LibreYOLOX("runs/train/exp/weights/last.pt", size="s")
2
results = model.train(data="coco128.yaml", resume=True)

1
path: /path/to/dataset
2
train: images/train
3
val: images/val
4
test: images/test  # optional
5
6
nc: 3
7
names: ["cat", "dog", "bird"]

1
from libreyolo import LibreYOLO9
2
3
model = LibreYOLO9("LibreYOLO9c.pt", size="c")
4
5
results = model.train(
6
    data="coco128.yaml",
7
    epochs=300,              # default: 300
8
    batch=16,
9
    imgsz=640,
10
    lr0=0.01,
11
    optimizer="SGD",
12
    device="0",
13
    workers=8,
14
    seed=0,
15
    project="runs/train",
16
    name="yolo9_exp",        # default: "yolo9_exp"
17
    exist_ok=False,
18
    resume=False,
19
    amp=True,
20
    patience=50,
21
)
22
23
print(f"Best mAP50-95: {results['best_mAP50_95']:.3f}")

1
from libreyolo import LibreRTDETR
2
3
model = LibreRTDETR(size="r50")
4
5
results = model.train(
6
    data="coco128.yaml",
7
    epochs=72,               # default: 72
8
    batch=4,                 # default: 4
9
    imgsz=640,
10
    lr0=1e-4,
11
    lr_backbone=1e-5,
12
    optimizer="AdamW",
13
    scheduler="linear",
14
    device="0",
15
    workers=4,
16
    seed=0,
17
    project="runs/train",
18
    name="rtdetr_exp",
19
    exist_ok=False,
20
    pretrained=True,
21
    resume=False,
22
    amp=True,
23
    patience=50,
24
)

1
from libreyolo import LibreRFDETR
2
3
model = LibreRFDETR(size="s")
4
5
results = model.train(
6
    data="path/to/dataset",  # Roboflow/COCO format directory
7
    epochs=100,
8
    batch_size=4,
9
    lr=1e-4,
10
    output_dir="runs/train",
11
)

1
dataset/
2
    train/
3
        _annotations.coco.json
4
        image1.jpg
5
        image2.jpg
6
    valid/
7
        _annotations.coco.json
8
        image1.jpg

1
results = model.val(
2
    data="coco128.yaml",   # dataset config
3
    batch=16,
4
    imgsz=640,
5
    conf=0.001,            # low conf for mAP calculation
6
    iou=0.6,               # NMS IoU threshold
7
    split="val",           # "val", "test", or "train"
8
    save_json=False,       # save predictions as COCO JSON
9
    verbose=True,          # print per-class metrics
10
)
11
12
print(f"mAP50:    {results['metrics/mAP50']:.3f}")
13
print(f"mAP50-95: {results['metrics/mAP50-95']:.3f}")

1
{
2
    "metrics/mAP50-95": 0.489,   # COCO primary metric (AP@[.5:.95])
3
    "metrics/mAP50": 0.721,      # AP@0.5 (PASCAL VOC style)
4
    "metrics/mAP75": 0.534,      # AP@0.75 (strict)
5
    "metrics/mAP_small": 0.291,
6
    "metrics/mAP_medium": 0.532,
7
    "metrics/mAP_large": 0.648,
8
    "metrics/AR1": 0.362,        # Average Recall (max 1 det)
9
    "metrics/AR10": 0.571,
10
    "metrics/AR100": 0.601,
11
    "metrics/AR_small": 0.387,
12
    "metrics/AR_medium": 0.641,
13
    "metrics/AR_large": 0.739,
14
}

1
# ONNX (default)
2
model.export()
3
4
# TorchScript
5
model.export(format="torchscript")
6
7
# TensorRT (requires NVIDIA GPU + TensorRT)
8
model.export(format="tensorrt")
9
10
# OpenVINO (optimized for Intel hardware)
11
model.export(format="openvino")
12
13
# NCNN (via PNNX)
14
model.export(format="ncnn")

1
path = model.export(
2
    format="onnx",            # "onnx", "torchscript", "tensorrt", "openvino", or "ncnn"
3
    output_path="model.onnx", # output file (auto-generated if None)
4
    imgsz=640,                # input resolution (default: model's native)
5
    opset=13,                 # ONNX opset version (RT-DETR / RF-DETR default to 17)
6
    simplify=True,            # run onnxsim graph simplification
7
    dynamic=True,             # enable dynamic batch axis
8
    half=False,               # export in FP16
9
    batch=1,                  # batch size for static graph
10
    device=None,              # device to trace on (default: model's current device)
11
    int8=False,               # INT8 quantization (TensorRT / OpenVINO only)
12
    data=None,                # calibration dataset for INT8
13
    fraction=1.0,             # fraction of calibration data to use
14
    workspace=4.0,            # TensorRT workspace size (GB)
15
    hardware_compatibility="none", # TensorRT compatibility mode
16
    gpu_device=0,             # GPU device index for TensorRT
17
    trt_config=None,          # optional TensorRT YAML config path
18
    verbose=False,            # verbose logging
19
)

1
from libreyolo.export import BaseExporter
2
3
exporter = BaseExporter.create("onnx", model)
4
path = exporter(dynamic=True, simplify=True)

1
from libreyolo import OnnxBackend
2
3
model = OnnxBackend("model.onnx")
4
5
result = model("image.jpg", conf=0.25, iou=0.45, save=True)
6
print(result.boxes.xyxy)

1
# Export with metadata
2
model.export(format="onnx", output_path="model.onnx")
3
4
# Load — names and nb_classes auto-populated
5
onnx_model = OnnxBackend("model.onnx")
6
print(onnx_model.names)       # {0: "person", 1: "bicycle", ...}
7
print(onnx_model.nb_classes)  # 80

1
model = OnnxBackend("external_model.onnx", nb_classes=20)

1
# Auto-detect (CUDA if available, else CPU)
2
model = OnnxBackend("model.onnx", device="auto")
3
4
# Force CPU
5
model = OnnxBackend("model.onnx", device="cpu")
6
7
# Force CUDA
8
model = OnnxBackend("model.onnx", device="cuda")

1
result = model(
2
    "image.jpg",
3
    conf=0.25,
4
    iou=0.45,
5
    imgsz=640,
6
    classes=[0, 2],
7
    max_det=300,
8
    save=True,
9
    output_path="output/annotated.jpg",  # final file path when save=True
10
    color_format="auto",
11
)

1
from libreyolo import TensorRTBackend
2
3
model = TensorRTBackend("model.engine")
4
5
result = model("image.jpg", conf=0.25, iou=0.45, save=True)
6
print(result.boxes.xyxy)

1
from libreyolo import LibreYOLO
2
3
# Auto-detects TensorRT engine
4
model = LibreYOLO("model.engine")

1
from libreyolo import OpenVINOBackend
2
3
model = OpenVINOBackend("model_openvino/")
4
5
result = model("image.jpg", conf=0.25, iou=0.45, save=True)
6
print(result.boxes.xyxy)

1
from libreyolo import LibreYOLO
2
3
# Auto-detects OpenVINO directory
4
model = LibreYOLO("model_openvino/")

1
from libreyolo import NcnnBackend
2
3
model = NcnnBackend("model_ncnn/")
4
5
result = model("image.jpg", conf=0.25, iou=0.45, save=True)
6
print(result.boxes.xyxy)

1
from libreyolo import LibreYOLO
2
3
# Auto-detects NCNN directory
4
model = LibreYOLO("model_ncnn/")

1
LibreYOLO(
2
    model_path: str,
3
    size: str = None,           # auto-detected from weights
4
    reg_max: int = 16,          # YOLO9 only
5
    nb_classes: int = None,     # auto-detected from weights
6
    device: str = "auto",
7
) -> LibreYOLOX | LibreYOLO9 | LibreRTDETR | LibreRFDETR | OnnxBackend | TensorRTBackend | OpenVINOBackend | NcnnBackend

1
model(
2
    source,                     # image input (see supported formats)
3
    *,
4
    conf: float = 0.25,
5
    iou: float = 0.45,
6
    imgsz: int = None,
7
    classes: list[int] = None,
8
    max_det: int = 300,
9
    save: bool = False,
10
    batch: int = 1,
11
    output_path: str = None,
12
    color_format: str = "auto",
13
    tiling: bool = False,
14
    overlap_ratio: float = 0.2,
15
    output_file_format: str = None,
16
) -> Results | list[Results]

1
backend(
2
    source,
3
    *,
4
    conf: float = 0.25,
5
    iou: float = 0.45,
6
    imgsz: int = None,
7
    classes: list[int] = None,
8
    max_det: int = 300,
9
    save: bool = False,
10
    batch: int = 1,
11
    output_path: str = None,    # final file path when save=True
12
    color_format: str = "auto",
13
) -> Results | list[Results]

1
result = Results(
2
    boxes: Boxes,
3
    orig_shape: tuple[int, int],  # (height, width)
4
    path: str | None,
5
    names: dict[int, str],
6
)
7
8
len(result)          # number of detections
9
result.cpu()         # copy with tensors on CPU

1
boxes = Boxes(boxes, conf, cls)
2
3
boxes.xyxy           # (N, 4) tensor — x1, y1, x2, y2
4
boxes.xywh           # (N, 4) tensor — cx, cy, w, h
5
boxes.conf           # (N,) tensor — confidence scores
6
boxes.cls            # (N,) tensor — class IDs
7
boxes.data           # (N, 6) tensor — [xyxy, conf, cls]
8
9
len(boxes)           # number of boxes
10
boxes.cpu()          # copy on CPU
11
boxes.numpy()        # copy as numpy arrays

1
model.export(
2
    format: str = "onnx",       # "onnx", "torchscript", "tensorrt", "openvino", or "ncnn"
3
    *,
4
    output_path: str = None,
5
    imgsz: int = None,
6
    opset: int = 13,
7
    simplify: bool = True,
8
    dynamic: bool = True,
9
    half: bool = False,
10
    batch: int = 1,
11
    device: str = None,
12
    int8: bool = False,
13
    data: str = None,           # calibration data for INT8
14
    fraction: float = 1.0,      # fraction of calibration data
15
    workspace: float = 4.0,     # TensorRT workspace (GB)
16
    hardware_compatibility: str = "none",
17
    gpu_device: int = 0,
18
    trt_config = None,          # optional TensorRT YAML config path
19
    verbose: bool = False,
20
) -> str                        # path to exported file or directory

1
from libreyolo.export import BaseExporter
2
3
exporter = BaseExporter.create("onnx", model)
4
path = exporter(dynamic=True, simplify=True)
5
6
BaseExporter.create("ncnn", model)(output_path="model_ncnn")

1
model.val(
2
    data: str = None,           # path to data.yaml
3
    batch: int = 16,
4
    imgsz: int = None,
5
    conf: float = 0.001,
6
    iou: float = 0.6,
7
    device: str = None,
8
    split: str = "val",         # "val", "test", or "train"
9
    save_json: bool = False,
10
    verbose: bool = True,
11
) -> dict

1
{
2
    "metrics/mAP50-95": float,   # COCO primary metric
3
    "metrics/mAP50": float,
4
    "metrics/mAP75": float,
5
    "metrics/mAP_small": float,
6
    "metrics/mAP_medium": float,
7
    "metrics/mAP_large": float,
8
    "metrics/AR1": float,
9
    "metrics/AR10": float,
10
    "metrics/AR100": float,
11
    "metrics/AR_small": float,
12
    "metrics/AR_medium": float,
13
    "metrics/AR_large": float,
14
}

1
model.train(
2
    data: str,                  # path to data.yaml (required)
3
    *,
4
    epochs: int = 100,
5
    batch: int = 16,
6
    imgsz: int = 640,
7
    lr0: float = 0.01,
8
    optimizer: str = "SGD",
9
    device: str = "",
10
    workers: int = 8,
11
    seed: int = 0,
12
    project: str = "runs/train",
13
    name: str = "exp",
14
    exist_ok: bool = False,
15
    pretrained: bool = True,
16
    resume: bool = False,
17
    amp: bool = True,
18
    patience: int = 50,
19
) -> dict

1
{
2
    "final_loss": float,
3
    "best_mAP50": float,
4
    "best_mAP50_95": float,
5
    "best_epoch": int,
6
    "save_dir": str,
7
    "best_checkpoint": str,
8
    "last_checkpoint": str,
9
}

1
model.train(
2
    data: str,                  # path to data.yaml (required)
3
    *,
4
    epochs: int = 300,
5
    batch: int = 16,
6
    imgsz: int = 640,
7
    lr0: float = 0.01,
8
    optimizer: str = "SGD",
9
    device: str = "",
10
    workers: int = 8,
11
    seed: int = 0,
12
    project: str = "runs/train",
13
    name: str = "yolo9_exp",
14
    exist_ok: bool = False,
15
    resume: bool = False,
16
    amp: bool = True,
17
    patience: int = 50,
18
) -> dict

1
model.train(
2
    data: str,                  # path to data.yaml (required)
3
    *,
4
    epochs: int = 72,
5
    batch: int = 4,
6
    imgsz: int = 640,
7
    lr0: float = 1e-4,
8
    lr_backbone: float = 1e-5,
9
    optimizer: str = "AdamW",
10
    scheduler: str = "linear",
11
    device: str = "",
12
    workers: int = 4,
13
    seed: int = 0,
14
    project: str = "runs/train",
15
    name: str = "rtdetr_exp",
16
    exist_ok: bool = False,
17
    pretrained: bool = True,
18
    resume: bool = False,
19
    amp: bool = True,
20
    patience: int = 50,
21
) -> dict

1
model.train(
2
    data: str,                  # path to dataset directory
3
    epochs: int = 100,
4
    batch_size: int = 4,
5
    lr: float = 1e-4,
6
    output_dir: str = "runs/train",
7
    resume: str = None,
8
    **kwargs,                   # additional RF-DETR training args
9
) -> dict

1
OnnxBackend(
2
    onnx_path: str,
3
    nb_classes: int = 80,       # auto-read from metadata if available
4
    device: str = "auto",
5
)

1
TensorRTBackend(
2
    engine_path: str,
3
    nb_classes: int | None = None,
4
    device: str = "auto",
5
)

1
OpenVINOBackend(
2
    model_dir: str,
3
    nb_classes: int | None = None,
4
    device: str = "auto",
5
)

1
NcnnBackend(
2
    model_dir: str,
3
    nb_classes: int | None = None,
4
    device: str = "auto",
5
)

1
from libreyolo import ValidationConfig
2
3
config = ValidationConfig(
4
    data="coco128.yaml",
5
    data_dir=None,             # override dataset root directory
6
    batch_size=16,
7
    imgsz=640,
8
    conf_thres=0.001,
9
    iou_thres=0.6,
10
    max_det=300,
11
    split="val",               # "val", "test", or "train"
12
    device="auto",
13
    save_json=False,
14
    verbose=True,
15
    half=False,
16
    use_coco_eval=True,        # use COCO eval (12 keys); False for legacy
17
    num_workers=4,
18
)
19
20
# Load/save YAML
21
config = ValidationConfig.from_yaml("config.yaml")
22
config.to_yaml("config.yaml")

1
libreyolo/
2
    __init__.py          # Public API exports
3
    models/
4
        __init__.py      # LibreYOLO() factory + model registry bootstrap
5
        base/
6
            model.py     # BaseModel
7
            inference.py # Shared prediction pipeline
8
        yolox/
9
            model.py
10
            nn.py
11
            utils.py
12
        yolo9/
13
            model.py
14
            nn.py
15
            utils.py
16
        rtdetr/
17
            model.py
18
            nn.py
19
            trainer.py
20
            utils.py
21
        rfdetr/
22
            model.py
23
            utils.py
24
            train.py
25
    backends/
26
        base.py          # BaseBackend runtime wrapper
27
        onnx.py          # OnnxBackend
28
        tensorrt.py      # TensorRTBackend
29
        openvino.py      # OpenVINOBackend
30
        ncnn.py          # NcnnBackend
31
    utils/
32
        results.py       # Results and Boxes classes
33
        image_loader.py  # Unified image loading
34
        general.py       # Path helpers, NMS, tiling utilities
35
    export/
36
        exporter.py      # BaseExporter and format registry
37
        onnx.py          # ONNX export logic
38
        torchscript.py   # TorchScript export logic
39
        tensorrt.py      # TensorRT export logic
40
        openvino.py      # OpenVINO export logic
41
        ncnn.py          # NCNN export logic
42
    training/
43
        config.py        # YOLOXTrainConfig / YOLOv9TrainConfig
44
        trainer.py       # YOLOXTrainer
45
        v9_trainer.py    # YOLOv9Trainer
46
        dataset.py       # Training dataset
47
        augment.py       # Mosaic, mixup, etc.
48
        loss.py          # YOLOX loss functions
49
        scheduler.py     # LR schedulers
50
        ema.py           # Exponential moving average
51
    validation/
52
        config.py        # ValidationConfig
53
        detection_validator.py  # DetectionValidator
54
        metrics.py       # DetMetrics, mAP computation
55
        base.py          # BaseValidator
56
        preprocessors.py # Per-model val preprocessing
57
    data/
58
        utils.py         # Dataset loading, YAML parsing
59
        yolo_coco_api.py # YOLO-to-COCO annotation bridge
60
    config/
61
        datasets/        # Built-in dataset YAML configs (coco8, coco128, coco5000, coco, etc.)

1
from libreyolo.export import BaseExporter
2
3
onnx_exporter = BaseExporter.create("onnx", model)
4
ncnn_exporter = BaseExporter.create("ncnn", model)

1
path: /absolute/path/to/dataset   # dataset root
2
train: images/train               # directory path, relative to path
3
val: images/val                   # directory path, relative to path
4
test: images/test                 # optional
5
6
nc: 80                            # number of classes
7
names: [                          # class names
8
  "person", "bicycle", "car", "motorcycle", "airplane",
9
  "bus", "train", "truck", "boat", "traffic light",
10
  # ...
11
]

1
path: /absolute/path/to/coco
2
train: train2017.txt
3
val: val2017.txt
4
test: test-dev2017.txt
5
6
nc: 80
7
names: ["person", "bicycle", "car", "..."]

1
dataset/
2
    images/
3
        train/
4
            img001.jpg
5
            img002.jpg
6
        val/
7
            img003.jpg
8
    labels/
9
        train/
10
            img001.txt
11
            img002.txt
12
        val/
13
            img003.txt