Contribuire ai progetti open source di Ultralytics

Benvenuti! Siamo entusiasti che stiate pensando di contribuire ai nostri progetti Ultralytics progetti open-source. Il vostro coinvolgimento non solo contribuisce a migliorare la qualità dei nostri repository, ma va anche a beneficio dell'intera comunità. Questa guida fornisce linee guida chiare e buone pratiche per aiutarvi a iniziare.

Codice di condotta

Per garantire un ambiente accogliente e inclusivo per tutti, tutti i collaboratori devono aderire al nostro Codice di condotta. Rispetto, gentilezza e professionalità sono al centro della nostra comunità.

Contribuire tramite richieste di pull

Apprezziamo molto i contributi sotto forma di richieste di pull. Per rendere il processo di revisione il più agevole possibile, si prega di seguire i seguenti passaggi:

1. Creare un fork del repository: Iniziare con il fork del repository Ultralytics YOLO sul proprio account GitHub.

2. Creare un ramo: Creare un nuovo ramo nel repository con un nome chiaro e descrittivo che rifletta le modifiche apportate.

3. Apportare le modifiche: Assicuratevi che il codice sia conforme alle linee guida di stile del progetto e che non introduca nuovi errori o avvisi.

4. Testate le modifiche: Prima di inviare le modifiche, testatele in locale per verificare che funzionino come previsto e non causino nuovi problemi.

5. Eseguire il commit delle modifiche: Impegnare le modifiche con un messaggio di commit conciso e descrittivo. Se le modifiche riguardano un problema specifico, includere il numero del problema nel messaggio di commit.

6. Creare una richiesta di pull: Inviare una richiesta di pull dal proprio repository biforcuto al repository principale Ultralytics YOLO . Fornire una spiegazione chiara e dettagliata delle modifiche apportate e del modo in cui migliorano il progetto.

Firma del CLA

Prima di poter unire la vostra richiesta di pull, dovete firmare il nostro Contributor License Agreement (CLA). Questo accordo legale assicura che i vostri contributi siano correttamente concessi in licenza, consentendo al progetto di continuare a essere distribuito sotto la licenza AGPL-3.0 .

Dopo aver inviato la richiesta di pull, il bot CLA vi guiderà nel processo di firma. Per firmare il CLA, è sufficiente aggiungere un commento nella propria PR che indichi:

I have read the CLA Document and I sign the CLA

Google-Docstringhe in stile

Quando si aggiungono nuove funzioni o classi, si prega di includere le docstrazioni in stile Google. Queste documentazioni forniscono una documentazione chiara e standardizzata che aiuta gli altri sviluppatori a comprendere e mantenere il codice.

def example_function(arg1, arg2=4):
    """
    Example function demonstrating Google-style docstrings.

    Args:
        arg1 (int): The first argument.
        arg2 (int): The second argument, with a default value of 4.

    Returns:
        (bool): True if successful, False otherwise.

    Examples:
        >>> result = example_function(1, 2)  # returns False
    """
    if arg1 == arg2:
        return True
    return False

def example_function(arg1: int, arg2: int = 4) -> bool:
    """
    Example function demonstrating Google-style docstrings.

    Args:
        arg1: The first argument.
        arg2: The second argument, with a default value of 4.

    Returns:
        True if successful, False otherwise.

    Examples:
        >>> result = example_function(1, 2)  # returns False
    """
    if arg1 == arg2:
        return True
    return False

def example_small_function(arg1: int, arg2: int = 4) -> bool:
    """Example function with a single-line docstring."""
    return arg1 == arg2

Azioni GitHub Test CI

Tutte le richieste di pull devono superare i test di GitHub Actions Continuous Integration (CI) prima di poter essere unite. Questi test includono linting, test unitari e altri controlli per garantire che le modifiche soddisfino gli standard di qualità del progetto. Esaminate i risultati della CI e risolvete eventuali problemi.

Segnalazione di bug

Apprezziamo molto le segnalazioni di bug, perché ci aiutano a mantenere la qualità dei nostri progetti. Quando si segnala un bug, si prega di fornire un esempio minimo riproducibile: unesempio di codice semplice e chiaro che riproduca in modo coerente il problema. Questo ci permette di identificare e risolvere rapidamente il problema.

Licenza

Ultralytics utilizza la GNU Affero General Public License v3.0 (AGPL-3.0 ) per i suoi repository. Questa licenza promuove l'apertura, la trasparenza e il miglioramento collaborativo nello sviluppo del software. Garantisce a tutti gli utenti la libertà di usare, modificare e condividere il software, favorendo una forte comunità di collaborazione e innovazione.

Incoraggiamo tutti i collaboratori a familiarizzare con i termini della licenza AGPL-3.0 per contribuire in modo efficace ed etico alla comunità open-source di Ultralytics .

Open-Sourcing dei progetti con YOLO e conformità a AGPL-3.0

Se avete intenzione di sviluppare e rilasciare un vostro progetto utilizzando i modelli di YOLO , la GNU Affero General Public License v3.0 (AGPL-3.0 ) garantisce che tutte le opere derivate rimangano aperte e accessibili. Questa sezione fornisce una guida, compresi i passaggi, le migliori pratiche e i requisiti, per aiutarvi a rendere open-source il vostro progetto rispettando la licenza AGPL-3.0.

Opzioni per l'avvio del progetto

Potete avviare il vostro progetto utilizzando uno di questi approcci:

1. Creare un fork del repository Ultralytics YOLO
   Sostituire il repository ufficiale Ultralytics YOLO direttamente da https://github.com/ultralytics/ ultralytics.

   • Usare questa opzione se si intende costruire direttamente sull'ultima implementazione di YOLO .
   • Modificare il codice biforcuto secondo le necessità, garantendo la conformità con AGPL-3.0.

2. Partire dal repository di modelli Ultralytics
   Utilizzare l'archivio di modelli Ultralytics disponibile all'indirizzo https://github.com/ultralytics/template.

   • Ideale per avviare un progetto pulito e modulare con best practice preconfigurate.
   • Questa opzione offre un punto di partenza leggero per i progetti che integrano o estendono i modelli di YOLO .

Cosa serve per l'open source

Per conformarsi a AGPL-3.0, è necessario rendere apertamente disponibili i seguenti componenti del progetto:

1. L'intero codice sorgente del progetto:

   • Includere tutto il codice del progetto più ampio contenente i modelli, gli script e le utilità di YOLO .

2. Pesi del modello (se modificato):

   • Condividere i pesi dei modelli perfezionati o modificati come parte del progetto open-source.

3. File di configurazione:

   • Fornite file di configurazione come .yaml o .json che definiscono l'impostazione dell'addestramento, gli iperparametri o le configurazioni di distribuzione.

4. Dati di addestramento (se ridistribuibili):

   • Se si includono dati preelaborati o generati che sono ridistribuibili, assicurarsi che facciano parte del repository o che siano chiaramente collegati.

5. Componenti dell'applicazione web:

   • Includere tutto il codice sorgente di backend e frontend se il progetto è un'applicazione web, in particolare i componenti lato server.

6. Documentazione:

   • Includere una documentazione chiara su come utilizzare, costruire ed estendere il progetto.

7. Script di compilazione e distribuzione:

   • Condividere gli script per la configurazione dell'ambiente, la costruzione dell'applicazione e la sua distribuzione, ad esempio Dockerfiles, requirements.txt, o Makefiles.

8. Struttura di test:

   • I casi di test, come i test unitari e di integrazione, sono open-source per garantire la riproducibilità e l'affidabilità.

9. Modifiche di terze parti:

   • Fornite il codice sorgente di tutte le librerie di terze parti che avete modificato.

Passi per l'open source del vostro progetto

1. Scegliere il punto di partenza:

   • Si può creare un fork del repository Ultralytics YOLO o partire dal repository dei template Ultralytics .

2. Impostare la licenza:

   • Aggiungere un LICENSE contenente il testo di AGPL-3.0 .

3. Credito Contributi a monte:

   • Includere l'attribuzione a Ultralytics YOLO nel README. Per esempio:

     This project builds on [Ultralytics YOLO](https://github.com/ultralytics/ultralytics), licensed under AGPL-3.0.
     

4. Rendete pubblico il vostro codice:

   • Spingere l'intero progetto (compresi i componenti elencati sopra) su un repository GitHub pubblico.

5. Documentare il progetto:

   • Scrivere un chiaro README.md con istruzioni per la configurazione, l'uso e i contributi.

6. Abilitare i contributi:

   • Creare un issue tracker e linee guida per i contributi per favorire la collaborazione.

Seguendo questi passaggi e assicurandovi di includere tutti i componenti necessari, sarete conformi a AGPL-3.0 e contribuirete in modo significativo alla comunità open-source. Continuiamo a promuovere la collaborazione e l'innovazione nella computer vision insieme! 🚀

Esempio di struttura del repository

Di seguito è riportato un esempio di struttura per un progetto AGPL-3.0 . Vedere https://github.com/ultralytics /template per i dettagli.

my-yolo-project/
│
├── LICENSE               # AGPL-3.0 license text
├── README.md             # Project overview and license information
├── src/                  # Source code for the project
│   ├── model.py          # YOLO-based model implementation
│   ├── utils.py          # Utility scripts
│   └── ...
├── pyproject.toml        # Python dependencies
├── tests/                # Unit and integration tests
├── .github/              # GitHub Actions for CI
│   └── workflows/
│       └── ci.yml        # Continuous integration configuration
└── docs/                 # Project documentation
    └── index.md

Seguendo questa guida, potete assicurarvi che il vostro progetto rimanga conforme a AGPL-3.0 , contribuendo al contempo alla comunità open-source. La vostra adesione rafforza l'etica di collaborazione, trasparenza e accessibilità che guida il successo di progetti come YOLO.

Conclusione

Grazie per il vostro interesse a contribuire ai progetti Ultralytics progetti open-source di YOLO . La vostra partecipazione è essenziale per plasmare il futuro del nostro software e costruire una comunità vibrante di innovazione e collaborazione. Che si tratti di migliorare il codice, segnalare bug o suggerire nuove funzionalità, i vostri contributi sono preziosi.

Siamo entusiasti di vedere le vostre idee prendere vita e apprezziamo il vostro impegno nel far progredire la tecnologia di rilevamento degli oggetti. Insieme, continuiamo a crescere e a innovare in questo entusiasmante viaggio open-source. Buon coding! 🚀🌟

FAQ

Perché dovrei contribuire ai repository open-source di Ultralytics YOLO ?

Contribuire ai repository open-source di Ultralytics YOLO migliora il software, rendendolo più robusto e ricco di funzionalità per l'intera comunità. I contributi possono includere miglioramenti del codice, correzioni di bug, miglioramenti della documentazione e implementazioni di nuove funzionalità. Inoltre, il contributo consente di collaborare con altri sviluppatori ed esperti del settore, migliorando le proprie capacità e la propria reputazione. Per i dettagli su come iniziare, consultare la sezione Contribuire tramite richieste di prelievo.

Come si firma il Contributor License Agreement (CLA) per Ultralytics YOLO ?

Per firmare il Contributor License Agreement (CLA), seguire le istruzioni fornite dal bot CLA dopo aver inviato la richiesta di pull. Questo processo assicura che i vostri contributi siano correttamente concessi in licenza secondo la licenza AGPL-3.0 , mantenendo l'integrità legale del progetto open-source. Aggiungere un commento nella richiesta di pull indicando:

I have read the CLA Document and I sign the CLA.

Per ulteriori informazioni, consultare la sezione Firma CLA.

Cosa sono le docstrazioni in stile Google e perché sono richieste per i contributi Ultralytics YOLO ?

Google-Le docstringhe in stile forniscono una documentazione chiara e concisa per le funzioni e le classi, migliorando la leggibilità e la manutenibilità del codice. Queste documentazioni descrivono lo scopo della funzione, gli argomenti e i valori di ritorno con regole di formattazione specifiche. Quando si contribuisce a Ultralytics YOLO , seguire i docstring in stile Google assicura che le aggiunte siano ben documentate e facilmente comprensibili. Per esempi e linee guida, visitare la sezione Google-Style Docstrings.

Come posso assicurarmi che le mie modifiche superino i test di GitHub Actions CI?

Prima che la richiesta di pull possa essere unita, deve superare tutti i test di GitHub Actions Continuous Integration (CI). Questi test includono il linting, i test unitari e altri controlli per garantire che il codice soddisfi

gli standard di qualità del progetto. Esaminare i risultati del CI e correggere eventuali problemi. Per informazioni dettagliate sul processo di CI e suggerimenti per la risoluzione dei problemi, consultare la sezione Test CI delle azioni GitHub.

Come posso segnalare un bug nei repository di Ultralytics YOLO ?

Per segnalare un bug, fornire un esempio minimo riproducibile chiaro e conciso insieme alla segnalazione del bug. Questo aiuta gli sviluppatori a identificare e risolvere rapidamente il problema. Assicurarsi che l'esempio sia minimo ma sufficiente per replicare il problema. Per informazioni più dettagliate sulla segnalazione dei bug, consultare la sezione Segnalazione dei bug.

📅C reato 1 anno fa ✏️ Aggiornato 13 giorni fa

Commenti