Python Utilisation

Bienvenue dans la documentation d'utilisation de YOLO11 Python ! Ce guide est conçu pour vous aider à intégrer YOLO11 dans vos projets Python pour la détection, la segmentation et la classification d'objets. Vous y apprendrez à charger et à utiliser des modèles pré-entraînés, à entraîner de nouveaux modèles et à effectuer des prédictions sur des images. L'interface Python , facile à utiliser, est une ressource précieuse pour tous ceux qui cherchent à incorporer YOLO11 dans leurs projets Python , ce qui leur permet de mettre rapidement en œuvre des fonctionnalités avancées de détection d'objets. C'est parti !

Regarder : Mastering Ultralytics YOLO11 : Python

Par exemple, les utilisateurs peuvent charger un modèle, l'entraîner, évaluer ses performances sur un ensemble de validation et même l'exporter au format ONNX avec seulement quelques lignes de code.

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolo11n.yaml")

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

# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)

# Evaluate the model's performance on the validation set
results = model.val()

# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")

# Export the model to ONNX format
success = model.export(format="onnx")

Train

Le mode Train est utilisé pour former un modèle YOLO11 sur un ensemble de données personnalisé. Dans ce mode, le modèle est entraîné à l'aide de l'ensemble de données et des hyperparamètres spécifiés. Le processus d'entraînement consiste à optimiser les paramètres du modèle afin qu'il puisse prédire avec précision les classes et les emplacements des objets dans une image.

from ultralytics import YOLO

model = YOLO("yolo11n.pt")  # pass any model type
results = model.train(epochs=5)

from ultralytics import YOLO

model = YOLO("yolo11n.yaml")
results = model.train(data="coco8.yaml", epochs=5)

model = YOLO("last.pt")
results = model.train(resume=True)

Exemples de trains

Val

Le mode Val est utilisé pour valider un modèle YOLO11 après son apprentissage. Dans ce mode, le modèle est évalué sur un ensemble de validation pour mesurer sa précision et ses performances de généralisation. Ce mode peut être utilisé pour ajuster les hyperparamètres du modèle afin d'améliorer ses performances.

from ultralytics import YOLO

# Load a YOLO11 model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on training data
model.val()

from ultralytics import YOLO

# Load a YOLO11 model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on separate data
model.val(data="path/to/separate/data.yaml")

Exemples de val

Prévoir

Le mode Prédire est utilisé pour faire des prédictions à l'aide d'un modèle YOLO11 entraîné sur de nouvelles images ou vidéos. Dans ce mode, le modèle est chargé à partir d'un fichier de point de contrôle et l'utilisateur peut fournir des images ou des vidéos pour effectuer l'inférence. Le modèle prédit les classes et les emplacements des objets dans les images ou les vidéos d'entrée.

import cv2
from PIL import Image

from ultralytics import YOLO

model = YOLO("model.pt")
# accepts all formats - image/dir/Path/URL/video/PIL/ndarray. 0 for webcam
results = model.predict(source="0")
results = model.predict(source="folder", show=True)  # Display preds. Accepts all YOLO predict arguments

# from PIL
im1 = Image.open("bus.jpg")
results = model.predict(source=im1, save=True)  # save plotted images

# from ndarray
im2 = cv2.imread("bus.jpg")
results = model.predict(source=im2, save=True, save_txt=True)  # save predictions as labels

# from list of PIL/ndarray
results = model.predict(source=[im1, im2])

# results would be a list of Results object including all the predictions by default
# but be careful as it could occupy a lot memory when there're many images,
# especially the task is segmentation.
# 1. return as a list
results = model.predict(source="folder")

# results would be a generator which is more friendly to memory by setting stream=True
# 2. return as a generator
results = model.predict(source=0, stream=True)

for result in results:
    # Detection
    result.boxes.xyxy  # box with xyxy format, (N, 4)
    result.boxes.xywh  # box with xywh format, (N, 4)
    result.boxes.xyxyn  # box with xyxy format but normalized, (N, 4)
    result.boxes.xywhn  # box with xywh format but normalized, (N, 4)
    result.boxes.conf  # confidence score, (N, 1)
    result.boxes.cls  # cls, (N, 1)

    # Segmentation
    result.masks.data  # masks, (N, H, W)
    result.masks.xy  # x,y segments (pixels), List[segment] * N
    result.masks.xyn  # x,y segments (normalized), List[segment] * N

    # Classification
    result.probs  # cls prob, (num_class, )

# Each result is composed of torch.Tensor by default,
# in which you can easily use following functionality:
result = result.cuda()
result = result.cpu()
result = result.to("cpu")
result = result.numpy()

Prévoir des exemples

Exportation

Le mode d'exportation est utilisé pour exporter un modèle YOLO11 dans un format qui peut être utilisé pour le déploiement. Dans ce mode, le modèle est converti dans un format qui peut être utilisé par d'autres applications logicielles ou dispositifs matériels. Ce mode est utile pour déployer le modèle dans des environnements de production.

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="onnx", dynamic=True)

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="onnx", device=0)

Exemples d'exportation

Poursuivre

Le mode Track est utilisé pour suivre des objets en temps réel à l'aide d'un modèle YOLO11 . Dans ce mode, le modèle est chargé à partir d'un fichier de point de contrôle et l'utilisateur peut fournir un flux vidéo en direct pour effectuer un suivi d'objet en temps réel. Ce mode est utile pour des applications telles que les systèmes de surveillance ou les voitures autonomes.

from ultralytics import YOLO

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

# Track with the model
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

Exemples de pistes

Repère

Le mode Benchmark est utilisé pour évaluer la vitesse et la précision de différents formats d'exportation pour YOLO11. Les repères fournissent des informations sur la taille du format exporté, sa vitesse et sa précision. mAP50-95 métriques (pour la détection et la segmentation d'objets) ou accuracy_top5 (pour la classification) et le temps d'inférence en millisecondes par image dans différents formats d'exportation tels que ONNX, OpenVINO, TensorRT et autres. Ces informations peuvent aider les utilisateurs à choisir le format d'exportation optimal pour leur cas d'utilisation spécifique, en fonction de leurs exigences en matière de vitesse et de précision.

from ultralytics.utils.benchmarks import benchmark

# Benchmark
benchmark(model="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)

Exemples de référence

Utilisation des formateurs

YOLO est une enveloppe de haut niveau pour les classes de formateurs. Chaque tâche YOLO possède son propre formateur qui hérite de la classe BaseTrainer.

from ultralytics.models.yolo import DetectionPredictor, DetectionTrainer, DetectionValidator

# trainer
trainer = DetectionTrainer(overrides={})
trainer.train()
trained_model = trainer.best

# Validator
val = DetectionValidator(args=...)
val(model=trained_model)

# predictor
pred = DetectionPredictor(overrides={})
pred(source=SOURCE, model=trained_model)

# resume from last weight
overrides["resume"] = trainer.last
trainer = detect.DetectionTrainer(overrides=overrides)

Vous pouvez facilement personnaliser les formateurs pour prendre en charge des tâches personnalisées ou explorer des idées de R&D. En savoir plus sur la personnalisation Trainers, Validators et Predictors pour répondre aux besoins de votre projet dans la section Personnalisation.

Tutoriels de personnalisation

FAQ

Comment puis-je intégrer YOLO11 dans mon projet Python pour la détection d'objets ?

L'intégration de Ultralytics YOLO11 dans vos projets Python est simple. Vous pouvez charger un modèle pré-entraîné ou entraîner un nouveau modèle à partir de zéro. Voici comment commencer :

from ultralytics import YOLO

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

# Perform object detection on an image
results = model("https://ultralytics.com/images/bus.jpg")

# Visualize the results
for result in results:
    result.show()

Vous trouverez des exemples plus détaillés dans la section Mode prédictif.

Quels sont les différents modes disponibles sur YOLO11?

Ultralytics YOLO11 propose plusieurs modes pour répondre aux différents flux de travail d'apprentissage automatique. Il s'agit notamment des modes suivants

• Train: Entraîner un modèle à l'aide d'ensembles de données personnalisés.
• Val: Valider les performances du modèle sur un ensemble de validation.
• Prévoir: Faire des prédictions sur de nouvelles images ou de nouveaux flux vidéo.
• Exportation: Exporter les modèles dans différents formats tels que ONNX, TensorRT.
• Piste: Suivi d'objets en temps réel dans les flux vidéo.
• Point de repère: Analyse comparative des performances du modèle dans différentes configurations.

Chaque mode est conçu pour fournir des fonctionnalités complètes à différentes étapes du développement et du déploiement du modèle.

Comment entraîner un modèle YOLO11 personnalisé à l'aide de mon ensemble de données ?

Pour entraîner un modèle YOLO11 personnalisé, vous devez spécifier votre ensemble de données et d'autres hyperparamètres. Voici un exemple rapide :

from ultralytics import YOLO

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

# Train the model with custom dataset
model.train(data="path/to/your/dataset.yaml", epochs=10)

Pour plus de détails sur la formation et des liens hypertextes vers des exemples d'utilisation, consultez notre page Mode de formation.

Comment exporter les modèles YOLO11 pour les déployer ?

L'exportation des modèles YOLO11 dans un format adapté au déploiement est simple grâce à la fonction export fonction. Par exemple, vous pouvez exporter un modèle au format ONNX :

from ultralytics import YOLO

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

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

Pour connaître les différentes options d'exportation, reportez-vous à la documentation sur le mode d'exportation.

Puis-je valider mon modèle YOLO11 sur différents ensembles de données ?

Oui, il est possible de valider les modèles YOLO11 sur différents ensembles de données. Après la formation, vous pouvez utiliser le mode de validation pour évaluer les performances :

from ultralytics import YOLO

# Load a YOLO11 model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate the model on a different dataset
model.val(data="path/to/separate/data.yaml")

Consultez la page Mode Val pour des exemples et une utilisation détaillés.

📅C réé il y a 1 an ✏️ Mis à jour il y a 1 mois

Commentaires