Python Utilisation

Bienvenue dans la documentation d'utilisation de YOLOv8 Python ! Ce guide est conçu pour t'aider à intégrer de façon transparente YOLOv8 dans tes projets Python pour la détection, la segmentation et la classification d'objets. Tu apprendras ici à 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 YOLOv8 dans leurs projets Python , ce qui leur permet de mettre rapidement en œuvre des capacités avancées de détection d'objets. C'est parti !

Regarde : Mastering Ultralytics YOLOv8 : 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("yolov8n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolov8n.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 YOLOv8 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("yolov8n.pt")  # pass any model type
results = model.train(epochs=5)

from ultralytics import YOLO

model = YOLO("yolov8n.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 YOLOv8 après qu'il a été entraîné. 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 régler les hyperparamètres du modèle afin d'améliorer ses performances.

from ultralytics import YOLO

# Load a YOLOv8 model
model = YOLO("yolov8n.yaml")

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

# Validate on training data
model.val()

from ultralytics import YOLO

# Load a YOLOv8 model
model = YOLO("yolov8n.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 YOLOv8 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édire des exemples

Exporter

Le mode d'exportation est utilisé pour exporter un modèle YOLOv8 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 appareils matériels. Ce mode est utile pour déployer le modèle dans des environnements de production.

from ultralytics import YOLO

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

from ultralytics import YOLO

model = YOLO("yolov8n.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 YOLOv8 . 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 auto-conduites.

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # load an official detection model
model = YOLO("yolov8n-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

Point de repère

Le mode Benchmark est utilisé pour établir le profil de la vitesse et de la précision de divers formats d'exportation pour YOLOv8. 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="yolov8n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)

Exemples de repères

Explorateur

L'API Explorer peut être utilisée pour explorer des ensembles de données avec des fonctions avancées de recherche sémantique, de similarité vectorielle et de recherche SQL, entre autres. Elle permet également de rechercher des images en fonction de leur contenu à l'aide du langage naturel en utilisant la puissance des LLM. L'API Explorer te permet d'écrire tes propres carnets ou scripts d'exploration d'ensembles de données pour obtenir des informations sur tes ensembles de données.

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
exp.create_embeddings_table()

similar = exp.get_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
print(similar.head())

# Search using multiple indices
similar = exp.get_similar(
    img=["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/bus.jpg"], limit=10
)
print(similar.head())

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
exp.create_embeddings_table()

similar = exp.get_similar(idx=1, limit=10)
print(similar.head())

# Search using multiple indices
similar = exp.get_similar(idx=[1, 10], limit=10)
print(similar.head())

Explorateur

Utiliser les formateurs

YOLO La classe de modèle est une enveloppe de haut niveau sur les classes de formateurs. Chaque tâche YOLO a son propre formateur qui hérite de la classe BaseTrainer.

```python
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)
```

Tu peux facilement personnaliser les formateurs pour prendre en charge des tâches personnalisées ou explorer des idées de recherche et développement. En savoir plus sur la personnalisation Trainers, Validators et Predictors pour répondre aux besoins de ton projet dans la section Personnalisation.

Tutoriels de personnalisation

FAQ

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

L'intégration de Ultralytics YOLOv8 dans tes projets Python est simple. Tu peux 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("yolov8n.pt")

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

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

Tu trouveras des exemples plus détaillés dans notre section sur le mode prédictif.

Quels sont les différents modes disponibles sur YOLOv8?

Ultralytics YOLOv8 propose divers modes pour répondre aux différents flux de travail d'apprentissage automatique. Il s'agit notamment de :

• Train: Entraîne un modèle à l'aide d'ensembles de données personnalisés.
• Val: Valide les performances du modèle sur un ensemble de validation.
• Prévoir: Fais des prédictions sur les nouvelles images ou les nouveaux flux vidéo.
• Exportation: Exporte les modèles vers 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 les performances du modèle dans différentes configurations.

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

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

Pour entraîner un modèle YOLOv8 personnalisé, tu dois spécifier ton jeu de données et d'autres hyperparamètres. Voici un exemple rapide :

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolov8n.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 hyperliens vers des exemples d'utilisation, visite notre page Mode de formation.

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

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

from ultralytics import YOLO

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

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

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

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

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

from ultralytics import YOLO

# Load a YOLOv8 model
model = YOLO("yolov8n.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")

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

Commentaires