Link to this sectionCréer un exemple minimal reproductible pour les rapports de bug#

Lorsque tu soumets un rapport de bug pour les dépôts Ultralytics YOLO, il est essentiel de fournir un Exemple Minimal Reproductible (MRE). Un MRE est un petit morceau de code autonome qui démontre le problème que tu rencontres. Fournir un MRE aide les mainteneurs et les contributeurs à comprendre le problème et à travailler sur une correction plus efficacement. Ce guide explique comment créer un MRE lors de la soumission de rapports de bug aux dépôts YOLO d'Ultralytics.

Link to this section1. Isoler le problème#

La première étape pour créer un MRE consiste à isoler le problème. Supprime tout code ou dépendance inutile qui n'est pas directement lié au problème. Concentre-toi sur la partie spécifique du code qui cause le problème et élimine toute section non pertinente.

Link to this section2. Utiliser des modèles et des jeux de données publics#

Lors de la création d'un MRE, utilise des modèles et des jeux de données accessibles au public pour reproduire le problème. Par exemple, utilise le modèle yolo26n.pt et le jeu de données coco8.yaml. Cela garantit que les mainteneurs et les contributeurs peuvent facilement exécuter ton exemple et enquêter sur le problème sans avoir besoin d'accéder à des données propriétaires ou à des modèles personnalisés.

Link to this section3. Inclure toutes les dépendances nécessaires#

Assure-toi que toutes les dépendances nécessaires sont incluses dans ton MRE. Si ton code repose sur des bibliothèques externes, précise les paquets requis et leurs versions. Idéalement, liste les dépendances dans ton rapport de bug en utilisant yolo checks si tu as installé ultralytics, ou pip list pour d'autres outils.

Link to this section4. Rédiger une description claire du problème#

Fournis une description claire et concise du problème que tu rencontres. Explique le comportement attendu et le comportement réel auquel tu es confronté. Si applicable, inclus tout message d'erreur ou journal pertinent.

Link to this section5. Formater correctement ton code#

Formate correctement ton code en utilisant des blocs de code dans la description du problème. Cela permet aux autres de lire et de comprendre plus facilement ton code. Sur GitHub, tu peux créer un bloc de code en entourant ton code avec trois backticks (```) et en précisant le langage :

```python
# Your Python code goes here
```

Link to this section6. Tester ton MRE#

Avant de soumettre ton MRE, teste-le pour t'assurer qu'il reproduit fidèlement le problème. Assure-toi que les autres peuvent exécuter ton exemple sans aucun problème ni modification.

Link to this sectionExemple d'un MRE#

Voici un exemple de MRE pour un rapport de bug hypothétique :

Description du bug :

Lors de l'exécution d'une inférence sur une image à 0 canal, je reçois une erreur liée aux dimensions du tenseur d'entrée.

MRE :

import torch

from ultralytics import YOLO

# Load the model
model = YOLO("yolo26n.pt")

# Load a 0-channel image
image = torch.rand(1, 0, 640, 640)

# Run the model
results = model(image)

Message d'erreur :

Dépendances :

• torch==2.3.0
• ultralytics==8.2.0

Dans cet exemple, le MRE démontre le problème avec une quantité minimale de code, utilise un modèle public ("yolo26n.pt"), inclut toutes les dépendances nécessaires et fournit une description claire du problème accompagnée du message d'erreur.

En suivant ces directives, tu aideras les mainteneurs et les contributeurs des dépôts YOLO d'Ultralytics à comprendre et résoudre ton problème plus efficacement.

Link to this sectionFAQ#

Link to this sectionComment créer un exemple minimal reproductible (MRE) efficace pour les rapports de bug dans les dépôts YOLO d'Ultralytics ?#

Pour créer un exemple minimal reproductible (MRE) efficace pour les rapports de bug dans les dépôts YOLO d'Ultralytics, suis ces étapes :

1. Isoler le problème : Supprime tout code ou dépendance non directement lié au problème.
2. Utiliser des modèles et des jeux de données publics : Utilise des ressources publiques comme yolo26n.pt et coco8.yaml pour faciliter la reproductibilité.
3. Inclure toutes les dépendances nécessaires : Précise les paquets requis et leurs versions. Tu peux lister les dépendances en utilisant yolo checks si tu as installé ultralytics ou pip list.
4. Rédiger une description claire du problème : Explique le comportement attendu et réel, en incluant tout message d'erreur ou journal.
5. Formater correctement ton code : Utilise des blocs de code pour formater ton code, le rendant plus facile à lire.
6. Tester ton MRE : Assure-toi que ton MRE reproduit le problème sans aucune modification.

Pour un guide détaillé, consulte Créer un exemple minimal reproductible.

Link to this sectionPourquoi devrais-je utiliser des modèles et des jeux de données accessibles au public dans mon MRE pour les rapports de bug d'Ultralytics YOLO ?#

Utiliser des modèles et des jeux de données accessibles au public dans ton MRE garantit que les mainteneurs peuvent facilement exécuter ton exemple sans avoir besoin d'accéder à des données propriétaires. Cela permet une résolution de problème plus rapide et plus efficace. Par exemple, utiliser le modèle yolo26n.pt et le jeu de données coco8.yaml aide à standardiser et simplifier le processus de débogage. Apprends-en plus sur les modèles et jeux de données publics dans la section Utiliser des modèles et des jeux de données publics.

Link to this sectionQuelles informations dois-je inclure dans mon rapport de bug pour Ultralytics YOLO ?#

Un rapport de bug complet pour Ultralytics YOLO devrait inclure :

• Description claire : Explique le problème, le comportement attendu et le comportement réel.
• Messages d'erreur : Inclus tout message d'erreur ou journal pertinent.
• Dépendances : Liste les dépendances requises et leurs versions.
• MRE : Fournis un exemple minimal reproductible.
• Étapes pour reproduire : Décris les étapes nécessaires pour reproduire le problème.

Pour une liste de contrôle complète, reporte-toi à la section Rédiger une description claire du problème.

Link to this sectionComment puis-je formater correctement mon code lors de la soumission d'un rapport de bug sur GitHub ?#

Pour formater correctement ton code lors de la soumission d'un rapport de bug sur GitHub :

• Utilise des triples backticks (```) pour créer des blocs de code.
• Précise le langage de programmation pour la coloration syntaxique, par exemple, ```python.
• Assure-toi que ton code est correctement indenté pour la lisibilité.

Exemple :

```python
# Your Python code goes here
```

Pour plus de conseils sur le formatage du code, vois Formater correctement ton code.

Link to this sectionQuelles sont les erreurs courantes à vérifier avant de soumettre mon MRE pour un rapport de bug ?#

Avant de soumettre ton MRE, assure-toi de :

• Vérifier que le problème est reproductible.
• S'assurer que toutes les dépendances sont listées et correctes.
• Supprimer tout code inutile.
• Tester le MRE pour s'assurer qu'il reproduit le problème sans modification.

Pour une liste de contrôle détaillée, visite la section Tester ton MRE.