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 |
- mAPval Les valeurs sont celles d'un modèle unique à échelle unique sur l'ensemble de données COCO val2017. dataset.
Reproduire en utilisantyolo val detect data=coco.yaml device=0
- Vitesse moyennée sur les images COCO val en utilisant une instance Amazon EC2 P4d. instance.
Reproduire en utilisantyolo val detect data=coco.yaml batch=1 device=0|cpu
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 :
- 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.
- 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.
- Entraîner le modèle: Exécuter la méthode
train
dans python ou la commandeyolo 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 :
- 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.
- Haute précision : Obtient des scores mAP impressionnants, garantissant une détection d'objets fiable.
- Vitesse : Optimisé pour l'inférence en temps réel, ce qui le rend idéal pour les applications nécessitant un traitement rapide.
- 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.