# How to Deploy YOLO Projects with reComputer AI Lab > Source: > Published: 2026-06-25 08:37:12+00:00 **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 scriptcurl -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 servicesudo systemctl enable dockersudo systemctl start docker# Verify successful installationsudo 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](https://sensecraft.seeed.cc/ai-lab/tutorials/rk/getting-start/hardware-connection) 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 successfullyStarting 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 inferencecurl -X POST "http://127.0.0.1:8000/api/models/yolo11/predict" -F "realtime=true"# Single-shot inference using default sample imagecurl -X POST "http://127.0.0.1:8000/api/models/yolo11/predict"# Run detection on a custom local image filecurl -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 filecurl -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](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 speedpython web_detection.py --model_path model/yolo11n.rknn --camera_id 1# YOLO11s: Balanced speed and accuracypython web_detection.py --model_path model/yolo11s.rknn --camera_id 1# YOLO11m: Higher detection precisionpython 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](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-utilsv4l2-ctl --device=/dev/video0 --list-formats-extv4l2-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:** ``` ``` **Consume stream via Python OpenCV:** ``` python import cv2stream_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'): breakcap.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** ``` python import requestsbase_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 profilerequests.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" ``` ConclusionThis 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](https://forum.seeedstudio.com/c/recomputer-ai-lab) Happy developing! [Read more](javascript:void(0)) [Seeed Studio](https://sensecraft.seeed.cc/ai-lab).