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

  model = YOLO('yolov8n.yaml')
  model.train(data='coco8.yaml', epochs=5)
  model.val()  # It'll automatically evaluate the data you trained.

  from ultralytics import YOLO

  model = YOLO("model.pt")
  # It'll use the data YAML file in model.pt if you don't set data.
  model.val()
  # or you can set the data you want to val
  model.val(data='coco8.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.

from ultralytics import YOLO
from PIL import Image
import cv2

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 DetectionTrainer, DetectionValidator, DetectionPredictor

# 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

Commentaires