1
pip install libreyolo

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

1
# ONNX export and inference
2
pip install libreyolo[onnx]
3
# or: pip install onnx onnxsim onnxruntime
4
5
# RT-DETR compatibility extra (currently no extra packages)
6
pip install libreyolo[rtdetr]
7
8
# RF-DETR support
9
pip install libreyolo[rfdetr]
10
# or: pip install transformers
11
12
# TensorRT export and inference (NVIDIA GPU)
13
pip install libreyolo[tensorrt]
14
# Installs TensorRT CUDA 12 Python packages on Linux/Windows.
15
# Host driver/CUDA compatibility still matters.
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
24
25
# ByteTrack API compatibility extra
26
pip install libreyolo[tracking]
27
# Tracking dependencies are part of the base install in v1.2.0 dev.
28
29
# CoreML export and inference (macOS only for runtime)
30
pip install libreyolo[coreml]
31
# or: pip install coremltools
32
33
# L2CS gaze optional auto-download helper
34
pip install libreyolo[gaze]
35
# Optional parity with the upstream RetinaFace-based L2CS pipeline
36
pip install libreyolo[gaze-retinaface]
37
38
# Install every optional LibreYOLO extra
39
pip install libreyolo[all]

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], .[coreml], .[gaze], .[tracking], or .[tensorrt] as needed

1
from libreyolo import LibreYOLO, SAMPLE_IMAGE
2
3
# Use the official checkpoint name and let the factory resolve the details
4
model = LibreYOLO("LibreYOLO9c.pt")
5
6
# Run on a single image (SAMPLE_IMAGE ships with the package)
7
result = model(SAMPLE_IMAGE)
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
from libreyolo import LibreYOLO, SAMPLE_IMAGE
2
3
# Same factory, same call shape - just point at an RF-DETR checkpoint
4
model = LibreYOLO("LibreRFDETRs.pt")
5
result = model(SAMPLE_IMAGE)
6
7
print(f"Found {len(result)} objects")
8
print(result.boxes.xyxy)

1
result = model(SAMPLE_IMAGE, save=True)
2
print(result.saved_path)   # e.g. runs/detect/predict/parkour.jpg

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("LibreYOLO9c.pt")
4
# Experimental segmentation variant
5
# model = LibreYOLO("LibreYOLO9c-seg.pt")

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreRFDETRs.pt")
4
# Segmentation variants exist for every RF-DETR size
5
# model = LibreYOLO("LibreRFDETRs-seg.pt")

1
from libreyolo import LibreYOLO
2
3
# Default: YOLO9 detection
4
model = LibreYOLO("LibreYOLO9c.pt")
5
6
# Flagship: RF-DETR
7
model = LibreYOLO("LibreRFDETRs.pt")
8
9
# Segmentation checkpoints use the same factory path
10
model = LibreYOLO("LibreRFDETRs-seg.pt")       # validated segmentation
11
model = LibreYOLO("LibreYOLO9c-seg.pt")        # experimental segmentation
12
13
# Exported deployment formats
14
model = LibreYOLO("model.onnx")                # ONNX Runtime
15
model = LibreYOLO("model.engine")              # TensorRT
16
model = LibreYOLO("model.mlpackage")           # CoreML (macOS)
17
model = LibreYOLO("model_openvino/")           # OpenVINO (directory)
18
model = LibreYOLO("model_ncnn/")               # NCNN (directory)

1
Libre<FAMILY><size>[-<task>].pt

1
explicit task=  →  checkpoint["task"]  →  filename suffix  →  family default

1
from libreyolo import LibreYOLO
2
3
# 1. Filename suffix decides → segment
4
model = LibreYOLO("LibreRFDETRs-seg.pt")
5
6
# 2. Override regardless of filename
7
model = LibreYOLO("custom_weights.pt", task="segment")
8
9
# 3. Detection is implicit
10
model = LibreYOLO("LibreYOLO9c.pt")  # task="detect"

1
# Detection (implicit)
2
LibreYOLO9c.pt
3
LibreRFDETRs.pt
4
LibreRTDETRr50.pt
5
6
# Segmentation
7
LibreYOLO9c-seg.pt
8
LibreRFDETRs-seg.pt
9
LibreECm-seg.pt
10
11
# Pose
12
LibreYOLONASn-pose.pt
13
LibreECs-pose.pt
14
15
# Gaze
16
LibreL2CSr50.pt   # gaze is L2CS's only task - suffix optional

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
    device="auto",        # "auto", "cpu", "mps", "0", "cuda:0", ...
7
    classes=[0, 2, 5],    # filter to specific class IDs (default: all)
8
    max_det=300,          # max detections per image (default: 300)
9
    augment=False,        # test-time augmentation where implemented
10
    save=True,            # save annotated image (default: False)
11
    batch=4,              # directory batch size
12
    stream=False,         # video only: yield frame results instead of a list
13
    vid_stride=1,         # video only: process every N-th frame
14
    show=False,           # video only: display annotated frames
15
    tiling=False,         # large-image tiled detection
16
    overlap_ratio=0.2,    # tile overlap ratio
17
    output_path="out/",   # where to save (default: runs/detect/predict*/)
18
    color_format="auto",  # "auto", "rgb", or "bgr"
19
    output_file_format="png",  # output format: "jpg", "png", "webp"
20
)

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
result = model("s3://bucket/image.jpg")
8
result = model("gs://bucket/image.jpg")
9
10
# PIL Image
11
from PIL import Image
12
img = Image.open("photo.jpg")
13
result = model(img)
14
15
# NumPy array (HWC or CHW, RGB or BGR, uint8 or float32)
16
import numpy as np
17
arr = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
18
result = model(arr)
19
20
# OpenCV (BGR) - specify color_format
21
import cv2
22
frame = cv2.imread("photo.jpg")
23
result = model(frame, color_format="bgr")
24
25
# PyTorch tensor (CHW or NCHW)
26
import torch
27
tensor = torch.randn(3, 640, 640)
28
result = model(tensor)
29
30
# Raw bytes
31
with open("photo.jpg", "rb") as f:
32
    result = model(f.read())
33
34
# BytesIO
35
from io import BytesIO
36
result = model(BytesIO(open("photo.jpg", "rb").read()))
37
38
# Directory of images
39
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
# Tracking adds a track_id column before conf/cls.
20
result.boxes.data        # shape (N, 6), or (N, 7) when tracked
21
22
# Metadata
23
result.orig_shape        # (height, width) of original image
24
result.path              # source file path (or None)
25
result.names             # {0: "person", 1: "bicycle", ...}
26
27
# Move to CPU / convert to numpy
28
result_cpu = result.cpu()
29
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 LibreYOLO
2
3
model = LibreYOLO("LibreYOLO9c.pt")
4
results = model("clip.mp4", save=True)
5
# Saved under runs/detect/predict*/clip.mp4

1
for result in model("long_clip.mp4", stream=True):
2
    print(f"frame {result.frame_idx}: {len(result)} detections")

1
# Process every 2nd frame (halves compute and saved fps)
2
results = model("clip.mp4", vid_stride=2, save=True)

1
# Display annotated frames in an OpenCV window while processing
2
results = model("clip.mp4", show=True)

1
from libreyolo import LibreYOLO
2
from libreyolo.utils.video import VideoSource, VideoWriter
3
4
model = LibreYOLO("LibreYOLO9c.pt")
5
6
with VideoSource("clip.mp4", vid_stride=1) as src, \
7
     VideoWriter("out.mp4", fps=src.fps, width=src.width, height=src.height) as out:
8
    for frame_bgr, frame_idx in src:
9
        result = model(frame_bgr, color_format="bgr")
10
        # ... draw, transform, etc.
11
        out.write_frame(frame_bgr)

1
pip install libreyolo[tracking]   # compatibility extra; tracking deps ship in base dev install

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreYOLO9c.pt")
4
5
for result in model.track(
6
    "clip.mp4",
7
    track_conf=0.25,
8
    iou=0.45,
9
    save=True,             # writes runs/track/<video_stem>.mp4 by default
10
    vid_stride=1,
11
):
12
    print(result.frame_idx, result.track_id)

1
from libreyolo import LibreYOLO, ByteTracker
2
from libreyolo.utils.video import VideoSource
3
4
model = LibreYOLO("LibreYOLO9c.pt")
5
tracker = ByteTracker()
6
7
with VideoSource("clip.mp4") as src:
8
    for frame_bgr, frame_idx in src:
9
        result = model(frame_bgr, color_format="bgr", conf=0.1)
10
        tracked = tracker.update(result)
11
12
        for i in range(len(tracked.boxes)):
13
            track_id = int(tracked.boxes.id[i])
14
            xyxy = tracked.boxes.xyxy[i].tolist()
15
            cls = int(tracked.boxes.cls[i])
16
            print(f"frame {frame_idx} - id {track_id} cls {cls} {xyxy}")

1
from libreyolo import ByteTracker, TrackConfig
2
3
cfg = TrackConfig(
4
    track_high_thresh=0.25,           # first-stage match threshold
5
    track_low_thresh=0.1,             # second-stage (low-conf recovery)
6
    new_track_thresh=0.25,            # minimum conf to start a new track
7
    match_thresh=0.8,                 # IoU cost cutoff (stage 1)
8
    match_thresh_low=0.5,             # IoU cost cutoff (stage 2)
9
    match_thresh_unconfirmed=0.7,     # IoU cost cutoff for unconfirmed tracks
10
    track_buffer=30,                  # frames to keep lost tracks before removal
11
    frame_rate=30,                    # scales track_buffer
12
    fuse_score=True,                  # multiply IoU by detection score
13
    minimum_consecutive_frames=1,     # frames to confirm a new track
14
)
15
tracker = ByteTracker(config=cfg)

1
tracker.reset()   # clears tracked / lost / removed lists and the ID counter

1
from libreyolo import LibreYOLO
2
3
# RF-DETR segmentation, heavily tested on single GPU
4
model = LibreYOLO("LibreRFDETRs-seg.pt")
5
result = model("photo.jpg")
6
7
# YOLO9 segmentation is available but experimental in v1.2.0
8
# model = LibreYOLO("LibreYOLO9c-seg.pt")
9
10
# Segmentation returns boxes + masks
11
print(result.boxes.xyxy)        # bounding boxes (N, 4)
12
print(result.boxes.cls)         # class IDs (N,)
13
print(result.masks.data.shape)  # (N, H, W) tensor of binary masks

1
# Raw bitmasks
2
result.masks.data        # tensor (N, H, W) - original image resolution
3
4
# Polygon contours (one ndarray of (M, 2) per instance)
5
result.masks.xy          # absolute pixel coords
6
result.masks.xyn         # normalized to [0, 1]
7
8
# Move / convert like Boxes
9
result.masks.cpu()
10
result.masks.numpy()

1
model("photo.jpg", save=True)

1
from libreyolo import LibreYOLO
2
3
# YOLO-NAS pose
4
model = LibreYOLO("LibreYOLONASs-pose.pt")
5
result = model("people.jpg")
6
7
# EdgeCrafter pose
8
# model = LibreYOLO("LibreECs-pose.pt")
9
10
# Per-person bbox + 17 keypoints
11
print(result.boxes.xyxy)          # person boxes (N, 4)
12
print(result.keypoints.xy.shape)  # (N, 17, 2) pixel coordinates

1
result.keypoints.xy        # (N, K, 2) absolute pixel coords
2
result.keypoints.xyn       # (N, K, 2) normalized to [0, 1]
3
result.keypoints.conf      # (N, K) per-keypoint confidence (None if model doesn't emit it)
4
result.keypoints.has_visible  # (N, K) bool - conf > 0
5
6
result.keypoints.cpu()
7
result.keypoints.numpy()

1
model("people.jpg", save=True)  # draws boxes + skeleton

1
pip install libreyolo[gaze]   # optional Google Drive helper for Gaze360 weights

1
from libreyolo import LibreYOLO
2
from libreyolo.models.l2cs.face import resolve_face_detector
3
4
# Gaze head
5
gaze = LibreYOLO("LibreL2CSr50.pt")
6
7
# Wire any LibreYOLO detector trained on faces
8
face = LibreYOLO("path/to/face-detector.pt")
9
gaze.face_detector = resolve_face_detector(face)
10
11
result = gaze("portrait.jpg")
12
print(result.boxes.xyxy)    # face boxes
13
print(result.gaze.data)     # (N, 2) tensor - pitch, yaw in radians

1
import math
2
3
for i in range(len(result.gaze)):
4
    pitch_rad, yaw_rad = result.gaze.data[i].tolist()
5
    pitch_deg = pitch_rad * 180.0 / math.pi
6
    yaw_deg = yaw_rad * 180.0 / math.pi
7
    print(f"face {i}: pitch={pitch_deg:.1f} deg, yaw={yaw_deg:.1f} deg")

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

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreRFDETRs.pt")
4
5
results = model.train(
6
    data="path/to/data.yaml",
7
    epochs=100,
8
    batch_size=4,            # NOTE: RF-DETR uses batch_size, not batch
9
    lr=1e-4,
10
    output_dir="runs/train/rfdetr_exp",
11
)

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/yolo9_exp",
7
    "best_checkpoint": "runs/train/yolo9_exp/weights/best.pt",
8
    "last_checkpoint": "runs/train/yolo9_exp/weights/last.pt",
9
}

1
# Load the checkpoint with the factory, then resume
2
model = LibreYOLO("runs/train/yolo9_exp/weights/last.pt")
3
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
model = LibreYOLO("LibreYOLO9c.pt")
2
results = model.train(cfg="configs/yolo9_finetune.yaml")
3
# Override individual fields:
4
# results = model.train(cfg="configs/yolo9_finetune.yaml", epochs=50)

1
# Effective batch 64 on a single GPU that only fits batch=8
2
model.train(data="coco128.yaml", batch=8, nbs=64)

1
# 4-GPU node
2
torchrun --nproc_per_node=4 train_yolo9.py
3
4
# Multi-node - see PyTorch's torchrun docs for --nnodes / --rdzv_endpoint

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("LibreYOLO9c.pt")
4
# Pass device="" (auto-detect) and let torchrun set the rank
5
model.train(data="coco128.yaml", epochs=300, batch=16)

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/precision": 0.68,
6
    "metrics/recall": 0.61,
7
    "metrics/precision(B)": 0.68, # bbox aliases
8
    "metrics/recall(B)": 0.61,
9
    "metrics/mAP50(B)": 0.721,
10
    "metrics/mAP50-95(B)": 0.489,
11
    "metrics/mAP_small": 0.291,
12
    "metrics/mAP_medium": 0.532,
13
    "metrics/mAP_large": 0.648,
14
    "metrics/AR1": 0.362,        # Average Recall (max 1 det)
15
    "metrics/AR10": 0.571,
16
    "metrics/AR100": 0.601,
17
    "metrics/AR_small": 0.387,
18
    "metrics/AR_medium": 0.641,
19
    "metrics/AR_large": 0.739,
20
    "speed/preprocess_ms": 1.2,
21
    "speed/inference_ms": 6.8,
22
    "speed/postprocess_ms": 0.9,
23
    "speed/total_ms": 8.9,
24
    "speed/total_s": 12.3,
25
    "speed/images_seen": 1382,
26
}

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")
15
16
# CoreML (.mlpackage, macOS runtime)
17
model.export(format="coreml")

1
path = model.export(
2
    format="onnx",            # "onnx", "torchscript", "tensorrt", "openvino", "ncnn", or "coreml"
3
    output_path="model.onnx", # output file (auto-generated if None)
4
    imgsz=640,                # input resolution (default: model's native)
5
    opset=None,               # ONNX opset (auto: 13, or 17 for wrappers that need it)
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
    allow_download_scripts=False, # allow data.yaml download hooks during calibration
15
    workspace=4.0,            # TensorRT workspace size (GB)
16
    min_batch=1,              # TensorRT dynamic profile minimum batch
17
    opt_batch=1,              # TensorRT dynamic profile optimal batch
18
    max_batch=8,              # TensorRT dynamic profile maximum batch
19
    hardware_compatibility="none", # TensorRT compatibility mode
20
    gpu_device=0,             # GPU device index for TensorRT
21
    trt_config=None,          # optional TensorRT YAML config path
22
    compute_units="all",      # CoreML routing: all, cpu_only, cpu_and_gpu, cpu_and_ne
23
    nms=False,                # CoreML embedded NMS where supported
24
    iou=0.45,                 # CoreML embedded NMS IoU threshold
25
    conf=0.25,                # CoreML embedded NMS confidence threshold
26
    verbose=False,            # verbose logging
27
)

1
from libreyolo import LibreYOLO
2
3
model = LibreYOLO("model.torchscript")
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
model = LibreYOLO("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 = LibreYOLO("model.onnx")
6
print(onnx_model.names)       # {0: "person", 1: "bicycle", ...}
7
print(onnx_model.nb_classes)  # 80

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

1
# Auto-detect (CUDA if available, else CPU)
2
model = LibreYOLO("model.onnx", device="auto")
3
4
# Force CPU
5
model = LibreYOLO("model.onnx", device="cpu")
6
7
# Force CUDA
8
model = LibreYOLO("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 LibreYOLO
2
3
model = LibreYOLO("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
model = LibreYOLO("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
model = LibreYOLO("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
model = LibreYOLO("model.mlpackage", compute_units="all")
4
5
result = model("image.jpg", conf=0.25, iou=0.45, save=True)
6
print(result.boxes.xyxy)

1
# Flagship: YOLO9
2
libreyolo predict model=yolo9-c source=image.jpg conf=0.25 save=true
3
4
# Flagship: RF-DETR
5
libreyolo predict model=rfdetr-s source=image.jpg save=true
6
7
# Video - saved under runs/detect/predict*/
8
libreyolo predict model=yolo9-c source=clip.mp4 save=true
9
10
# Tiled inference for very large images
11
libreyolo predict model=yolo9-c source=aerial.jpg tiling=true save=true
12
13
# Gaze (requires a face detector)
14
libreyolo predict model=LibreL2CSr50.pt source=portrait.jpg \
15
    --face-detector path/to/face.pt save=true