Améliorer les applications de vision par ordinateur avec des visualisations

Étape 1 : Mise en place de 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, en fonction de ce avec quoi tu es le plus à l'aise.

Si tu travailles dans Google Colab, garde à l'esprit qu'il utilise par défaut un CPU , ce qui peut ralentir les performances. Pour accélérer les choses, passe au GPU en allant dans le menu "Runtime", en sélectionnant "Change runtime type" et en réglant l'accélérateur matériel sur GPU (idéalement un T4).

Pour préparer ton environnement, tu devras installer le packageUltralytics Python à l'aide de la commande mentionnée ci-dessous. Dans les outils basés sur un carnet de notes comme Colab ou Jupyter, veille à ajouter un point d'exclamation ( !) avant la commande.

pip install ultralytics

‍

Étape 2 : Téléchargement d'un fichier vidéo

Ensuite, nous aurons besoin d'une vidéo pour travailler. Tu peux facilement en télécharger une sur un site de stock gratuit comme Pexels. Assure-toi de choisir une vidéo qui contient des objets que YOLO11 peut détecter. Étant donné que le modèle est pré-entraîné sur l'ensemble de données COCO, il peut reconnaître des objets courants tels que des personnes, des voitures et des vélos. 

Pour ce tutoriel, nous allons utiliser une vidéo de la 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 qui corresponde à ton projet.

‍

Étape 3 : Importer des paquets

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

Nous commencerons par importer OpenCV (cv2), qui est une bibliothèque largement utilisée pour travailler avec des images et des vidéos dans le domaine de la vision par ordinateur. Nous importerons également la bibliothèque Ultralytics , qui nous aide à effectuer 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 spécifiant son chemin d'accès. Veille à remplacer "path/to/video.mp4" par l'emplacement réel du fichier vidéo téléchargé. 

De plus, l'extrait de code ci-dessous comprend une simple vérification pour s'assurer que la vidéo se charge correctement. Si le chemin est erroné ou si le fichier est corrompu, le programme s'arrête et affiche un message d'erreur : "Erreur de lecture du fichier vidéo".

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'auteur de la vidéo

Ensuite, nous mettrons en place un graveur vidéo pour enregistrer le résultat. Lorsque nous exécuterons les analyses, cette partie du code créera un nouveau fichier vidéo qui enregistrera les graphiques mis à jour générés à partir de chaque image de la vidéo d'origine.

Dans l'extrait de code ci-dessous, nous commençons par extraire les propriétés clés de la vidéo d'entrée - sa largeur, sa hauteur et son nombre d'images par seconde (ips). Ces valeurs sont extraites directement de la vidéo et converties en nombres entiers pour s'assurer qu'elles sont dans le bon format pour 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, qui est une méthode de compression vidéo courante. La résolution de sortie est fixée à 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 : Mise en place de la solution Ultralytics Analytics

Nous allons maintenant configurer la solution Ultralytics Analytics pour qu'elle génère des graphiques à partir de la vidéo. Tu peux choisir le mode d'affichage des données, comme un diagramme linéaire, circulaire, de surface ou à barres, ainsi que le modèleYOLO à utiliser. Dans cet exemple, nous utiliserons le modèle léger "yolo11n.pt" et afficherons les résultats sous la forme d'un graphique de surface.

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

‍

Étape 6 : Traitement de la vidéo d'entrée

La dernière partie du code exécute une boucle qui traite la vidéo une image à la fois. Chaque image est transmise à l'outil d'analyse, qui met à jour le graphique en temps réel. Le graphique mis à jour est ensuite écrit sur la vidéo de sortie. Si une image ne peut pas être lue, la boucle s'arrête. Une fois que toutes les images ont été 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 le tout

Enfin, mettons tout ensemble. Avec quelques lignes de code supplémentaires, nous pouvons générer deux vidéos de sortie : l'une montrant les résultats de ladétection d'objets de YOLO11 avec des boîtes de délimitation et des étiquettes, et l'autre montrant les graphiques d'analyse en temps réel.

Pour ce faire, nous allons mettre en place deux instances de VideoWriter - une pour enregistrer la vidéo de prédiction et une autre pour les analyses. Cette version du code inclut à la fois le suivi des objets et la génération de graphiques, afin que tu puisses voir les résultats de la détection en même temps que les aperçus visuels.

Voici le code complet ainsi que des exemples de prédictions et d'analyses.

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 avec succès, il génère deux vidéos de sortie. Le fichier "output_predictions.avi" montrera les résultats de la détection d'objets avec les boîtes de délimitation et les étiquettes, tandis que "output_analytics.avi" affichera les graphiques d'analyse en temps réel basés sur les détections.

‍

Voici une image de la sortie analytique basée sur les prédictions. À l'aide du diagramme de zone, nous pouvons obtenir des informations comme les fluctuations du nombre de valises au fil du temps, par exemple un pic autour de l'image 268, indiquant un mouvement de valise ou une activité dans cette partie de la vidéo.

‍