CV / DeepLab v3

DeepLabV3 RKNN

DeepLabV3 semantic segmentation accelerated by RKNN on reComputer RK3576 and RK3588.

8 descargas

Precisión

RKNN

Elige el dispositivo que estás usando. La guía de configuración y la documentación se actualizarán en consecuencia.

Plataforma

Motor de inferencia

Primeros pasos

Desplegar

sudo docker run --rm --privileged -p 8000:8000 \
  -v /dev/dri/renderD129:/dev/dri/renderD129 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-deeplabv3:latest \
  python3 web_service.py --platform rk3576 --model_path /app/model/deeplabv3.rknn \
  --sample_path /app/model/test.jpg --overlay_alpha 0.5 --camera_id -1 --host 0.0.0.0 --port 8000

API REST

Usa la API REST para ejecutar inferencia. Copia los comandos siguientes.

Curl

curl http://localhost:8080/v1/chat/completions -d '{
  "model": "deeplab-v3-rknn",
  "messages": [{"role": "user", "content": "Hello"}]
}'

Python

import requests

resp = requests.post(
    "http://localhost:8080/v1/chat/completions",
    json={"model": "deeplab-v3-rknn", "messages": [{"role": "user", "content": "Hello"}]},
)
print(resp.json())

Detalles del modelo

Inicio rápido

1. Instalar Docker

Ejecute los siguientes comandos en la placa de desarrollo para instalar Docker:

bash

# Docker
curl -fsSL https://get.docker.com -o get-docker.sh
# Aliyun
sudo sh get-docker.sh --mirror Aliyun
# systemd
sudo systemctl enable docker
sudo systemctl start docker

2. Ejecutar el proyecto (un comando y vista previa de doble modo)

Esta página documenta el servicio de segmentación semántica DeepLabV3 de reComputer-RK-CV. Admite imágenes fijas, cámaras, vídeo local en bucle, análisis de archivos MP4 subidos y una vista previa MJPEG con superposición.

Información del modelo

Propiedad	Valor
Modelo	`/app/model/deeplabv3.rknn`
Entrada	`513 x 513` RGB
Salida	Logits de 21 clases PASCAL VOC
Renderizado	Máscara Argmax con opacidad de superposición de color configurable

El servicio valida las disposiciones de salida NCHW y NHWC y restaura la máscara a la resolución de origen.

Paso A: Descargar las imágenes

bash

sudo docker pull ghcr.io/seeed-projects/recomputer-rk-cv/rk3588-deeplabv3:latest
sudo docker pull ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-deeplabv3:latest

Paso B: Ejecutar con un clic

Para RK3576:

bash

sudo docker run --rm --privileged -p 8000:8000 \
  -v /dev/dri/renderD129:/dev/dri/renderD129 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-deeplabv3:latest \
  python3 web_service.py --platform rk3576 \
  --model_path /app/model/deeplabv3.rknn \
  --sample_path /app/model/test.jpg --overlay_alpha 0.5 \
  --camera_id -1 --host 0.0.0.0 --port 8000

Para RK3588:

bash

sudo docker run --rm --privileged -p 8000:8000 \
  -v /dev/dri/renderD129:/dev/dri/renderD129 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3588-deeplabv3:latest \
  python3 web_service.py --platform rk3588 \
  --model_path /app/model/deeplabv3.rknn \
  --sample_path /app/model/test.jpg --overlay_alpha 0.5 \
  --camera_id -1 --host 0.0.0.0 --port 8000

Abra http://<BOARD_IP>:8000 o /docs. Para una cámara USB, asigne su nodo /dev/videoN y establezca --camera_id N. Para un vídeo local montado, use --video /data/input.mp4; el vídeo local tiene prioridad sobre la cámara.

🔌 Documentación de la API

1. Interfaz de segmentación (Predict)

Endpoint: POST /api/models/deeplabv3/predict

Parámetros de solicitud (Multipart/Form-Data):

Suba file y use los parámetros opcionales específicos del modelo para ajustar la salida.

Ejemplos de uso:

bash

curl -X POST "http://<BOARD_IP>:8000/api/models/deeplabv3/predict" \
  -F "file=@test.jpg" -F "overlay_alpha=0.65"

La respuesta indica el tamaño de la imagen, el tiempo de inferencia, la opacidad y todas las clases PASCAL VOC presentes con su número de píxeles. La última superposición renderizada está disponible en GET /api/video_feed.

Formato de respuesta (JSON):

json

{
  "success": true,
  "model": "deeplabv3",
  "inference_time": 0.052,
  "result": {
    "classes": [{"id": 15, "class": "person", "pixels": 18234}],
    "width": 1280,
    "height": 720,
    "overlay_alpha": 0.65
  }
}

2. Interfaz de configuración del sistema (Config)

GET/POST /api/config gestiona la opacidad global de la superposición. También se incluyen endpoints de estado, carga de MP4, estado del análisis, lista y descarga. Los modelos con otro número de clases requieren cambios correspondientes en las etiquetas y el código de procesamiento de salida.

3. Argumentos de línea de comandos

Argumento	Predeterminado	Descripción
`--platform`	Obligatorio	`rk3576` o `rk3588`.
`--model_path`	`model/deeplabv3.rknn`	Archivo RKNN de DeepLabV3.
`--sample_path`	`model/test.jpg`	Imagen de calentamiento y vista previa inicial.
`--overlay_alpha`	`0.5`	Opacidad inicial de la máscara, de 0 a 1.
`--camera_id`	`-1`	Cámara `N`, o `-1` para permitir solo cargas.
`--video`, `--video_path`	Ninguno	Vídeo local en bucle; prevalece sobre la cámara.
`--host` / `--port`	`0.0.0.0` / `8000`	Dirección del servicio y puerto del contenedor.

Al usar -p, cambie solo el lado del host si el puerto 8000 está ocupado. El servicio del contenedor debe permanecer en el puerto 8000 para su comprobación de estado.

Interfaz de vídeo en tiempo real (Video Feed)

Obtenga el último flujo MJPEG anotado para la vista previa en el navegador:

Endpoint: GET /api/video_feed
Ejemplo de uso: <img src="http://<BOARD_IP>:8000/api/video_feed">

🛠️ Guía para desarrolladores (recomendaciones de producción)

Detalles del procesamiento

La entrada se redimensiona a 513 x 513 y se convierte de BGR a RGB. El runtime acepta logits NCHW o NHWC, comprueba que la salida tenga 21 canales, restaura los logits a la resolución de origen, aplica argmax y superpone el mapa de colores PASCAL VOC. POST /api/video/analyze acepta un filename subido; los archivos de estado y resultado se exponen mediante los endpoints /api/video/*.

Compilar localmente

bash

docker build -f docker/rk3576/deeplabv3.dockerfile \
  -t rk3576-deeplabv3:local src/rk3576_deeplabv3

docker build -f docker/rk3588/deeplabv3.dockerfile \
  -t rk3588-deeplabv3:local src/rk3588_deeplabv3

Entradas y salidas

Input: image, video frame, or camera frame. Output: PASCAL VOC semantic mask, class pixel counts, and overlay.