Creare un esempio minimo riproducibile per le segnalazioni di bug

Quando invii una segnalazione di bug per i repository Ultralytics YOLO, è essenziale fornire un Esempio Minimo Riproducibile (MRE). Un MRE è un piccolo frammento di codice autosufficiente che dimostra il problema che stai riscontrando. Fornire un MRE aiuta i manutentori e i contributori a comprendere il problema e a lavorare su una correzione in modo più efficiente. Questa guida spiega come creare un MRE quando invii segnalazioni di bug ai repository YOLO di Ultralytics.

Isola il problema

Il primo passo per creare un MRE è isolare il problema. Rimuovi qualsiasi codice o dipendenza non necessaria che non sia direttamente correlata al problema. Concentrati sulla parte specifica del codice che sta causando il problema ed elimina le sezioni irrilevanti.

Usa modelli e dataset pubblici

Quando crei un MRE, usa modelli e dataset disponibili pubblicamente per riprodurre il problema. Ad esempio, usa il modello yolo26n.pt e il dataset coco8.yaml. Questo garantisce che i manutentori e i contributori possano eseguire facilmente il tuo esempio e indagare sul problema senza bisogno di accedere a dati proprietari o modelli personalizzati.

Includi tutte le dipendenze necessarie

Assicurati che tutte le dipendenze necessarie siano incluse nel tuo MRE. Se il tuo codice si basa su librerie esterne, specifica i pacchetti richiesti e le loro versioni. Idealmente, elenca le dipendenze nella tua segnalazione di bug usando yolo checks se hai installato ultralytics o pip list per altri strumenti.

Scrivi una descrizione chiara del problema

Fornisci una descrizione chiara e concisa del problema che stai riscontrando. Spiega il comportamento previsto e il comportamento effettivo che stai incontrando. Se applicabile, includi eventuali messaggi di errore o log pertinenti.

Formatta correttamente il tuo codice

Formatta correttamente il tuo codice usando blocchi di codice nella descrizione della segnalazione. Questo rende più facile per gli altri leggere e comprendere il tuo codice. In GitHub, puoi creare un blocco di codice racchiudendo il codice tra tripli backtick (```) e specificando il linguaggio:

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

Testa il tuo MRE

Prima di inviare il tuo MRE, testalo per assicurarti che riproduca accuratamente il problema. Assicurati che altri possano eseguire il tuo esempio senza problemi o modifiche.

Esempio di un MRE

Ecco un esempio di un MRE per una ipotetica segnalazione di bug:

Descrizione del bug:

Quando eseguo l'inferenza su un'immagine a 0 canali, ricevo un errore relativo alle dimensioni del tensore di input.

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)

Messaggio di errore:

Dipendenze:

• torch==2.3.0
• ultralytics==8.2.0

In questo esempio, l'MRE dimostra il problema con una quantità minima di codice, utilizza un modello pubblico ("yolo26n.pt"), include tutte le dipendenze necessarie e fornisce una descrizione chiara del problema insieme al messaggio di errore.

Seguendo queste linee guida, aiuterai i manutentori e i contributori dei repository YOLO di Ultralytics a comprendere e risolvere il tuo problema in modo più efficiente.

FAQ

Come creo un Esempio Minimo Riproducibile (MRE) efficace per le segnalazioni di bug nei repository YOLO di Ultralytics?

Per creare un Esempio Minimo Riproducibile (MRE) efficace per le segnalazioni di bug nei repository YOLO di Ultralytics, segui questi passaggi:

1. Isola il problema: Rimuovi qualsiasi codice o dipendenza non direttamente correlata al problema.
2. Usa modelli e dataset pubblici: Utilizza risorse pubbliche come yolo26n.pt e coco8.yaml per una riproducibilità più semplice.
3. Includi tutte le dipendenze necessarie: Specifica i pacchetti richiesti e le relative versioni. Puoi elencare le dipendenze usando yolo checks se hai installato ultralytics o pip list.
4. Scrivi una descrizione chiara del problema: Spiega il comportamento previsto e quello effettivo, inclusi eventuali messaggi di errore o log.
5. Formatta correttamente il tuo codice: Usa i blocchi di codice per formattare il tuo codice, rendendolo più facile da leggere.
6. Testa il tuo MRE: Assicurati che il tuo MRE riproduca il problema senza modifiche.

Per una guida dettagliata, vedi Creare un esempio minimo riproducibile.

Perché dovrei usare modelli e dataset pubblicamente disponibili nel mio MRE per le segnalazioni di bug di YOLO di Ultralytics?

L'uso di modelli e dataset pubblicamente disponibili nel tuo MRE garantisce che i manutentori possano eseguire facilmente il tuo esempio senza bisogno di accedere a dati proprietari. Ciò consente una risoluzione dei problemi più rapida ed efficiente. Ad esempio, l'uso del modello yolo26n.pt e del dataset coco8.yaml aiuta a standardizzare e semplificare il processo di debug. Scopri di più sui modelli e dataset pubblici nella sezione Usa modelli e dataset pubblici.

Quali informazioni dovrei includere nella mia segnalazione di bug per YOLO di Ultralytics?

Una segnalazione di bug completa per YOLO di Ultralytics dovrebbe includere:

• Descrizione chiara: Spiega il problema, il comportamento previsto e il comportamento effettivo.
• Messaggi di errore: Includi eventuali messaggi di errore o log pertinenti.
• Dipendenze: Elenca le dipendenze richieste e le relative versioni.
• MRE: Fornisci un Esempio Minimo Riproducibile.
• Passaggi per riprodurre: Delinea i passaggi necessari per riprodurre il problema.

Per una checklist completa, consulta la sezione Scrivi una descrizione chiara del problema.

Come posso formattare correttamente il mio codice quando invio una segnalazione di bug su GitHub?

Per formattare correttamente il tuo codice quando invii una segnalazione di bug su GitHub:

• Usa tripli backtick (```) per creare blocchi di codice.
• Specifica il linguaggio di programmazione per l'evidenziazione della sintassi, ad esempio ```python.
• Assicurati che il tuo codice sia indentato correttamente per la leggibilità.

Esempio:

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

Per ulteriori suggerimenti sulla formattazione del codice, vedi Formatta correttamente il tuo codice.

Quali sono alcuni errori comuni da controllare prima di inviare il mio MRE per una segnalazione di bug?

Prima di inviare il tuo MRE, assicurati di:

• Verificare che il problema sia riproducibile.
• Assicurarti che tutte le dipendenze siano elencate e corrette.
• Rimuovere qualsiasi codice non necessario.
• Testare l'MRE per assicurarti che riproduca il problema senza modifiche.

Per una checklist dettagliata, visita la sezione Testa il tuo MRE.