Utilisation de Python
Bienvenue dans la documentation sur l'utilisation de Ultralytics YOLO en Python ! Ce guide est conçu pour t'aider à intégrer facilement Ultralytics YOLO dans tes projets Python pour la détection d'objets, la segmentation et la classification. Ici, tu apprendras comment 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, simple d'utilisation, est une ressource précieuse pour quiconque cherche à incorporer YOLO dans ses projets Python, te permettant d'implémenter rapidement des capacités avancées de détection d'objets. Commençons !
Watch: Mastering Ultralytics YOLO: Python
Par exemple, tu peux 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("yolo26n.yaml")
# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo26n.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 Entraînement est utilisé pour entraîner un modèle YOLO sur un jeu de données personnalisé. Dans ce mode, le modèle est entraîné en utilisant le jeu de données et les hyperparamètres spécifiés. Le processus d'entraînement implique l'optimisation des 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("yolo26n.pt") # pass any model type
results = model.train(epochs=5)Valider
Le mode Validation est utilisé pour valider un modèle YOLO après son entraînement. Dans ce mode, le modèle est évalué sur un jeu 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("yolo26n.yaml")
# Train the model
model.train(data="coco8.yaml", epochs=5)
# Validate on training data
model.val()Prédire
Le mode Prédiction est utilisé pour effectuer des prédictions avec 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 (checkpoint), et tu peux 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])Exporter
Le mode Exportation est utilisé pour exporter un modèle YOLO vers un format exploitable pour le déploiement. Dans ce mode, le modèle est converti dans un format utilisable par d'autres applications logicielles ou appareils matériels. Ce mode est utile lors du déploiement du modèle dans des environnements de production.
Exporter un modèle YOLO officiel vers ONNX avec une taille de lot (batch-size) et une taille d'image dynamiques.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)Suivre
Le mode Suivi est utilisé pour suivre des objets en temps réel avec un modèle YOLO. Dans ce mode, le modèle est chargé depuis un fichier de point de contrôle, et tu peux fournir un flux vidéo en direct pour effectuer un suivi d'objets 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("yolo26n.pt") # load an official detection model
model = YOLO("yolo26n-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")Benchmark
Le mode Benchmark 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é, ses métriques mAP50-95 (pour la détection d'objets et la segmentation) ou accuracy_top5 (pour la classification), ainsi que le temps d'inférence en millisecondes par image à travers divers formats d'exportation comme ONNX, OpenVINO, TensorRT et d'autres. Ces informations peuvent t'aider à choisir le format d'exportation optimal pour ton cas d'utilisation spécifique en fonction de tes besoins en matière de vitesse et de précision.
Benchmark d'un modèle YOLO officiel sur tous les formats d'exportation.
from ultralytics.utils.benchmarks import benchmark
# Benchmark
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)Utilisation des entraîneurs (Trainers)
La classe de modèle YOLO sert de wrapper de haut niveau pour les classes d'entraînement. Chaque tâche YOLO possède son propre entraîneur, qui hérite de BaseTrainer. Cette architecture permet une plus grande flexibilité et personnalisation dans tes workflows de machine learning.
from ultralytics.models.yolo.detect 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)Tu peux facilement personnaliser les entraîneurs pour prendre en charge des tâches personnalisées ou explorer des idées de recherche et développement. La conception modulaire de Ultralytics YOLO te permet d'adapter le framework à tes besoins spécifiques, que tu travailles sur une nouvelle tâche de vision par ordinateur ou que tu affines des modèles existants pour de meilleures performances.
FAQ
Comment puis-je intégrer YOLO dans mon projet Python pour la détection d'objets ?
L'intégration de Ultralytics YOLO dans tes projets Python est simple. Tu peux charger un modèle pré-entraîné ou entraîner un nouveau modèle depuis zéro. Voici comment commencer :
from ultralytics import YOLO
# Load a pretrained YOLO model
model = YOLO("yolo26n.pt")
# Perform object detection on an image
results = model("https://ultralytics.com/images/bus.jpg")
# Visualize the results
for result in results:
result.show()Vois des exemples plus détaillés dans notre section Mode Prédiction.
Quels sont les différents modes disponibles dans YOLO ?
Ultralytics YOLO propose divers modes pour répondre à différents workflows de machine learning. Ceux-ci incluent :
- Train : Entraîne un modèle en utilisant des jeux de données personnalisés.
- Val : Valide les performances du modèle sur un jeu de validation.
- Predict : Effectue des prédictions sur de nouvelles images ou des flux vidéo.
- Export : Exporte les modèles vers divers formats comme ONNX et TensorRT.
- Track : Suivi d'objets en temps réel dans des flux vidéo.
- Benchmark : Évalue les performances du modèle selon 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 entraîner un modèle YOLO personnalisé en utilisant mon jeu de données ?
Pour entraîner un modèle YOLO 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("yolo26n.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 vers des exemples d'utilisation, visite notre page Mode Entraînement.
Comment exporter des modèles YOLO pour le déploiement ?
Exporter des modèles YOLO dans un format adapté au déploiement est simple avec la fonction export. Par exemple, tu peux exporter un modèle au format ONNX :
from ultralytics import YOLO
# Load the YOLO model
model = YOLO("yolo26n.pt")
# Export the model to ONNX format
model.export(format="onnx")Pour diverses options d'exportation, réfère-toi à la documentation du Mode Exportation.
Puis-je valider mon modèle YOLO sur différents jeux de données ?
Oui, valider des modèles YOLO sur différents jeux de données est possible. Après l'entraînement, tu peux utiliser le mode validation pour évaluer les performances :
from ultralytics import YOLO
# Load a YOLO model
model = YOLO("yolo26n.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 Validation pour des exemples détaillés et l'utilisation.