Utiliser l'accélérateur USB Google Coral avec le reComputer RK3576

L'accélérateur USB Google Coral ajoute un coprocesseur Edge TPU à un hôte via USB. Ce tutoriel présente une méthode testée pour le connecter à un reComputer RK3576, vérifier l'état de l'USB, installer le runtime Edge TPU, exécuter un modèle TensorFlow Lite compilé pour Edge TPU et reproduire un benchmark de latence.

Portée du benchmark : le résultat de cette page compare le Edge TPU de Coral à une référence TensorFlow Lite sur CPU à huit threads. Il ne teste pas le NPU intégré du RK3576. Comparer les deux accélérateurs exigerait de déployer le même modèle et un prétraitement équivalent à la fois via les chaînes d'outils Edge TPU et RKNN.

Environnement de test

C'est la configuration utilisée pour les mesures ci-dessous, et non une déclaration de versions minimales prises en charge. La documentation du USB Accelerator de Coral indique que Linux Armv8 dérivé de Debian est pris en charge et recommande l'USB 3 pour de meilleures performances.

Connexion matérielle

Utilisez un port hôte USB 3 et un câble de bonne qualité. Les photographies suivantes montrent le reComputer RK3576, l'accélérateur USB Coral et le câble utilisés pour le test.

Connectez le Coral à l'un des ports USB 3 du RK3576. Le gros plan ci-dessous montre la connexion réelle du test.

Rechercher et vérifier le Coral

Exécutez la commande suivante pour rechercher l'un des deux identifiants USB utilisés par l'accélérateur :

lsusb | grep -Ei '1a6e:089a|18d1:9302|Google|Global Unichip'

Ces identifiants décrivent deux états normaux de l'appareil :

Vérifiez la vitesse USB négociée :

lsusb -t

Pour une connexion USB 3, la branche de l'accélérateur devrait rapporter 5000M. Une entrée 480M indique de l'USB 2.

Pour inspecter les événements récents d'énumération et de firmware, exécutez :

sudo dmesg | grep -E 'device firmware changed|New USB device found' | tail -n 10

La capture d'écran réelle ci-dessous montre l'accélérateur testé en mode runtime comme 18d1:9302, connecté à 5000M, avec l'énumération DFU antérieure et les messages de changement de firmware visibles dans dmesg.

Voir 1a6e:089a juste après avoir connecté l'accélérateur est normal. Le chargement du délégué Edge TPU peut charger le firmware de l'appareil et le faire se réénumérer en 18d1:9302.

Installer le runtime Edge TPU

Utilisez le dépôt Linux de Coral et installez le runtime standard :

echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo apt-get update
sudo apt-get install libedgetpu1-std

Si l'accélérateur était déjà connecté pendant l'installation, débranchez-le et rebranchez-le une fois pour que la règle udev nouvellement installée prenne effet.

libedgetpu1-std utilise la fréquence de fonctionnement réduite. Coral fournit également libedgetpu1-max comme runtime alternatif à fréquence maximale, mais il augmente la consommation d'énergie et peut rendre le boîtier métallique très chaud. Les deux paquets de runtime ne peuvent pas être installés en même temps.

Créer l'environnement Python

La carte testée utilisait Python 3.11 et l'API Python de TensorFlow Lite directement plutôt que PyCoral. Créez un environnement isolé et installez les paquets utilisés par les exemples :

sudo apt-get install python3-venv
python3 -m venv /tmp/coral-venv
/tmp/coral-venv/bin/pip install --upgrade pip
/tmp/coral-venv/bin/pip install tflite-runtime opencv-python-headless

Vérifiez que Python peut charger le délégué Edge TPU :

/tmp/coral-venv/bin/python -c "from tflite_runtime.interpreter import load_delegate; print(load_delegate('libedgetpu.so.1.0'))"

La commande devrait afficher un objet délégué TensorFlow Lite. Elle peut aussi déclencher le passage de 1a6e:089a à 18d1:9302 au premier accès.

Télécharger les ressources de test

Créez un répertoire de travail et téléchargez les modèles Edge TPU et CPU appariés de Google ainsi que l'image d'exemple :

mkdir -p /tmp/coral-test
cd /tmp/coral-test

curl -fL -o model.tflite \
  https://raw.githubusercontent.com/google-coral/test_data/master/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite
curl -fL -o model_cpu.tflite \
  https://raw.githubusercontent.com/google-coral/test_data/master/mobilenet_v2_1.0_224_inat_bird_quant.tflite
curl -fL -o labels.txt \
  https://raw.githubusercontent.com/google-coral/test_data/master/inat_bird_labels.txt
curl -fL -o parrot.jpg \
  https://raw.githubusercontent.com/google-coral/test_data/master/parrot.jpg

parrot.jpg est l'image d'exemple du dépôt public google-coral/test_data de Google ; ce n'est pas une photographie créée pour ce tutoriel. Le modèle Edge TPU a été compilé pour l'accélérateur, tandis que model_cpu.tflite est sa contrepartie TensorFlow Lite sans Edge TPU.

Exécuter une inférence minimale sur Edge TPU

Enregistrez ce qui suit sous /tmp/coral-test/inference.py :

import cv2
from tflite_runtime.interpreter import Interpreter, load_delegate

delegate = load_delegate("libedgetpu.so.1.0")
interpreter = Interpreter(
    model_path="model.tflite",
    experimental_delegates=[delegate],
)
interpreter.allocate_tensors()

input_info = interpreter.get_input_details()[0]
image = cv2.cvtColor(cv2.imread("parrot.jpg"), cv2.COLOR_BGR2RGB)
height, width = input_info["shape"][1:3]
tensor = cv2.resize(image, (int(width), int(height))).astype(input_info["dtype"])

interpreter.set_tensor(input_info["index"], tensor[None, ...])
interpreter.invoke()
print("Edge TPU inference completed")

Exécutez-le depuis le répertoire de travail :

cd /tmp/coral-test
/tmp/coral-venv/bin/python inference.py

Vérification facultative des performances

Le benchmark effectue 10 invocations de préchauffage suivies de 100 invocations chronométrées pour chaque chemin. Il chronomètre uniquement Interpreter.invoke(), y compris l'exécution du délégué et la communication hôte-appareil associée. Il exclut l'initialisation du modèle/délégué, le chargement de l'image et le redimensionnement de l'image.

Le chemin CPU utilise la version sans Edge TPU du modèle avec num_threads=8. Les modèles Edge TPU et CPU proviennent du même jeu de test Google Coral MobileNet V2 iNaturalist oiseaux, et reçoivent tous deux le même tenseur d'entrée prétraité.

Le script de test facultatif complet est disponible sous forme de benchmark.py. Après avoir téléchargé les trois ressources ci-dessus, enregistrez-le ou téléchargez-le sous /tmp/coral-test/benchmark.py.

Exécutez le benchmark :

cd /tmp/coral-test
/tmp/coral-venv/bin/python benchmark.py

Résultat observé

Une exécution sur le RK3576 testé a donné :

Pour cette exécution, la latence moyenne du chemin Coral était 3.34x plus basse que la latence moyenne du chemin CPU à huit threads. Les valeurs FPS sont 1000 / latence moyenne pour des inférences répétées d'une seule image ; elles ne sont pas des mesures d'un pipeline complet de caméra, décodage, prétraitement et affichage.

Ces valeurs sont une mesure d'un seul appareil et d'une seule configuration logicielle, pas une spécification produit garantie. La mise à l'échelle de fréquence, l'état thermique, l'activité en arrière-plan, le choix du runtime, le partitionnement du modèle et la topologie USB peuvent changer le résultat.

Remarque : Cette vérification facultative compare uniquement le Coral Edge TPU au chemin TensorFlow Lite sur CPU avec huit threads. Elle ne compare pas Coral au NPU du RK3576, qui n'est pas utilisé dans ce test. Les valeurs de pointe de 4 TOPS pour Coral et de 6 TOPS pour le NPU du RK3576 ne décrivent donc pas et ne prédisent pas ce résultat.

Dépannage

• Aucune entrée Coral dans lsusb : rebranchez l'appareil, utilisez un câble known-good, essayez un autre port hôte USB et inspectez dmesg.
• L'appareil reste sur 1a6e:089a : vérifiez d'abord que libedgetpu.so.1.0 se charge correctement. Rebranchez ensuite l'accélérateur et inspectez les messages de firmware dans dmesg.
• 480M dans lsusb -t : la connexion a négocié à la vitesse USB 2. Déplacez l'accélérateur vers un port USB 3 et vérifiez le câble.
• Failed to load delegate : vérifiez que le runtime Edge TPU est installé et que l'utilisateur actuel peut accéder à l'appareil USB.
• Température du boîtier élevée : utilisez le runtime standard libedgetpu1-std et maintenez la circulation d'air. Le runtime à fréquence maximale peut devenir très chaud.

Références

• Seeed Studio reComputer AI Lab : série reComputer RK
• Coral : démarrer avec le USB Accelerator
• Coral : exécuter une inférence sur le Edge TPU avec Python
• Fiche technique du Coral USB Accelerator
• Données de test publiques de Google Coral