CV / RetinaFace

RetinaFace

reComputer RK3588

Détection de visages et estimation de cinq points de repère avec RetinaFace accélérées par RKNN.

52 téléchargements

Précision

RKNN

Choisissez l'appareil que vous utilisez. Le guide de configuration et la documentation seront mis à jour en conséquence.

Plateforme

Taille

Moteur d'inférence

Pour commencer

Armbian 26.8.7 Gnome ou version ultérieure avec OTA overlayroot : Configurez le stockage de Docker avant de lancer des conteneurs pour éviter les erreurs de montage overlay.

Déployer

sudo docker run --rm --privileged --net=host -e RKNN_LOG_LEVEL=0 \
  --device /dev/dri/renderD129:/dev/dri/renderD129 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3588-retinaface:latest \
  python web_service.py --platform rk3588 --model_dir /app/model --camera_id -1 --host 0.0.0.0 --port 8000

API REST

Utilisez l'API REST pour exécuter l'inférence. Copiez les commandes ci-dessous.

Curl

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

Python

import requests

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

Détails du modèle

Armbian 26.8.7 Gnome ou version ultérieure avec OTA overlayroot : Configurez le stockage de Docker avant de lancer des conteneurs pour éviter les erreurs de montage overlay.

Démarrage rapide

1. Installer Docker

Exécutez les commandes suivantes sur la carte de développement pour installer 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. Exécuter le projet (une commande, aperçu double mode)

Cette page documente le service RetinaFace de reComputer-RK-CV. Il détecte les visages et cinq points faciaux avec accélération RKNN et fournit les modes image, caméra, vidéo locale et vidéo téléversée.

Informations sur le modèle

Propriété	Valeur
Modèle actif	`model/retinaface_mobile.rknn`
Alternative fournie	`model/retinaface_resnet50.rknn`
Entrée	RGB letterbox `320 x 320`
Sortie	Boîte du visage, confiance et cinq points
NMS	Seuil IoU fixe de `0.5`

Étape A : télécharger les images

bash

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

Étape B : exécuter en un clic

Pour RK3576:

bash

sudo docker run --rm --privileged --net=host \
  -e PYTHONUNBUFFERED=1 -e RKNN_LOG_LEVEL=0 \
  --device /dev/dri/renderD129:/dev/dri/renderD129 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-retinaface:latest \
  python web_service.py --platform rk3576 --model_dir /app/model \
  --camera_id -1 --host 0.0.0.0 --port 8000

Pour RK3588:

bash

sudo docker run --rm --privileged --net=host \
  -e PYTHONUNBUFFERED=1 -e RKNN_LOG_LEVEL=0 \
  --device /dev/dri/renderD129:/dev/dri/renderD129 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3588-retinaface:latest \
  python web_service.py --platform rk3588 --model_dir /app/model \
  --camera_id -1 --host 0.0.0.0 --port 8000

Ouvrez http://<BOARD_IP>:8000 ou /docs. Mappez /dev/videoN et utilisez --camera_id N pour une caméra, ou passez --video video/test.mp4 pour une vidéo locale.

🔌 Documentation de l’API

1. Interface de détection des visages (Predict)

Endpoint : POST /api/models/retinaface/predict

Paramètres de requête (Multipart/Form-Data) :

Téléversez file ; threshold définit la confiance des visages pour cette requête.

Exemples d’utilisation :

bash

curl -X POST "http://<BOARD_IP>:8000/api/models/retinaface/predict" \
  -F "file=@test.jpg" -F "threshold=0.5"

Chaque résultat contient confidence, box sous la forme [x1,y1,x2,y2] et cinq landmarks. Mettez à jour le seuil de l’aperçu/vidéo avec POST /api/config et un JSON tel que {"threshold":0.5}.

Format de réponse (JSON) :

json

{
  "success": true,
  "model": "retinaface",
  "result": {
    "count": 1,
    "faces": [
      {
        "confidence": 0.96,
        "box": [120, 80, 310, 290],
        "landmarks": [[166, 145], [255, 144], [210, 190], [176, 232], [247, 231]]
      }
    ]
  }
}

2. Interface de configuration système (Config)

Obtenir la configuration actuelle

Endpoint: GET /api/config

Mettre à jour la configuration système

Endpoint: POST /api/config
JSON: {"threshold":0.5}

Le champ générique topk est réservé à la compatibilité du service et n’est pas utilisé. NMS utilise un seuil IoU fixe de 0.5.

Endpoint	Fonction
`GET /api/health`	Plateforme, noms des modèles et état de préparation.
`GET /api/video_feed`	Dernières boîtes de visage et points au format MJPEG.
`POST /api/video/upload`	Téléverser un MP4.
`POST /api/video/analyze`	Analyser un `filename` téléversé.
`GET /api/video/status`	Progression et erreurs.
`GET /api/video/list`	Fichiers MP4 téléversés et générés.
`GET /api/video/download/{filename}`	Télécharger un résultat.

Le constructeur upstream charge actuellement retinaface_mobile.rknn explicitement. L’utilisation de retinaface_resnet50.rknn exige de modifier task_runtime.py et de vérifier la même disposition à trois sorties ; un paramètre de commande Docker ne suffit pas. Les images sont letterboxées en 320 x 320, converties de BGR en RGB, décodées avec les boîtes a priori et cinq points, restaurées dans les coordonnées source, filtrées par confiance et traitées par NMS.

3. Arguments de ligne de commande

Argument	Valeur par défaut	Description
`--platform`	Obligatoire	`rk3576` ou `rk3588`.
`--model_dir`	`model`	Fichiers RKNN RetinaFace et `test.jpg`.
`--camera_id`	`-1`	Indice de caméra ; `-1` désactive la capture.
`--video`, `--video_path`	Aucun	Vidéo locale en boucle ; remplace la caméra.
`--host` / `--port`	`0.0.0.0` / `8000`	Adresse et port du service.

RKNN_LOG_LEVEL=0 masque les messages d’initialisation de forme statique confirmés comme inoffensifs. Retirez-le pour diagnostiquer le démarrage RKNN.

Interface de flux vidéo en temps réel (Video Feed)

Obtenez le dernier flux MJPEG annoté pour l’aperçu dans le navigateur :

Endpoint: GET /api/video_feed
Exemple d’utilisation: <img src="http://<BOARD_IP>:8000/api/video_feed">

🛠️ Guide du développeur (recommandations de production)

Compiler localement

bash

docker build -f docker/rk3576/retinaface.dockerfile \
  -t rk3576-retinaface:local src/rk3576_retinaface

docker build -f docker/rk3588/retinaface.dockerfile \
  -t rk3588-retinaface:local src/rk3588_retinaface

Entrées et sorties

Input: image, video frame, or camera frame. Output: face boxes, confidence scores, and five landmarks.