How to Build a Retail Shelf Monitoring Camera System with Edge AI

This guide walks you through building a complete real-time out-of-stock detection system — a shelf camera that runs AI inference on-device, detects when products are missing, and fires structured alerts to your store operations stack. Every step maps to real CamThink hardware and open-source tooling. By the end, you'll have a working system you can iterate on, scale across shelves, and deploy to production.

This is part of CamThink's Retail Shelf Monitoring guide series. If you want to understand the business case and architecture options before diving in, start there. If you're ready to build — read on.

Getting the camera position right is the single most important determinant of model performance. A great model trained on poorly-framed images will underperform a mediocre model with consistent, well-framed images. Spend the time here — it pays off in every subsequent step.

Choosing the Right FOV Lens

Mounting & Positioning Guidelines

• Height: Mount at the middle shelf rail, roughly eye-level (100–130cm). This gives the most consistent product-facing view — the same angle a shopper sees.
• Distance from shelf: 50–90cm from the shelf face works well for the 88° lens. Closer gives higher resolution per product; farther gives wider coverage per camera.
• Tilt angle: Keep the camera facing the shelf straight-on (0–5° tilt). Severe downward angles distort product geometry and reduce detection accuracy by 10–15%.
• Lighting: Avoid positions where a ceiling spot creates a moving shadow across the shelf face. If the store uses LED shelf strips, these dramatically improve model consistency.

First Boot & Network Connection

# 1. Power up the NE301 (USB-C or PoE)
# 2. Hold button 2–3s → "NE301_[MAC6]" AP appears in Wi-Fi list
# 3. Connect to AP, then navigate to Web UI:

$ open http://192.168.10.10      # default Web UI address
# Default credentials: admin / admin123

# 4. In Web UI → Settings → Network → add your store Wi-Fi SSID + password
# 5. Reboot; NE301 joins your LAN and gets a DHCP address
# 6. Find the assigned IP in your router's DHCP table, reconnect to Web UI

CamThink AI Tool Stack is a self-hosted, open-source end-to-end AI development environment built specifically for NE301. It covers every step from image collection through annotation, training, quantization, and deployment — running entirely on your local machine. No data leaves your premises.

Install and Start AI Tool Stack

# Prerequisites: Docker + Docker Compose v2.0+

# Clone the repository
$ git clone https://github.com/camthink-ai/AIToolStack.git
$ cd AIToolStack

# Pull the NE301 quantization environment (needed for model export)
$ docker pull camthink/ne301-dev:latest

# Start AI Tool Stack services
$ docker compose up -d

# Open Web UI
$ open http://localhost:8000

Bind NE301 and Capture Shelf Images

In the AI Tool Stack Web UI:

• Create a new project named shelf-monitor-[your-shelf-id]
• Go to Data Sources → Bind Device, enter the NE301's IP address
• Click Start Collection — the NE301 will begin pushing live images to the project

What images to capture:

• Fully stocked shelf (baseline — "this is what correct looks like")
• 75%, 50%, 25% fill levels — simulate progressive depletion
• Completely empty shelf — critical for high-confidence gap detection
• Multiple times of day — morning shadow, midday flat light, evening overhead
• Common occlusion scenarios — misaligned products, labels turned sideways

With your dataset collected, the next step is training a YOLOv8-based object detection model and quantizing it to INT8 format for the NE301's Neural-ART NPU. AI Tool Stack handles both steps — you do not need to write any training code or deal with TensorFlow Lite directly.

Annotation: Two Classes for Shelf Gap Detection

In the AI Tool Stack annotation interface, create two classes:

• product_present — draw bounding boxes around visible product facings on the shelf
• shelf_gap — draw bounding boxes around empty shelf areas where products should be

Use Auto Annotation once you've manually labeled 20–30 images: the built-in inference backend pre-labels the remaining images. Review and correct the auto-labels, then export the verified dataset.

Training with YOLOv8

# Inside AI Tool Stack or standalone — uses ultralytics
# imgsz=256 is required for NE301 NPU quantization

$ yolo detect train \
    data=shelf_gap.yaml \
    model=yolov8n.pt \
    epochs=100 \
    imgsz=256 \
    device=0          # device=cpu if no GPU

# Expected output on a 300-image dataset:
Epoch 100/100:  box_loss=0.82  cls_loss=0.41  dfl_loss=0.95
mAP50: 0.943   mAP50-95: 0.671
Training complete. Results saved to runs/detect/train/

One-Click Quantization to NE301 Model Package

# In AI Tool Stack Web UI → Model Management → Export NE301 Package
# OR via CLI inside the ne301-dev container:

$ docker run --rm \
    -v "$(pwd)/runs/detect/train/weights:/workspace/weights" \
    -v "$(pwd)/export:/workspace/export" \
    camthink/ne301-dev:latest \
    yolo export \
        model=/workspace/weights/best.pt \
        format=tflite \
        imgsz=256 \
        int8=True \
        data=shelf_gap.yaml \
        fraction=0.2

# AI Tool Stack wraps the .tflite + config JSON into a deployable .zip
✔ Exported: shelf_gap_v1_ne301.zip  (ready to upload to NE301)

The exported shelf_gap_v1_ne301.zip is a complete NE301 model package — it includes the quantized .tflite model, the class label JSON, and the inference configuration file. No further configuration needed before deployment.

Deploying the model to the NE301 is done entirely through the Web UI — no terminal access or firmware flashing required for model updates.

• Open the NE301 Web UI (http://[ne301-ip])
• Navigate to Application Management → Upload Model
• Drag and drop the shelf_gap_v1_ne301.zip package
• Click Apply — the NE301 reboots into the new model (takes ~30s)
• Go to Live View — you should see bounding boxes appearing around detected products and any gaps on the shelf

Configure Inference Thresholds

{
  "model":            "shelf_gap_v1_ne301",
  "confidence_min":   0.55,   // minimum detection confidence to report
  "nms_iou":          0.45,   // non-max suppression overlap threshold
  "alert_classes":    ["shelf_gap"],
  "alert_threshold": {
    "shelf_gap": {
      "min_area_pct":   5,     // gaps smaller than 5% of frame are ignored
      "fill_pct_alert": 30    // fire alert when fill % drops below 30%
    }
  },
  "inference_fps":     5,     // 5 FPS adequate for shelf monitoring; saves power
  "power_mode":       "performance"
}

The NE301 outputs detection results over MQTT. This is where your shelf monitoring system connects to the real world — routing gap detection events to store associates, dashboards, or ERP systems.

Start a Local MQTT Broker

$ docker run -d \
    --name mosquitto \
    -p 1883:1883 \
    -p 9001:9001 \
    eclipse-mosquitto:latest

# Verify broker is running
$ mosquitto_sub -h localhost -t "#" -v   # subscribe to all topics

Configure NE301 MQTT Output

In the NE301 Web UI, go to Settings → MQTT:

• Broker: 192.168.1.x (your Docker host's LAN IP — not localhost)
• Port: 1883
• Uplink topic: shelf/[your-shelf-id]/events (e.g., shelf/aisle3-bay2/events)
• Publish on: Detection event (not continuous — only fires when a gap is detected)

Example Alert Payload

{
  "device_id":    "NE301_A3F2C1",
  "shelf_id":     "aisle3-bay2-left",
  "timestamp":    "2025-03-01T09:47:12Z",
  "event":        "shelf_gap_detected",
  "detections": [
    {
      "class":        "shelf_gap",
      "confidence":   0.94,
      "bbox":         [320, 140, 580, 390],
      "fill_pct":     14
    }
  ],
  "image_url":    "http://192.168.1.45/snap/20250301_094712.jpg"
}

Home Assistant Automation for Store Alerts

alias: "Shelf OOS Alert — Aisle 3"
trigger:
  - platform: mqtt
    topic: "shelf/aisle3-bay2-left/events"
condition:
  - condition: template
    value_template: "{{ trigger.payload_json.detections[0].fill_pct | int < 30 }}"
action:
  - service: notify.mobile_app_store_phone
    data:
      title:   "⚠️ Low Stock Alert"
      message: >
        Aisle 3, Bay 2 Left is at
        {{ trigger.payload_json.detections[0].fill_pct }}% fill.
        Please restock.
      data:
        image: "{{ trigger.payload_json.image_url }}"
        # attaches the shelf snapshot to the notification

The first deployed model is a starting point, not a finished product. Plan for one to two weeks of live operation before declaring the system production-ready. The data you collect in this phase is the most valuable training data you'll ever have.

• False positive log Record every alert that fired incorrectly — a box shadow misidentified as a gap, a product with non-standard packaging. Add these as product_present annotations and retrain.
• False negative log Walk the shelf daily and note any gaps the system missed. Capture images of these missed cases, annotate as shelf_gap, and add to training set.
• Threshold tuning If false positive rate is high, increase confidence_min from 0.55 to 0.65. If you're missing real gaps, decrease it or lower fill_pct_alert.
• Lighting variation Note whether performance drops at specific times of day (opening, closing, late-afternoon sun). Capture images at those times and add to training set.
• Response time KPI Measure the time from gap occurrence to associate notification. Target: under 15 minutes for fast-moving SKUs. Adjust inference frequency (inference_fps) if needed.

Once your single-shelf prototype is validated, the path to full-store coverage is straightforward. The NE301's OTA model update capability means scaling from 1 to 30 cameras doesn't require physical access to each device.