Link to this sectionBeitrag zu Ultralytics Open-Source-Projekten#

Willkommen! Wir freuen uns sehr, dass du in Erwägung ziehst, zu unseren Ultralytics Open-Source-Projekten beizutragen. Dein Engagement hilft nicht nur dabei, die Qualität unserer Repositories zu verbessern, sondern kommt auch der gesamten Computer Vision-Community zugute. Dieser Leitfaden bietet klare Richtlinien und Best Practices, die dir den Einstieg erleichtern.

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

Link to this section🤝 Verhaltenskodex#

Um eine einladende und inklusive Umgebung für alle zu gewährleisten, müssen sich alle Mitwirkenden an unseren Code of Conduct halten. Respekt, Freundlichkeit und Professionalität stehen im Mittelpunkt unserer Community.

Link to this section🚀 Beitrag über Pull Requests#

Wir schätzen Beiträge in Form von Pull Requests (PRs) sehr. Um den Review-Prozess so reibungslos wie möglich zu gestalten, befolge bitte diese Schritte:

Forke das Repository: Beginne damit, das relevante Ultralytics-Repository (z. B. ultralytics/ultralytics) auf deinen GitHub-Account zu forken.
Erstelle einen Branch: Erstelle einen neuen Branch in deinem geforkten Repository mit einem klaren, beschreibenden Namen, der deine Änderungen widerspiegelt (z. B. fix-issue-123, add-feature-xyz).
Nimm deine Änderungen vor: Implementiere deine Verbesserungen oder Korrekturen. Stelle sicher, dass dein Code den Style-Richtlinien des Projekts entspricht und keine neuen Fehler oder Warnungen einführt.
Teste deine Änderungen: Bevor du sie einreichst, teste deine Änderungen lokal, um zu bestätigen, dass sie wie erwartet funktionieren und keine Regressionen verursachen. Füge Tests hinzu, wenn du neue Funktionen einführst.
Commite deine Änderungen: Commite deine Änderungen mit prägnanten und beschreibenden Commit-Nachrichten. Wenn deine Änderungen ein spezifisches Problem beheben, füge die Issue-Nummer hinzu (z. B. Fix #123: Corrected calculation error.).
Erstelle einen Pull Request: Reiche einen Pull Request von deinem Branch an den main-Branch des ursprünglichen Ultralytics-Repositorys ein. Gib einen klaren Titel und eine detaillierte Beschreibung an, in der du Zweck und Umfang deiner Änderungen erläuterst.

Link to this section📝 CLA-Unterzeichnung#

Bevor wir deinen Pull Request mergen können, musst du unser Contributor License Agreement (CLA) unterzeichnen. Diese rechtliche Vereinbarung stellt sicher, dass deine Beiträge ordnungsgemäß lizenziert sind, damit das Projekt weiterhin unter der AGPL-3.0 license verbreitet werden kann.

Nach dem Einreichen deines Pull Requests wird dich der CLA-Bot durch den Unterzeichnungsprozess führen. Um das CLA zu unterzeichnen, füge einfach einen Kommentar in deinem PR hinzu:

I have read the CLA Document and I sign the CLA

Link to this section✍️ Google-Style Docstrings#

Wenn du neue Funktionen oder Klassen hinzufügst, verwende Google-style docstrings für eine klare, standardisierte Dokumentation. Schließe immer sowohl Eingabe- als auch Ausgabe-types in Klammern ein (z. B. (bool), (np.ndarray)).

Beispiel-Docstrings

Dieses Beispiel veranschaulicht das standardmäßige Google-Style Docstring-Format. Beachte, wie es Funktionsbeschreibung, Argumente, Rückgabewert und Beispiele für maximale Lesbarkeit klar voneinander trennt.

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✅ GitHub Actions CI Tests#

Alle Pull Requests müssen die GitHub Actions Continuous Integration (CI) Tests bestehen, bevor sie gemergt werden können. Diese Tests umfassen Linting, Unit-Tests und andere Überprüfungen, um sicherzustellen, dass deine Änderungen den Qualitätsstandards des Projekts entsprechen. Überprüfe die CI-Ausgabe und behebe auftretende Probleme.

Link to this section✨ Best Practices für Code-Beiträge#

Wenn du Code zu Ultralytics-Projekten beiträgst, beachte diese Best Practices:

Vermeide Codeduplizierung: Verwende vorhandenen Code wo immer möglich wieder und minimiere unnötige Argumente.
Nimm kleinere, fokussierte Änderungen vor: Konzentriere dich auf gezielte Anpassungen statt auf großflächige Änderungen.
Vereinfache, wo möglich: Suche nach Möglichkeiten, den Code zu vereinfachen oder unnötige Teile zu entfernen.
Berücksichtige Kompatibilität: Überlege vor Änderungen, ob diese vorhandenen Code, der Ultralytics verwendet, beschädigen könnten.
Verwende konsistente Formatierung: Tools wie der Ruff Formatter können helfen, stilistische Konsistenz zu wahren.
Füge entsprechende Tests hinzu: Beziehe tests für neue Funktionen mit ein, um sicherzustellen, dass sie wie erwartet funktionieren.

Link to this section👀 Pull Requests prüfen#

Das Prüfen von Pull Requests ist eine weitere wertvolle Form des Beitrags. Beim Prüfen von PRs:

Auf Unit-Tests prüfen: Verifiziere, dass der PR Tests für neue Funktionen oder Änderungen enthält.
Überprüfe Dokumentations-Updates: Stelle sicher, dass die documentation aktualisiert wird, um Änderungen widerzuspiegeln.
Bewerte den Performance-Einfluss: Überlege, wie sich Änderungen auf die performance auswirken könnten.
Verifiziere CI-Tests: Bestätige, dass alle Continuous Integration tests bestehen.
Konstruktives Feedback geben: Biete spezifisches, klares Feedback zu Problemen oder Bedenken.
Aufwand anerkennen: Würdige die Arbeit des Autors, um eine positive, kollaborative Atmosphäre zu wahren.

Link to this section🐞 Bugs melden#

Wir schätzen Bug-Reports sehr, da sie uns helfen, die Qualität und Zuverlässigkeit unserer Projekte zu verbessern. Wenn du einen Bug über GitHub Issues meldest:

Existierende Issues prüfen: Suche zuerst, ob der Bug bereits gemeldet wurde.
Stelle ein Minimum Reproducible Example bereit: Erstelle einen kleinen, in sich geschlossenen Code-Schnipsel, der das Problem konsistent reproduziert. Dies ist entscheidend für ein effizientes Debugging.
Beschreibe die Umgebung: Gib dein Betriebssystem, deine Python-Version, relevante Bibliotheksversionen (z. B. torch, ultralytics) und die Hardware (CPU/GPU) an.
Erkläre erwartetes vs. tatsächliches Verhalten: Gib klar an, was du erwartet hast und was tatsächlich passiert ist. Füge alle Fehlermeldungen oder Tracebacks bei.

Link to this section📜 Lizenz#

Ultralytics verwendet die GNU Affero General Public License v3.0 (AGPL-3.0) für seine Repositories. Diese Lizenz fördert Offenheit, Transparenz und kollaborative Verbesserung bei der Softwareentwicklung. Sie stellt sicher, dass alle Nutzer die Freiheit haben, die Software zu nutzen, zu verändern und zu teilen, was eine starke Community für Zusammenarbeit und Innovation fördert.

Wir ermutigen alle Mitwirkenden, sich mit den Bedingungen der AGPL-3.0-Lizenz vertraut zu machen, um effektiv und ethisch zur Ultralytics Open-Source-Community beizutragen.

Link to this section🌍 Open-Source-Veröffentlichung deines YOLO-Projekts unter AGPL-3.0#

Nutzt du Ultralytics YOLO-Modelle oder Code in deinem Projekt? Die AGPL-3.0-Lizenz erfordert, dass dein gesamtes abgeleitetes Werk ebenfalls unter der AGPL-3.0 als Open Source zur Verfügung gestellt wird. Dies stellt sicher, dass Modifikationen und größere Projekte, die auf Open-Source-Grundlagen aufbauen, offen bleiben.

Link to this sectionWarum AGPL-3.0-Konformität wichtig ist#

Hält Software offen: Stellt sicher, dass Verbesserungen und abgeleitete Werke der Community zugutekommen.
Rechtliche Anforderung: Die Verwendung von AGPL-3.0-lizenziertem Code bindet dein Projekt an dessen Bedingungen.
Fördert Zusammenarbeit: Ermutigt zum Teilen und zur Transparenz.

Wenn du dein Projekt nicht als Open Source veröffentlichen möchtest, ziehe den Erwerb einer Enterprise-Lizenz in Betracht.

Link to this sectionSo erfüllst du die Anforderungen der AGPL-3.0#

Konformität bedeutet, den vollständigen korrespondierenden Quellcode deines Projekts öffentlich unter der AGPL-3.0-Lizenz zur Verfügung zu stellen.

Wähle deinen Startpunkt:
- Forke Ultralytics YOLO: Forke direkt das Ultralytics YOLO-Repository, wenn du eng darauf aufbaust.
- Verwende die Ultralytics-Vorlage: Beginne mit dem Ultralytics-Vorlagen-Repository für ein sauberes, modulares Setup, das YOLO integriert.
Lizenziere dein Projekt:
- Füge eine LICENSE-Datei hinzu, die den vollständigen Text der AGPL-3.0-Lizenz enthält.
- Füge am Anfang jeder Quelldatei einen Hinweis hinzu, der auf die Lizenz hinweist.
Veröffentliche deinen Quellcode:
- Mache den Quellcode deines gesamten Projekts öffentlich zugänglich (z. B. auf GitHub). Dies umfasst:
  - Die vollständige größere Anwendung oder das System, das das YOLO-Modell oder den Code einbindet.
  - Alle Modifikationen, die am ursprünglichen Ultralytics YOLO-Code vorgenommen wurden.
  - Skripte für Training, Validierung und Inferenz.
  - Modellgewichte, sofern modifiziert oder feinabgestimmt.
  - Configuration files, Umgebungs-Setups (requirements.txt, Dockerfiles).
  - Backend- und Frontend-Code, falls Teil einer Webanwendung.
  - Alle Drittanbieter-Bibliotheken, die du modifiziert hast.
  - Trainingsdaten, falls erforderlich zum Ausführen/Retrainieren und weiterverbreitbar.
Dokumentiere klar:
- Aktualisiere deine README.md, um anzugeben, dass das Projekt unter AGPL-3.0 lizenziert ist.
- Füge klare Anweisungen hinzu, wie dein Projekt aus dem Quellcode eingerichtet, gebaut und ausgeführt wird.
- Nenne Ultralytics YOLO angemessen und verlinke auf das ursprüngliche Repository. Beispiel:
```
This project utilizes code from [Ultralytics YOLO](https://github.com/ultralytics/ultralytics), licensed under AGPL-3.0.
```

Link to this sectionBeispiel-Repository-Struktur#

Siehe das Ultralytics-Vorlagen-Repository für eine praktische Beispielstruktur:

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

Indem du diese Richtlinien befolgst, stellst du die Konformität mit der AGPL-3.0 sicher und unterstützt das Open-Source-Ökosystem, das leistungsstarke Tools wie Ultralytics YOLO ermöglicht.

Link to this sectionFazit#

Vielen Dank für dein Interesse, zu den Ultralytics Open-Source YOLO-Projekten beizutragen. Deine Teilnahme ist entscheidend, um die Zukunft unserer Software zu gestalten und eine lebendige Community der Innovation und Zusammenarbeit aufzubauen. Ob du Code verbesserst, Bugs meldest oder neue Funktionen vorschlägst – deine Beiträge sind unschätzbar.

Wir sind gespannt, wie deine Ideen zum Leben erweckt werden, und schätzen dein Engagement, die Objekterkennungs-Technologie voranzubringen. Lass uns gemeinsam in dieser spannenden Open-Source-Reise weiter wachsen und innovieren.

Link to this sectionFAQ#

Link to this sectionWarum sollte ich zu den Open-Source-Repositories von Ultralytics YOLO beitragen?#

Beiträge zu den Open-Source-Repositories von Ultralytics YOLO verbessern die Software und machen sie robuster und funktionsreicher für die gesamte Community. Beiträge können Code-Verbesserungen, Bug-Fixes, Dokumentations-Updates und die Implementierung neuer Funktionen umfassen. Außerdem ermöglicht dir die Mitarbeit, mit anderen qualifizierten Entwicklern und Experten auf dem Gebiet zusammenzuarbeiten, was deine eigenen Fähigkeiten und dein Ansehen steigert. Details zum Einstieg findest du im Abschnitt Beitrag über Pull Requests.

Link to this sectionWie unterzeichne ich das Contributor License Agreement (CLA) für Ultralytics YOLO?#

Um das Contributor License Agreement (CLA) zu unterzeichnen, befolge die Anweisungen, die der CLA-Bot nach dem Einreichen deines Pull Requests bereitstellt. Dieser Prozess stellt sicher, dass deine Beiträge ordnungsgemäß unter der AGPL-3.0-Lizenz lizenziert sind, was die rechtliche Integrität des Open-Source-Projekts aufrechterhält. Füge einen Kommentar in deinem Pull Request hinzu:

I have read the CLA Document and I sign the CLA

Weitere Informationen findest du im Abschnitt CLA-Unterzeichnung.

Link to this sectionWas sind Google-Style Docstrings und warum sind sie für Beiträge zu Ultralytics YOLO erforderlich?#

Google-Style Docstrings bieten eine klare, prägnante Dokumentation für Funktionen und Klassen, was die Lesbarkeit und Wartbarkeit des Codes verbessert. Diese Docstrings umreißen den Zweck der Funktion, Argumente und Rückgabewerte mit spezifischen Formatierungsregeln. Wenn du zu Ultralytics YOLO beiträgst, stellt das Befolgen der Google-Style Docstrings sicher, dass deine Ergänzungen gut dokumentiert und leicht verständlich sind. Für Beispiele und Richtlinien besuche den Abschnitt Google-Style Docstrings.

Link to this sectionWie kann ich sicherstellen, dass meine Änderungen die GitHub Actions CI-Tests bestehen?#

Bevor dein Pull Request zusammengeführt werden kann, muss er alle GitHub Actions Continuous Integration (CI)-Tests bestehen. Diese Tests umfassen Linting, Unit-Tests und weitere Prüfungen, um sicherzustellen, dass der Code den Qualitätsstandards des Projekts entspricht. Überprüfe die CI-Ausgabe und behebe alle Probleme. Detaillierte Informationen zum CI-Prozess und Tipps zur Fehlerbehebung findest du im Abschnitt GitHub Actions CI Tests.

Link to this sectionWie melde ich einen Bug in den Ultralytics YOLO Repositories?#

Um einen Bug zu melden, stelle zusammen mit deinem Bug-Report ein klares und prägnantes Minimum Reproducible Example bereit. Dies hilft Entwicklern dabei, das Problem schnell zu identifizieren und zu beheben. Stelle sicher, dass dein Beispiel minimal, aber ausreichend ist, um das Problem zu replizieren. Für detailliertere Schritte zum Melden von Bugs, siehe den Abschnitt Reporting Bugs.

Link to this sectionWas bedeutet die AGPL-3.0-Lizenz, wenn ich Ultralytics YOLO in meinem eigenen Projekt verwende?#

Wenn du Code oder Modelle von Ultralytics YOLO (lizenziert unter AGPL-3.0) in deinem Projekt verwendest, verlangt die AGPL-3.0-Lizenz, dass dein gesamtes Projekt (das abgeleitete Werk) ebenfalls unter der AGPL-3.0 lizenziert sein muss und dessen vollständiger Quellcode öffentlich zugänglich gemacht werden muss. Dies stellt sicher, dass der Open-Source-Charakter der Software über ihre Derivate hinweg gewahrt bleibt. Wenn du diese Anforderungen nicht erfüllen kannst, musst du eine Enterprise License erwerben. Weitere Details findest du im Abschnitt Open-Sourcing Your Project.

Mitwirkende

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

Erstellt 12. Nov. 2023Aktualisiert vor 3 Tagen