Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tutoriel : effectuer une inférence de classification d'images d'échantillons sur des images provenant d'un appareil photo à l'aide TensorFlow de Lite
Ce didacticiel explique comment utiliser le composant d'inférence de [classification d'images TensorFlow Lite](tensorflow-lite-image-classification-component.md) pour effectuer une inférence de classification d'images par exemple sur des images provenant d'une caméra en local sur un périphérique principal Greengrass. Ce composant inclut les dépendances suivantes :
+ TensorFlow Composant de magasin de modèles de classification d'images Lite
+ TensorFlow Composant d'exécution Lite
**Note**
Ce didacticiel accède au module caméra pour les appareils [Raspberry Pi](https://www.raspberrypi.org/) ou [NVIDIA Jetson Nano](https://developer.nvidia.com/embedded/jetson-nano), mais AWS IoT Greengrass prend en charge d'autres appareils sur les plateformes ARMv7L, Armv8 ou x86\$164. Pour configurer une caméra pour un autre appareil, consultez la documentation correspondante à votre appareil.
Pour plus d'informations sur l'apprentissage automatique sur les appareils Greengrass, consultez. [Exécuter l'inférence de Machine Learning](perform-machine-learning-inference.md)
**Topics**
+ [Conditions préalables](#ml-tutorial-camera-prereqs)
+ [Étape 1 : configurer le module de caméra sur votre appareil](#ml-tutorial-image-classification-camera-install)
+ [Étape 2 : vérifier votre abonnement à la rubrique de notifications par défaut](#ml-image-classification-camera-subscribe)
+ [Étape 3 : modifier la configuration du composant de classification d'images TensorFlow Lite et le déployer](#ml-image-classification-camera-deploy)
+ [Étape 4 : Afficher les résultats de l'inférence](#ml-image-classification-camera-results)
+ [Étapes suivantes](#ml-image-classification-camera-next-steps)
## Conditions préalables
Pour terminer ce didacticiel, vous devez d'abord le terminer[Tutoriel : Effectuer une inférence de classification d'images d'échantillons à l'aide TensorFlow de Lite](ml-tutorial-image-classification.md).
Vous avez également besoin des éléments suivants :
+ Un appareil central Linux Greengrass doté d'une interface de caméra. Ce didacticiel permet d'accéder au module caméra sur l'un des appareils compatibles suivants :
+ [Raspberry Pi](https://www.raspberrypi.org/) exécutant le système d'[exploitation Raspberry Pi](https://www.raspberrypi.org/downloads/) (auparavant appelé Raspbian)
+ [NVIDIA Jetson Nano](https://developer.nvidia.com/embedded/jetson-nano)
Pour plus d'informations sur la configuration d'un appareil Greengrass Core, consultez. [Tutoriel : Débuter avec AWS IoT Greengrass V2](getting-started.md)
Le périphérique principal doit répondre aux exigences suivantes :
+ Sur les appareils principaux de Greengrass exécutant Amazon Linux 2 ou Ubuntu 18.04, la version 2.27 ou ultérieure de la [bibliothèque GNU C](https://www.gnu.org/software/libc/) (glibc) est installée sur l'appareil.
+ Sur les appareils ARMv7L, tels que le Raspberry Pi, les dépendances pour OpenCV-Python sont installées sur l'appareil. Exécutez la commande suivante pour installer les dépendances.
```
sudo apt-get install libopenjp2-7 libilmbase23 libopenexr-dev libavcodec-dev libavformat-dev libswscale-dev libv4l-dev libgtk-3-0 libwebp-dev
```
+ Les appareils Raspberry Pi qui exécutent le système d'exploitation Raspberry Pi Bullseye doivent répondre aux exigences suivantes :
+ NumPy 1.22.4 ou version ultérieure installée sur l'appareil. Raspberry Pi OS Bullseye inclut une version antérieure de NumPy. Vous pouvez donc exécuter la commande suivante pour effectuer la mise à niveau NumPy sur l'appareil.
```
pip3 install --upgrade numpy
```
+ L'ancienne pile de caméras activée sur l'appareil. Raspberry Pi OS Bullseye inclut une nouvelle pile de caméras qui est activée par défaut et qui n'est pas compatible. Vous devez donc activer la pile de caméras existante.
**Pour activer l'ancienne pile de caméras**
1. Exécutez la commande suivante pour ouvrir l'outil de configuration du Raspberry Pi.
```
sudo raspi-config
```
1. Sélectionnez **Options d'interface**.
1. Sélectionnez **Legacy camera** pour activer l'ancienne pile de caméras.
1. Redémarrez l'appareil Raspberry Pi.
+ Pour les appareils Raspberry Pi ou NVIDIA Jetson Nano, [module de caméra Raspberry Pi V2 - 8 mégapixels, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Pour savoir comment configurer la caméra, consultez la section [Connexion de la caméra](https://www.raspberrypi.org/documentation/usage/camera/) dans la documentation du Raspberry Pi.
## Étape 1 : configurer le module de caméra sur votre appareil
Au cours de cette étape, vous allez installer et activer le module caméra de votre appareil. Exécutez les commandes suivantes sur l'appareil.
------
#### [ Raspberry Pi (Armv7l) ]
1. Installez l'`picamera`interface du module de caméra. Exécutez la commande suivante pour installer le module caméra et les autres bibliothèques Python requises pour ce didacticiel.
```
sudo apt-get install -y python3-picamera
```
1. Vérifiez que Picamera a été correctement installé.
```
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Si la sortie ne contient pas d'erreurs, la validation a abouti.
**Note**
Si le fichier exécutable Python installé sur votre appareil l'est`python3.7`, utilisez-le `python3.7` plutôt que `python3` pour les commandes de ce didacticiel. Assurez-vous que votre installation pip correspond à la version correcte (`python3.7` ou `python3`) pour éviter les erreurs de dépendance.
1. Redémarrez l'appareil.
```
sudo reboot
```
1. Ouvrez l'outil de configuration du Raspberry Pi.
```
sudo raspi-config
```
1. Utilisez les touches flèches pour ouvrir les **Options d'interface** et activer l'interface de la caméra. Si vous y êtes invité, autorisez le redémarrage de l'appareil.
1. Exécutez la commande suivante pour tester la configuration de la caméra.
```
raspistill -v -o test.jpg
```
Elle ouvre une fenêtre d'aperçu sur le Raspberry Pi, enregistre une image nommée `test.jpg` dans votre répertoire actuel et affiche des informations sur la caméra dans la fenêtre de terminal du Raspberry Pi.
1. Exécutez la commande suivante pour créer un lien symbolique permettant au composant d'inférence d'accéder à votre caméra depuis l'environnement virtuel créé par le composant d'exécution.
```
sudo ln -s /usr/lib/python3/dist-packages/picamera "MLRootPath/greengrass_ml_tflite_venv/lib/python3.7/site-packages"
```
La valeur par défaut *MLRootPath* pour ce didacticiel est`/greengrass/v2/work/variant.TensorFlowLite/greengrass_ml`. Le `greengrass_ml_tflite_venv` dossier situé à cet emplacement est créé lorsque vous déployez le composant d'inférence pour la première fois dans[Tutoriel : Effectuer une inférence de classification d'images d'échantillons à l'aide TensorFlow de Lite](ml-tutorial-image-classification.md).
------
#### [ Jetson Nano (Armv8) ]
1. Exécutez la commande suivante pour tester la configuration de la caméra.
```
gst-launch-1.0 nvarguscamerasrc num-buffers=1 ! "video/x-raw(memory:NVMM), width=1920, height=1080, format=NV12, framerate=30/1" ! nvjpegenc ! filesink location=test.jpg
```
Cela capture et enregistre une image nommée `test.jpg` dans votre répertoire actuel.
1. (Facultatif) Redémarrez l'appareil. Si vous rencontrez des problèmes lors de l'exécution de la `gst-launch` commande à l'étape précédente, le redémarrage de votre appareil peut les résoudre.
```
sudo reboot
```
**Note**
Pour les appareils Armv8 (AArch64), tels qu'un Jetson Nano, il n'est pas nécessaire de créer un lien symbolique pour permettre au composant d'inférence d'accéder à la caméra depuis l'environnement virtuel créé par le composant d'exécution.
------
## Étape 2 : vérifier votre abonnement à la rubrique de notifications par défaut
Dans[Tutoriel : Effectuer une inférence de classification d'images d'échantillons à l'aide TensorFlow de Lite](ml-tutorial-image-classification.md), vous avez configuré le client AWS IoT MQTT est configuré dans la AWS IoT console pour regarder les messages MQTT publiés par le composant de classification d'images TensorFlow Lite sur le `ml/tflite/image-classification` sujet. Dans la AWS IoT console, vérifiez que cet abonnement existe. Si ce n'est pas le cas, suivez les étapes décrites [Étape 1 : Abonnez-vous à la rubrique de notifications par défaut](ml-tutorial-image-classification.md#ml-image-classification-subscribe) pour vous abonner à cette rubrique avant de déployer le composant sur votre appareil principal Greengrass.
## Étape 3 : modifier la configuration du composant de classification d'images TensorFlow Lite et le déployer
Au cours de cette étape, vous configurez et déployez le composant de classification d'images TensorFlow Lite sur votre appareil principal :
### Pour configurer et déployer le composant de classification d'images TensorFlow Lite (console)
1. Dans le menu de navigation de la [AWS IoT Greengrass console](https://console.aws.amazon.com/greengrass), sélectionnez **Composants**.
1. Sur la page **Components (Composants)**, sous l'onglet **Public components (Composants publics)**, choisissez `aws.greengrass.TensorFlowLiteImageClassification`.
1. Sur la page **aws.greengrass.TensorFlowLiteImageClassification**, choisissez **Deploy (Déployer)**.
1. Dans **Ajouter au déploiement**, sélectionnez l'une des options suivantes :
1. Pour fusionner ce composant avec un déploiement existant sur votre dispositif cible, choisissez **Add to existing deployment (Ajouter à un déploiement existant)**, puis sélectionnez le déploiement à réviser.
1. Pour créer un nouveau déploiement sur votre dispositif cible, choisissez **Create new deployment (Créer un déploiement)**. S'il existe un déploiement sur votre dispositif et que vous choisissez cette étape, le déploiement existant sera remplacé.
1. Sur la page **Specify target (Spécifier une cible)**, procédez comme suit :
1. Sous **Deployment information (Informations sur le déploiement)**, saisissez ou modifiez le nom convivial de votre déploiement.
1. Sous **Deployment targets (Cibles de déploiement)**, sélectionnez une cible pour votre déploiement, puis choisissez **Next (Suivant)**. Vous ne pouvez pas modifier la cible de déploiement si vous révisez un déploiement existant.
1. Sur la page **Sélectionner les composants**, sous **Composants publics**, vérifiez que le `aws.greengrass.TensorFlowLiteImageClassification` composant est sélectionné, puis choisissez **Next**.
1. Sur la page **Configurer les composants**, procédez comme suit :
1. Sélectionnez le composant d'inférence, puis sélectionnez **Configurer le composant**.
1. Sous **Mise à jour de configuration**, entrez la mise à jour de **configuration suivante dans la zone Configuration à fusionner**.
```
{
"InferenceInterval": "60",
"UseCamera": "true"
}
```
Avec cette mise à jour de configuration, le composant accède au module de caméra de votre appareil et effectue des inférences sur les images prises par la caméra. Le code d'inférence s'exécute toutes les 60 secondes.
1. Choisissez **Confirm (Confirmer)**, puis **Next (Suivant)**.
1. Sur la page **Configure advanced settings (Configurer les paramètres avancés)**, conservez les paramètres de configuration par défaut et choisissez **Next (Suivant)**.
1. Sur la page de **révision**, choisissez **Déployer**
### Pour configurer et déployer le composant de classification d'images TensorFlow Lite (AWS CLI)
1. Créez un `deployment.json` fichier pour définir la configuration de déploiement du composant de classification d'images TensorFlow Lite. Ce fichier doit ressembler à ce qui suit :
```
{
"targetArn":"targetArn",
"components": {
"aws.greengrass.TensorFlowLiteImageClassification": {
"componentVersion": 2.1.0,
"configurationUpdate": {
"InferenceInterval": "60",
"UseCamera": "true"
}
}
}
}
```
+ Dans le champ `targetArn`, remplacez `targetArn` par l'Amazon Resource Name (ARN) de l'objet ou du groupe d'objets à cibler pour le déploiement, au format suivant :
+ Objet : `arn:aws:iot:region:account-id:thing/thingName`
+ Groupe d'objets : `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
+ Ce didacticiel utilise la version 2.1.0 du composant. Dans l'objet `aws.greengrass.TensorFlowLiteImageClassification` composant, remplacez-le *2.1.0* pour utiliser une version différente du composant de classification d'images TensorFlow Lite.
Avec cette mise à jour de configuration, le composant accède au module de caméra de votre appareil et effectue des inférences sur les images prises par la caméra. Le code d'inférence s'exécute toutes les 60 secondes. Remplacez les valeurs suivantes
1. Exécutez la commande suivante pour déployer le composant de classification d'images TensorFlow Lite sur le périphérique :
```
aws greengrassv2 create-deployment \
--cli-input-json file://path/to/deployment.json
```
L'exécution du déploiement peut prendre plusieurs minutes. À l'étape suivante, vérifiez le journal des composants pour vous assurer que le déploiement s'est terminé avec succès et afficher les résultats des inférences.
## Étape 4 : Afficher les résultats de l'inférence
Après avoir déployé le composant, vous pouvez consulter les résultats de l'inférence dans le journal du composant sur votre périphérique principal Greengrass et dans AWS IoT le client MQTT de la console. AWS IoT Pour vous abonner à la rubrique sur laquelle le composant publie les résultats d'inférence, consultez[Étape 2 : vérifier votre abonnement à la rubrique de notifications par défaut](#ml-image-classification-camera-subscribe).
**Topics**
+ **AWS IoT Client MQTT** : pour afficher les résultats publiés par le composant d'inférence dans la [rubrique des notifications par défaut](ml-tutorial-image-classification.md#ml-image-classification-subscribe), procédez comme suit :
1. Dans le menu de navigation de la [AWS IoT console](https://console.aws.amazon.com/iot/), choisissez **Test, client de test MQTT**.
1. Sous **Abonnements**, sélectionnez**ml/tflite/image-classification**.
+ **Journal des composants** : pour afficher les résultats de l'inférence dans le journal des composants, exécutez la commande suivante sur votre appareil principal Greengrass.
```
sudo tail -f /greengrass/v2/logs/aws.greengrass.TensorFlowLiteImageClassification.log
```
Si vous ne pouvez pas voir les résultats d'inférence dans le journal des composants ou dans le client MQTT, cela signifie que le déploiement a échoué ou n'a pas atteint le périphérique principal. Cela peut se produire si votre appareil principal n'est pas connecté à Internet ou ne dispose pas des autorisations requises pour exécuter le composant. Exécutez la commande suivante sur votre appareil principal pour afficher le fichier journal du logiciel AWS IoT Greengrass Core. Ce fichier inclut les journaux du service de déploiement de l'appareil principal Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
Pour de plus amples informations, veuillez consulter [Résolution des problèmes liés à l'inférence par apprentissage automatique](ml-troubleshooting.md).
## Étapes suivantes
Ce didacticiel explique comment utiliser le composant de classification d'images TensorFlow Lite, avec des options de configuration personnalisées pour effectuer une classification d'images d'échantillons sur des images prises par un appareil photo.
Pour plus d'informations sur la personnalisation de la configuration des composants publics ou la création de composants d'apprentissage automatique personnalisés, consultez[Personnalisez vos composants d'apprentissage automatique](ml-customization.md).