Foire aux questions (FAQ) sur Ultralytics YOLO#

Ultralytics est une entreprise d'IA spécialisée en computer vision qui propose des modèles de pointe pour la détection d'objets et la segmentation d'images, avec un accent particulier sur la famille YOLO (You Only Look Once). Leurs offres incluent :

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

L'installation du package Ultralytics est simple grâce à pip :

pip install ultralytics

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

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

Des instructions d'installation détaillées sont disponibles dans le guide de démarrage rapide.

Configurations minimales requises :

• 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
• 50 Go+ d'espace disque libre (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 de YOLO.

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

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

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

3. Utilise le code Python suivant pour démarrer 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, incluant la préparation des données et les options d'entraînement avancées, consulte le guide d'entraînement complet.

Ultralytics propose une gamme variée de modèles pré-entraînés pour diverses 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 varient en taille et en complexité, offrant différents compromis entre vitesse et précision. Explore la gamme complète de modèles pré-entraînés pour trouver celui qui correspond 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 des options d'inférence avancées, incluant le traitement par lots et l'inférence vidéo, consulte le guide de prédiction détaillé.

Absolument ! Les modèles Ultralytics sont conçus pour un déploiement polyvalent sur diverses plateformes :

• Appareils en périphérie : Optimise l'inférence sur des appareils tels que NVIDIA Jetson ou Intel Neural Compute Stick en utilisant TensorRT, ONNX ou OpenVINO.
• Mobile : déploie sur des appareils Android ou iOS en convertissant tes modèles vers LiteRT ou CoreML.
• Cloud : Utilise des frameworks tels que TensorFlow Serving ou PyTorch Serve pour des déploiements cloud évolutifs.
• Web : implémente l'inférence dans le navigateur en utilisant LiteRT.js ou ONNX.js.

Ultralytics propose des fonctions d'exportation pour convertir les modèles vers divers formats en vue du déploiement. Explore le large éventail d'options de déploiement pour trouver la meilleure solution pour ton cas d'usage.

Les distinctions clés incluent :

• Inférence de bout en bout sans NMS : YOLO26 est nativement de bout en bout et produit des prédictions directement sans suppression non maximale (NMS), ce qui réduit la latence et simplifie le déploiement.
• Suppression de DFL : YOLO26 supprime le module Distribution Focal Loss, simplifiant l'exportation et améliorant la compatibilité avec les appareils en périphérie et à faible consommation.
• Optimiseur MuSGD : Un hybride de SGD et Muon (inspiré par Kimi K2 de Moonshot AI) pour un entraînement plus stable et une convergence plus rapide.
• Performance CPU : YOLO26 offre une inférence CPU jusqu'à 43 % plus rapide, ce qui le rend idéal pour les appareils sans GPU.
• Optimisations spécifiques aux tâches : Segmentation améliorée avec perte sémantique et protos multi-échelle, RLE pour une estimation de pose de précision, et décodage OBB amélioré avec perte d'angle.
• 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 par 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 cadre unifié.

Pour une comparaison approfondie des fonctionnalités et des métriques de performance, visite 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 tu peux t'impliquer :

1. Fork le dépôt Ultralytics sur GitHub.
2. Crée une nouvelle branche pour ta fonctionnalité ou ton correctif de bug.
3. Apporte tes modifications et assure-toi que tous les tests passent.
4. Soumets une pull request avec une description claire de tes modifications.
5. Participe au processus de revue de code.

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

Installer le package Ultralytics en Python est simple. Utilise pip en exécutant la commande suivante dans ton terminal ou ton invite de commande :

pip install ultralytics

Pour la version de développement à la pointe, installe directement depuis le dépôt GitHub :

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

Pour des instructions d'installation spécifiques à ton environnement et des conseils de dépannage, consulte le guide de démarrage rapide complet.

Ultralytics YOLO bénéficie d'un riche ensemble de fonctionnalités pour des tâches avancées de vision par ordinateur :

• Détection en temps réel : Détecte et classifie efficacement les objets dans des scénarios en temps réel.
• Capacités multi-tâches : Réalise de la détection d'objets, de la segmentation d'instances, de la segmentation sémantique, de l'estimation de profondeur monoculaire, de la classification, de l'estimation de pose et de la détection d'objets orientés (OBB) avec un cadre unifié.
• Modèles pré-entraînés : Accède à une variété de modèles pré-entraînés qui équilibrent vitesse et précision pour différents cas d'usage.
• Entraînement personnalisé : Ajuste facilement les modèles sur des jeux de données personnalisés grâce au pipeline d'entraînement flexible.
• Nombreuses options de déploiement : Exporte les modèles vers divers formats tels que TensorRT, ONNX et CoreML pour un déploiement sur différentes plateformes.
• Documentation complète : Profite d'une documentation détaillée et d'une communauté solidaire pour tes flux de travail en computer vision.

Améliorer la performance de ton modèle YOLO peut être réalisé 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 de données : Mets en œuvre des techniques telles que le retournement, la mise à l'échelle, la rotation et les ajustements de couleur pour enrichir ton jeu d'entraînement et améliorer la généralisation du modèle.
3. Apprentissage par transfert : Tire parti de modèles pré-entraînés et affine-les sur ton jeu de données spécifique à l'aide du Guide d'entraînement.
4. Export vers des formats efficaces : Convertis ton modèle en formats optimisés comme TensorRT ou ONNX pour une inférence plus rapide en utilisant le Guide d'exportation.
5. Benchmarking : Utilise le Mode Benchmark pour mesurer et améliorer systématiquement la vitesse et la précision de l'inférence.

Oui, les modèles Ultralytics YOLO sont conçus pour un déploiement polyvalent, y compris sur des appareils mobiles et en périphérie :

• Mobile : Convertis les modèles vers LiteRT ou CoreML pour une intégration fluide dans des applications Android ou iOS. Consulte le Guide d'intégration LiteRT et le Guide d'intégration CoreML pour des instructions spécifiques à chaque plateforme.
• Appareils Edge : Optimise l'inférence sur des appareils tels que NVIDIA Jetson ou d'autres matériels Edge en utilisant TensorRT ou ONNX. Le Guide d'intégration Edge TPU fournit des étapes détaillées pour le déploiement sur Edge.

Pour un aperçu complet des stratégies de déploiement sur différentes plateformes, consulte le guide des options de déploiement.

Effectuer une inférence avec un modèle Ultralytics YOLO entraîné est simple :

1. Charger le modèle :

   from ultralytics import YOLO
   
   model = YOLO("path/to/your/model.pt")

2. Exécuter l'inférence :

   results = model("path/to/image.jpg")
   
   for r in results:
       print(r.boxes)  # print bounding box predictions
       print(r.masks)  # print mask predictions
       print(r.probs)  # print class probabilities

Pour des techniques d'inférence avancées, incluant le traitement par lots, l'inférence vidéo et le prétraitement personnalisé, réfère-toi au guide de prédiction détaillé.

Ultralytics fournit une mine de ressources pour t'aider à démarrer et à maîtriser ses outils :

• 📚 Documentation officielle : Guides complets, références d'API et bonnes pratiques.
• 💻 Dépôt GitHub : Code source, scripts d'exemple et contributions de la communauté.
• ✍️ Blog d'Ultralytics : Articles approfondis, cas d'usage et aperçus techniques.
• 💬 Forums communautaires : Connecte-toi avec d'autres utilisateurs, pose des questions et partage tes expériences.
• 🎥 Chaîne YouTube : Tutoriels vidéo, démos et webinaires sur divers sujets liés à Ultralytics.

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

Si tu as besoin d'aide supplémentaire, consulte la documentation d'Ultralytics ou contacte la communauté via les GitHub Issues ou le forum de discussion officiel.