Link to this sectionContribuer aux projets open-source d'Ultralytics#

Welcome! We're thrilled that you're considering contributing to our Ultralytics open-source projects. Your involvement not only helps enhance the quality of our repositories but also benefits the entire computer vision community. This guide provides clear guidelines and best practices to help you get started.

Watch: How to Contribute to Ultralytics Repository | Ultralytics Models, Datasets and Documentation 🚀

Link to this section🤝 Code de conduite#

Pour garantir un environnement accueillant et inclusif pour tout le monde, tous les contributeurs doivent respecter notre Code of Conduct. Le respect, la bienveillance et le professionnalisme sont au cœur de notre communauté.

Link to this section🚀 Contribuer via des Pull Requests#

Nous apprécions grandement les contributions sous forme de pull requests (PRs). Afin de rendre le processus de revue aussi fluide que possible, merci de suivre ces étapes :

Forker le dépôt : Commence par forker le dépôt Ultralytics concerné (par exemple, ultralytics/ultralytics) vers ton compte GitHub.
Créer une branche : Crée une nouvelle branche dans ton dépôt forké avec un nom clair et descriptif reflétant tes changements (par exemple, fix-issue-123, add-feature-xyz).
Effectue tes changements : Implémente tes améliorations ou correctifs. Assure-toi que ton code respecte les directives de style du projet et ne génère pas de nouvelles erreurs ou avertissements.
Teste tes changements : Avant de soumettre, teste tes modifications localement pour confirmer qu'elles fonctionnent comme prévu et ne causent pas de régressions. Ajoute des tests si tu introduis de nouvelles fonctionnalités.
Commit tes changements : Valide tes changements avec des messages de commit concis et descriptifs. Si tes changements traitent un problème spécifique, inclue le numéro du problème (par exemple, Fix #123: Corrected calculation error.).
Créer une pull request : Soumets une pull request depuis ta branche vers la branche main du dépôt Ultralytics original. Fournis un titre clair et une description détaillée expliquant l'objectif et la portée de tes changements.

Link to this section📝 Signature du CLA#

Avant que nous puissions fusionner ta pull request, tu dois signer notre Contributor License Agreement (CLA). Cet accord juridique garantit que tes contributions sont correctement licenciées, permettant au projet de continuer à être distribué sous la AGPL-3.0 license.

Après avoir soumis ta pull request, le bot CLA te guidera tout au long du processus de signature. Pour signer le CLA, ajoute simplement un commentaire dans ta PR indiquant :

I have read the CLA Document and I sign the CLA

Link to this section✍️ Docstrings de style Google#

Lorsque tu ajoutes de nouvelles fonctions ou classes, inclue des docstrings de style Google pour une documentation claire et standardisée. Entoure toujours les types d'entrée et de sortie entre parenthèses (par exemple, (bool), (np.ndarray)).

Exemples de Docstrings

Cet exemple illustre le format standard de docstring de style Google. Note comment il sépare clairement la description de la fonction, les arguments, la valeur de retour et les exemples pour une lisibilité maximale.

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

    Args:
        arg1 (int): The first argument.
        arg2 (int): The second argument.

    Returns:
        (bool): True if arguments are equal, False otherwise.

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

Link to this section✅ Tests CI GitHub Actions#

All pull requests must pass the GitHub Actions Continuous Integration (CI) tests before they can be merged. These tests include linting, unit tests, and other checks to ensure that your changes meet the project's quality standards. Review the CI output and address any issues that arise.

Link to this section✨ Meilleures pratiques pour les contributions de code#

Lorsque tu contribues du code aux projets Ultralytics, garde ces bonnes pratiques à l'esprit :

Évite la duplication de code : Réutilise le code existant chaque fois que possible et minimise les arguments inutiles.
Fais des changements plus petits et ciblés : Concentre-toi sur des modifications ciblées plutôt que sur des changements à grande échelle.
Simplifie quand c'est possible : Recherche des opportunités pour simplifier le code ou supprimer des parties inutiles.
Considère la compatibilité : Avant de faire des changements, considère s'ils pourraient briser le code existant utilisant Ultralytics.
Utilise un formatage cohérent : Des outils comme Ruff Formatter peuvent aider à maintenir une cohérence stylistique.
Ajoute des tests appropriés : Inclus des tests pour les nouvelles fonctionnalités afin de t'assurer qu'elles fonctionnent comme prévu.

Link to this section👀 Revue des Pull Requests#

La revue de pull requests est une autre façon précieuse de contribuer. Lors de la revue de PRs :

Vérifie les tests unitaires : Vérifie que la PR inclue des tests pour les nouvelles fonctionnalités ou changements.
Examine les mises à jour de la documentation : Assure-toi que la documentation est mise à jour pour refléter les changements.
Évalue l'impact sur les performances : Réfléchis à la manière dont les changements pourraient affecter les performances.
Vérifie les tests de CI : Confirme que tous les Continuous Integration tests passent avec succès.
Fournis des feedbacks constructifs : Offre des retours spécifiques et clairs sur tout problème ou préoccupation.
Reconnais les efforts : Reconnais le travail de l'auteur pour maintenir une atmosphère collaborative positive.

Link to this section🐞 Signaler des bugs#

Nous accordons une grande valeur aux rapports de bugs car ils nous aident à améliorer la qualité et la fiabilité de nos projets. Lors du signalement d'un bug via GitHub Issues :

Vérifie les problèmes existants : Cherche d'abord à voir si le bug a déjà été signalé.
Fournis un Minimum Reproducible Example : Crée un petit extrait de code autonome qui reproduit systématiquement le problème. C'est crucial pour un débogage efficace.
Décris l'environnement : Spécifie ton système d'exploitation, la version de Python, les versions des bibliothèques pertinentes (par exemple, torch, ultralytics) et le matériel (CPU/GPU).
Explique le comportement attendu vs actuel : Indique clairement ce que tu attendais comme résultat et ce qui s'est réellement passé. Inclue tous les messages d'erreur ou les tracebacks.

Link to this section📜 Licence#

Ultralytics utilise la GNU Affero General Public License v3.0 (AGPL-3.0) pour ses dépôts. Cette licence promeut l'ouverture, la transparence et l'amélioration collaborative dans le développement logiciel. Elle garantit que tous les utilisateurs ont la liberté d'utiliser, de modifier et de partager le logiciel, favorisant une communauté solide de collaboration et d'innovation.

Nous encourageons tous les contributeurs à se familiariser avec les termes de la licence AGPL-3.0 pour contribuer efficacement et de manière éthique à la communauté open-source Ultralytics.

Link to this section🌍 Mettre ton projet YOLO en open-source sous AGPL-3.0#

Tu utilises des modèles ou du code Ultralytics YOLO dans ton projet ? La licence AGPL-3.0 exige que l'intégralité de ton œuvre dérivée soit également mise en open-source sous AGPL-3.0. Cela garantit que les modifications et les projets plus vastes construits sur des bases open-source restent ouverts.

Link to this sectionPourquoi la conformité AGPL-3.0 est-elle importante ?#

Maintient le logiciel ouvert : Assure que les améliorations et les œuvres dérivées profitent à la communauté.
Exigence légale : Utiliser du code sous licence AGPL-3.0 lie ton projet à ses termes.
Favorise la collaboration : Encourage le partage et la transparence.

Si tu préfères ne pas mettre ton projet en open-source, envisage d'obtenir une Licence Entreprise.

Link to this sectionComment se conformer à l'AGPL-3.0#

Se conformer signifie rendre le code source complet correspondant de ton projet publiquement disponible sous la licence AGPL-3.0.

Choisis ton point de départ :
- Fork Ultralytics YOLO : Forke directement le dépôt Ultralytics YOLO si tu construis étroitement dessus.
- Utilise le modèle Ultralytics : Commence avec le dépôt de modèle Ultralytics pour une configuration propre et modulaire intégrant YOLO.
Licencie ton projet :
- Ajoute un fichier LICENSE contenant le texte intégral de la licence AGPL-3.0.
- Ajoute une notice en haut de chaque fichier source indiquant la licence.
Publie ton code source :
- Rends le code source de l'intégralité de ton projet accessible au public (par exemple, sur GitHub). Cela inclut :
  - L'application ou le système global complet qui intègre le modèle ou le code YOLO.
  - Toute modification apportée au code original Ultralytics YOLO.
  - Les scripts d'entraînement, de validation et d'inférence.
  - Poids du modèle s'ils sont modifiés ou affinés.
  - Configuration files, configurations d'environnement (requirements.txt, Dockerfiles).
  - Le code backend et frontend s'il fait partie d'une application web.
  - Toutes les bibliothèques tierces que tu as modifiées.
  - Données d'entraînement si elles sont nécessaires pour exécuter/ré-entraîner et redistribuables.
Documente clairement :
- Mets à jour ton README.md pour indiquer que le projet est sous licence AGPL-3.0.
- Inclue des instructions claires sur la façon de configurer, construire et exécuter ton projet à partir du code source.
- Attribué Ultralytics YOLO de manière appropriée, en renvoyant vers le dépôt original. Exemple :
```
This project utilizes code from [Ultralytics YOLO](https://github.com/ultralytics/ultralytics), licensed under AGPL-3.0.
```

Link to this sectionExemple de structure de dépôt#

Référe-toi au Dépôt de modèle Ultralytics pour une structure d'exemple pratique :

my-yolo-project/
│
├── LICENSE               # Full AGPL-3.0 license text
├── README.md             # Project description, setup, usage, license info & attribution
├── pyproject.toml        # Dependencies (or requirements.txt)
├── scripts/              # Training/inference scripts
│   └── train.py
├── src/                  # Your project's source code
│   ├── __init__.py
│   ├── data_loader.py
│   └── model_wrapper.py  # Code interacting with YOLO
├── tests/                # Unit/integration tests
├── configs/              # YAML/JSON config files
├── docker/               # Dockerfiles, if used
│   └── Dockerfile
└── .github/              # GitHub specific files (e.g., workflows for CI)
    └── workflows/
        └── ci.yml

En suivant ces lignes directrices, tu assures la conformité avec l'AGPL-3.0, soutenant l'écosystème open-source qui permet des outils puissants comme Ultralytics YOLO.

Link to this sectionConclusion#

Thank you for your interest in contributing to Ultralytics open-source YOLO projects. Your participation is essential in shaping the future of our software and building a vibrant community of innovation and collaboration. Whether you're enhancing code, reporting bugs, or suggesting new features, your contributions are invaluable.

Nous sommes impatients de voir tes idées prendre vie et apprécions ton engagement à faire avancer la technologie de détection d'objets. Ensemble, continuons à grandir et à innover dans cette passionnante aventure open-source.

Link to this sectionFAQ#

Link to this sectionPourquoi devrais-je contribuer aux dépôts open-source Ultralytics YOLO ?#

Contribuer aux dépôts open-source Ultralytics YOLO améliore le logiciel, le rendant plus robuste et riche en fonctionnalités pour toute la communauté. Les contributions peuvent inclure des améliorations de code, des correctifs de bugs, des améliorations de la documentation et l'implémentation de nouvelles fonctionnalités. De plus, contribuer te permet de collaborer avec d'autres développeurs qualifiés et experts du domaine, améliorant tes propres compétences et ta réputation. Pour plus de détails sur la façon de commencer, réfère-toi à la section Contribuer via des Pull Requests.

Link to this sectionComment signer le Contrat de Licence Contributeur (CLA) pour Ultralytics YOLO ?#

Pour signer le Contrat de Licence Contributeur (CLA), suis les instructions fournies par le bot CLA après avoir soumis ta pull request. Ce processus garantit que tes contributions sont correctement licenciées sous la licence AGPL-3.0, maintenant l'intégrité juridique du projet open-source. Ajoute un commentaire dans ta pull request indiquant :

I have read the CLA Document and I sign the CLA

Pour plus d'informations, vois la section Signature du CLA.

Link to this sectionQue sont les docstrings de style Google, et pourquoi sont-elles requises pour les contributions à Ultralytics YOLO ?#

Les docstrings de style Google fournissent une documentation claire et concise pour les fonctions et les classes, améliorant la lisibilité et la maintenabilité du code. Ces docstrings décrivent l'objectif, les arguments et les valeurs de retour de la fonction avec des règles de formatage spécifiques. Lors d'une contribution à Ultralytics YOLO, suivre les docstrings de style Google garantit que tes ajouts sont bien documentés et facilement compris. Pour des exemples et des directives, visite la section Docstrings de style Google.

Link to this sectionComment puis-je m'assurer que mes modifications réussissent les tests CI de GitHub Actions ?#

Avant que ta pull request puisse être fusionnée, elle doit réussir tous les tests d'intégration continue (CI) de GitHub Actions. Ces tests incluent le linting, les tests unitaires et d'autres vérifications pour garantir que ton code respecte les standards de qualité du projet. Examine les résultats de la CI et corrige les problèmes éventuels. Pour des informations détaillées sur le processus CI et des conseils de dépannage, consulte la section GitHub Actions CI Tests.

Link to this sectionComment puis-je signaler un bug dans les dépôts Ultralytics YOLO ?#

Pour signaler un bug, fournis un Minimum Reproducible Example clair et concis avec ton rapport de bug. Cela aide les développeurs à identifier et corriger rapidement le problème. Assure-toi que ton exemple est minimal mais suffisant pour reproduire le problème. Pour des étapes plus détaillées sur le signalement de bugs, réfère-toi à la section Reporting Bugs.

Link to this sectionQue signifie la licence AGPL-3.0 si j'utilise Ultralytics YOLO dans mon propre projet ?#

Si tu utilises du code ou des modèles Ultralytics YOLO (sous licence AGPL-3.0) dans ton projet, la licence AGPL-3.0 exige que l'intégralité de ton projet (l'œuvre dérivée) soit également sous licence AGPL-3.0 et que son code source complet soit rendu public. Cela garantit que la nature open-source du logiciel est préservée à travers ses dérivés. Si tu ne peux pas respecter ces exigences, tu dois obtenir une Enterprise License. Consulte la section Open-Sourcing Your Project pour plus de détails.

Contributeurs

GLglenn-jocher²³ RIRizwanMunawar³ RAraimbekovm¹ PDpderrenger¹ Y-Y-T-G¹ WIWillieMaddox¹ LEleonnil¹ MAMatthewNoyce¹ BUBurhan-Q¹

Créé 12 nov. 2023Mis à jour il y a 3 jours