Passer au contenu

Détection d'objets

Exemples de détection d'objets

La détection d'objets est une tâche qui consiste à identifier l'emplacement et la classe des objets dans une image ou un flux vidéo.

Le résultat d'un détecteur d'objets est un ensemble de boîtes englobantes qui entourent les objets dans l'image, ainsi que les étiquettes de classe et les scores de confiance pour chaque boîte. La détection d'objets est un bon choix lorsque vous devez identifier des objets d'intérêt dans une scène, mais que vous n'avez pas besoin de connaître exactement l'emplacement de l'objet ou sa forme exacte.



Regarder : Détection d'objets avec le modèle Ultralytics YOLO pré-entraîné.

Astuce

Les modèles de détection YOLO11 sont les modèles YOLO11 par défaut, c'est-à-dire yolo11n.pt et sont pré-entraînés sur COCO.

Modèles

Les modèles de détection YOLO11 pré-entraînés sont présentés ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur l'ensemble de données COCO, tandis que les modèles Classify sont pré-entraînés sur l'ensemble de données ImageNet.

Les modèles sont téléchargés automatiquement depuis la dernière version d'Ultralytics lors de la première utilisation.

Modèle Taille
(pixels)
mAPval
50-95
Vitesse
CPU ONNX
(ms)
Vitesse
T4 TensorRT10
(ms)
paramètres
(M)
FLOPs
(B)
YOLO11n 640 39.5 56.1 ± 0.8 1.5 ± 0.0 2.6 6.5
YOLO11s 640 47.0 90.0 ± 1.2 2.5 ± 0.0 9.4 21.5
YOLO11m 640 51.5 183,2 ± 2,0 4,7 ± 0,1 20.1 68.0
YOLO11l 640 53.4 238,6 ± 1,4 6,2 ± 0,1 25.3 86.9
YOLO11x 640 54.7 462,8 ± 6,7 11,3 ± 0,2 56.9 194.9

Entraîner

Entraînez YOLO11n sur l'ensemble de données COCO8 pendant 100 epochs à une taille d'image de 640. Pour une liste complète des arguments disponibles, consultez la page Configuration.

Exemple

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.yaml")  # build a new model from YAML
model = YOLO("yolo11n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo11n.yaml").load("yolo11n.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
# Build a new model from YAML and start training from scratch
yolo detect train data=coco8.yaml model=yolo11n.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640

# Build a new model from YAML, transfer pretrained weights to it and start training
yolo detect train data=coco8.yaml model=yolo11n.yaml pretrained=yolo11n.pt epochs=100 imgsz=640

Format du jeu de données

Le format de l'ensemble de données de détection YOLO est décrit en détail dans le Guide de l'ensemble de données. Pour convertir votre ensemble de données existant à partir d'autres formats (comme COCO, etc.) au format YOLO, veuillez utiliser l'outil JSON2YOLO d'Ultralytics.

Valider

Valider le modèle YOLO11n entraîné précision sur l'ensemble de données COCO8. Aucun argument n'est nécessaire car le model conserve son entraînement data et ses arguments en tant qu'attributs du modèle.

Exemple

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # a list contains map50-95 of each category
yolo detect val model=yolo11n.pt      # val official model
yolo detect val model=path/to/best.pt # val custom model

Prédire

Utilisez un modèle YOLO11n entraîné pour exécuter des prédictions sur des images.

Exemple

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    xywh = result.boxes.xywh  # center-x, center-y, width, height
    xywhn = result.boxes.xywhn  # normalized
    xyxy = result.boxes.xyxy  # top-left-x, top-left-y, bottom-right-x, bottom-right-y
    xyxyn = result.boxes.xyxyn  # normalized
    names = [result.names[cls.item()] for cls in result.boxes.cls.int()]  # class name of each box
    confs = result.boxes.conf  # confidence score of each box
yolo detect predict model=yolo11n.pt source='https://ultralytics.com/images/bus.jpg'      # predict with official model
yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model

Voir tous les predict détails du mode dans la Prédire page.

Exporter

Exporter un modèle YOLO11n vers un format différent comme ONNX, CoreML, etc.

Exemple

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom trained model

# Export the model
model.export(format="onnx")
yolo export model=yolo11n.pt format=onnx      # export official model
yolo export model=path/to/best.pt format=onnx # export custom trained model

Les formats d'exportation YOLO11 disponibles sont indiqués dans le tableau ci-dessous. Vous pouvez exporter vers n'importe quel format en utilisant l' format argument, c'est-à-dire format='onnx' ou format='engine'. Vous pouvez prédire ou valider directement sur les modèles exportés, c'est-à-dire yolo predict model=yolo11n.onnx. Des exemples d'utilisation sont présentés pour votre modèle une fois l'exportation terminée.

Format format Argument Modèle Métadonnées Arguments
PyTorch - yolo11n.pt -
TorchScript torchscript yolo11n.torchscript imgsz, half, dynamic, optimize, nms, batch, device
ONNX onnx yolo11n.onnx imgsz, half, dynamic, simplify, opset, nms, batch, device
OpenVINO openvino yolo11n_openvino_model/ imgsz, half, dynamic, int8, nms, batch, data, fraction, device
TensorRT engine yolo11n.engine imgsz, half, dynamic, simplify, workspace, int8, nms, batch, data, fraction, device
CoreML coreml yolo11n.mlpackage imgsz, half, int8, nms, batch, device
TF SavedModel saved_model yolo11n_saved_model/ imgsz, keras, int8, nms, batch, device
TF GraphDef pb yolo11n.pb imgsz, batch, device
TF Lite tflite yolo11n.tflite imgsz, half, int8, nms, batch, data, fraction, device
TF Edge TPU edgetpu yolo11n_edgetpu.tflite imgsz, device
TF.js tfjs yolo11n_web_model/ imgsz, half, int8, nms, batch, device
PaddlePaddle paddle yolo11n_paddle_model/ imgsz, batch, device
MNN mnn yolo11n.mnn imgsz, batch, int8, half, device
NCNN ncnn yolo11n_ncnn_model/ imgsz, half, batch, device
IMX500 imx yolo11n_imx_model/ imgsz, int8, data, fraction, device
RKNN rknn yolo11n_rknn_model/ imgsz, batch, name, device

Voir tous les export détails dans la section Exporter page.

FAQ

Comment entraîner un modèle YOLO11 sur mon propre jeu de données ?

L'entraînement d'un modèle YOLO11 sur un jeu de données personnalisé implique quelques étapes :

  1. Préparer le jeu de données : Assurez-vous que votre jeu de données est au format YOLO. Pour obtenir de l'aide, consultez notre Guide sur les jeux de données.
  2. Charger le modèle : Utilisez la bibliothèque Ultralytics YOLO pour charger un modèle pré-entraîné ou créer un nouveau modèle à partir d'un fichier YAML.
  3. Entraîner le modèle: Exécuter la méthode train dans python ou la commande yolo detect train dans la CLI.

Exemple

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo11n.pt")

# Train the model on your custom dataset
model.train(data="my_custom_dataset.yaml", epochs=100, imgsz=640)
yolo detect train data=my_custom_dataset.yaml model=yolo11n.pt epochs=100 imgsz=640

Pour des options de configuration détaillées, consultez la page Configuration.

Quels modèles pré-entraînés sont disponibles dans YOLO11 ?

Ultralytics YOLO11 offre divers modèles pré-entraînés pour la détection d'objets, la segmentation et l'estimation de pose. Ces modèles sont pré-entraînés sur l'ensemble de données COCO ou ImageNet pour les tâches de classification. Voici quelques-uns des modèles disponibles :

Pour une liste détaillée et des mesures de performance, consultez la section Modèles.

Comment puis-je valider la précision de mon modèle YOLO entraîné ?

Pour valider la précision de votre modèle YOLO11 entraîné, vous pouvez utiliser la commande .val() dans python ou la commande yolo detect val dans la CLI. Cela fournira des mesures telles que mAP50-95, mAP50, et plus encore.

Exemple

from ultralytics import YOLO

# Load the model
model = YOLO("path/to/best.pt")

# Validate the model
metrics = model.val()
print(metrics.box.map)  # mAP50-95
yolo detect val model=path/to/best.pt

Pour plus de détails sur la validation, consultez la page Val.

Dans quels formats puis-je exporter un modèle YOLO11 ?

Ultralytics YOLO11 permet d’exporter des modèles vers différents formats tels que ONNX, TensorRT, CoreML, et plus encore pour assurer la compatibilité entre différentes plateformes et appareils.

Exemple

from ultralytics import YOLO

# Load the model
model = YOLO("yolo11n.pt")

# Export the model to ONNX format
model.export(format="onnx")
yolo export model=yolo11n.pt format=onnx

Consultez la liste complète des formats pris en charge et les instructions sur la page Export.

Pourquoi devrais-je utiliser Ultralytics YOLO11 pour la détection d'objets ?

Ultralytics YOLO11 est conçu pour offrir des performances de pointe en matière de détection d'objets, de segmentation et d'estimation de pose. Voici quelques avantages clés :

  1. Modèles pré-entraînés : Utilisez des modèles pré-entraînés sur des ensembles de données populaires comme COCO et ImageNet pour un développement plus rapide.
  2. Haute précision : Obtient des scores mAP impressionnants, garantissant une détection d'objets fiable.
  3. Vitesse : Optimisé pour l'inférence en temps réel, ce qui le rend idéal pour les applications nécessitant un traitement rapide.
  4. Flexibilité : Exportez les modèles vers différents formats tels que ONNX et TensorRT pour un déploiement sur plusieurs plateformes.

Explorez notre Blog pour découvrir des cas d'utilisation et des exemples de réussite de YOLO11 en action.



📅 Créé il y a 1 an ✏️ Mis à jour il y a 5 mois

Commentaires