Améliorer les applications de vision par ordinateur grâce aux visualisations

Chaque minute, d’énormes quantités de données sont créées, des terminaux d’aéroport et des gares aux centres commerciaux. À mesure que l’IA est de plus en plus utilisée, une grande partie de ces données est désormais analysée et décomposée. Mais les résultats de ces modèles d’IA peuvent parfois rendre difficile l’identification des schémas ou la compréhension des tendances en un coup d’œil. C’est là que la visualisation des données intervient : elle transforme des résultats complexes en informations claires et faciles à assimiler.

Cela est particulièrement vrai pour les applications de vision par ordinateur. La vision par ordinateur est une branche de l’intelligence artificielle (AI) qui aide les machines à interpréter et à comprendre les informations visuelles du monde qui les entoure, comme les images et les vidéos. Si les modèles d’IA visuelle, comme Ultralytics YOLO11, peuvent analyser ces données visuelles pour en extraire des informations, la visualisation des données aide à présenter ces informations dans un format facile à comprendre.

En termes simples, la visualisation des données comble l’écart entre les données brutes et leur compréhension réelle grâce à des graphiques analytiques pertinents. Dans le monde actuel fondé sur les données, c’est essentiel, car il ne suffit pas que les machines exécutent des tâches : nous voulons qu’elles racontent une histoire.

Ce besoin de raconter une histoire explique précisément pourquoi la visualisation des données est en plein essor, le marché devant atteindre $18,36 milliards d’ici 2030. Nous avons précédemment étudié comment la vision par ordinateur peut fournir des informations commerciales précieuses. Aujourd’hui, nous allons aller plus loin en parcourant la génération de graphiques analytiques clairs et pertinents pour les applications de vision par ordinateur à l’aide du package Ultralytics. C’est parti !

Fig. 1. Exemple de visualisation de données basée sur les sorties de YOLO11.

Présentation de la visualisation des données dans les applications de vision par ordinateur#

La visualisation des données dans les applications de vision par ordinateur consiste à transformer les résultats de tâches de vision par ordinateur, comme la détection et le suivi d’objets, en graphiques ou tableaux de bord faciles à comprendre. Ces représentations visuelles aident à identifier les schémas et les tendances, en particulier lorsqu’on travaille avec de gros volumes de séquences vidéo.

Par exemple, au lieu de regarder manuellement des heures de vidéosurveillance, un simple graphique linéaire présentant le nombre de voitures ou de personnes détectées au fil du temps peut rapidement mettre en évidence les heures de pointe ou les périodes inhabituellement calmes.

Voici quelques raisons essentielles pour lesquelles la visualisation des données est utile :

• Simplifie les données complexes : Des milliers de détections d’objets peuvent être difficiles à appréhender, mais des visualisations comme les graphiques à barres ou en secteurs facilitent la compréhension de la situation globale, par exemple pour voir quels objets apparaissent le plus souvent.

• Révèle les tendances : Les graphiques linéaires et à barres aident à identifier les schémas au fil du temps, comme les moments et les endroits où la circulation des piétons tend à augmenter.

• Fait gagner du temps : Au lieu d’examiner chaque image d’une vidéo, les graphiques peuvent rapidement mettre en évidence des détails importants, comme des pics soudains de l’activité des véhicules ou l’apparition inhabituelle d’objets dans des zones réservées.

• Améliore la communication : Les représentations visuelles facilitent le partage d’informations avec les publics non techniques et aident tout le monde à mieux comprendre les résultats.

Différents types de visualisations de données#

Différents types de graphiques analytiques peuvent transformer les résultats de la vision par ordinateur en représentations visuelles claires et faciles à comprendre. Imaginons que tu travailles sur une application de vision par ordinateur qui détecte des personnes et des véhicules dans des séquences de vidéosurveillance. Dans ce cas, un graphique linéaire est idéal pour montrer comment le nombre de détections évolue au fil du temps, par exemple pour suivre les pics de circulation piétonne tout au long de la journée.

De même, les graphiques à barres sont utiles lorsque tu veux comparer le nombre de différents types d’objets détectés, par exemple pour voir si la vidéo contient davantage de voitures, de vélos ou de piétons. Les graphiques en secteurs, quant à eux, montrent le pourcentage que représente chaque type d’objet par rapport au total des détections. Chaque graphique a sa propre utilité et contribue à rendre les données complexes de vision par ordinateur plus faciles à interpréter et à partager.

Fig. 2. Exemples de graphiques analytiques.

Générer des graphiques analytiques pour obtenir des informations sur la vision par ordinateur#

Maintenant que nous avons étudié ce qu’est la visualisation des données et pourquoi les différents types de graphiques analytiques sont importants, examinons de plus près comment utiliser la solution Ultralytics Analytics pour visualiser les résultats des prédictions de ton modèle de vision par ordinateur. Avant de détailler le processus étape par étape, intéressons-nous aux outils et aux options de configuration permettant d’entraîner et d’utiliser le package Ultralytics ainsi que des modèles comme YOLO11.

Le package Python Ultralytics facilite l’entraînement des modèles, la détection d’objets, l’exécution de prédictions et la visualisation des résultats. Pour commencer, tu auras besoin d’un environnement de programmation. Voici trois options simples :

• Interface de ligne de commande (CLI) : Il s’agit d’un outil de base, uniquement textuel, dans lequel tu peux saisir des commandes pour exécuter ton code. Il ne possède pas d’interface visuelle et tu interagis avec lui en saisissant des instructions dans un terminal ou une invite de commande.

• Jupyter Notebooks : Il s’agit d’un environnement de programmation interactif dans lequel tu peux écrire, exécuter et tester de petits morceaux de code (appelés « cellules ») un par un. Les résultats s’affichent directement sous chaque cellule, ce qui facilite la compréhension de ce qui se passe étape par étape. Cet environnement est particulièrement utile pour l’apprentissage et l’expérimentation.

• Google Colab : cette option est une version gratuite de Jupyter Notebooks, hébergée dans le cloud et exécutée dans ton navigateur web. Elle ne nécessite aucune configuration sur ton ordinateur et te donne accès à des GPU gratuits pour accélérer le traitement.

Ces outils sont parfaits pour démarrer rapidement, mais tu peux également intégrer Ultralytics dans des environnements de développement intégrés (IDE) comme Visual Studio Code (VS Code), ou dans des pipelines de production. Pour découvrir d’autres options, consulte la documentation officielle d’Ultralytics.

Étape 1 : configurer l’environnement#

Une fois que tu as choisi ton environnement préféré, l’étape suivante consiste à le configurer pour exécuter les prédictions et visualiser les résultats. Tu peux utiliser n’importe lequel des environnements mentionnés ci-dessus, selon celui avec lequel tu es le plus à l’aise.

Si tu travailles dans Google Colab, n’oublie pas qu’il utilise un CPU par défaut, ce qui peut ralentir les performances. Pour accélérer les choses, passe à un GPU en ouvrant le menu « Runtime », en sélectionnant « Change runtime type » et en définissant l’accélérateur matériel sur GPU (idéalement un T4).

Pour préparer ton environnement, tu devras installer le package Python Ultralytics à l’aide de la commande indiquée ci-dessous. Dans les outils basés sur des notebooks comme Colab ou Jupyter, veille à ajouter un point d’exclamation (!) avant la commande.

pip install ultralytics

Étape 2 : Télécharger un fichier vidéo#

Ensuite, nous aurons besoin d’une vidéo avec laquelle travailler. Tu peux facilement en télécharger une depuis un site de vidéos libres de droits comme Pexels. Veille à choisir une vidéo contenant des objets qu’Ultralytics YOLO11 peut détecter. Comme le modèle a été préentraîné sur le jeu de données COCO, il peut reconnaître des objets courants comme les personnes, les voitures et les vélos.

Pour ce tutoriel, nous utiliserons une vidéo de manutention des bagages dans un terminal d’aéroport très fréquenté. Tu peux utiliser la même vidéo ou en choisir une autre adaptée à ton projet.

Fig. 3. Une image de la vidéo d’entrée montrant la manutention des bagages dans un terminal d’aéroport.

Étape 3 : Importer les packages#

Ensuite, nous pouvons importer les bibliothèques nécessaires et charger la vidéo d’entrée.

Nous commencerons par importer OpenCV (cv2), une bibliothèque très utilisée pour travailler avec des images et des vidéos en vision par ordinateur. Nous importerons également la bibliothèque Ultralytics, qui nous aide à exécuter la détection d’objets et à générer des analyses à partir de la vidéo.

Ensuite, nous essaierons d’ouvrir le fichier vidéo en indiquant son chemin. Veille à remplacer "path/to/video.mp4" par l’emplacement réel du fichier vidéo téléchargé.

L’extrait de code ci-dessous comprend également une vérification simple pour s’assurer que la vidéo se charge correctement. Si le chemin est incorrect ou si le fichier est corrompu, le programme s’arrêtera et affichera le message d’erreur suivant : "Error reading video file."

import cv2
from ultralytics import solutions

cap = cv2.VideoCapture("path/to/video.mp4")
assert cap.isOpened(), "Error reading video file"

Étape 4 : Préparer l’écriture de la vidéo#

Ensuite, nous allons configurer un outil d’écriture vidéo pour enregistrer la sortie. Lorsque nous exécuterons les analyses, cette partie du code créera un nouveau fichier vidéo contenant les graphiques mis à jour générés à partir de chaque image de la vidéo originale.

Dans l’extrait de code ci-dessous, nous extrayons d’abord les propriétés clés de la vidéo d’entrée : sa largeur, sa hauteur et ses images par seconde (fps). Ces valeurs sont extraites directement de la vidéo et converties en entiers pour garantir leur compatibilité avec l’écriture de la sortie.

Ensuite, nous utilisons la fonction cv2.VideoWriter pour créer un nouveau fichier vidéo nommé "analytics_output.avi" (tu peux le renommer si nécessaire). La vidéo est enregistrée au format MJPG, une méthode courante de compression vidéo. La résolution de sortie est définie sur 1280×720 pixels, quelle que soit la taille de la vidéo originale.

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
out = cv2.VideoWriter(
    "analytics_output.avi",
    cv2.VideoWriter_fourcc(*"MJPG"),
    fps,
    (1280, 720),
)

Étape 5 : Configurer la solution Ultralytics Analytics#

Nous allons maintenant configurer la solution Ultralytics Analytics pour générer des graphiques à partir de la vidéo. Tu peux choisir le mode d’affichage des données, par exemple un graphique linéaire, en secteurs, en aires ou à barres, ainsi que le modèle YOLO à utiliser. Dans cet exemple, nous utiliserons le modèle léger "yolo11n.pt" et afficherons les résultats sous forme de graphique en aires.

analytics = solutions.Analytics(
    show=True,
    analytics_type="area",
    model="yolo11n.pt",
)

Étape 6 : Traiter la vidéo d’entrée#

La dernière partie du code exécute une boucle qui traite la vidéo image par image. Chaque image est transmise à l’outil d’analyse, qui met à jour le graphique en temps réel. Le graphique mis à jour est ensuite écrit dans la vidéo de sortie. Si une image ne peut pas être lue, la boucle s’arrête. Une fois toutes les images traitées, la vidéo est enregistrée et toutes les fenêtres ouvertes sont fermées.

frame_count = 0
while cap.isOpened():
    success, im0 = cap.read()
    if success:
        frame_count += 1
        results = analytics(im0, frame_count)
        out.write(results.plot_im)
    else:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

Étape 7 : Assembler tous les éléments#

Enfin, assemblons tous les éléments. Avec seulement quelques lignes de code supplémentaires, nous pouvons générer deux vidéos de sortie : l’une montrant les résultats de détection d’objets d’Ultralytics YOLO11 avec des boîtes englobantes et des étiquettes, et l’autre affichant les graphiques d’analyse en temps réel.

Pour ce faire, nous allons configurer deux instances de VideoWriter : l’une pour enregistrer la vidéo des prédictions et l’autre pour les analyses. Cette version du code comprend à la fois le suivi des objets et la génération de graphiques, afin que tu puisses voir les résultats des détections לצד des informations visuelles.

Voici le code complet ainsi que des exemples des sorties de prédiction et d’analyse.

import cv2
from ultralytics import YOLO, solutions

# Load model and video
model = YOLO('yolo11n.pt')
cap = cv2.VideoCapture('path/to/video.mp4')
assert cap.isOpened(), "Error opening video"

# Get properties
w, h = int(cap.get(3)), int(cap.get(4))
fps = cap.get(5)
analytics_res = (1280, 720)

# Writers for prediction and analytics videos
out_pred = cv2.VideoWriter('output_predictions.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, (w, h))
out_ana = cv2.VideoWriter('output_analytics.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, analytics_res)

# Analytics setup
analytics = solutions.Analytics(show=True, analytics_type="area", model='yolo11n.pt')

# Process frames
frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    frame_count += 1
    pred_frame = model.track(frame, persist=True)[0].plot()
    out_pred.write(pred_frame)
    resized = cv2.resize(pred_frame, analytics_res)
    out_ana.write(analytics(resized, frame_count).plot_im)

cap.release(), out_pred.release(), out_ana.release(), cv2.destroyAllWindows()

Lorsque le code ci-dessus s’exécute correctement, il génère deux vidéos de sortie. Le fichier “output_predictions.avi” affiche les résultats de la détection d’objets avec des boîtes englobantes et des étiquettes, tandis que “output_analytics.avi” affiche les graphiques d’analyse en temps réel basés sur les détections.

Fig. 4. Une image du fichier “output_predictions.avi”.

Voici une image de la sortie d’analyse basée sur les prédictions. Grâce au graphique en aires, nous pouvons obtenir des informations telles que les fluctuations du nombre de valises au fil du temps, notamment un pic autour de l’image 268, indiquant un déplacement ou une activité des valises à cet endroit de la vidéo.

Fig. 5. Prédictions d’Ultralytics YOLO11 visualisées sous forme de graphique en aires.

Utiliser des graphiques dans des applications de vision par ordinateur réelles#

Voici quelques applications concrètes de la vision par ordinateur dans lesquelles la visualisation des données a un impact significatif :

• Santé : Les systèmes de vision par ordinateur peuvent surveiller en temps réel l’activité des patients, les déplacements du personnel et l’utilisation des équipements. Cela génère d’importantes quantités de données visuelles qui, une fois visualisées, peuvent révéler des schémas, comme les périodes de forte occupation des patients ou les retards d’intervention.

• Commerce de détail et e-commerce : L’IA visuelle peut être utilisée pour suivre les déplacements des clients, le temps passé devant les rayons et les interactions avec les produits. Les analyses visuelles, comme les graphiques à barres ou en secteurs, peuvent mettre en évidence les zones du magasin ou les articles qui attirent le plus l’attention, aidant ainsi les commerçants à optimiser le placement des produits et à améliorer les conversions.

• Industrie manufacturière : Des caméras équipées de modèles de vision par ordinateur peuvent surveiller les lignes d’assemblage pour détecter les défauts, les violations des règles de sécurité ou l’état des équipements. La visualisation des données peut montrer les tendances des types de défauts les plus courants ou mettre en évidence les périodes présentant les taux d’erreur les plus élevés, permettant une prise de décision plus rapide et une maintenance préventive.

Points clés à retenir#

Avec le package Ultralytics, tu peux facilement transformer des séquences vidéo en graphiques clairs et pertinents qui révèlent ce qui se passe, par exemple en suivant le nombre de personnes ou d’objets présents au fil du temps. Au lieu d’examiner manuellement des heures de vidéo, tu peux générer des synthèses visuelles qui mettent en évidence les principaux schémas et tendances, ce qui facilite une intervention rapide. Que ce soit dans les hôpitaux, les magasins ou les sites industriels, ces graphiques transforment des résultats complexes de l’IA en informations que tout le monde peut comprendre et utiliser.

Tu veux en savoir plus sur l’AI ? Explore notre dépôt GitHub, rejoins notre communauté et consulte nos options de licence pour donner un nouvel élan à ton projet de vision par ordinateur. Découvre également d’autres innovations, comme l’AI dans l’industrie manufacturière et la vision par ordinateur dans le secteur de la logistique, sur nos pages consacrées aux solutions.