Utilisation de Python#
Bienvenue dans la documentation sur l’utilisation de Python avec Ultralytics YOLO ! Ce guide t’aidera à intégrer facilement Ultralytics YOLO à tes projets Python pour la détection d’objets, la segmentation d’instances, la segmentation sémantique, l’estimation de profondeur et la classification. 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 quiconque souhaite intégrer YOLO à ses projets Python ; elle permet de mettre rapidement en œuvre des fonctionnalité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 jeu de validation et même l’exporter au format ONNX en quelques lignes de code.
from ultralytics import YOLO
# Créer un nouveau modèle YOLO à partir de zéro
model = YOLO("yolo26n.yaml")
# Charger un modèle YOLO préentraîné (recommandé pour l’entraînement)
model = YOLO("yolo26n.pt")
# Entraîner le modèle avec le jeu de données 'coco8.yaml' pendant 3 époques
results = model.train(data="coco8.yaml", epochs=3)
# Évaluer les performances du modèle sur le jeu de validation
results = model.val()
# Effectuer une détection d’objets dans une image à l’aide du modèle
results = model("https://ultralytics.com/images/bus.jpg")
# Exporter le modèle au format ONNX
success = model.export(format="onnx")Entraînement#
Le mode Train sert à entraîner un modèle YOLO sur un jeu de données personnalisé. Dans ce mode, le modèle est entraîné à l’aide du jeu 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("yolo26n.pt") # transmettre n’importe quel type de modèle
results = model.train(epochs=5)Validation#
Le mode Val sert à valider un modèle YOLO après son entraînement. Dans ce mode, le modèle est évalué sur un ensemble de validation afin de mesurer sa précision et ses performances de généralisation. Ce mode peut servir à ajuster les hyperparamètres du modèle pour améliorer ses performances.
from ultralytics import YOLO
# Charger un modèle YOLO
model = YOLO("yolo26n.yaml")
# Entraîner le modèle
model.train(data="coco8.yaml", epochs=5)
# Valider sur la partition de validation du jeu de données d’entraînement
model.val()Prédiction#
Le mode Predict sert à effectuer des prédictions sur de nouvelles images ou vidéos à l’aide d’un modèle YOLO entraîné. Dans ce mode, le modèle est chargé depuis un fichier de 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")
# accepte tous les formats - image/dir/Path/URL/video/PIL/ndarray. 0 pour la webcam
results = model.predict(source="0")
results = model.predict(source="folder", show=True) # Afficher les prédictions. Accepte tous les arguments YOLO predict
# from PIL
im1 = Image.open("bus.jpg")
results = model.predict(source=im1, save=True) # enregistrer les images tracées
# from ndarray
im2 = cv2.imread("bus.jpg")
results = model.predict(source=im2, save=True, save_txt=True) # enregistrer les prédictions sous forme d’étiquettes
# à partir d’une liste de PIL/ndarray
results = model.predict(source=[im1, im2])Export#
Le mode Export sert à exporter un modèle YOLO dans un format adapté au 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 pour déployer le modèle dans des environnements de production.
Exporter un modèle YOLO officiel vers ONNX avec une taille de lot et une taille d’image dynamiques.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)Suivi#
Le mode Track sert à suivre des objets en temps réel à l’aide d’un modèle YOLO. Dans ce mode, le modèle est chargé depuis un fichier de checkpoint, et tu peux fournir un flux vidéo en direct pour effectuer le suivi d’objets en temps réel. Ce mode est utile pour des applications comme les systèmes de surveillance ou les voitures autonomes.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n.pt") # charger un modèle de détection officiel
model = YOLO("yolo26n-seg.pt") # charger un modèle de segmentation officiel
model = YOLO("path/to/best.pt") # charger un modèle personnalisé
# Effectuer le suivi avec le modèle
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 sert à évaluer la vitesse et la précision de différents 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 ses métriques accuracy_top1 (pour la classification), ainsi que le temps d’inférence en millisecondes par image pour différents formats d’exportation comme ONNX, OpenVINO, TensorRT et d’autres. Ces informations peuvent aider à choisir le format d’exportation optimal selon le cas d’utilisation et les exigences de vitesse et de précision.
Évaluer un modèle YOLO officiel dans tous les formats d’exportation.
from ultralytics.utils.benchmarks import benchmark
# Benchmark
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)Utiliser les entraîneurs#
La classe de modèle YOLO sert d’interface de haut niveau aux classes Trainer. Chaque tâche YOLO possède son propre entraîneur, qui hérite de BaseTrainer. Cette architecture offre davantage de flexibilité et de possibilités de personnalisation dans tes workflows de machine learning.
from ultralytics.models.yolo.detect import DetectionPredictor, DetectionTrainer, DetectionValidator
overrides = {"model": "yolo26n.pt", "data": "coco8.yaml", "epochs": 3}
# Trainer
trainer = DetectionTrainer(overrides=overrides)
trainer.train()
trained_model = trainer.best # chemin vers best.pt
# Validator
validator = DetectionValidator(args={"data": "coco8.yaml"})
validator(model=trained_model)
# Predictor
predictor = DetectionPredictor(overrides={"model": trained_model})
predictor(source="https://ultralytics.com/images/bus.jpg")
# Reprendre un entraînement interrompu à partir de son dernier checkpoint
trainer = DetectionTrainer(overrides={"resume": "path/to/last.pt"})
trainer.train()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 d’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 en améliorer les performances.
FAQ#
L’intégration d’Ultralytics YOLO à 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 # Charger un modèle YOLO préentraîné model = YOLO("yolo26n.pt") # Effectuer la détection d’objets sur une image results = model("https://ultralytics.com/images/bus.jpg") # Visualiser les résultats for result in results: result.show()Consulte des exemples plus détaillés dans la section Mode Predict.
Ultralytics YOLO propose différents modes adaptés à divers workflows de machine learning, notamment :
- Train : entraîne un modèle à l’aide de jeux de données personnalisés.
- Val : valide les performances du modèle sur un ensemble de validation.
- Predict : effectue des prédictions sur de nouvelles images ou des flux vidéo.
- Export : exporte des modèles dans différents formats, comme ONNX et TensorRT.
- Track : effectue le suivi d’objets en temps réel dans des flux vidéo.
- Benchmark : évalue les performances du modèle avec 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 de modèles.
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 # Charger le modèle YOLO model = YOLO("yolo26n.yaml") # Entraîner le modèle avec un jeu de données personnalisé 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, consulte notre page Mode Train.
Avec la fonction
export, exporter des modèles YOLO dans un format adapté au déploiement est simple. Par exemple, tu peux exporter un modèle au format ONNX :from ultralytics import YOLO # Charger le modèle YOLO model = YOLO("yolo26n.pt") # Exporter le modèle au format ONNX model.export(format="onnx")Pour connaître les différentes options d’exportation, consulte la documentation du Mode Export.
Oui, il est possible de valider des modèles YOLO sur différents jeux de données. Après l’entraînement, tu peux utiliser le mode de validation pour évaluer les performances :
from ultralytics import YOLO # Charger un modèle YOLO model = YOLO("yolo26n.yaml") # Entraîner le modèle model.train(data="coco8.yaml", epochs=5) # Valider le modèle sur un autre jeu de données model.val(data="path/to/separate/data.yaml")Consulte la page Mode Val pour des exemples détaillés et des informations sur son utilisation.