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é.

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.

• mAP^val Les valeurs sont celles d'un modèle unique à échelle unique sur l'ensemble de données COCO val2017. dataset.
  Reproduire en utilisant yolo 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 utilisant yolo 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.

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.

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.

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.

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.

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.

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 :

• YOLO11n
• YOLO11s
• YOLO11m
• YOLO11l
• YOLO11x

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.

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.

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