Protéger les personnes des zones dangereuses grâce à des frontières virtuelles avec Computer Vision

Alors que les entreprises accueillent de plus en plus de robots autonomes et d'autres équipements lourds sur le lieu de travail, nous devons nous assurer que l'équipement peut fonctionner en toute sécurité autour de coéquipiers humains. Dans cet article, nous vous montrerons comment construire une frontière virtuelle avec la vision par ordinateur et AWS DeepLens, la caméra vidéo AWS compatible avec l'apprentissage en profondeur conçue pour permettre aux développeurs d'apprendre l'apprentissage automatique (ML). En utilisant les techniques d'apprentissage automatique de cet article, vous pouvez créer des limites virtuelles pour les zones restreintes qui arrêtent automatiquement l'équipement ou émettent une alerte lorsque des humains s'approchent.

Pour ce projet, vous entraînerez un modèle de détection d'objet personnalisé avec Amazon Sage Maker et déployer le modèle sur un appareil AWS DeepLens. La détection d'objets est un algorithme ML qui prend une image en entrée et identifie les objets et leur emplacement dans l'image. En plus des solutions de limites virtuelles, vous pouvez appliquer les techniques apprises dans cet article lorsque vous devez détecter l'emplacement de certains objets dans une image ou compter le nombre d'instances d'un objet souhaité dans une image, comme compter les éléments dans un bac de stockage ou sur une étagère de vente au détail.

Vue d'ensemble de la solution

La procédure pas à pas comprend les étapes suivantes:

1. Préparez votre ensemble de données pour alimenter un algorithme ML.
2. Entraînez un modèle avec Amazon SageMaker.
3. Modèle de test avec des zones de restriction personnalisées.
4. Déployez la solution sur AWS DeepLens.

Nous discutons également d'autres cas d'utilisation réels où vous pouvez appliquer cette solution.

Le diagramme suivant illustre l'architecture de la solution.

Pré-requis

Pour terminer cette procédure pas à pas, vous devez disposer des prérequis suivants:

Préparez votre ensemble de données pour alimenter un algorithme de ML

Cet article utilise un algorithme ML appelé modèle de détection d'objets pour créer une solution qui détecte si une personne se trouve dans une zone restreinte personnalisée. Vous utilisez le public disponible Ensemble de données de détection des piétons disponible sur Kaggle, qui compte plus de 2,000 XNUMX images. Cet ensemble de données contient des étiquettes pour les objets humains et ressemblant à des humains (comme des mannequins) afin que le modèle formé puisse distinguer plus précisément les vrais humains des accessoires ou des statues en carton.

Par exemple, les images suivantes sont des exemples d'un travailleur de la construction détecté et s'il se trouve dans la zone de restriction personnalisée (contour rouge).

Pour commencer l'entraînement de votre modèle, créer d'abord un compartiment S3 pour stocker vos données d'entraînement et la sortie du modèle. Pour les projets AWS DeepLens, les noms de compartiment S3 doivent commencer par le préfixe deeplens-. Vous utilisez ces données pour former un modèle avec SageMaker, un service entièrement géré qui offre la possibilité de créer, former et déployer rapidement des modèles ML.

Former un modèle avec Amazon SageMaker

Vous utilisez les blocs-notes SageMaker Jupyter comme environnement de développement pour former le modèle. Jupyter Notebook est une application Web open source qui vous permet de créer et de partager des documents contenant du code en direct, des équations, des visualisations et du texte narratif. Pour ce poste, nous fournissons Train_Object_Detection_People_DeepLens.ipynb, un cahier complet à suivre.

Pour créer un modèle de détection d'objet personnalisé, vous devez utiliser une instance de tâche de formation compatible avec l'unité de traitement graphique (GPU). Les GPU sont excellents pour paralléliser les calculs nécessaires à l'entraînement d'un réseau de neurones. Bien que le bloc-notes lui-même soit une seule instance ml.t2.medium, la tâche de formation utilise spécifiquement une instance ml.p2.xlarge. Pour accéder à une instance de tâche d'entraînement compatible GPU, vous devez soumettre une demande d'augmentation de la limite de service au centre de support AWS.

Après avoir reçu votre augmentation de limite, effectuez les étapes suivantes pour créer une instance de bloc-notes SageMaker :

1. Sur la console SageMaker, choisissez Instances de bloc-notes.
2. Selectionnez Créer une instance de bloc-notes.
3. Pour Nom de l'instance de notebook, saisissez un nom pour votre instance de bloc-notes.
4. Pour Type d'instance, choisissez t2.moyen.

Il s'agit du type d'instance le moins cher pris en charge par les instances de bloc-notes, et il suffit pour ce didacticiel.

5. Pour Rôle IAM, choisissez Créer un nouveau rôle.

Assurez-vous que Gestion des identités et des accès AWS (IAM) a accès au compartiment S3 que vous avez créé précédemment (préfixe deeplens-).

6. Selectionnez Créer une instance de bloc-notes. Le démarrage de votre instance de bloc-notes peut prendre quelques minutes.

7. Lorsque l'état de la page des instances de bloc-notes passe à InService, choisissez Ouvrez Jupyter pour lancer votre instance de notebook Jupyter nouvellement créée.
8. Selectionnez Téléchargement pour télécharger le Train_Object_Detection_people_DeepLens.ipynb fichier que vous avez téléchargé plus tôt.

9. Ouvrez le cahier et suivez-le jusqu'à la fin.
10. Si vous êtes invité à configurer le noyau, sélectionnez conda_mxnet_p36.

Le bloc-notes Jupyter contient un mélange de cellules de texte et de code. Pour exécuter un morceau de code, choisissez la cellule et appuyez sur Maj + Entrée. Pendant l'exécution de la cellule, un astérisque apparaît à côté de la cellule. Lorsque la cellule est complète, un numéro de sortie et une nouvelle cellule de sortie apparaissent sous la cellule d'origine.

11. Téléchargez l'ensemble de données du compartiment S3 public dans l'instance locale de SageMaker et décompressez les données. Cela peut être fait en suivant le code dans le notebook :

     !aws s3 cp s3://deeplens-public/samples/pedestriansafety/humandetection_data.zip . !rm -rf humandetection/ !unzip humandetection_data.zip -d humandetection 

12. Convertir le jeu de données dans un format (EnregistrementIO) qui peut être introduit dans l'algorithme SageMaker :

     !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/train_mask.lst $DATA_PATH/ !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/val_mask.lst $DATA_PATH/ 

13. Transférez les fichiers RecordIO vers Amazon S3.

Maintenant que vous avez terminé toute la préparation des données, vous êtes prêt à entraîner le détecteur d'objets.

Il existe de nombreux types d'algorithmes de détection d'objets. Pour ce poste, vous utilisez le Algorithme de détection multiboîte à un seul coup (SSD). L'algorithme SSD offre un bon équilibre entre vitesse et précision, ce qui le rend idéal pour s'exécuter sur des appareils périphériques tels qu'AWS DeepLens.

Dans le cadre de la tâche de formation, vous disposez de nombreuses options pour les hyperparamètres qui aident à configurer le comportement de formation (tels que le nombre d'époques, le taux d'apprentissage, le type d'optimiseur et la taille du mini-lot). Les hyperparamètres vous permettent de régler la vitesse d'entraînement et la précision de votre modèle. Pour plus d'informations sur les hyperparamètres, voir Algorithme de détection d'objets.

15. Configurez vos hyperparamètres et canaux de données. Envisagez d'utiliser l'exemple de définition d'hyperparamètres suivant :

     od_model = sagemaker.estimator.Estimator(training_image, role, train_instance_count=1, train_instance_type='ml.p2.xlarge', train_volume_size = 50, train_max_run = 360000, input_mode= 'File', output_path=s3_output_location, sagemaker_session=sess) od_model.set_hyperparameters(base_network='resnet-50', use_pretrained_model=1, num_classes=2, mini_batch_size=32, epochs=100, learning_rate=0.003, lr_scheduler_step='3,6', lr_scheduler_factor=0.1, optimizer='sgd', momentum=0.9, weight_decay=0.0005, overlap_threshold=0.5, nms_threshold=0.45, image_shape=300, num_training_samples=n_train_samples) 

Le bloc-notes comporte des hyperparamètres par défaut qui ont été présélectionnés. Pour la détection des piétons, vous entraînez le modèle pendant 100 époques. Cette étape de formation devrait prendre environ 2 heures en utilisant une instance ml.p2.xlarge. Vous pouvez expérimenter différentes combinaisons d'hyperparamètres ou vous entraîner sur plus d'époques pour améliorer les performances. Pour plus d'informations sur les derniers prix, voir Tarification d'Amazon SageMaker.

16. Vous pouvez démarrer une tâche d'entraînement avec une seule ligne de code et surveiller la précision au fil du temps sur la console SageMaker :

    od_model.fit(inputs=data_channels, logs=True) 

Pour plus d'informations sur le fonctionnement de la formation, voir CréerTrainingJob. L'approvisionnement et le téléchargement des données prennent du temps, en fonction de la taille des données. Par conséquent, il peut s'écouler quelques minutes avant que vous ne commenciez à obtenir des journaux de données pour vos tâches d'entraînement.

Vous pouvez surveiller la progression de votre tâche d'entraînement grâce à la précision moyenne métrique (mAP), qui vous permet de surveiller la qualité de la capacité du modèle à classer les objets et à détecter les boîtes englobantes correctes. Les journaux de données impriment également le mAP sur les données de validation, entre autres pertes, pour chaque exécution de l'ensemble de données, une fois pour une époque. Cette métrique est un indicateur de la qualité des performances de l'algorithme pour détecter avec précision la classe et la boîte englobante précise qui l'entoure.

Lorsque la tâche est terminée, vous pouvez trouver les fichiers de modèle entraînés dans le compartiment et le dossier S3 spécifiés précédemment dans s3_output_location:

s3_output_location = 's3://{}/{}/output'.format(BUCKET, PREFIX)

Pour cet article, nous montrons les résultats sur l'ensemble de validation à la fin de la 10e époque et de la 100e époque. À la fin de la 10e époque, nous voyons une validation mAP d'environ 0.027, alors que la 100e époque était d'environ 0.42.

Pour obtenir de meilleurs résultats de détection, vous pouvez essayer de régler les hyperparamètres en utilisant la fonctionnalité intégrée à SageMaker pour réglage automatique du modèle et former le modèle pour plus d'époques. Vous arrêtez généralement de vous entraîner lorsque vous constatez une diminution du gain de précision.

Modèle de test avec des zones de restriction personnalisées

Avant de déployer le modèle formé sur AWS DeepLens, vous pouvez le tester dans le cloud à l'aide d'un point de terminaison hébergé SageMaker. Un point de terminaison SageMaker est un service entièrement géré qui vous permet de faire des inférences en temps réel via une API REST. SageMaker vous permet de déployer rapidement de nouveaux points de terminaison pour tester vos modèles afin que vous n'ayez pas à héberger le modèle sur l'instance locale qui a été utilisée pour former le modèle. Cela vous permet de faire des prédictions (ou des inférences) à partir du modèle sur des images que l'algorithme n'a pas vues pendant la formation.

Vous n'êtes pas obligé d'héberger sur le même type d'instance que celui que vous avez utilisé pour l'entraînement. La formation est un travail prolongé et gourmand en calcul qui nécessite un ensemble différent d'exigences de calcul et de mémoire que l'hébergement ne nécessite généralement pas. Vous pouvez choisir n'importe quel type d'instance pour héberger le modèle. Dans ce cas, nous avons choisi l'instance ml.p3.2xlarge à former, mais nous avons choisi d'héberger le modèle sur l'instance CPU la moins chère, ml.m4.xlarge. L'extrait de code suivant montre notre déploiement de point de terminaison.

object_detector = od_model.deploy(initial_instance_count = 1, instance_type = 'ml.m4.xlarge') 

Détection dans une zone de restriction personnalisée (région d'intérêt)

Le format de la sortie peut être représenté par [class_index, confidence_score, xmin, ymin, xmax, ymax]. Les prédictions à faible confiance ont souvent plus de chances d'obtenir un faux positif ou un faux négatif, vous devriez donc probablement ignorer les prédictions à faible confiance. Vous pouvez utiliser le code suivant pour détecter si la zone de délimitation de la personne chevauche la zone restreinte.

def inRestrictedSection(ImShape = None, R1 = None, restricted_region = None, kclass = None, score = None, threshold = None): statement = 'Person Not Detected in Restricted Zone' if (kclass == 1) and (score > threshold): Im1 = np.zeros((ImShape[0],ImShape[1],3), np.int32) cv2.fillPoly(Im1, [R1], 255) Im2 = np.zeros((ImShape[0],ImShape[1],3), np.int32) if restricted_region is None: restricted_region = np.array([[0,ImShape[0]],[ImShape[1],ImShape[0]],[ImShape[1],0], [0,0]], np.int32) cv2.fillPoly(Im2, [restricted_region], 255) Im = Im1 * Im2 if np.sum(np.greater(Im, 0))>0: statement = 'Person Detected in Restricted Zone' else: statement = statement return statement 

Par défaut, la trame complète est évaluée pour la présence humaine. Cependant, vous pouvez facilement spécifier la région d'intérêt dans laquelle la présence d'une personne est considérée comme à haut risque. Si vous souhaitez ajouter une zone de restriction personnalisée, ajoutez les coordonnées des sommets de la région représentée par [axe X, axe Y] et créez le polygone. Les coordonnées doivent être saisies dans le sens des aiguilles d'une montre ou dans le sens inverse des aiguilles d'une montre. Voir le code suivant :

restricted_region = None #restricted_region = np.array([[0,200],[100,200],[100,0], [10,10]], np.int32) 

L'exemple de code suivant montre les piétons qui sont identifiés dans une zone réglementée :

file_name = 'humandetection/test_images/t1_image.jpg' img = cv2.imread(file_name) img =cv2.cvtColor(img,cv2.COLOR_BGR2RGB) thresh = 0.2 height = img.shape[0] width = img.shape[1] colors = dict() with open(file_name, 'rb') as image: f = image.read() b = bytearray(f) ne = open('n.txt','wb') ne.write(b) results = object_detector.predict(b, initial_args={'ContentType': 'image/jpeg'}) detections = json.loads(results) object_categories = ['no-person', 'person'] for det in detections['prediction']: (klass, score, x0, y0, x1, y1) = det if score < thresh: continue cls_id = int(klass) prob = score if cls_id not in colors: colors[cls_id] = (random.random(), random.random(), random.random()) xmin = int(x0 * width) ymin = int(y0 * height) xmax = int(x1 * width) ymax = int(y1 * height) R1 = np.array([[xmin,ymin],[xmax,ymin],[xmax,ymax], [xmin,ymax]], np.int32) cv2.polylines(img,[R1],True, (255,255,0), thickness = 5) cv2.polylines(img,[restricted_region],True, (255,0,0), thickness = 5) plt.imshow(img) print(inRestrictedSection(img.shape,R1 = R1, restricted_region= restricted_region, kclass = cls_id, score = prob, threshold=0.2)) 

Les images suivantes montrent nos résultats.

Déployer la solution sur AWS DeepLens

Convertir le modèle pour le déploiement vers AWS DeepLens

Lors du déploiement d'un modèle SSD formé par SageMaker sur AWS DeepLens, vous devez d'abord exécuter déployer.py pour convertir l'artefact de modèle en modèle déployable :

!rm -rf incubator-mxnet !git clone -b v1.7.x https://github.com/apache/incubator-mxnet MODEL_PATH = od_model.model_data TARGET_PATH ='s3://'+BUCKET+'/'+PREFIX+'/patched/' !rm -rf tmp && mkdir tmp rm -rf tmp && mkdir tmp !aws s3 cp $MODEL_PATH tmp !tar -xzvf tmp/model.tar.gz -C tmp !mv tmp/model_algo_1-0000.params tmp/ssd_resnet50_300-0000.params !mv tmp/model_algo_1-symbol.json tmp/ssd_resnet50_300-symbol.json !python incubator-mxnet/example/ssd/deploy.py --network resnet50 --data-shape 300 --num-class 2 --prefix tmp/ssd_ !tar -cvzf ./patched_model.tar.gz -C tmp ./deploy_ssd_resnet50_300-0000.params ./deploy_ssd_resnet50_300-symbol.json ./hyperparams.json !aws s3 cp patched_model.tar.gz $TARGET_PATH

Importez votre modèle dans AWS DeepLens

Pour exécuter le modèle sur un appareil AWS DeepLens, vous devez créer un projet AWS DeepLens. Commencez par importer votre modèle dans AWS DeepLens.

1. Sur la console AWS DeepLens, sous Ressources, choisissez Des modèles photo.
2. Selectionnez Importer un modèle.

3. Pour Source d'importation, sélectionnez Modèle formé en externe.
4. Entrez l'emplacement Amazon S3 du modèle patché que vous avez enregistré en exécutant deploy.py à l'étape ci-dessus.
5. Pour Cadre de modèle, choisissez MXNet.
6. Selectionnez Importer un modèle.

Créer la fonction d'inférence

La fonction d'inférence alimente chaque image de caméra dans le modèle pour obtenir des prédictions et exécute toute logique métier personnalisée sur l'utilisation des résultats d'inférence. Tu utilises AWS Lambda pour créer une fonction que vous déployez sur AWS DeepLens. La fonction exécute l'inférence localement sur l'appareil AWS DeepLens.

Tout d'abord, nous devons créer une fonction Lambda à déployer sur AWS DeepLens.

1. Télécharger fonction Lambda d'inférence.
2. Sur la console Lambda, choisissez Les fonctions.
3. Selectionnez Créer une fonction.
4. Sélectionnez Auteur à partir de zéro.
5. Pour Nom de la fonction, entrez un nom.
6. Pour Runtime, choisissez Python 3.7.
7. Pour Choisissez ou créez un rôle d'exécution, choisissez Utiliser un rôle existant.
8. Selectionnez rôle de service/AWSDeepLensLambdaRole.
9. Selectionnez Créer une fonction.

10. Sur la page de détail de la fonction, sur la Actions menu, choisissez Téléchargez un fichier .zip.

11. Télécharger le inférence Lambda fichier que vous avez téléchargé plus tôt.
12. Selectionnez Épargnez pour enregistrer le code saisi.
13. Sur le Actions menu, choisissez Publier une nouvelle version.

La publication de la fonction la rend disponible sur la console AWS DeepLens afin que vous puissiez l'ajouter à votre projet personnalisé.

14. Saisissez un numéro de version et choisissez Publier.

Comprendre la fonction d'inférence

Cette section vous guide à travers certaines parties importantes de la fonction d'inférence. Tout d'abord, vous devez faire attention à deux fichiers spécifiques :

• étiquettes.txt – Contient un mappage de la sortie du réseau neuronal (entiers) vers des étiquettes lisibles par l'homme (chaîne)
• fonction_lambda.py - Contient le code de la fonction appelée pour générer des prédictions sur chaque image de caméra et renvoyer les résultats

Dans lambda_function.py, vous chargez et optimisez d'abord le modèle. Comparé aux machines virtuelles cloud avec un GPU, AWS DeepLens a moins de puissance de calcul. AWS DeepLens utilise l'optimiseur de modèle Intel OpenVino pour optimiser le modèle formé dans SageMaker pour qu'il s'exécute sur son matériel. Le code suivant optimise votre modèle pour qu'il s'exécute localement :

client.publish(topic=iot_topic, payload='Optimizing model...') ret, model_path = mo.optimize('deploy_ssd_resnet50_300', INPUT_W, INPUT_H) # Load the model onto the GPU. client.publish(topic=iot_topic, payload='Loading model...') model = awscam.Model(model_path, {'GPU': 1}) 

Ensuite, vous exécutez le modèle image par image sur les images de la caméra. Voir le code suivant :

while True: # Get a frame from the video stream ret, frame = awscam.getLastFrame() if not ret: raise Exception('Failed to get frame from the stream') # Resize frame to the same size as the training set. frame_resize = cv2.resize(frame, (INPUT_H, INPUT_W)) # Run the images through the inference engine and parse the results using # the parser API, note it is possible to get the output of doInference # and do the parsing manually, but since it is a ssd model, # a simple API is provided. parsed_inference_results = model.parseResult(model_type, model.doInference(frame_resize)) 

Enfin, vous renvoyez les résultats de la prédiction de texte vers le cloud. L'affichage des résultats textuels dans le cloud est un moyen pratique de s'assurer que le modèle fonctionne correctement. Chaque appareil AWS DeepLens dispose d'un iot_topic dédié créé automatiquement pour recevoir les résultats d'inférence. Voir le code suivant :

# Send results to the cloud client.publish(topic=iot_topic, payload=json.dumps(cloud_output)) 

Créer un projet AWS DeepLens personnalisé

Pour créer un nouveau projet AWS DeepLens, procédez comme suit :

1. Sur la console AWS DeepLens, sur le Projets page, choisissez Créer un projet.
2. Pour Type de projet, sélectionnez Créer un nouveau projet vierge.
3. Selectionnez Suivant.

4. Nommez votre projet yourname-pedestrian-detector-.
5. Selectionnez Ajouter un modèle.
6. Sélectionnez le modèle que vous venez de créer.
7. Selectionnez Ajouter une fonction.
8. Recherchez la fonction Lambda que vous avez créée précédemment par son nom.
9. Selectionnez Créer un projet.
10. Sur le Projets , sélectionnez le projet que vous souhaitez déployer.
11. Choisissez Déployer sur l'appareil.
12. Pour Dispositif cible, choisissez votre appareil.
13. Selectionnez Avis.
14. Vérifiez vos paramètres et choisissez Déployer.

Le déploiement peut prendre jusqu'à 10 minutes, selon la vitesse du réseau auquel votre AWS DeepLens est connecté. Lorsque le déploiement est terminé, vous devriez voir une bannière verte sur la page avec le message « Félicitations, votre modèle s'exécute maintenant localement sur AWS DeepLens !

Pour voir la sortie de texte, faites défiler vers le bas sur la page des détails de l'appareil jusqu'à la Sortie du projet section. Suivez les instructions de la section pour copier la rubrique et accédez à la Noyau AWS IoT console pour vous abonner au sujet. Vous devriez voir les résultats comme dans la capture d'écran suivante.

Pour obtenir des instructions détaillées sur l'affichage du flux vidéo ou de la sortie texte, consultez Affichage des résultats d'AWS DeepLens.

Cas d'utilisation du monde réel

Maintenant que vous avez des prédictions de votre modèle s'exécutant sur AWS DeepLens, convertissons ces prédictions en alertes et informations. Certaines utilisations les plus courantes pour un projet comme celui-ci incluent :

• Comprendre combien de personnes un jour donné sont entrées dans une zone réglementée afin que les chantiers de construction puissent identifier les endroits qui nécessitent plus de panneaux de sécurité. Cela peut être fait en collectant les résultats et en les utilisant pour créer un tableau de bord à l'aide de Amazon QuickSight. Pour plus de détails sur la création d'un tableau de bord à l'aide de QuickSight, voir Créez un outil de suivi de la posture de travail à domicile avec AWS DeepLens et GluonCV.
• Collecte de la sortie d'AWS DeepLens et configuration d'un Raspberry Pi pour qu'il émette une alerte lorsque quelqu'un entre dans une zone restreinte. Pour plus de détails sur la connexion d'un appareil AWS DeepLens à un appareil Raspberry Pi, consultez Construire un trieur de déchets avec AWS DeepLens.

Conclusion

Dans cet article, vous avez appris à former un modèle de détection d'objets et à le déployer sur AWS DeepLens pour détecter les personnes entrant dans des zones restreintes. Vous pouvez utiliser ce didacticiel comme référence pour former et déployer vos propres projets de détection d'objets personnalisés sur AWS DeepLens.

Pour une présentation plus détaillée de ce didacticiel et d'autres didacticiels, exemples et idées de projet avec AWS DeepLens, consultez Recettes AWS DeepLens.

À propos des auteurs

Yash Shah est un data scientist au Amazon ML Solutions Lab, où il travaille sur une gamme de cas d'utilisation de l'apprentissage automatique, des soins de santé à la fabrication et à la vente au détail. Il a une formation formelle en facteurs humains et statistiques, et faisait auparavant partie de l'équipe Amazon SCOT qui concevait des produits pour guider les vendeurs 3P avec une gestion efficace des stocks.

Phu Nguyên est chef de produit pour AWS Panorama. Il conçoit des produits qui offrent aux développeurs de tout niveau de compétence une introduction simple et pratique à l'apprentissage automatique.

Source : https://aws.amazon.com/blogs/machine-learning/protecting-people-through-virtual-boundaries-computer-vision/