Créer un exemple minimal reproductible pour les rapports de bugs

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 plus efficacement sur une correction. Ce guide explique comment créer un MRE lorsque tu soumets des rapports de bug pour les dépôts Ultralytics YOLO.

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

Utilise 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 disponibles publiquement 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.

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

Rédige 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 que tu constates. Si applicable, inclus tout message d'erreur ou journal pertinent.

Formate ton code correctement

Formate ton code correctement 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 de triples backticks (```) et en précisant le langage :

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

Teste ton MRE

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

Exemple d'un MRE

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

Description du bug :

Lors de l'exécution de l'inférence sur une image à 0 canal, j'obtiens 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 ainsi que le message d'erreur.

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

FAQ

Comment puis-je créer un exemple minimal reproductible (MRE) efficace pour les rapports de bugs dans les dépôts Ultralytics YOLO ?

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

1. Isole le problème : Supprime tout code ou dépendance qui n'est pas directement lié au problème.
2. Utilise des modèles et des jeux de données publics : Utilise des ressources publiques comme yolo26n.pt et coco8.yaml pour une reproductibilité plus facile.
3. Inclus 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édige une description claire du problème : Explique le comportement attendu et réel, en incluant tout message d'erreur ou journal.
5. Formate ton code correctement : Utilise des blocs de code pour formater ton code afin de le rendre plus facile à lire.
6. Teste ton MRE : Assure-toi que ton MRE reproduit le problème sans modifications.

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

Pourquoi devrais-je utiliser des modèles et des jeux de données publiquement disponibles dans mon MRE pour les rapports de bug Ultralytics YOLO ?

L'utilisation de modèles et de jeux de données publiquement disponibles dans ton MRE garantit que les mainteneurs peuvent facilement exécuter ton exemple sans avoir besoin d'accès à des données propriétaires. Cela permet une résolution de problème plus rapide et plus efficace. Par exemple, l'utilisation du modèle yolo26n.pt et du 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.

Quelles informations dois-je inclure dans mon rapport de bug pour Ultralytics YOLO ?

Un rapport de bug complet pour Ultralytics YOLO doit 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.

Comment 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 ton code correctement.

Quelles 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.
• T'assurer que toutes les dépendances sont listées et correctes.
• Supprimer tout code inutile.
• Tester le MRE pour t'assurer qu'il reproduit le problème sans modifications.

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