Foire aux questions (FAQ) sur Ultralytics YOLO#

Ultralytics est une entreprise d’IA spécialisée en vision par ordinateur, qui développe des modèles de pointe de détection d’objets et de segmentation d’images, en mettant l’accent sur la famille YOLO. Ses offres comprennent :

• Des implémentations open source de YOLO26 (la plus récente) et de YOLO11 (la génération précédente)
• Une vaste gamme de modèles préentraînés pour diverses tâches de vision par ordinateur
• Un package Python complet pour intégrer facilement les modèles YOLO à tes projets
• Des outils polyvalents pour entraîner, tester et déployer des modèles
• Une documentation complète et une communauté active

Non. YOLO27 est en phase finale de R&D pour un lancement prévu plus tard cette année, sans date de lancement fixe. La documentation présente en avant-première les fonctionnalités de YOLO27, les benchmarks préliminaires de YOLO27 et les exemples d'utilisation de YOLO27 après la sortie de YOLO27. Continue d'utiliser YOLO26 pour les projets actuels.

L’installation du package Ultralytics est simple avec pip :

pip install ultralytics

Pour obtenir la dernière version de développement, installe-la directement depuis le dépôt GitHub :

pip install git+https://github.com/ultralytics/ultralytics.git

Tu trouveras des instructions d’installation détaillées dans le guide de démarrage rapide.

Configuration minimale :

• Python 3.8+
• PyTorch 1.8+
• GPU compatible CUDA (pour l’accélération GPU)

Configuration recommandée :

• Python 3.8+
• PyTorch 1.10+
• GPU NVIDIA avec CUDA 11.2+
• 8 Go de RAM ou plus
• 50 Go ou plus d’espace disque disponible (pour le stockage des jeux de données et l’entraînement des modèles)

Pour résoudre les problèmes courants, consulte la page Problèmes courants liés à YOLO.

Pour entraîner un modèle YOLO personnalisé :

1. Prépare ton jeu de données au format YOLO (images et fichiers txt d’annotations correspondants).

2. Crée un fichier YAML décrivant la structure et les classes de ton jeu de données (voir l’exemple de fichier YAML de jeu de données).

3. Utilise le code Python suivant pour commencer l’entraînement :

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolo26n.yaml")  # build a new model from scratch
   model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)
   
   # Train the model
   results = model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

Pour un guide plus approfondi, notamment sur la préparation des données et les options d’entraînement avancées, consulte le guide complet sur l’entraînement.

Ultralytics propose une gamme variée de modèles préentraînés pour différentes tâches :

• Détection d’objets : YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x
• Segmentation d’instances : YOLO26n-seg, YOLO26s-seg, YOLO26m-seg, YOLO26l-seg, YOLO26x-seg
• Segmentation sémantique : YOLO26n-sem, YOLO26s-sem, YOLO26m-sem, YOLO26l-sem, YOLO26x-sem
• Estimation de profondeur : YOLO26n-depth, YOLO26s-depth, YOLO26m-depth, YOLO26l-depth, YOLO26x-depth
• Classification : YOLO26n-cls, YOLO26s-cls, YOLO26m-cls, YOLO26l-cls, YOLO26x-cls
• Estimation de pose : YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, YOLO26l-pose, YOLO26x-pose
• Détection orientée (OBB) : YOLO26n-obb, YOLO26s-obb, YOLO26m-obb, YOLO26l-obb, YOLO26x-obb

Ces modèles diffèrent par leur taille et leur complexité, offrant différents compromis entre rapidité et précision. Explore la gamme complète de modèles préentraînés pour trouver celui qui convient le mieux à ton projet.

Pour effectuer une inférence avec un modèle entraîné :

from ultralytics import YOLO

# Load a model
model = YOLO("path/to/your/model.pt")

# Perform inference
results = model("path/to/image.jpg")

# Process results
for r in results:
    print(r.boxes)  # print bbox predictions
    print(r.masks)  # print mask predictions
    print(r.probs)  # print class probabilities

Pour découvrir les options d’inférence avancées, notamment le traitement par lots et l’inférence vidéo, consulte le guide détaillé sur la prédiction.

Absolument ! Les modèles Ultralytics sont conçus pour être déployés sur différentes plateformes :

• Appareils de périphérie : optimise ton inférence sur des appareils comme NVIDIA Jetson ou Raspberry Pi en utilisant TensorRT, ONNX ou OpenVINO.
• Mobile : déploie les modèles sur des appareils Android ou iOS en les convertissant au format LiteRT ou Core ML.
• Cloud : exploite des frameworks comme TensorFlow Serving ou TorchServe pour des déploiements cloud scalables.
• Web : implémente l'inférence dans le navigateur en utilisant ONNX Runtime Web.

Ultralytics fournit des fonctions d’exportation pour convertir les modèles dans différents formats de déploiement. Explore la vaste gamme d’options de déploiement pour trouver la meilleure solution adaptée à ton cas d’utilisation.

Les principales différences sont les suivantes :

• Inférence sans NMS de bout en bout : YOLO26 propose une inférence sans NMS avec nms=False. Son chemin par défaut un-à-plusieurs utilise le NMS pour la précision.
• Suppression de DFL : YOLO26 supprime le module Distribution Focal Loss, ce qui simplifie l’exportation et améliore la compatibilité avec les appareils edge et basse consommation.
• Optimiseur MuSGD : un hybride de SGD et de Muon (inspiré de Kimi K2 de Moonshot AI) pour un entraînement plus stable et une convergence plus rapide.
• Performances sur CPU : YOLO26n s’exécute jusqu’à 43 % plus rapidement que YOLO11n lors d’une inférence ONNX sur CPU (Intel Xeon CPU @ 2.00 GHz), ce qui le rend idéal pour les appareils dépourvus de GPU.
• Optimisations spécifiques aux tâches : segmentation améliorée grâce à une perte sémantique et à des prototypes multi-échelles, RLE pour une estimation précise de la pose et décodage OBB amélioré avec une perte angulaire.
• Tâches : les deux modèles prennent en charge la détection d’objets et la segmentation d’instances, tandis que YOLO26 ajoute également la segmentation sémantique pour une prédiction dense au niveau des pixels et l’estimation de profondeur monoculaire pour la profondeur de chaque pixel. Les deux modèles prennent aussi en charge la classification, l’estimation de pose et la détection d’objets orientés (OBB) dans un framework unifié.

Pour une comparaison approfondie des fonctionnalités et des métriques de performance, consulte la page de documentation de YOLO26.

Contribuer à Ultralytics est un excellent moyen d’améliorer le projet et de développer tes compétences. Voici comment participer :

1. Forke le dépôt Ultralytics sur GitHub.
2. Crée une nouvelle branche pour ta fonctionnalité ou ta correction de bug.
3. Effectue tes modifications et vérifie que tous les tests réussissent.
4. Soumets une pull request avec une description claire de tes modifications.
5. Participe au processus de revue du code.

Tu peux également contribuer en signalant des bugs, en suggérant des fonctionnalités ou en améliorant la documentation. Pour connaître les consignes détaillées et les bonnes pratiques, consulte le guide de contribution.

Ultralytics YOLO offre un riche ensemble de fonctionnalités pour les tâches avancées de vision par ordinateur :

• Détection en temps réel : détecte et classe efficacement les objets dans des scénarios en temps réel.
• Capacités multitâches : effectue la détection d’objets, la segmentation d’instances, la segmentation sémantique, l’estimation de profondeur monoculaire, la classification, l’estimation de pose et la détection d’objets orientés (OBB) avec un framework unifié.
• Modèles préentraînés : accède à une variété de modèles préentraînés offrant un équilibre entre rapidité et précision pour différents cas d’utilisation.
• Entraînement personnalisé : ajuste facilement les modèles sur des jeux de données personnalisés grâce au pipeline d’entraînement flexible.
• Vastes options de déploiement : exporte les modèles dans différents formats, tels que TensorRT, ONNX et CoreML, pour les déployer sur différentes plateformes.
• Documentation complète : profite d’une documentation complète et d’une communauté active pour tes workflows de vision par ordinateur.

Tu peux améliorer les performances de ton modèle YOLO grâce à plusieurs techniques :

1. Réglage des hyperparamètres : expérimente différents hyperparamètres à l’aide du guide de réglage des hyperparamètres pour optimiser les performances du modèle.
2. Augmentation des données : mets en œuvre des techniques telles que le retournement, le changement d’échelle, la rotation et les ajustements de couleur pour enrichir ton jeu de données d’entraînement et améliorer la généralisation du modèle.
3. Apprentissage par transfert : exploite des modèles préentraînés et ajuste-les sur ton jeu de données spécifique à l’aide du guide d’entraînement.
4. Exportation vers des formats efficaces : convertis ton modèle dans des formats optimisés tels que TensorRT ou ONNX pour accélérer l’inférence à l’aide du guide d’exportation.
5. Évaluation comparative : utilise le mode Benchmark pour mesurer et améliorer systématiquement la vitesse et la précision de l’inférence.

Ultralytics met à ta disposition de nombreuses ressources pour t’aider à débuter et à maîtriser ses outils :

• 📚 Documentation officielle : guides complets, références de l’API et bonnes pratiques.
• 💻 Dépôt GitHub : code source, scripts d’exemple et contributions de la communauté.
• ✍️ Blog Ultralytics : articles approfondis, cas d’usage et analyses techniques.
• 💬 Forums communautaires : échange avec d’autres utilisateurs, pose tes questions et partage tes expériences.
• 🎥 Chaîne YouTube : tutoriels vidéo, démonstrations et webinaires sur divers sujets liés à Ultralytics.

Ces ressources fournissent des exemples de code, des cas d’usage concrets et des guides étape par étape pour diverses tâches utilisant les modèles Ultralytics.

Si tu as besoin d’une aide supplémentaire, consulte la documentation Ultralytics ou contacte la communauté via les problèmes GitHub ou le forum de discussion officiel.