Kubii m’a confié pour test un ensemble composé d’un Raspberry Pi 5 équipé de 16 Go de RAM, une carte PineBoards pouvant accueillir un SSD M.2 et un module AI Coral Accelerator. Le montage est facile et à la portée de tous. Je vous présente dans cet article les tests de ce matériel.

 

Raspberry Pi 5 avec SSD 256 Go et Accélérateur AI Coral M.2 sur carte PineBoards

J’ai passé quelques jours un peu éprouvants à essayer d’installer le module Coral TPU sur le Raspberry Pi 5. Il date un peu et les modules nécessaires… également. D’où leur incompatibilité avec les versions d’OS et de Python disponibles actuellement sur le Raspberry Pi 5 (Raspberry Pi OS Bookworm version 6.6.62+rpt-rpi-v8 et Python 3.11.2 au jour où j’écris ces lignes).
Après plusieurs tentatives infructueuses tu te dis bon, il y en a certainement d’autres qui ont essayé. Là tu fais des recherches et tu trouve un forum où il est dit que les développeurs des modules Coral ont été interrogés à ce sujet et ont répondu : »Vous n’avez qu’à installer un vieil OS et une version de Python 3.8 ! ». Euhhh…

En fait on a toujours un module qui n’est pas disponible dans la version nécessaire. J’ai tenté de créer des environnements virtuels Python 3.9 puis 3.8, de compiler les sources etc… mais à chaque fois il en manque un bout ! Une fois c’est numpy, une autre fois c’est pyCoral…

On trouve par exemple sur ce forum : « Pycoral n’est disponible qu’avec le support de Python 3.9. La plupart des distributions ne sont plus livrées avec cette version, mais plutôt avec la 3.10 ou la 3.11. Il n’y a donc en réalité aucune version de pycoral disponible au téléchargement. De plus, construire pycoral à partir des sources n’est pas compatible avec Python 3.10 ou 3.11 (encore une fois, non supporté) et repose sur une ancienne version de tensorFlow (2.5.0) pour fonctionner. Bien que cela indique un manque de maintenance, il serait bon d’au moins faire une mise à jour pour qu’il puisse être utilisé avec, eh bien, à peu près n’importe quelle version moderne du système d’exploitation.« 

Les mises à jour semblent s’être arrêtées en 2021 et la bibliothèque ne fonctionne plus avec les distributions Python modernes. Je suis donc parti voir ce qu’en disait PineBoards après avoir contacté en direct Miroslaw, un des créateurs de la carte. Il m’a renvoyé vers cette page qui utilise un container créé par Jeff Gearling, un des makers les plus avancés sur l’expérimentation du PCIe sur le Raspberry Pi. C’est ce que je vous décris ici. On ne va pas se cacher qu’il faut avoir un bon niveau pour se lancer dans l’aventure d’où la classification « expert » de cet article.

Installation de la carte PineBoards, du SSD et du module Coral TPU

La carte PineBoards avec ses 2 ports M.2, un M.2 M et un M.2 E. Le M.2 succédait à deux autres formats : les PCI Express Mini Card (mPCIe) et mini S-ATA (mSATA. Après, alors que ce format M.2 aurait pu (dû ?) simplifier les choses, on se retrouve avec des largeurs de 12, 16, 22 ou 30 mm et des longueurs de 16, 26, 30, 42, 60, 80 ou 110 mm.  Mais toutes les combinaisons ne sont pas utilisées. Attention, toutes les combinaisons ne peuvent pas être exploitées. Pour les  SSD, la largeur est forcément de 22 mm, alors que la longueur peut varier entre 30 et 110 mm. Un peu comme pour les piles, la référence indique la dimension : un SSD M.2 2260 mesure 22×60 mm, alors qu’un 2280 mesure 22×80 mm.
Vous suivez jusque là ? Parce qu’en plus de tout ça les M.2 peuvent être simple (S) ou double (D) face, et comporter des encoches différentes appelées clés A, B, E et M… En fait il y a 12 clés définies dans les caractéristiques, mais seules ces 4 sont utilisées (pour le moment !). Et pour simplifier encore (au point où on en est) certains modules ont… plusieurs clés. Bon, pour en savoir plus allez lire cet excellent  article qui explique tout ça. Son sous titre est « Moi je voulais juste acheter un SSD… »

La partie active de la carte est un circuit intégré Asmedia ASM1182e,commutateur de paquets PCI Express avec un port en entrée PCIe x1 Gen2 et deux ports en sortie PCIe x1 Gen2, permettant d’étendre les ports PCIe sur une carte mère ou comme ici sur une carte HAT. On règle le Pi 5 pour utiliser PCIe GEN 3, mais il s’adapte de toute façon, donc ça n’a pas de conséquence.

Sur la carte on trouve 2 ports M.2 Clé M pour le SSD et Clé E pour le Coral TPU. Voir plus haut.
Sous la carte il n’y a rien de particulier. La nappe était livrée montée sur le connecteur PCIe de la carte.

A côté du connecteur PCIe, on trouve les LED PXR et ACT qui indiquent que la carte est sous tension et que la liaison PCIe est active.

Avec la carte on trouve une nappe PCIe de rechange (une bonne idée car ce genre de câble plat est assez fragile et pour des expérimentations on manipule pas mal la liaison. j’y reviendrai. On a aussi les entretoises et les vis pour fixer la carte HAT et le Raspberry Pi. Pas de visserie en rab, et une seule vis/entretoise en laiton pour le SSD. J’aurais aimé en trouver 2 puisqu’il y a 2 ports M.2. D’autant plus que le module Coral était livré sans entretoise et que j’ai monté un écrou nylstop pour fixer le module.
Positionnement des 2 cartes pour montrer comment elles se connectent.

La carte HAT PineBoards se positionnera sous le Raspberry Pi

Ici les entretoises sont montées sur la carte PineBoards
Le SSD 256 Go Raspberry Pi est livré dans un boîtier en carton.

Ses caractéristiques sont indiquées sous la boîte

On le met en place dans le port M.2 adéquat, d’abord incliné comme ici.

Puis on positionne la vis/entretoise pour que la carte se place dans l’encoche, ce qui assure l’espacement avec la carte et le montage horizontal du SSD.

Autre vue de la vis/entretoise et de sa position par rapport à la carte du SSD.

On placera de la même manière le module d’IA Coral TPU
Avant de le fixer. Bon, ici j’ai fait  avec ce que j’avais sous la main (en fait dans ma boîte de visserie) avec une vise de 2,5mm et un écrou nylstop (écrou frein). Voilà tout es monté on va pouvoir commencer la configuration.

L’intérieur du module Coral TPU. Pour plus d’informations cliquez sur ce lien pour lire la page du produit.

Configuration du Raspberry Pi d’après PineBoards

Ce tutoriel vous guidera dans le processus de configuration de la TPU Google Coral Edge sur un Raspberry Pi 5, y compris le paramétrage du matériel et l’installation du logiciel. J’ai démarré avec une carte SD faite à neuf avec la dernière version de l’OS, puis j’ai transféré l’OS sur le SSD, mais vous faites bien comme vous voulez.

Configurer les paramètres matériels

Tout d’abord, vous devez modifier le fichier de configuration du Raspberry Pi afin d’activer les paramètres matériels nécessaires à la TPU Coral Edge. Ouvrez le fichier de configuration :

sudo nano /boot/firmware/config.txt

Ajoutez les lignes suivantes au fichier :

[all]
# Activer le connecteur PCIe externe.
dtparam=pciex1
kernel=kernel8.img
# Activer Pineboards Hat Ai
dtoverlay=pineboards-hat-ai

Le Raspberry Pi 5 n’est pas certifié pour les vitesses Gen 3.0. Les connexions PCIe Gen 3.0 peuvent être instables. Par défaut, le Raspberry Pi 5 utilise les vitesses de la Gen 2.0 (5 GT/s). Vous pouvez essayer de forcer les vitesses Gen 3.0 (8 GT/s)

Pour activer les vitesses PCIe Gen 3.0, lorsque vous modifiez le fichier /boot/firmware/config.txt saisissez cette ligne au lieu de pciex1 :

dtparam=pciex1_gen=3

Sauvegardez et fermez le fichier en appuyant sur CTRL+X, puis sur Y pour confirmer, et sur Enter pour quitter. Redémarrez votre Raspberry Pi pour appliquer ces changements.

sudo reboot

Ici on peut vérifier que le SSD est vu après modification des paramètres matériels (/dev/nvme…)

Lorsque le SSD est vu par le système vous pouvez transférer la carte SD sur le SSD puis redémarrer sans la carte SD, directement sur le SSD.

Dans les Accessoires du menu, utilisez SD Card Copier et renseignez les champs comme ci-dessus. Validez New Partition UUIDs
Les partitions de la carte SD sont reportées sur le SSD. Modifiez l’ordre de démarrage dans raspi-config =>  Boot Order => NVMe / USB Boot
Au redémarrage on boot sur le SSD et la carte SD apparait sur le bureau. C’est tout bon, éteignez proprement le Raspberry Pi, enlevez la carte SD et au redémarrage vous démarrez sur le SSD.

Mise à jour du noyau si besoin

La version 6.6.30 du noyau ou une version plus récente est nécessaire pour l’utilisation de l’overlay Pineboards Hat Ai. Pour vérifier la version de votre noyau, utilisez la commande suivante :

uname -a

A ce jour (janvier 2025) le noyau 6.6.51 supporte donc l’overlay PineBoard

Installer le pilote PCIe et le moteur d’exécution Edge TPU

Mettez à jour votre liste de paquets :

sudo apt update

Ajoutez le dépôt de paquets Google Coral Edge TPU :

echo « deb https://packages.cloud.google.com/apt coral-edgetpu-stable main » | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list

Importez la clé GPG du dépôt :

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add –

Mettez à nouveau à jour votre liste de paquets :

sudo apt-get update

Installez les paquets nécessaires :

sudo apt-get install cmake libedgetpu1-std devscripts debhelper dkms dh-dkms

Installer le pilote Gasket

Clonez le dépôt du pilote Gasket :

git clone https://github.com/google/gasket-driver.git

Entrez dans le répertoire et compilez le pilote :

cd gasket-driver

sudo debuild -us -uc -tc -b

Retournez dans le répertoire parent et installez le paquet construit :

cd ..

sudo dpkg -i gasket-dkms_1.0-18_all.deb

Configurer la règle udev

Ajoutez une règle udev pour gérer les permissions des périphériques :

sudo sh -c « echo ‘SUBSYSTEM==\ »apex\ », MODE=\ »0660\ », GROUP=\ »apex\ »‘ >> /etc/udev/rules.d/65-apex.rules »

Créez un nouveau groupe et ajoutez-y votre utilisateur :

sudo groupadd apex
sudo adduser $USER apex

Redémarrez votre Raspberry Pi pour appliquer tous les changements :

sudo reboot

Vérifiez que le pilote est chargé en utilisant la commande suivante :

sudo lspci -v

votre Raspberry Pi est maintenant configuré pour utiliser Coral Edge TPU. Vous pouvez commencer à déployer des modèles d’apprentissage automatique et à exécuter des tâches d’inférence avec une puissance de traitement améliorée.

Installer Docker sur le Raspberry Pi 5

Le plus simple est d’installer Docker en suivant les instructions  d »installation via leur dépôt apt.

# Ajouter la clé GPG officielle de Docker :
sudo apt update

sudo apt-get install -y ca-certificates curl gnupg

curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg –dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Ajouter le dépôt aux sources d’Apt :

echo « deb [arch=$(dpkg –print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(. /etc/os-release && echo « $VERSION_CODENAME ») stable » | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Ceci ajoutera la clé GPG de Docker, installera quelques paquets nécessaires, et ajoutera le dépôt Docker APT à votre fichier sources.list afin que vous puissiez télécharger leurs paquets :

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Une fois que vous aurez confirmé l’installation des paquets ci-dessus, vous serez prêt(e) à utiliser Docker !

Vérification du fonctionnement de Docker

et on peut tester le container Hello World

Pour éliminer le besoin de mettre sudo devant Docker on peut ajouter l’utiliateur au groupe :

sudo usermod -aG docker

puis redémarrez le système ou sortez/rentrez dans la session, pour prendre le changement en compte.

Pour que docker démarre à chaque démarrage du systèmle :

sudo systemctl enable docker

Création du conteneur Docker PyCoral

Avec Docker installé, nous pouvons commencer à travailler sur la création du conteneur Docker qui fera tourner PyCoral. Jeff Geerling a un fichier Docker prêt à l’emploi pour cela, alors pourquoi réinventer la roue ? Merci, Jeff !

Créer un fichier Dockerfile

Ce fichier Dockerfile est un fichier texte contenant une série d’instructions utilisées pour créer une image Docker. Créez ce fichier dans le répertoire de votre choix et ajoutez-y les instructions suivantes.
FROM debian:10
Cela signifie que l’image Docker sera construite à partir de l’image de base debian:10. Vous utiliserez Debian 10 comme système d’exploitation de base.
Définir le répertoire de travail :
WORKDIR /home
Change le répertoire de travail actuel dans l’image Docker à /home.
Définir la variable d’environnement HOME :
ENV HOME=/home
Définit la variable d’environnement HOME à /home.
Exécuter des commandes de mise à jour et d’installation :
RUN cd ~
RUN apt-get update
RUN apt-get install -y git nano python3-pip python-dev pkg-config wget usbutils curl

RUN cd ~ : Change le répertoire courant en répertoire personnel
RUN apt update : Met à jour la liste des paquets disponibles.
RUN apt-get install -y <packages> : Installe les paquets nécessaires : git, nano, python3-pip, python-dev, pkg-config, wget, usbutils, et curl.

Ajouter le dépôt Coral Edge TPU :
RUN echo « deb https://packages.cloud.google.com/apt coral-edgetpu-stable main » | tee /etc/apt/sources.list.d/coral-edgetpu.list
RUN curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add –

Ajoute le dépôt Coral Edge TPU à la liste des sources APT.
Télécharge et ajoute la clé GPG pour vérifier l’intégrité des paquets téléchargés depuis ce dépôt.
Mettre à jour les paquets et installer edgetpu-examples :
RUN apt-get update
RUN apt-get install -y edgetpu-examples

Met à jour la liste des paquets.
Installe edgetpu-examples qui contient des exemples d’utilisation du Coral Edge TPU.
Construire l’image Docker :
sudo docker build -t « coral » .

Cette commande construit l’image Docker en utilisant le Dockerfile dans le répertoire courant et la tague avec le nom coral.
En suivant ces étapes, vous allez créer une image Docker basée sur Debian 10, avec tous les paquets nécessaires pour utiliser les exemples Coral Edge TPU.

Le fichier dockerfile :

FROM debian:10
WORKDIR /home
ENV HOME=/home
RUN cd ~
RUN apt update
RUN apt install -y git nano python3-pip python-dev pkg-config wget usbutils curl

RUN echo « deb https://packages.cloud.google.com/apt coral-edgetpu-stable main » ?
| tee /etc/apt/sources.list.d/coral-edgetpu.list
RUN curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add –
Exécuter apt-get update
RUN apt-get install -y edgetpu-examples

Il reste à construire l’image :

sudo docker build –t « coral » .

Tester le conteneur Docker PyCoral

Si vous êtes arrivé jusqu’ici sans problème, vous êtes prêt à tester votre nouvelle TPU Google Coral avec le conteneur Docker précédemment créé.

Tout d’abord, vérifions que le périphérique « /dev/apex_0 » est bien présent sur votre machine :

ls /dev | grep apex_0

Il devrait afficher apex_0 s’il est présent, mais si ce n’est pas le cas, vous devrez à nouveau vérifier vos connexions physiques, et que toutes les étapes précédentes ont été suivies correctement.

Nous allons maintenant initialiser le conteneur Docker, lui passer le périphérique « apex_0 », et nous placer dans un prompt BASH :

sudo docker run -it –device /dev/apex_0:/dev/apex_0 coral /bin/bash

Maintenant, dans l’invite BASH à l’intérieur du conteneur, nous pouvons exécuter l’un des exemples que nous avons installés :

python3 /usr/share/edgetpu/examples/classify_image.py –model /usr/share/edgetpu/examples/models/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite –label /usr/share/edgetpu/examples/models/inat_bird_labels.txt –image /usr/share/edgetpu/examples/images/bird.bmp

Si les oiseaux ont bien été identifiés, le résultat sera le suivant :

---

Poecile atricapillus (Mésange à tête noire)
Score : 0.44140625
—————————
Poecile carolinensis (Mésange de Caroline)
Score : 0.29296875

et si vous remplacez bird.bmp par parrot.jpg :

Les autres images disponibles sont :

• bird.bmp
• cat.bmp
• grace_hopper.bmp
• parrot.jpg
• sunflower.bmp

Vous pouvez maintenant appuyer sur CTRL+D pour quitter le conteneur et revenir au système d’exploitation principal de votre Raspberry Pi.

Conclusion

La carte PineBoards et le SSD Raspberry Pi 256 Go m’ont donné pleine satisfaction. Facilité de mise en œuvre, démarrage rapide sur le SSD et fonctionnement fluide du système d’exploitation Raspberry Pi OS Bookworm.

Les TPU Google Coral sont un moyen excellent et abordable de découvrir l’IA sans avoir à compter sur le CPU du Raspberry Pi. Avec la carte PineBoards vous pouvez coupler l’utilisation du TPU Coral et celle d’un SSD connecté directement en PCIe. Vous ne pourrez l’utiliser qu’avec des éléments logiciels qui datent un peu.

Après le Coral TPU est sorti en 2019 (c’est vieux en informatique)  et sa version M2 est apparue sur le marché plus récemment mais  avec ses 4 TOPS  (Tera Operations Per Second : 1 000 000 000 000 d’opérations par seconde) il est derrière le module HAILO-8L qui affiche 13 TOPS ou le HAILO-8 et ses 26 TOPS, qui sont en plus conçus pour fonctionner avec le Raspberry Pi 5

Caractéristique	Google Coral TPU M.2	Hailo 8L
Performance (TOPS)	4 TOPS	13 TOPS
Efficacité (TOPS/Watt)	2 TOPS/Watt	3 TOPS/Watt
Compatibilité	Raspberry Pi 4, Raspberry Pi 3	Raspberry Pi 5
Support des frameworks	TensorFlow Lite	Plusieurs frameworks

On peut aussi noter dans les benchmarks qu’un Raspberry Pi 5 seul a des performances équivalentes à celles de ses prédécesseurs équipés d’un module Coral TPU… (source Allan Alasdair).

 

Vous trouverez le matériel chez Kubii :

Carte PineBoards AI = 48 €

SSD Raspberry Pi 256Go = 35,40 €

Module IA Coral TPU M.2 (A+E) = 36,90 €

Sources

https://www.kubii.com/fr/cartes-embarquees/4454-m2-accelerator-ae-key-google-edge-tpu-193575003924.html?mot_tcid=6895b990-83f4-4478-8582-f8e4f0fdff4c

https://coral.ai/products/m2-accelerator-ae/

https://wiki.seeedstudio.com/install_m2_coral_to_rpi5/

https://wiki.seeedstudio.com/convert_model_to_edge_tpu_tflite_format_for_google_coral/

https://ai.google.dev/edge/litert/models/model_optimization?hl=fr

https://github.com/google-coral/test_data

https://www.jeffgeerling.com/blog

https://www.jeffgeerling.com/tags/coral

https://www.jeffgeerling.com/blog/2023/testing-coral-tpu-accelerator-m2-or-pcie-docker

https://pineboards.io/blogs/tutorials/installing-frigate-on-raspberry-pi-5-with-a-google-coral-tpu

https://pineboards.io/blogs/tutorials/how-to-configure-the-google-coral-edge-tpu-on-the-raspberry-pi-5

https://www.asmedia.com.tw/product/213yQcasx8gNAzS4/b7FyQBCxz2URbzg0