Utilisation de Python

Bienvenue dans la documentation d'utilisation de YOLO Python Ultralytics ! Ce guide est conçu pour vous aider à intégrer de manière transparente Ultralytics YOLO dans vos projets Python pour la détection d'objets, la segmentation et la classification. Ici, vous 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 à intégrer YOLO dans leurs projets Python, vous permettant de mettre en œuvre rapidement des capacités avancées de détection d'objets. Commençons !

Regarder : Maîtriser Ultralytics YOLO : 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")

Entraîner

Le mode Train est utilisé pour entraîner un modèle YOLO 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 d’entraînement

Valider

Le mode Val est utilisé pour valider un modèle YOLO après son entraînement. 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 YOLO 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 YOLO 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 Val

Prédire

Le mode Prédiction est utilisé pour faire des prédictions à l'aide d'un modèle YOLO 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 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()

Exemples de prédiction

Exporter

Le mode d'exportation est utilisé pour exporter un modèle YOLO 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 périphériques matériels. Ce mode est utile lors du déploiement du 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="engine", device=0)

Exemples d’exportation

Suivre

Le mode Track est utilisé pour suivre les objets en temps réel à l'aide d'un modèle YOLO. 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 le suivi d'objets en temps réel. Ce mode est utile pour les 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 suivi

Benchmark

Mode d'évaluation comparative est utilisé pour profiler la vitesse et la précision de divers formats d'exportation pour YOLO. Les benchmarks fournissent des informations sur la taille du format exporté, son mAP50-95 métriques (pour la détection d'objets et la segmentation) ou accuracy_top5 métriques (pour la classification), et le temps d'inférence en millisecondes par image à travers divers formats d'exportation comme 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 benchmarks

Utilisation des entraîneurs

L'argument YOLO La classe de modèle sert de wrapper de haut niveau pour les classes Trainer. Chaque tâche YOLO a son propre entraîneur, qui hérite de BaseTrainer. Cette architecture permet une plus grande flexibilité et personnalisation dans votre flux de travail d'apprentissage automatique.

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 = DetectionTrainer(overrides=overrides)

Vous pouvez facilement personnaliser les Trainers pour prendre en charge des tâches personnalisées ou explorer des idées de recherche et développement. La conception modulaire d'Ultralytics YOLO vous permet d'adapter le framework à vos besoins spécifiques, que vous travailliez sur une nouvelle tâche de computer vision ou que vous affiniez des modèles existants pour de meilleures performances.

Tutoriels de personnalisation

FAQ

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

L'intégration d'Ultralytics YOLO 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()

Consultez des exemples plus détaillés dans notre section Mode Predict.

Quels sont les différents modes disponibles dans YOLO ?

Ultralytics YOLO propose différents modes pour répondre aux différents flux de travail d'apprentissage automatique. Ceux-ci inclus:

• Train : Entraîner un modèle en utilisant des ensembles de données personnalisés.
• Val : Valider les performances du modèle sur un ensemble de validation.
• Predict : Faire des prédictions sur de nouvelles images ou flux vidéo.
• Exportation : Exportez les modèles vers différents formats tels que ONNX et TensorRT.
• Track : Suivi d'objets en temps réel dans les flux vidéo.
• Benchmark : Évaluer les performances du modèle à travers différentes configurations.

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

Comment puis-je entraîner un modèle YOLO personnalisé en utilisant mon jeu de données ?

Pour entraîner un modèle YOLO personnalisé, vous devez spécifier votre jeu 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 l'entraînement et des liens hypertextes vers des exemples d'utilisation, consultez notre page Mode Entraînement.

Comment puis-je exporter les modèles YOLO pour le déploiement ?

L'exportation de modèles YOLO dans un format adapté au déploiement est simple avec le 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 diverses options d'exportation, consultez la documentation du Mode Exportation.

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

Oui, il est possible de valider les modèles YOLO sur différents ensembles de données. Après l'entraînement, vous pouvez utiliser le mode de validation pour évaluer les performances :

from ultralytics import YOLO

# Load a YOLO 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 détaillés et des instructions d'utilisation.

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

Commentaires