Analyse de compteurs intelligents avec le kit d'outils OpenVINO™ : reconnaissance et segmentation d'objets par l'IA

Voir tous les kits de référence pour l'IA à l'Edge

author-image

Par

Présentation

Dans ce tutoriel, vous allez apprendre à développer une application d'analyse de compteurs intelligents à l'aide du kit d'outils OpenVINO™ en suivant le notebook Jupyter*. Consultez les données de référence réelle et réalisez des bancs d'essai concrets sur votre propre installation.

Grâce à la boîte à outils OpenVINO, vous pouvez développer une application basée sur l'IA pour la lecture numérique des compteurs industriels en utilisant la reconnaissance d'objets, l'OCR pour les compteurs numériques et la segmentation pour les compteurs à aiguille. La boîte à outils OpenVINO minimise le temps nécessaire au traitement des données d'entrée pour produire une prédiction en sortie. La prise de décision est plus rapide et les interactions avec le système sont plus efficaces. Cela permet d'utiliser la vision par ordinateur pour lire les compteurs, de minimiser les erreurs et d'atteindre un degré de précision plus élevé.

Dans des domaines tels que la consommation d'énergie, l'inspection manuelle des compteurs analogiques est imprécise, et leur remplacement par des compteurs numériques peut s'avérer coûteux. Les données en temps réel de cette application permettent aux entreprises d'identifier de manière proactive les points à améliorer et les problèmes de sécurité, et même de détecter les dysfonctionnements potentiels de en cas d’anomalies dans les schémas d’utilisation.

De plus, cette solution peut être appliquée à tout ce qui implique la transformation de données analogiques en données numériques par le biais de la reconnaissance et de la segmentation d'objets.

Pré-requis

Étape 1 : cloner le référentiel

Pour cloner le référentiel d'analyse des compteurs intelligents sur votre système, exécutez la commande suivante :

git clone -b recipes https://github.com/openvinotoolkit/openvino_notebooks.git

Cette opération clone le référentiel dans le dossier openvino_notebooks. Ensuite, accédez au dossier :

cd openvino_notebooks/recipes/meter_reader

Cette application utilise Python pour mettre en place un environnement virtuel pour ce projet. Si le package de l'environnement virtuel n'est pas installé, exécutez la commande suivante :

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python3-ven

Si vous disposez d'un processeur avec une carte graphique intégrée d'Intel, pour activer l'inférence sur cet appareil, installez le pilote Intel® Graphics Compute Runtime for oneAPI Level Zero and OpenCL™ Driver. Voici la commande pour Ubuntu* 20.04 :

sudo apt-get install intel-opencl-icd

Ensuite, préparez votre environnement virtuel.

Étape 2 : créer et activer un environnement virtuel

Pour éviter d'affecter votre système de manière globale, la bonne pratique consiste à isoler un projet Python dans son propre environnement. Pour configurer un environnement virtuel, ouvrez le terminal ou l'invite de commande et naviguez jusqu'au répertoire dans lequel vous souhaitez installer l'environnement. Ensuite, exécutez la commande suivante pour créer un nouvel environnement virtuel : 

Pour les systèmes d'exploitation basés sur UNIX* comme Linux* ou macOS*, utilisez :

python3 -m venv venv

Pour Windows*, utilisez :

python -m venv venv

Cette opération crée un nouvel environnement virtuel, venv, dans le dossier actuel. Ensuite, activez l'environnement que vous venez de créer. La commande utilisée dépend de votre système d'exploitation. 

Pour les systèmes d'exploitation basés sur UNIX comme Linux ou macOS, exécutez :

source venv/bin/activate

Pour Windows, exécutez :

 venvScriptsactivate

Cela active l'environnement virtuel et modifie l'invite de votre shell pour l'indiquer.

Étape 3 : installer les dépendances

L'application d'analyse des compteurs intelligents comporte un certain nombre de dépendances qui doivent être installées afin de pouvoir fonctionner. Ces dernières sont énumérées dans le fichier requirements.txt inclus et peuvent être installées à l'aide du programme d'installation des packages Python. 

Pour installer les bibliothèques Python requises, y compris le kit d'outils OpenVINO, exécutez la commande suivante :

python -m pip install --upgrade pip 

pip install -r requirements.txt

Toutes les dépendances sont désormais installées. Ensuite, vous allez préparer les modèles et configurer l'application.

Étape 4 : préparer les modèles

Les modèles pour une solution de relevé de compteur comprennent des modèles de reconnaissance et de segmentation. Ils peuvent être créés avec n'importe quel framework d'entraînement IA, tel que PyTorch* ou TensorFlow*. Dans cet exemple, exécutez la commande suivante pour télécharger des modèles pré-entraînés à partir de PaddlePaddle* :

cd model

sudo sh ./download_pdmodel.sh

Étape 5 : configurer l'application d'analyse de compteurs intelligents

L'image test de ce projet contient différents types de compteurs industriels, dont il faut prédéfinir les paramètres pour calculer les relevés finaux. Ces paramètres comprennent la plage du compteur, les valeurs de l'intervalle d'échelle et les unités. Ils peuvent être configurés comme suit :

"meter_config": [

 {

 "scale_interval_value": 0.5,

 "range": 25.0,

 "unit": "(MPa)"

 },

 {

 "scale_interval_value": 0.05,

 "range": 1.6,

 "unit": "(MPa)"

 }

	],

Outre la configuration des compteurs, les paramètres du modèle sont également définis, notamment le chemin d'accès au fichier du modèle, la forme de l'entrée, le paramètre de normalisation et le format des couleurs. Ces paramètres sont mis en œuvre dans l'étape de prétraitement de chaque modèle :

"model_config": {

 "detector": {

 "model_path": "./model/meter_det_model/model.pdmodel",

 "device": "CPU",

 "input_shape": 608,

 "model_shape": {"image": [1, 3, 608, 608], "im_shape": [1, 2], "scale_factor": [1, 2]},

 "scale": 255,

 "color_format": "bgr",

 "mean": [

 0.485,

 0.456,

 0.406

 ],

 "std": [

 0.229,

 0.224,

 0.225

 ]

 },

 "segmenter": {

 "model_path": "./model/meter_seg_model/model.pdmodel",

 "device": "CPU",

 "batch_size": 2,

 "input_shape": 512,

 "model_shape": {"image": [-1, 3, 512, 512]},

 "scale": 255,

 "color_format": "bgr",

  "mean": [

 0.5,

 0.5,

 0.5

 ],

 "std": [

 0.5,

 0.5,

 0.5

 ]

 }

 } 

Ces paramètres se trouvent dans le dossier config/config.json. Ces valeurs doivent être ajustées en conséquence pour d'autres scénarios avec des compteurs et des modèles différents.

Étape 6 : comprendre le prétraitement et le post-traitement

Le relevé de compteur analogique peut être divisé en deux parties : le prétraitement, qui implique le formatage de l'image pour la reconnaissance et la segmentation des compteurs, et le post-traitement, qui traite les données pour produire le relevé de compteur final.

L'application commence par le prétraitement des images. Ce processus comprend la transposition de la disposition, la normalisation et le redimensionnement des images pour qu'elles correspondent aux exigences d'entrée du modèle. Cette image est alors prête à être utilisée avec un modèle de reconnaissance d'objets, dans le but de détecter tous les compteurs sur l'image.

def detect(self, input):  

 # Prepare the input data for meter detection model 

 im_shape = np.array([[self.input_shape, self.input_shape]]).astype('float32') 

 scale_factor = np.array([[1, 2]]).astype('float32') 

 input_image = self.det_preprocess(input, self.input_shape) 

 inputs_dict = {'image': input_image, "im_shape": im_shape, "scale_factor": scale_factor} 

 # Run meter detection model 

 det_results = self.det_compiled_model(inputs_dict)[self.det_output_layer] 

 # Filter out the bounding box with low confidence 

 filtered_results = self.filter_bboxes(det_results, self.score_threshold) 

 # Prepare the input data for meter segmentation model 

 scale_x = input.shape[1] / self.input_shape * 2 

 scale_y = input.shape[0] / self.input_shape 

 # Create the individual picture for each detected meter 

 roi_imgs, self.loc = self.roi_crop(input, filtered_results, scale_x, scale_y)  

 roi_imgs, resize_imgs = self.roi_process(roi_imgs, self.METER_SHAPE) 

 # Create the pictures of detection results 

 roi_stack = np.hstack(resize_imgs) 

 cv2.imwrite("./data/detection_results.jpg", roi_stack) 

 return roi_imgs 

Les résultats de reconnaissance peu fiables sont également filtrés, et les régions d'intérêt (ROI) pertinentes sont renvoyées. Ces images sont ensuite recadrées et traitées pour la segmentation.

def roi_crop(image, results, scale_x, scale_y): 

 roi_imgs = [] 

 loc = [] 

 for result in results: 

 bbox = result[2:] 

 xmin, ymin, xmax, ymax = [int(bbox[0] * scale_x), int(bbox[1] * scale_y), int(bbox[2] * scale_x), int(bbox[3] * scale_y)] 

 sub_img = image[ymin:(ymax + 1), xmin:(xmax + 1), :] 

 roi_imgs.append(sub_img) 

 loc.append([xmin, ymin, xmax, ymax]) 

 return roi_imgs, loc 

Dans ce cas, le nombre de compteurs potentiellement détectés dans une photo est arbitraire, ce qui signifie que la forme d'entrée du modèle de segmentation peut varier en fonction de la taille du lot. Cela s'appelle une forme dynamique. Il existe plusieurs approches pour traiter des entrées de taille arbitraire, telles que le remplissage (padding), le remodelage de modèle et les modèles pré-compilés multiples. 

Le kit d'outils OpenVINO présente l'avantage de permettre le chargement direct de données avec mise en forme dynamique dans l'environnement d'exécution d'OpenVINO. Si le nombre maximum de compteurs dans l'image peut être prédit, il est fortement recommandé de fixer la limite supérieure de la taille des données d'entrée par le biais de la plage de dimensions, qui offre de meilleures performances d'inférence en raison d'une consommation de mémoire plus faible.

def segment(self, input):  

 seg_results = list() 

 num_imgs = len(input) 

 image_list = list() 

 # Run meter segmentation model on all detected meters 

 for i in range(0, num_imgs, self.seg_batch_size): 

 batch = input[i : min(num_imgs, i + self.seg_batch_size)] 

 seg_result = self.seg_compiled_model({"image": np.array(batch)})[self.seg_output_layer] 

 seg_results.extend(seg_result) 

 results = [] 

 for i in range(len(seg_results)): 

 results.append(np.argmax(seg_results[i], axis=0))  

 seg_results = self.erode(results, self.erode_kernel) 

 # Create the pictures of segmentation results 

 for i in range(len(seg_results)): 

  image_list.append(self.segmentation_map_to_image( 

	 seg_results[i], self.COLORMAP)) 

 # Create the pictures of segmentation results 

 mask_stack = np.hstack(image_list) 

 cv2.imwrite("./data/segmentation_results.jpg", cv2.cvtColor(mask_stack, cv2.COLOR_RGB2BGR)) 

 return seg_results 

Une fois la segmentation effectuée, le prétraitement est terminé et les résultats peuvent être intégrés dans le post-traitement. Une fois les compteurs détectés et segmentés, les relevés finaux doivent être traités et renvoyés. Cela inclut la binarisation des échelles et des pointeurs pour calculer l'emplacement du pointeur dans une carte à l'échelle afin d'obtenir un relevé de compteur final.

def postprocess(self, input): 

 # Find the pointer location in scale map and calculate the meters reading  

 rectangle_meters = self.circle_to_rectangle(input) 

 line_scales, line_pointers = self.rectangle_to_line(rectangle_meters) 

 binaried_scales = self.mean_binarization(line_scales) 

 binaried_pointers = self.mean_binarization(line_pointers) 

 scale_locations = self.locate_scale(binaried_scales) 

 pointer_locations = self.locate_pointer(binaried_pointers) 

 pointed_scales = self.get_relative_location(scale_locations, pointer_locations) 

 meter_readings = self.calculate_reading(pointed_scales) 

Le pipeline de post-traitement peut également être visualisé comme suit : 

diagramme du processus du pipeline

 

 

Étape 7 : exécuter l'application d'analyse de compteurs intelligents

Maintenant que vous avez compris ce que sont le prétraitement et le post-traitement, vous pouvez exécuter l'application et obtenir un relevé de compteur final.

Pour charger et compiler les modèles de deep learning pour la reconnaissance et la segmentation des compteurs, exécutez le code suivant :

# Loading and compiling for meter detection: 

self.det_model = ie_core.read_model(det_model_path) 

self.det_model.reshape(det_model_shape) 

self.det_compiled_model = ie_core.compile_model( 

model=self.det_model, device_name=self.config["model_config"] 

	["detector"]["device"]) 

self.det_output_layer = self.det_compiled_model.output(0) 

 

# Loading and compiling for meter segmentation: 

 self.seg_model = ie_core.read_model(seg_model_path) 

self.seg_model.reshape(seg_model_shape) 

self.seg_compiled_model = ie_core.compile_model( 

model=self.seg_model, device_name=self.config["model_config"] 

	["segmenter"]["device"]) 

self.seg_output_layer = self.seg_compiled_model.output(0) 

Remarque Dans le paramètre device_name utilisé pour l'exécution de l'inférence, vous pouvez indiquer votre préférence pour le dispositif ou le régler sur AUTO pour laisser le kit d'outils OpenVINO choisir le meilleur dispositif d'inférence parmi ceux disponibles. 

Pour exécuter l'application, exécutez la commande suivante. Veillez à remplacer config/config.json et data/test.jpg par le chemin d'accès à votre fichier de configuration et à votre image test. Les images de résultats sont exportées dans le même dossier que l'image test.

python main.py -i data/test.jpg -c config/config.json -t "analog"

Les paramètres d'entrée pour exécuter l'application comprennent : 

  • -i : le chemin d'accès à l'image d'entrée, une image des compteurs industriels capturée par une caméra en direct. 
  • -c : le chemin d'accès au fichier de configuration, qui comprend les paramètres pour l'inférence du modèle ainsi que les étapes de prétraitement et de post-traitement. 
  • -t : choisissez entre analog et digital pour mettre en œuvre une lecture automatique des compteurs pour les compteurs industriels analogiques ou numériques. 

Grâce à cela, vous obtenez vos relevés de compteur.

Étape 8 : banc d'essai de performances avec Benchmark_App

Pour évaluer les performances des modèles dans le pipeline des relevés de compteurs, utilisez l'outil Benchmark_App du kit d'outils OpenVINO. Cette étape permet de connaître les performances réelles du modèle et de planifier son déploiement.

Le nouveau modèle YOLO* v8l entraîné qui utilise le framework Ultralytics est recommandé (PPYOLO v2 n'est actuellement pas pris en charge par les GPU). Vous pouvez le télécharger depuis le même référentiel dans GitHub*

Pour exécuter cette application avec le pipeline YOLO v8l, remplacez le fichier de configuration par défaut par ./config/yolov8.json à l'aide de la commande suivante :

python main.py -i data/test.jpg -c config/yolov8.json 

  -t "analog"

Pour exécuter l'application Benchmark_App dans l'Intel® Developer Cloud ou sur votre machine locale, référez-vous aux exemples suivants :

!python benchmark_app -m ./model/yolov8.onnx  

	 -shape [1, 3, 608, 608]  

            -d $DEVICE  

            -niter 50  

            -hint $PERF_HINT  

            --report_type detailed_counters  

            --report_folder ${SAMPLEPATH}/${OUTPUT_FILE}/${JOB_ID} 

 

!python benchmark_app -m ./model/deeplabv3+.onnx  

	 -shape [1, 3, 512, 512]  

            -d $DEVICE  

            -niter 50  

            -hint $PERF_HINT  

            --report_type detailed_counters  

            --report_folder ${SAMPLEPATH}/${OUTPUT_FILE}/${JOB_ID}

Ici, les performances de YOLO v8l entraîné dans le pipeline Ultralytics ont été testées pour la détection des compteurs, et les performances de DeepLabv3+ entraîné dans le framework PyTorch ont été testées pour la segmentation des compteurs.

Conclusion

Vous avez appris à utiliser OpenVINO pour créer une application d'analyse de compteurs intelligents qui utilise la vision par ordinateur pour la reconnaissance et la segmentation d'objets afin de lire des compteurs industriels analogiques. Cette solution constitue une alternative fiable et évolutive à la reconnaissance manuelle et permet d'améliorer la précision, la rapidité d'exécution et la sécurité. 

Dans tous les secteurs qui utilisent des compteurs analogiques, comme celui de l'énergie ou de la fabrication, un grand nombre de compteurs nécessitent des relevés d'inspection constants pour garantir un fonctionnement durable et la sécurité. Ces compteurs se présentent sous des formes très diverses, sont dispersés sur différents sites et sont soumis à des conditions de fonctionnement difficiles.

L'utilisation de l'inférence IA permet de créer des applications intelligentes capables d'analyser en temps réel des données visuelles, d'en extraire des informations précieuses et d'améliorer les opérations commerciales. OpenVINO veille à ce que ce processus soit performant et offre une faible latence.

Si vous avez des questions ou des choses à partager, rejoignez la discussion sur GitHub ou sur la chaîne d'assistance de la communauté Intel. Pour en savoir plus sur le développement avec le kit d'outils OpenVINO, consultez la documentation

 

Pour des informations plus détaillées sur les bancs d'essai de performances, consultez GitHub.