Outcome and proof
The working prototype runs its detector on a Jetson Nano at 100 ms or less per frame. Inference happens where the camera is, without sending the video stream to a remote datacenter.
Context and problem
An early-warning detector is useful only if the alert arrives quickly. A Jetson Nano has a fraction of the compute available during model training, so the deployment problem was to fit a capable detector into a tight on-device inference budget.
My role and responsibility
I trained the smoke-and-fire detector and owned the deployment optimization: conversion, reduced-precision execution, and the live frame-processing path on the target device.
Solution and architecture
- Capture — receive live video frames from the camera.
- Preprocess — resize and normalize frames for the detector.
- Infer — execute the YOLO model through a hardware-targeted TensorRT engine.
- Signal — pass detections to the alerting path.
Key engineering decisions
Compile for the target hardware
The trained model is converted into a TensorRT engine for the Nano rather than run through a generic training runtime.
Reduce precision deliberately
FP16 and INT8 execution reduce inference cost. Public claims are limited to the verified latency result because accuracy deltas and test-set quality figures are not available for disclosure.
Tune the full frame path
Decode, preprocessing, and inference are treated as one latency path so the GPU does not sit idle waiting for frame handling.
Verified results
- Inference latency: 100 ms or less per frame
- Target hardware: Jetson Nano
- Deployment state: working prototype on device
Visual evidence
The diagram above documents the on-device route from live video to alert output.
Technology stack
YOLO, TensorRT, Jetson Nano, PyTorch, OpenCV, and reduced-precision inference.