How to Deploy YOLO Projects with reComputer AI Lab

How to Deploy YOLO Projects with reComputer AI Lab

Introduction to reComputer AI Lab

Platform Overview of reComputer AI Lab

reComputer AI Lab is an edge AI development platform launched by Seeed, built around an out-of-the-box experience. It pre-packages mainstream AI use cases including YOLO via customized system images and supports one-click deployment & inference execution, drastically lowering the learning curve for developers working with the AI Box product lineup.

Three hardware series are currently supported:

• RK Series: Rockchip RK3588 / RK3576
• R Series: Raspberry Pi paired with Hailo NPU
• J Series: NVIDIA Jetson

During hands-on testing, I noticed the official website lacks granular step-by-step guidance for full deployment workflows. This tutorial documents every critical detail of deploying models via AI Lab, enabling a smoother experience for future developers.

This guide focuses exclusively on the RK Series (RK3588 / RK3576).

Platform Navigation Layout

The AI Lab platform features six core navigation tabs; the four most critical sections are Models, Tools, Tutorials and Projects.

Their respective functions are outlined below:

• Model library with pre-built deployable models and core runtime scripts
• Central repository of all utility tools (including RKNN model converters, LLM benchmarking tools) paired with dedicated usage guides
• Hardware documentation and setup tutorials for supported edge devices
• Gallery of open-source projects built using the platform and compatible hardware, for learning and reference

Pre-integrated YOLO Models on AI Lab

YOLO (You Only Look Once) stands as one of the most iconic model families for object detection. First released in 2015, the series has evolved all the way to YOLO11. Its core innovation lies in single-shot detection: framing object detection as a regression task that requires only one forward pass per frame, delivering ultra-fast inference speeds.

reComputer AI Lab hosts four categories of pre-packaged model suites: CV, LLM, SOUND and VLM. The YOLO suite alone contains 18 pre-converted models spanning YOLOv5, YOLOv8 and YOLO11, broken down as follows:

• YOLO11 Family: 3 lightweight object detection variants trained on the COCO 80-class dataset

• YOLOv5 Family: 3 standard-sized object detection models, 1 ReLU-optimized detection variant, and 3 instance segmentation models (7 total; all trained on COCO 80)

• YOLOv8 Family: 1 human pose estimation model, 3 object detection variants, 3 instance segmentation models, and 1 rotated bounding box detection model (all detection & segmentation models trained on COCO 80)

• Additional Computer Vision Models: DeepLab v3, Depth Estimation, Person Attribute Recognition, U-Net, SegFormer, SCRFD, Depth Anything

Docker Environment Setup

All AI applications on reComputer AI Lab are distributed as Docker containers. Containerization ensures complete environment isolation between different workloads and eliminates manual dependency installation.

Install Docker

Run the following commands on your edge board terminal:

# Download official Docker installation script
curl -fsSL https://get.docker.com -o get-docker.sh
# Install via Alibaba Cloud mirror (recommended for users in China)
sudo sh get-docker.sh --mirror Aliyun
# Enable Docker auto-start on boot and launch the service
sudo systemctl enable docker
sudo systemctl start docker
# Verify successful installation
sudo docker --version

A successful installation will output the Docker version number, example output:

Docker version 24.0.7, build afdd53b

Configure Docker User Permissions

By default, only the root user can execute Docker commands. To avoid prefixing every command with sudo, add your current user to the Docker group:

sudo usermod -aG docker $USER

Re-login your user session for permission changes to take effect. Validate with:

docker ps

If no permission errors appear, the permission configuration is complete.

Model Deployment

Hardware Connection & Device Initialization

Flashing and basic debugging workflows for reComputer RK3576 are not covered in this software-focused tutorial. Refer to the official documentation via the link below for hardware flashing guidance: Official Hardware Connection Guide

Follow this hardware connection sequence:

• Input peripherals: Plug keyboard and mouse into available USB ports
• Display output: Connect the development board to a monitor via HDMI cable
• Network access: Insert an Ethernet cable into the Gigabit Ethernet port Camera module
• USB cameras: Directly plug into any USB port
• CSI cameras: Power off the board first, attach the camera ribbon cable, then power back on
• Power supply: Connect power last. The board will boot automatically with no physical power switch.

First Boot System Configuration

On initial startup, an interactive setup prompt will appear to set the root account password and other core system configurations:

New password:
Retype new password:

Once setup finishes, you will be directed to the graphical login screen. Log in using the username and password created during setup to access the desktop environment.

Pull the YOLO Docker Image

Now that you have reviewed the full YOLO model lineup on AI Lab, select your target model for deployment. This tutorial uses YOLO11-m as the demonstration model.

Click the Details button next to your chosen model to open the dedicated model page, split into three main sections:

• 1. Quick deployment & one-click inference launch scripts

• 2. Full setup documentation, including Docker installation steps, standalone image pull commands, and complete deployment/inference workflows

• 3. Inference API reference: multiple invocation methods, response format definitions and supplementary technical details

We will use the quick-start workflow from Section ① for fast model deployment and backend startup. Copy and execute the command below:

sudo docker run --rm --privileged --net=host \
 -e RKNN_LOG_LEVEL=0 \
 --device /dev/video1:/dev/video1 \
 --device /dev/dri/renderD129:/dev/dri/renderD129 \
 --device /dev/dri/renderD129:/dev/dri/renderD129 \
 -v /proc/device-tree/compatible:/proc/device-tree/compatible \
    ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-yolo11:latest \
 python web_detection.py --model_path model/yolo11m.rknn --video video/test.mp4

This command configures critical Docker runtime parameters:

• --rm: Automatically delete the container after shutdown
• --privileged: Grant full hardware access permissions

It handles full YOLO11-m image downloading and launches the local inference server.

The compressed container image size ranges from 1GB to 2GB; download duration depends on your network bandwidth. Key parameter breakdown:

• --device /dev/video1:/dev/video1: Maps the host camera device into the container for camera access. Modify the device index before the colon if multiple cameras are connected.
• ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-yolo11:latest: Official pre-built container image bundling RK3576 runtime, YOLO11 and RKNN toolkit
• python web_detection.py --model_path model/yolo11m.rknn --video video/test.mp4: Launch the web-based object detection service, load the pre-converted RKNN YOLO11-m model, and run inference on a sample test video

After container launch, the terminal will print output similar to the following:

Loading model...
Model loaded successfully
Starting web server on http://0.0.0.0:8000

Run Model Inference

Two methods are available to send inference requests and retrieve detection results:

• Terminal cURL Requests

# Real-time camera streaming inference
curl -X POST "http://127.0.0.1:8000/api/models/yolo11/predict" -F "realtime=true"
# Single-shot inference using default sample image
curl -X POST "http://127.0.0.1:8000/api/models/yolo11/predict"
# Run detection on a custom local image file
curl -X POST "http://127.0.0.1:8000/api/models/yolo11/predict" -F "file=@/home/cat/001.jpg"
# Run inference on a specific frame from a local video file
curl -X POST "http://127.0.0.1:8000/api/models/yolo11/predict" -F "video=@/home/cat/test.mp4" -F "timestamp=5.5"

http://127.0.0.1:8000/api/models/yolo11/predict is the core API endpoint for all YOLO inference requests. Adjust the request parameters above to match your use case.

• Programmatic Code Invocation

This approach is recommended if you plan to build custom applications and secondary logic around the detection pipeline. Select the invocation method that best fits your project requirements.

Sample API response format:

Customization & Modification Guide

Switch Pre-converted YOLO11 Models

Multiple YOLO11 variants are pre-installed inside the container for direct swapping:

# YOLO11n: Fastest inference speed
python web_detection.py --model_path model/yolo11n.rknn --camera_id 1
# YOLO11s: Balanced speed and accuracy
python web_detection.py --model_path model/yolo11s.rknn --camera_id 1
# YOLO11m: Higher detection precision
python web_detection.py --model_path model/yolo11m.rknn --camera_id 1

Model performance comparison table:

Restrict Detection to a Subset of COCO 80 Classes

By default, the YOLO model detects all 80 COCO object classes. You can limit detection to specific target categories to boost inference speed or filter irrelevant results with the steps below:

• Create a local file named class_config.txt, and list target class labels in the format: "person", "bicycle", "car", "motorbike"

Note: All pre-packaged YOLO models use the COCO 80-class label set.

• Add a volume mount flag -v to your Docker run command to map the local label config file into the container. Append the --class_path argument to the Python startup command to load the custom filter.

Full reference command:

sudo docker run --rm --privileged --net=host \
 -e PYTHONUNBUFFERED=1 \
 -v $(pwd)/class_config.txt:/app/class_config.txt \
 --device /dev/video1:/dev/video1 \lass_config.txt \
 --device /dev/dri/renderD129:/dev/dri/renderD129 \
 -v /proc/device-tree/compatible:/proc/device-tree/compatible \
 -v /proc/device-tree/compatible:/proc/device-tree/compatible \
    ghcr.io/Seeed-Projects/recomputer-rk-cv/rk3588-yolo:latest \
 python web_detection.py --model_path model/yolo11n.rknn --camera_id 1 --class_path class_config.txt

Important Note: This class filter only hides unwanted detection outputs. The underlying neural network is still trained on the full COCO 80-class dataset. To detect custom objects outside COCO labels, you must train a custom YOLO model from scratch.

Deploy Custom Trained YOLO Models

To detect domain-specific objects such as industrial components, safety helmets or open flames, train a custom YOLO model and convert it to RKNN format for edge deployment.

End-to-end workflow overview:

• Dataset Preparation: Annotate object detection datasets with LabelImg, CVAT or equivalent labeling tools
• Model Training: Train the custom detector via Ultralytics YOLO framework
• ONNX Export: Export the finished trained model to ONNX format
• RKNN Conversion: Convert ONNX weights to RKNN using RKNN Toolkit2
• Container Deployment: Replace the default.rknn model file inside the Docker container with your custom model

Official RKNN conversion documentation: https://github.com/airockchip/rknn-toolkit2

Video Stream Configuration

Step 1: Identify Camera Device Index

List all connected video devices with this command before deployment:

ls /dev/video*

Typical output:

/dev/video0 /dev/video1

Default camera index conventions:

• RK3588: Camera usually mapped to /dev/video1
• RK3576: Camera usually mapped to /dev/video0

Test each index one by one if the camera is unrecognized. Install v4l-utils to view detailed camera hardware specifications:

sudo apt install v4l-utils
v4l2-ctl --device=/dev/video0 --list-formats-ext
v4l2-ctl --device=/dev/video1 --list-formats-ext

The service returns an MJPEG real-time video stream overlaid with detection bounding boxes.

Stream Endpoint: GET /api/video_feed

Embed stream in HTML web pages:

<img src="http://192.168.1.100:8000/api/video_feed">

Consume stream via Python OpenCV:

import cv2
stream_url = "http://192.168.1.100:8000/api/video_feed"
cap = cv2.VideoCapture(stream_url)
while True:
    ret, frame = cap.read()
    if not ret:
        break
    cv2.imshow("Detection", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

Inference Parameter Tuning Guide

Confidence Threshold (obj_thresh / conf)

Function: Filters out detection bounding boxes with confidence scores below the defined threshold.

Tuning reference table:

Real-world scenario examples:

• Security monitoring: Set 0.3–0.4 to minimize false alerts during off-hours
• Footfall counting: Set 0.2–0.3 to avoid undercounting pedestrians (statistical corrections applied post-inference)
• Industrial quality inspection: Set ≥0.5 to eliminate false defect detections

NMS IOU Threshold (nms_thresh / iou)

• Function: Non-Max Suppression (NMS) removes duplicate overlapping bounding boxes for the same target object. NMS retains the box with the highest confidence score and discards overlapping alternatives.

Tuning reference table:

Adjustment guidance:

• Lower NMS threshold to 0.3–0.4 if separate adjacent objects are incorrectly merged into one detection box
• Raise NMS threshold to 0.5–0.6 if duplicate boxes appear for a single object due to partial occlusion or pose variation

Dynamic Global Parameter Update Example

import requests
base_url = "http://192.168.1.100:8000"
# Profile 1: High precision mode (reduce false detections)
requests.post(f"{base_url}/api/config", json={
"obj_thresh": 0.5,
"nms_thresh": 0.4
})
# Profile 2: High recall mode (minimize missed objects)
requests.post(f"{base_url}/api/config", json={
"obj_thresh": 0.2,
"nms_thresh": 0.5
})
# Profile 3: Dense crowd detection profile
requests.post(f"{base_url}/api/config", json={
"obj_thresh": 0.3,
"nms_thresh": 0.35
})

Single-Request Temporary Threshold Override

Pass confidence and IOU parameters directly in individual inference requests to override global config temporarily:

curl -X POST "http://192.168.1.100:8000/api/models/yolo11/predict" \
 -F "conf=0.6" \g" \
 -F "iou=0.3"6" \
    -F "iou=0.3"

Conclusion

This tutorial documents the complete end-to-end workflow for full YOLO object detection deployment on reComputer AI Lab, covering:

Hardware preparation and peripheral connection

• System setup: SD card flashing & first-boot configuration
• Network configuration: Wired Ethernet & remote SSH access
• Docker environment installation, permission setup and mirror acceleration
• Full model deployment pipeline: image pull, container launch, parameter explanation
• API reference: inference endpoints, dynamic config API and real-time video streaming
• Inference parameter tuning: confidence threshold, NMS IOU threshold and scenario-based tuning advice
• Customization extensions: switching pre-built models, class filtering, and custom model deployment

reComputer AI Lab’s core advantage lies in its out-of-the-box design. Docker containerization abstracts low-level hardware and dependency complexity, letting developers focus entirely on application business logic.

If you encounter technical issues, visit the official community forum for support: https://forum.seeedstudio.com/c/recomputer-ai-lab

Happy developing!