Basic Object Detection

from fotonet import Fotonet
import cv2

# Load model checkpoint
model = Fotonet("fotonet_last.pt")

# Read image and run inference (conf=0.25)
frame = cv2.imread("sample.jpg")
results = model.predict_bgr(frame, imgsz=640, conf=0.25)

# Print detected bounding boxes and scores
for box in results[0].boxes:
    print(f"Class: {box.cls} | Score: {box.conf:.3f} | BBox: {box.xyxy}")

Related Sections

Official Checkpoint Lineup

All weights conform strictly to Schema 3 invariance (1,723,672 training parameters; 1,698,564 deployment parameters):

Checkpoints are written continuously during training, so the fingerprint above refers to the snapshot used for the currently published benchmark figures. Weights are distributed through GitHub Releases and never committed to the repository.

Strict Mathematical Contract

In fotonet, EXPERIMENT_SCHEMA = 3 is the permanent standard. All proposed code refactors must guarantee:

• Output tensor shape strictly preserved: [Batch, 8400, nc + 4] (where nc = 80, 4 = xywh coordinates).
• Exact integer channel counts across stages: Backbone [64, 96, 160], Neck [64, 96, 160].
• No conversion scripts required when resuming training or loading public weights.
• Unvarying architecture_fingerprint hash across all platforms.

Design Principles

Traditional transformer and depthwise architectures incur significant latency overhead on edge memory busses. fotonete utilizes dense residual blocks operating with explicit integer channels, keeping compute density high while maintaining a small GPU footprint.

One-to-One vs One-to-Many Dual Training

During training, two branches operate simultaneously:

• Auxiliary One-to-Many Branch: Provides rich gradient supervision during early epochs for rapid convergence.
• Deploy One-to-One Branch: Matches exactly 1 prediction per ground-truth bounding box via Hungarian bipartite matching.

At deployment time, the auxiliary branch is completely discarded with zero cost. Predictions from the one-to-one head are 100% deterministic and require no NMS heuristics.

Fotonet(weights_path)

Initializes the deploy graph and auto-detects CUDA / CPU availability.

Methods:

• model.predict_bgr(image_or_path, imgsz=640, conf=0.25): Primary entrypoint for OpenCV BGR images or file paths.
• FastPredictor(model, device="cuda", half=True): High-throughput path with pinned memory and a reusable staging buffer; predict(frame) returns an (N, 6) array of x1, y1, x2, y2, score, class.
• model.export(format="onnx", **kwargs): Export engine supporting ONNX, TensorRT, and CoreML.

Pinned Memory & CUDA Stream Binding

By pinning host memory and reusing one staging buffer and one GPU tensor per stream, per-frame allocation and host-device roundtrips disappear, bringing end-to-end latency down toward the pure GPU-pass time (see the Benchmarks section for current measured figures).

What the measured pipeline covers

The figures below are TensorRT stage timings, not PyTorch and not browser ONNX timings. Each timing run used a fresh process, a 1-second warmup, and 1,000 measured inferences. The engine used FP16 where TensorRT selected it; TensorRT reports the resulting precision as FP32+FP16. H2D, enqueue, GPU compute, and D2H are independently measured and can overlap, so they should not be added together to recreate E2E latency.

Fotonete stage speeds

VRAM is TensorRT's execution-context device memory. It does not include the entire CUDA process, desktop compositor, or other applications using the GPU.

Fotonete vs YOLO26n

Both systems were compiled as static FP16 TensorRT engines at 640 x 640 and measured on the same RTX 4060 using the same 15-run protocol. The comparison is runtime-only; it does not change or imply an accuracy claim.

Python Export API

from fotonet import Fotonet

model = Fotonet("fotonet_best.pt")
model.export(
    format="tensorrt",
    path="fotonete.engine",
    imgsz=640,
    batch=1,
    half=True,
    dynamic=False,
    device="cuda",
)

1-Line CLI Export

fotonet export model=fotonet_last.pt format=onnx path=fotonete.onnx opset=17

Cost Matching Equation

The bipartite matching cost between prediction $i$ and ground truth $j$ is formulated as:

Cost(i, j) = λ_cls · FL(p_i, c_j) + λ_box · L1(b_i, b_j) + λ_siou · SIoU(b_i, b_j)

Automatic Resume

fotonet train model=fotonete data=my_dataset.yaml resume=fotonet_last.pt

Test Bench Specifications

• CPU: 13th Gen Intel Core i3-13100F · 4 cores / 8 threads
• GPU: NVIDIA GeForce RTX 4060 (8 GB VRAM) · driver 610.74
• Memory: 16 GB system RAM
• Storage: WDC WDS480G2G0C SSD · 395 MB/s measured sequential read
• Runtime: Windows 11 · CUDA 12.8 · PyTorch 2.11.0+cu128
• Load: Benchmarks are recorded in a clean process with no training job running. Timing, memory, and cold-start figures are averages of 15 independent runs. Peer models (YOLO26n and D-FINE N) are evaluated on the same machine and COCO val2017 sample; nothing is quoted from vendor pages.