YOLO Vision 2026 :

Cré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 Minimum Reproducible Example (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 un correctif plus efficacement. Ce guide explique comment créer un MRE lors de la soumission de rapports de bug aux dépôts Ultralytics YOLO.

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

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

3. Inclure toutes les dépendances nécessaires#

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

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

5. 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
```

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

Exemple 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 :

RuntimeError: Expected input[1, 0, 640, 640] to have 3 channels, but got 0 channels instead

Dépendances :

  • torch==2.3.0
  • ultralytics==8.2.0

Dans cet exemple, le MRE démontre le problème avec un minimum 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#

  • 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. 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. Inclue toutes les dépendances nécessaires : Spécifie les paquets requis et leurs versions. Tu peux lister les dépendances en utilisant yolo checks si tu as ultralytics installé 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 Creating a Minimum Reproducible Example.

  • 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éder à des données propriétaires. Cela permet une résolution des problèmes 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 davantage sur les modèles et les jeux de données publics dans la section Use Public Models and Datasets.

  • 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, réfère-toi à la section Write a Clear Description of the Issue.

  • 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, consulte la section Format Your Code Properly.

  • 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 Test Your MRE.

Commentaires