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 allons explorer les capacités des modèles Ultralytics' YOLOv5 et YOLOv8 en matière de détection d'objets et de segmentation. Nous allons découvrir comment intégrer ces modèles faciles à utiliser dans tes projets avec seulement quelques lignes de code. 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 Transformer.

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

Link to this sectionBien 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 aux derniers 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, consulte la page de documentation d'Ultralytics. Tu y trouveras des informations détaillées sur chaque modèle, y compris leurs fonctionnalités clés, leurs architectures et comment les utiliser dans tes scripts Python.

Link to this sectionConfiguration 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 YOLOv8 comme exemple.

Link to this sectionFonctionnalités clés de YOLOv8#

YOLOv8 apporte 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

Link to this sectionExécuter YOLOv8 avec Python#

Voici comment tu peux te lancer avec YOLOv8 en seulement quelques lignes de code :

from ultralytics import YOLO

# Load a pretrained 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.

Link to this sectionDétection par webcam en direct#

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

from ultralytics import YOLO

# Load a pretrained 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 ouvrira ta webcam et appliquera le modèle YOLOv8 pour détecter des objets en temps réel.

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

Link to this sectionExplorer d'autres modèles#

Ultralytics ne s'arrête pas à YOLOv8. Ils prennent également en charge divers autres modèles comme YOLOv5, YOLO-NAS et des modèles basés sur Transformer pour la détection en temps réel. Chaque modèle a ses propres forces et cas d'utilisation.

Link to this sectionModè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")

Link to this sectionModè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.

Link to this sectionExé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.

Link to this sectionPerformances 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).

Link to this sectionPoints 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 communauté Ultralytics !