Exécuter les modèles de détection et de segmentation d'objets Ultralytics en quelques lignes de code

Bienvenue dans un nouvel article de blog où nous plongeons dans les capacités des modèles Ultralytics' YOLOv5 et YOLOv8 en matière de détection d'objets et de segmentation. Nous allons explorer comment intégrer ces modèles faciles à utiliser dans tes projets en quelques lignes de code seulement. Que tu sois débutant ou développeur expérimenté, tu verras comment Ultralytics prend en charge divers modèles et architectures, y compris différentes versions de YOLO et des modèles basés sur les Transformer.

Dans sa vidéo, Nicolai Nielsen nous guide à travers le processus de configuration et d'utilisation de différents modèles au sein du framework Ultralytics. Décomposons cela étape par étape et voyons comment tu peux démarrer avec ces outils incroyables.

Bien démarrer avec les modèles Ultralytics#

Ultralytics propose un framework complet qui prend en charge plusieurs modèles de détection d'objets et de segmentation. Cela inclut les modèles YOLO populaires, allant de YOLOv3 au dernier YOLOv8, ainsi que les modèles YOLO-NAS et SAM. Ces modèles sont conçus pour gérer une variété de tâches telles que la détection en temps réel, la segmentation et l'estimation de pose.

Pour commencer, visite la page de documentation d'Ultralytics. Tu y trouveras des informations détaillées sur chaque modèle, y compris leurs principales caractéristiques, leurs architectures et la manière de les utiliser dans tes scripts Python.

Configuration de ton environnement#

Tout d'abord, assure-toi d'avoir installé Ultralytics. Tu peux le faire en exécutant :

pip install ultralytics

Une fois que c'est fait, tu peux commencer à utiliser ces modèles dans tes projets. Commençons par le modèle Ultralytics YOLOv8 comme exemple.

Principales caractéristiques d'Ultralytics YOLOv8#

Ultralytics YOLOv8 propose plusieurs améliorations par rapport à ses prédécesseurs. Il est conçu pour être plus rapide et plus précis, ce qui le rend parfait pour les applications en temps réel. Quelques fonctionnalités clés incluent :

• Vitesse et précision améliorées
• Poids pré-entraînés pour de multiples tâches
• Support pour la détection d'objets, la segmentation et la classification
• Architecture de modèle améliorée pour de meilleures performances

Exécuter Ultralytics YOLOv8 en Python#

Voici comment tu peux démarrer avec Ultralytics YOLOv8 en quelques lignes de code seulement :

from ultralytics import YOLO

# Load a pretrained Ultralytics YOLOv8 model
model = YOLO("yolov8n.pt")

# Run inference on an image
results = model("path/to/image.jpg")

C'est tout ! Tu viens d'exécuter un modèle YOLOv8 sur une image. Cette simplicité est ce qui rend les modèles Ultralytics si puissants et conviviaux.

Détection par webcam en direct#

Tu veux voir Ultralytics YOLOv8 en action sur un flux de webcam en direct ? Voici comment faire :

from ultralytics import YOLO

# Load a pretrained Ultralytics YOLOv8 model
model = YOLO("yolov8n.pt")

# Run inference on the webcam feed (source=0) and display the results
results = model.predict(source=0, show=True)

Ce script va ouvrir ta webcam et appliquer le modèle Ultralytics YOLOv8 pour détecter des objets en temps réel.

Fig 1. Nicolai Nielsen expliquant comment exécuter les modèles de détection d'objets et de segmentation d'Ultralytics.

Explorer d'autres modèles#

Ultralytics ne s'arrête pas à YOLOv8. Il prend également en charge d'autres modèles tels que YOLOv5, YOLO-NAS et des modèles basés sur les Transformer pour la détection en temps réel. Chaque modèle a ses propres points forts et cas d'utilisation.

Modèles Transformer et comment les exécuter#

Le modèle RT-DETR, développé par Baidu et pris en charge par Ultralytics, est un détecteur d'objets de bout en bout de pointe qui offre des performances en temps réel et une haute précision. Il utilise une backbone basée sur la convolution et un encodeur hybride efficace pour une vitesse en temps réel, excelle sur CUDA avec TensorRT et prend en charge un ajustement flexible de la vitesse d'inférence.

Voici comment tu peux exécuter un modèle RT-DETR :

from ultralytics import RTDETR

# Load a COCO-pretrained RT-DETR-l model
model = RTDETR("rtdetr-l.pt")

# Run inference on an image
results = model("path/to/image.jpg")

Modèles de segmentation (Segment Anything Models)#

Ultralytics propose également des modèles pour les tâches de segmentation, tels que MobileSAM et FastSAM. Ces modèles sont conçus pour segmenter tout ce qui se trouve dans une image, offrant des perspectives détaillées sur la scène.

Exécuter FastSAM#

FastSAM est optimisé pour la segmentation en temps réel, et voici comment tu peux l'exécuter :

from ultralytics import FastSAM

# Create a FastSAM model
model = FastSAM("FastSAM-s.pt")  # or FastSAM-x.pt

# Run inference on an image
results = model("path/to/image.jpg", device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)

Ce modèle est parfait pour les applications qui nécessitent une segmentation rapide et précise.

Performances et comparaisons#

L'une des grandes fonctionnalités du framework Ultralytics est la possibilité de comparer différents modèles côte à côte. Tu peux facilement déterminer quel modèle fonctionne le mieux pour ton application spécifique en examinant les mesures de performance telles que la vitesse d'inférence et la précision moyenne (mAP).

Points clés à retenir#

Ultralytics rend incroyablement facile l'exécution de modèles de détection d'objets et de segmentation avec seulement quelques lignes de code. Que tu travailles sur des applications en temps réel ou que tu aies besoin de modèles de haute précision, Ultralytics a une solution pour toi. Assure-toi de consulter le tutoriel complet de Nicolai Nielsen sur la chaîne YouTube d'Ultralytics pour plus d'informations et d'exemples détaillés.

Reste à l'écoute pour plus de tutoriels et de mises à jour de la part de la communauté Ultralytics !