Skip to content

Python Utilisation

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



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.

Python

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

Train

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

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 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 de val

Prévoir

Le mode Prédire 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 les vidéos d'entrée.

Prévoir

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 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 dispositifs matériels. Ce mode est utile pour déployer le modèle dans des environnements de production.

Exportation

Exporter un modèle officiel de YOLO vers ONNX avec une taille de lot et une taille d'image dynamiques. 

from ultralytics import YOLO

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

Exporter un modèle officiel de YOLO vers TensorRT sur device=0 pour l'accélération sur les appareils CUDA . 

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="engine", 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 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 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.

Poursuivre

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

Mode benchmark est utilisé pour évaluer la vitesse et la précision de différents formats d'exportation pour YOLO. Les points de référence fournissent des informations sur la taille du format exporté, son 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 comme ONNX, OpenVINOTensorRT 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 rapidité et de précision.

Repère

Étalonnage d'un modèle officiel de YOLO dans tous les formats d'exportation. 

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

Le YOLO sert d'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. Cette architecture permet une plus grande flexibilité et une meilleure personnalisation de votre système d'information. flux de travail pour l'apprentissage automatique.

Exemple d'entraîneur à la détection

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 formateurs pour prendre en charge des tâches personnalisées ou explorer des idées de recherche et de développement. La conception modulaire d'Ultralytics YOLO vous permet d'adapter le cadre à vos besoins spécifiques, que vous travailliez sur une nouvelle tâche de vision par ordinateur ou que vous ajustiez des modèles existants pour de meilleures performances.

Tutoriels de personnalisation

FAQ

Comment 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()

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

Quels sont les différents modes disponibles dans YOLO?

Ultralytics YOLO propose plusieurs modes pour répondre aux différents flux de travail d'apprentissage automatique. Ces modes sont les 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: Exportation des modèles vers différents formats tels que ONNX et 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 YOLO personnalisé à partir de 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 la formation et des liens hypertextes vers des exemples d'utilisation, consultez notre page Mode de formation.

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

L'exportation des modèles YOLO 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 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 et une utilisation détaillés.

📅C réé il y a 1 an ✏️ Mis à jour il y a 8 jours
glenn-jocher RizwanMunawar jk4e UltralytiqueAssistant MatthewNoyce IvorZhu331 AyushExel Rire-q

Commentaires