Foire aux questions (FAQ) sur Ultralytics YOLO

Cette section FAQ répond aux questions et problèmes courants que tu pourrais rencontrer en travaillant avec les dépôts Ultralytics YOLO.

FAQ

Qu'est-ce qu'Ultralytics et que propose l'entreprise ?

Ultralytics est une entreprise d'IA spécialisée dans la vision par ordinateur qui se concentre sur des modèles de pointe pour la détection d'objets et la segmentation d'images, avec une spécialisation dans la famille YOLO (You Only Look Once). Ses offres comprennent :

Des implémentations open-source de YOLO26 (la plus récente) et YOLO11 (génération précédente)
Une large gamme de modèles pré-entraînés pour diverses tâches de vision par ordinateur
Un package Python complet pour une intégration fluide des modèles YOLO dans tes projets
Des outils polyvalents pour l'entraînement, le test et le déploiement de modèles
Une documentation exhaustive et une communauté prête à t'aider

Comment installer le package Ultralytics ?

L'installation du package Ultralytics est simple en utilisant pip :

pip install ultralytics

Pour la dernière version de développement, installe 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.

Quelles sont les configurations système requises pour faire fonctionner les modèles Ultralytics ?

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
50 Go+ 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, visite la page Problèmes courants YOLO.

Comment puis-je entraîner un modèle YOLO personnalisé sur mon propre jeu de données ?

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

Prépare ton jeu de données au format YOLO (images et fichiers texte de label correspondants).
Crée un fichier YAML décrivant la structure de ton jeu de données et tes classes (vois l'exemple de YAML pour jeu de données).

Utilise le code Python suivant pour lancer 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, réfère-toi au guide d'entraînement complet.

Quels modèles pré-entraînés sont disponibles dans Ultralytics ?

Ultralytics offre une gamme diversifiée de modèles pré-entraînés pour diverses tâches :

Détection d'objets : YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x
Segmentation d'instance : YOLO26n-seg, YOLO26s-seg, YOLO26m-seg, YOLO26l-seg, YOLO26x-seg
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 toute la gamme des modèles pré-entraînés pour trouver celui qui correspond le mieux à ton projet.

Comment effectuer une inférence en utilisant un modèle Ultralytics entraîné ?

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é.

Les modèles Ultralytics peuvent-ils être déployés sur des appareils en périphérie ou dans des environnements de production ?

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 comme NVIDIA Jetson ou Intel Neural Compute Stick en utilisant TensorRT, ONNX ou OpenVINO.
Mobile : Déploie sur des appareils Android ou iOS en convertissant les modèles en TFLite ou Core ML.
Cloud : Utilise des frameworks comme TensorFlow Serving ou PyTorch Serve pour des déploiements cloud évolutifs.
Web : Implémente l'inférence dans le navigateur en utilisant ONNX.js ou TensorFlow.js.

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

Quelle est la différence entre YOLO11 et YOLO26 ?

Les distinctions clés incluent :

Inférence end-to-end sans NMS : YOLO26 est nativement end-to-end, produisant des prédictions directement sans non-maximum suppression (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 à basse 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-échelles, RLE pour une estimation de pose précise, et décodage OBB amélioré avec perte d'angle.
Tâches : Les deux modèles prennent en charge la détection d'objets, la segmentation d'instance, 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 mesures de performance, visite la page de documentation de YOLO26.

Comment contribuer au projet open-source Ultralytics ?

Contribuer à Ultralytics est un excellent moyen d'améliorer le projet et d'élargir tes compétences. Voici comment tu peux t'impliquer :

Fais un fork du dépôt Ultralytics sur GitHub.
Crée une nouvelle branche pour ta fonctionnalité ou ta correction de bug.
Apporte tes modifications et assure-toi que tous les tests passent.
Soumets une pull request avec une description claire de tes modifications.
Participe au processus de révision de code.

Tu peux aussi 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, réfère-toi au guide de contribution.

Comment installer le package Ultralytics en Python ?

L'installation du 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.

Quelles sont les fonctionnalités principales d'Ultralytics YOLO ?

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 : Effectue de la détection d'objets, de la segmentation d'instance, de la classification et de l'estimation de pose avec un framework 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 avec le pipeline d'entraînement flexible.
Nombreuses options de déploiement : Exporte les modèles vers divers formats comme TensorRT, ONNX et CoreML pour un déploiement sur différentes plateformes.
Documentation exhaustive : Bénéficie d'une documentation complète et d'une communauté prête à t'aider pour tes flux de travail en vision par ordinateur.

Comment puis-je améliorer la performance de mon modèle YOLO ?

L'amélioration de la performance de ton modèle YOLO peut être obtenue grâce à plusieurs techniques :

Réglage des hyperparamètres : Expérimente avec différents hyperparamètres en utilisant le Guide de réglage des hyperparamètres pour optimiser la performance du modèle.
Augmentation des données : Implémente des techniques comme le retournement, la mise à l'é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.
Apprentissage par transfert : Exploite des modèles pré-entraînés et ajuste-les sur ton jeu de données spécifique en utilisant le Guide d'entraînement.
Exportation vers des formats efficaces : Convertis ton modèle vers des formats optimisés comme TensorRT ou ONNX pour une inférence plus rapide en utilisant le Guide d'exportation.
Benchmarking : Utilise le Mode Benchmark pour mesurer et améliorer systématiquement la vitesse et la précision de l'inférence.

Puis-je déployer des modèles Ultralytics YOLO sur des appareils mobiles et en périphérie ?

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 en TFLite ou CoreML pour une intégration transparente dans tes applications Android ou iOS. Réfère-toi au Guide d'intégration TFLite et au Guide d'intégration CoreML pour des instructions spécifiques à la plateforme.
Appareils en périphérie : Optimise l'inférence sur des appareils comme NVIDIA Jetson ou autre matériel en périphérie en utilisant TensorRT ou ONNX. Le Guide d'intégration Edge TPU fournit des étapes détaillées pour le déploiement en périphérie.

Pour une vue d'ensemble complète des stratégies de déploiement sur diverses plateformes, consulte le guide des options de déploiement.

Comment effectuer une inférence en utilisant un modèle Ultralytics YOLO entraîné ?

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

Charger le modèle :

from ultralytics import YOLO

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

Lancer 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é.

Où puis-je trouver des exemples et des tutoriels pour utiliser Ultralytics ?

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

📚 Documentation officielle : Guides complets, références d'API et meilleures pratiques.
💻 Dépôt GitHub : Code source, exemples de scripts et contributions de la communauté.
✍️ Blog Ultralytics : Articles approfondis, cas d'usage et perspectives techniques.
💬 Forums de la communauté : Entre en contact 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.

Contributors

GLglenn-jocher¹¹ LALaughing-q² RAraimbekovm¹ SEsergiuwaxmann¹ PDpderrenger¹ RIRizwanMunawar¹

Created 12 nov. 2023Updated la semaine dernière