feat: initial HSAP platform
Huaxu Sentinel Active Safety Platform with embedded algorithm code, Docker Compose setup, and vendored dataset scaffolds for clone-and-run. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
96
algorithms/dms_yolo/code/docs/en/help/CI.md
Normal file
96
algorithms/dms_yolo/code/docs/en/help/CI.md
Normal file
@@ -0,0 +1,96 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn about Ultralytics CI actions, Docker deployment, broken link checks, CodeQL analysis, and PyPI publishing to ensure high-quality code.
|
||||
keywords: Ultralytics, Continuous Integration, CI, Docker deployment, CodeQL, PyPI publishing, code quality, automated testing
|
||||
---
|
||||
|
||||
# Continuous Integration (CI)
|
||||
|
||||
Continuous Integration (CI) is an essential aspect of software development which involves integrating changes and testing them automatically. CI allows us to maintain high-quality code by catching issues early and often in the development process. At Ultralytics, we use various CI tests to ensure the quality and integrity of our codebase.
|
||||
|
||||
## CI Actions
|
||||
|
||||
Here's a brief description of our CI actions:
|
||||
|
||||
- **[CI](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml):** This is our primary CI test that involves running unit tests, linting checks, and sometimes more comprehensive tests depending on the repository.
|
||||
- **[Docker Deployment](https://github.com/ultralytics/ultralytics/actions/workflows/docker.yml):** This test checks the deployment of the project using Docker to ensure the Dockerfile and related scripts are working correctly.
|
||||
- **[Broken Links](https://github.com/ultralytics/ultralytics/actions/workflows/links.yml):** This test scans the codebase for any broken or dead links in our markdown or HTML files.
|
||||
- **[CodeQL](https://github.com/ultralytics/ultralytics/actions/workflows/codeql.yaml):** CodeQL is a tool from GitHub that performs semantic analysis on our code, helping to find potential security vulnerabilities and maintain high-quality code.
|
||||
- **[PyPI Publishing](https://github.com/ultralytics/ultralytics/actions/workflows/publish.yml):** This test checks if the project can be packaged and published to PyPI without any errors.
|
||||
|
||||
### CI Results
|
||||
|
||||
Below is the table showing the status of these CI tests for our main repositories:
|
||||
|
||||
| Repository | CI | Docker Deployment | Broken Links | CodeQL | PyPI and Docs Publishing |
|
||||
| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| [yolov3](https://github.com/ultralytics/yolov3) | [](https://github.com/ultralytics/yolov3/actions/workflows/ci-testing.yml) | [](https://github.com/ultralytics/yolov3/actions/workflows/docker.yml) | [](https://github.com/ultralytics/yolov3/actions/workflows/links.yml) | [](https://github.com/ultralytics/yolov3/actions/workflows/github-code-scanning/codeql) | |
|
||||
| [yolov5](https://github.com/ultralytics/yolov5) | [](https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml) | [](https://github.com/ultralytics/yolov5/actions/workflows/docker.yml) | [](https://github.com/ultralytics/yolov5/actions/workflows/links.yml) | [](https://github.com/ultralytics/yolov5/actions/workflows/github-code-scanning/codeql) | |
|
||||
| [ultralytics](https://github.com/ultralytics/ultralytics) | [](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml) | [](https://github.com/ultralytics/ultralytics/actions/workflows/docker.yml) | [](https://github.com/ultralytics/ultralytics/actions/workflows/links.yml) | [](https://github.com/ultralytics/ultralytics/actions/workflows/github-code-scanning/codeql) | [](https://github.com/ultralytics/ultralytics/actions/workflows/publish.yml) [](https://github.com/conda-forge/ultralytics-feedstock/actions/workflows/check-prs.yml) |
|
||||
| [yolo-ios-app](https://github.com/ultralytics/yolo-ios-app) | [](https://github.com/ultralytics/yolo-ios-app/actions/workflows/ci.yml) | | | [](https://github.com/ultralytics/yolo-ios-app/actions/workflows/github-code-scanning/codeql) | [](https://github.com/ultralytics/yolo-ios-app/actions/workflows/publish.yml) |
|
||||
| [yolo-flutter-app](https://github.com/ultralytics/yolo-flutter-app) | [](https://github.com/ultralytics/yolo-flutter-app/actions/workflows/ci.yml) | | | [](https://github.com/ultralytics/yolo-flutter-app/actions/workflows/github-code-scanning/codeql) | [](https://github.com/ultralytics/yolo-flutter-app/actions/workflows/publish.yml) |
|
||||
| [hub](https://github.com/ultralytics/hub) | [](https://github.com/ultralytics/hub/actions/workflows/ci.yml) | | [](https://github.com/ultralytics/hub/actions/workflows/links.yml) | | |
|
||||
| [hub-sdk](https://github.com/ultralytics/hub-sdk) | [](https://github.com/ultralytics/hub-sdk/actions/workflows/ci.yml) | | [](https://github.com/ultralytics/hub-sdk/actions/workflows/links.yml) | [](https://github.com/ultralytics/hub-sdk/actions/workflows/github-code-scanning/codeql) | [](https://github.com/ultralytics/hub-sdk/actions/workflows/publish.yml) |
|
||||
| [thop](https://github.com/ultralytics/thop) | [](https://github.com/ultralytics/thop/actions/workflows/format.yml) | | | [](https://github.com/ultralytics/thop/actions/workflows/github-code-scanning/codeql) | [](https://github.com/ultralytics/thop/actions/workflows/publish.yml) |
|
||||
| [actions](https://github.com/ultralytics/actions) | [](https://github.com/ultralytics/actions/actions/workflows/ci.yml) | | | [](https://github.com/ultralytics/actions/actions/workflows/github-code-scanning/codeql) | [](https://github.com/ultralytics/actions/actions/workflows/publish.yml) |
|
||||
| [mkdocs](https://github.com/ultralytics/mkdocs) | [](https://github.com/ultralytics/mkdocs/actions/workflows/format.yml) | | | [](https://github.com/ultralytics/mkdocs/actions/workflows/github-code-scanning/codeql) | [](https://github.com/ultralytics/mkdocs/actions/workflows/publish.yml) |
|
||||
| [docs](https://github.com/ultralytics/docs) | [](https://github.com/ultralytics/docs/actions/workflows/format.yml) | | [](https://github.com/ultralytics/docs/actions/workflows/links.yml)[](https://github.com/ultralytics/docs/actions/workflows/check_domains.yml) | | [](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment) |
|
||||
| [handbook](https://github.com/ultralytics/handbook) | [](https://github.com/ultralytics/handbook/actions/workflows/format.yml) | | [](https://github.com/ultralytics/handbook/actions/workflows/links.yml) | | [](https://github.com/ultralytics/handbook/actions/workflows/pages/pages-build-deployment) |
|
||||
| [stars](https://github.com/ultralytics/stars) | [](https://github.com/ultralytics/stars/actions/workflows/format.yml) | | | | [](https://github.com/ultralytics/stars/actions/workflows/analytics.yml) |
|
||||
| [CLIP](https://github.com/ultralytics/CLIP) | [](https://github.com/ultralytics/CLIP/actions/workflows/ci.yml) | | | | |
|
||||
|
||||
Each badge shows the status of the last run of the corresponding CI test on the `main` branch of the respective repository. If a test fails, the badge will display a "failing" status, and if it passes, it will display a "passing" status.
|
||||
|
||||
If you notice a test failing, it would be a great help if you could report it through a GitHub issue in the respective repository.
|
||||
|
||||
Remember, a successful CI test does not mean that everything is perfect. It is always recommended to manually review the code before deployment or merging changes.
|
||||
|
||||
## Code Coverage
|
||||
|
||||
Code coverage is a metric that represents the percentage of your codebase that is executed when your tests run. It provides insight into how well your tests exercise your code and can be crucial in identifying untested parts of your application. A high code coverage percentage is often associated with a lower likelihood of bugs. However, it's essential to understand that code coverage does not guarantee the absence of defects. It merely indicates which parts of the code have been executed by the tests.
|
||||
|
||||
### Integration with [codecov.io](https://about.codecov.io/)
|
||||
|
||||
At Ultralytics, we have integrated our repositories with [codecov.io](https://about.codecov.io/), a popular online platform for measuring and visualizing code coverage. Codecov provides detailed insights, coverage comparisons between commits, and visual overlays directly on your code, indicating which lines were covered.
|
||||
|
||||
By integrating with Codecov, we aim to maintain and improve the quality of our code by focusing on areas that might be prone to errors or need further testing.
|
||||
|
||||
### Coverage Results
|
||||
|
||||
To quickly get a glimpse of the code coverage status of the `ultralytics` Python package, we have included a badge and sunburst visual of the `ultralytics` coverage results. These images show the percentage of code covered by our tests, offering an at-a-glance metric of our testing efforts. For full details, visit the [Ultralytics Codecov report](https://app.codecov.io/github/ultralytics/ultralytics).
|
||||
|
||||
| Repository | Code Coverage |
|
||||
| --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| [ultralytics](https://github.com/ultralytics/ultralytics) | [](https://codecov.io/gh/ultralytics/ultralytics) |
|
||||
|
||||
In the sunburst graphic below, the innermost circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.
|
||||
|
||||
<a href="https://app.codecov.io/github/ultralytics/ultralytics">
|
||||
<img src="https://codecov.io/gh/ultralytics/ultralytics/branch/main/graphs/sunburst.svg?token=HHW7IIVFVY" alt="Ultralytics Codecov Image">
|
||||
</a>
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is Continuous Integration (CI) in Ultralytics?
|
||||
|
||||
Continuous Integration (CI) in Ultralytics involves automatically integrating and testing code changes to ensure high-quality standards. Our CI setup includes running [unit tests, linting checks, and comprehensive tests](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml). Additionally, we perform [Docker deployment](https://github.com/ultralytics/ultralytics/actions/workflows/docker.yml), [broken link checks](https://github.com/ultralytics/ultralytics/actions/workflows/links.yml), [CodeQL analysis](https://github.com/ultralytics/ultralytics/actions/workflows/codeql.yaml) for security vulnerabilities, and [PyPI publishing](https://github.com/ultralytics/ultralytics/actions/workflows/publish.yml) to package and distribute our software.
|
||||
|
||||
### How does Ultralytics check for broken links in documentation and code?
|
||||
|
||||
Ultralytics uses a specific CI action to [check for broken links](https://github.com/ultralytics/ultralytics/actions/workflows/links.yml) within our markdown and HTML files. This helps maintain the integrity of our documentation by scanning and identifying dead or broken links, ensuring that users always have access to accurate and live resources.
|
||||
|
||||
### Why is CodeQL analysis important for Ultralytics' codebase?
|
||||
|
||||
[CodeQL analysis](https://github.com/ultralytics/ultralytics/actions/workflows/codeql.yaml) is crucial for Ultralytics as it performs semantic code analysis to find potential security vulnerabilities and maintain high-quality standards. With CodeQL, we can proactively identify and mitigate risks in our code, helping us deliver robust and secure [software solutions](https://www.ultralytics.com/solutions).
|
||||
|
||||
### How does Ultralytics utilize Docker for deployment?
|
||||
|
||||
Ultralytics employs Docker to validate the deployment of our projects through a dedicated CI action. This process ensures that our [Dockerfile and associated scripts](https://github.com/ultralytics/ultralytics/actions/workflows/docker.yml) are functioning correctly, allowing for consistent and reproducible deployment environments which are critical for scalable and reliable AI solutions.
|
||||
|
||||
### What is the role of automated PyPI publishing in Ultralytics?
|
||||
|
||||
Automated [PyPI publishing](https://github.com/ultralytics/ultralytics/actions/workflows/publish.yml) ensures that our projects can be packaged and published without errors. This step is essential for distributing Ultralytics' Python packages, allowing users to easily install and use our tools via the [Python Package Index (PyPI)](https://pypi.org/project/ultralytics/).
|
||||
|
||||
### How does Ultralytics measure code coverage and why is it important?
|
||||
|
||||
Ultralytics measures code coverage by integrating with [Codecov](https://app.codecov.io/github/ultralytics/ultralytics), providing insights into how much of the codebase is executed during tests. High code coverage can indicate well-tested code, helping to uncover untested areas that might be prone to bugs. Detailed code coverage metrics can be explored via badges displayed on our main repositories or directly on [Codecov](https://app.codecov.io/gh/ultralytics/ultralytics).
|
||||
130
algorithms/dms_yolo/code/docs/en/help/CLA.md
Normal file
130
algorithms/dms_yolo/code/docs/en/help/CLA.md
Normal file
@@ -0,0 +1,130 @@
|
||||
---
|
||||
description: Review the terms for contributing to Ultralytics projects. Learn about copyright, patent licenses, and moral rights for your contributions.
|
||||
keywords: Ultralytics, Contributor License Agreement, open source, contributions, copyright license, patent license, moral rights
|
||||
---
|
||||
|
||||
# Ultralytics Individual Contributor License Agreement
|
||||
|
||||
Thank you for your interest in contributing to software projects managed by Ultralytics Inc. ("**Ultralytics**", "**We**" or "**Us**"). This Contributor License Agreement ("**Agreement**") sets out the rights granted by contributors ("**You**" or "**Your**") to Us and the terms governing any contributions as defined in Section 1. This license is for your protection as a Contributor as well as the protection of Ultralytics; it does not change your rights to use your own Contributions for any other purpose.
|
||||
|
||||
By accepting and agreeing to these terms and conditions You accept and agree to the following terms and conditions for Your past, present and future Contributions submitted to Ultralytics. Except for the license granted herein to Ultralytics and recipients of software distributed by Ultralytics, You reserve all right, title, and interest in and to Your Contributions.
|
||||
|
||||
If you have any questions regarding this Agreement, please contact hello@ultralytics.com.
|
||||
|
||||
## 1. Definitions
|
||||
|
||||
### 1.1 "You" or "Your"
|
||||
|
||||
Shall mean the individual who submits a Contribution to Ultralytics or the legal entity authorized by the copyright owner that is making this Agreement with Ultralytics. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single Contributor. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
### 1.2 "Contribution"
|
||||
|
||||
Shall mean any original work of authorship, including but not limited to source code, object code, bug fixes, configuration changes, tools, specifications, documentation, data, materials, feedback, information, or any other works of authorship, that is intentionally submitted by You to Ultralytics, in any form and in any manner, for inclusion in, or documentation of, any of the projects managed by Ultralytics (the "**Work**"). This includes any modifications or additions to existing works that are submitted for the purpose of contributing to a Project and improving the Work.
|
||||
|
||||
### 1.3 "Copyright"
|
||||
|
||||
Means all rights protecting works of authorship owned or controlled by You, including copyright, moral and neighboring rights, as appropriate, for the full term of their existence including any extensions by You.
|
||||
|
||||
### 1.4 "Submit" or "Submission" or "Submitted"
|
||||
|
||||
Or any derivatives shall mean any form of electronic, verbal, or written communication sent to Ultralytics or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, Ultralytics for the purpose of discussing and improving the Project, but excluding communication that is conspicuously marked or otherwise designated in writing by You as "Not a Contribution."
|
||||
|
||||
### 1.5 "Project"
|
||||
|
||||
Shall mean any of the software projects owned, managed, or maintained by Ultralytics, including but not limited to open-source projects made available by Ultralytics to which Contributions may be submitted.
|
||||
|
||||
## 2. Grant of Rights
|
||||
|
||||
### 2.1 Copyright License
|
||||
|
||||
To the maximum extent permitted by the relevant law, and subject to the terms and conditions of this Agreement, You hereby grant to Ultralytics and to recipients of software distributed by Ultralytics a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works.
|
||||
|
||||
### 2.2 Patent License
|
||||
|
||||
To the maximum extent permitted by the relevant law, and subject to the terms and conditions of this Agreement, You hereby grant to Ultralytics and to recipients of software distributed by Ultralytics a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by combination of Your Contribution(s) with the Work to which such Contribution(s) was submitted. If any entity institutes patent litigation against You or any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your Contribution, or the Work to which you have contributed, constitutes direct or contributory patent infringement, then any patent licenses granted to that entity under this Agreement for that Contribution or Work shall terminate as of the date such litigation is filed.
|
||||
|
||||
### 2.3 Outbound License
|
||||
|
||||
Based on the grant of rights in Sections 2.1 and 2.2, if We include Your Contribution in a Material, We may license the Contribution under any license, including copyleft, permissive, commercial, or proprietary licenses.
|
||||
|
||||
### 2.4 Moral Rights
|
||||
|
||||
To the fullest extent permitted by law, You hereby waive, and agree not to assert, all of Your "moral rights" in or relating to Your Contributions for the benefit of Ultralytics, its assigns, and their respective direct and indirect sublicensees.
|
||||
|
||||
## 3. Representations and Warranties
|
||||
|
||||
You represent that:
|
||||
|
||||
(a) You have the legal authority to enter into this Agreement.
|
||||
|
||||
(b) You own the Copyright and patent claims covering the Contribution which are required to grant the rights under Section 2.
|
||||
|
||||
(c) The grant of rights under Section 2 does not violate any grant of rights which You have made to third parties, including Your employer. If Your Contributions were created in the course of Your employment with Your past or present employer(s), You represent that such employer(s) has authorized You to make Contributions on behalf of such employer(s) or such employer(s) has waived all of their right, title, or interest in or to Your Contributions.
|
||||
|
||||
(d) You have followed the instructions provided by Ultralytics if You do not own the Copyright in the entire work of authorship submitted.
|
||||
|
||||
(e) Should You wish to submit work that is not Your original creation, You may submit it to Ultralytics separately from any Contribution, identifying the complete details of its source and of any license or other restriction (including, but not limited to, related patents, trademarks, and license agreements) of which You are personally aware, and conspicuously marking the work as "Submitted on behalf of a third-party: [named here]."
|
||||
|
||||
(f) You agree to notify Ultralytics of any facts or circumstances of which You become aware that would make these representations inaccurate in any respect.
|
||||
|
||||
## 4. Disclaimer of Warranties
|
||||
|
||||
EXCEPT FOR THE EXPRESS WARRANTIES IN SECTION 3, THE CONTRIBUTION IS PROVIDED "AS IS". MORE PARTICULARLY, ALL EXPRESS OR IMPLIED WARRANTIES INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE EXPRESSLY DISCLAIMED BY YOU TO US. TO THE EXTENT THAT ANY SUCH WARRANTIES CANNOT BE DISCLAIMED, SUCH WARRANTY IS LIMITED IN DURATION TO THE MINIMUM PERIOD PERMITTED BY LAW.
|
||||
|
||||
## 5. Miscellaneous
|
||||
|
||||
### 5.1 Governing Law and Jurisdiction
|
||||
|
||||
This Agreement will be governed by and construed in accordance with the laws of the State of New York, United States of America, excluding its conflicts of law provisions. The parties submit to venue in, and jurisdiction of, the courts located in New York, New York, for purposes relating to this Agreement. You waive all defenses of lack of personal jurisdiction and forum non-conveniens.
|
||||
|
||||
### 5.2 Entire Agreement
|
||||
|
||||
This Agreement sets out the entire agreement between You and Ultralytics for Your Contributions and overrides all other agreements or understandings.
|
||||
|
||||
### 5.3 Assignment
|
||||
|
||||
Ultralytics may assign this Agreement, and all of its rights, obligations, and licenses hereunder, without Your prior consent.
|
||||
|
||||
### 5.4 Waiver of Performance
|
||||
|
||||
The failure of either party to require performance by the other party of any provision of this Agreement in one situation shall not affect the right of a party to require such performance at any time in the future. A waiver of performance under a provision in one situation shall not be considered a waiver of the performance of the provision in the future or a waiver of the provision in its entirety.
|
||||
|
||||
### 5.5 Severability
|
||||
|
||||
If any provision of this Agreement is found void and unenforceable, such provision will be replaced to the extent possible with a provision that comes closest to the meaning of the original provision and which is enforceable. The terms and conditions set forth in this Agreement shall apply notwithstanding any failure of essential purpose of this Agreement or any limited remedy to the maximum extent possible under law.
|
||||
|
||||
### 5.6 No Obligation
|
||||
|
||||
You acknowledge that Ultralytics is under no obligation to use or incorporate your Contributions into any of the Work. The decision to use or incorporate your Contributions into any of the Work will be made at the sole discretion of Ultralytics or its authorized delegates.
|
||||
|
||||
### 5.7 Effective Date
|
||||
|
||||
The Effective Date of this Agreement shall be the date You execute this Agreement or the date You first Submit a Contribution to Ultralytics, whichever is earlier.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the purpose of the Ultralytics Contributor License Agreement (CLA)?
|
||||
|
||||
The Ultralytics CLA defines the terms under which you contribute to Ultralytics' software projects. It outlines the rights and obligations related to your contributions, including granting copyright and patent licenses, and addressing the handling of third-party content.
|
||||
|
||||
### Why do I need to agree to the Copyright License in the CLA?
|
||||
|
||||
Agreeing to the Copyright License allows Ultralytics and its users to use, modify, distribute, and create derivative works from your contributions. This ensures that your contributions can be integrated into [Ultralytics projects](https://github.com/ultralytics) and shared with the community, fostering collaboration and software development.
|
||||
|
||||
### How does the Patent License benefit both contributors and Ultralytics?
|
||||
|
||||
The Patent License grants Ultralytics the rights to use, make, and sell contributions covered by your patents. This is essential for product development and commercialization. In return, your patented innovations gain wider use and recognition, promoting innovation within the community. The patent license is similar to provisions found in other [open-source licenses](https://www.ultralytics.com/legal/agpl-3-0-software-license) like AGPL-3.0.
|
||||
|
||||
### What should I do if my contribution includes third-party content?
|
||||
|
||||
If your contribution includes third-party content, you must clearly mark it and provide comprehensive details about its source and any applicable licenses or restrictions. This ensures proper attribution and legal compliance within Ultralytics projects, maintaining transparency and respecting the rights of original content creators.
|
||||
|
||||
### What happens if Ultralytics decides not to use my contribution?
|
||||
|
||||
Ultralytics is not obligated to use or incorporate your contributions into any projects. The decision to use your contributions is entirely at Ultralytics' discretion, meaning that while your contributions are valuable, they may not always align with the project's current needs or directions.
|
||||
|
||||
---
|
||||
|
||||
**Need More Help?**
|
||||
|
||||
If you have any further questions or need clarification regarding the Contributor License Agreement, please contact us at hello@ultralytics.com. For more information about contributing to Ultralytics projects, see our [Contributing Guide](https://docs.ultralytics.com/help/contributing/).
|
||||
231
algorithms/dms_yolo/code/docs/en/help/FAQ.md
Normal file
231
algorithms/dms_yolo/code/docs/en/help/FAQ.md
Normal file
@@ -0,0 +1,231 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore common questions and solutions related to Ultralytics YOLO, from hardware requirements to model fine-tuning and real-time detection.
|
||||
keywords: Ultralytics, YOLO, FAQ, object detection, hardware requirements, fine-tuning, ONNX, TensorFlow, real-time detection, model accuracy
|
||||
---
|
||||
|
||||
# Ultralytics YOLO Frequently Asked Questions (FAQ)
|
||||
|
||||
This FAQ section addresses common questions and issues users might encounter while working with [Ultralytics](https://www.ultralytics.com/) YOLO repositories.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is Ultralytics and what does it offer?
|
||||
|
||||
Ultralytics is a [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) AI company specializing in state-of-the-art object detection and [image segmentation](https://www.ultralytics.com/glossary/image-segmentation) models, with a focus on the YOLO (You Only Look Once) family. Their offerings include:
|
||||
|
||||
- Open-source implementations of [YOLO26](https://docs.ultralytics.com/models/yolo26/) (latest) and [YOLO11](https://docs.ultralytics.com/models/yolo11/) (previous generation)
|
||||
- A wide range of [pretrained models](https://docs.ultralytics.com/models/) for various computer vision tasks
|
||||
- A comprehensive [Python package](https://docs.ultralytics.com/usage/python/) for seamless integration of YOLO models into projects
|
||||
- Versatile [tools](https://docs.ultralytics.com/modes/) for training, testing, and deploying models
|
||||
- [Extensive documentation](https://docs.ultralytics.com/) and a supportive community
|
||||
|
||||
### How do I install the Ultralytics package?
|
||||
|
||||
Installing the Ultralytics package is straightforward using pip:
|
||||
|
||||
```bash
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
For the latest development version, install directly from the GitHub repository:
|
||||
|
||||
```bash
|
||||
pip install git+https://github.com/ultralytics/ultralytics.git
|
||||
```
|
||||
|
||||
Detailed installation instructions can be found in the [quickstart guide](https://docs.ultralytics.com/quickstart/).
|
||||
|
||||
### What are the system requirements for running Ultralytics models?
|
||||
|
||||
Minimum requirements:
|
||||
|
||||
- Python 3.8+
|
||||
- [PyTorch](https://www.ultralytics.com/glossary/pytorch) 1.8+
|
||||
- CUDA-compatible GPU (for GPU acceleration)
|
||||
|
||||
Recommended setup:
|
||||
|
||||
- Python 3.8+
|
||||
- PyTorch 1.10+
|
||||
- NVIDIA GPU with CUDA 11.2+
|
||||
- 8GB+ RAM
|
||||
- 50GB+ free disk space (for dataset storage and model training)
|
||||
|
||||
For troubleshooting common issues, visit the [YOLO Common Issues](https://docs.ultralytics.com/guides/yolo-common-issues/) page.
|
||||
|
||||
### How can I train a custom YOLO model on my own dataset?
|
||||
|
||||
To train a custom YOLO model:
|
||||
|
||||
1. Prepare your dataset in YOLO format (images and corresponding label txt files).
|
||||
2. Create a YAML file describing your dataset structure and classes.
|
||||
3. Use the following Python code to start training:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.yaml") # build a new model from scratch
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
For a more in-depth guide, including data preparation and advanced training options, refer to the comprehensive [training guide](https://docs.ultralytics.com/modes/train/).
|
||||
|
||||
### What pretrained models are available in Ultralytics?
|
||||
|
||||
Ultralytics offers a diverse range of pretrained models for various tasks:
|
||||
|
||||
- Object Detection: YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x
|
||||
- [Instance Segmentation](https://www.ultralytics.com/glossary/instance-segmentation): YOLO26n-seg, YOLO26s-seg, YOLO26m-seg, YOLO26l-seg, YOLO26x-seg
|
||||
- Classification: YOLO26n-cls, YOLO26s-cls, YOLO26m-cls, YOLO26l-cls, YOLO26x-cls
|
||||
- Pose Estimation: YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, YOLO26l-pose, YOLO26x-pose
|
||||
- Oriented Detection (OBB): YOLO26n-obb, YOLO26s-obb, YOLO26m-obb, YOLO26l-obb, YOLO26x-obb
|
||||
|
||||
These models vary in size and complexity, offering different trade-offs between speed and [accuracy](https://www.ultralytics.com/glossary/accuracy). Explore the full range of [pretrained models](https://docs.ultralytics.com/models/) to find the best fit for your project.
|
||||
|
||||
### How do I perform inference using a trained Ultralytics model?
|
||||
|
||||
To perform inference with a trained model:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/your/model.pt")
|
||||
|
||||
# Perform inference
|
||||
results = model("path/to/image.jpg")
|
||||
|
||||
# Process results
|
||||
for r in results:
|
||||
print(r.boxes) # print bbox predictions
|
||||
print(r.masks) # print mask predictions
|
||||
print(r.probs) # print class probabilities
|
||||
```
|
||||
|
||||
For advanced inference options, including batch processing and video inference, check out the detailed [prediction guide](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
### Can Ultralytics models be deployed on edge devices or in production environments?
|
||||
|
||||
Absolutely! Ultralytics models are designed for versatile deployment across various platforms:
|
||||
|
||||
- Edge devices: Optimize inference on devices like NVIDIA Jetson or Intel Neural Compute Stick using TensorRT, ONNX, or OpenVINO.
|
||||
- Mobile: Deploy on Android or iOS devices by converting models to TFLite or Core ML.
|
||||
- Cloud: Leverage frameworks like [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) Serving or PyTorch Serve for scalable cloud deployments.
|
||||
- Web: Implement in-browser inference using ONNX.js or TensorFlow.js.
|
||||
|
||||
Ultralytics provides export functions to convert models to various formats for deployment. Explore the wide range of [deployment options](https://docs.ultralytics.com/guides/model-deployment-options/) to find the best solution for your use case.
|
||||
|
||||
### What's the difference between YOLO11 and YOLO26?
|
||||
|
||||
Key distinctions include:
|
||||
|
||||
- End-to-End NMS-Free Inference: YOLO26 is natively end-to-end, producing predictions directly without non-maximum suppression (NMS), reducing latency and simplifying deployment.
|
||||
- DFL Removal: YOLO26 removes the Distribution Focal Loss module, simplifying export and improving compatibility with edge and low-power devices.
|
||||
- MuSGD Optimizer: A hybrid of SGD and Muon (inspired by Moonshot AI's Kimi K2) for more stable training and faster convergence.
|
||||
- CPU Performance: YOLO26 delivers up to 43% faster CPU inference, making it ideal for devices without GPUs.
|
||||
- Task-Specific Optimizations: Enhanced segmentation with semantic loss and multi-scale protos, RLE for precision pose estimation, and improved OBB decoding with angle loss.
|
||||
- Tasks: Both models support [object detection](https://www.ultralytics.com/glossary/object-detection), instance segmentation, classification, pose estimation, and oriented object detection (OBB) in a unified framework.
|
||||
|
||||
For an in-depth comparison of features and performance metrics, visit the [YOLO26 documentation page](https://docs.ultralytics.com/models/yolo26/).
|
||||
|
||||
### How can I contribute to the Ultralytics open-source project?
|
||||
|
||||
Contributing to Ultralytics is a great way to improve the project and expand your skills. Here's how you can get involved:
|
||||
|
||||
1. Fork the Ultralytics repository on GitHub.
|
||||
2. Create a new branch for your feature or bug fix.
|
||||
3. Make your changes and ensure all tests pass.
|
||||
4. Submit a pull request with a clear description of your changes.
|
||||
5. Participate in the code review process.
|
||||
|
||||
You can also contribute by reporting bugs, suggesting features, or improving documentation. For detailed guidelines and best practices, refer to the [contributing guide](https://docs.ultralytics.com/help/contributing/).
|
||||
|
||||
### How do I install the Ultralytics package in Python?
|
||||
|
||||
Installing the Ultralytics package in Python is simple. Use pip by running the following command in your terminal or command prompt:
|
||||
|
||||
```bash
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
For the cutting-edge development version, install directly from the GitHub repository:
|
||||
|
||||
```bash
|
||||
pip install git+https://github.com/ultralytics/ultralytics.git
|
||||
```
|
||||
|
||||
For environment-specific installation instructions and troubleshooting tips, consult the comprehensive [quickstart guide](https://docs.ultralytics.com/quickstart/).
|
||||
|
||||
### What are the main features of Ultralytics YOLO?
|
||||
|
||||
Ultralytics YOLO boasts a rich set of features for advanced computer vision tasks:
|
||||
|
||||
- Real-Time Detection: Efficiently detect and classify objects in real-time scenarios.
|
||||
- Multi-Task Capabilities: Perform object detection, instance segmentation, classification, and pose estimation with a unified framework.
|
||||
- Pretrained Models: Access a variety of [pretrained models](https://docs.ultralytics.com/models/) that balance speed and accuracy for different use cases.
|
||||
- Custom Training: Easily fine-tune models on custom datasets with the flexible [training pipeline](https://docs.ultralytics.com/modes/train/).
|
||||
- Wide [Deployment Options](https://docs.ultralytics.com/guides/model-deployment-options/): Export models to various formats like TensorRT, ONNX, and CoreML for deployment across different platforms.
|
||||
- Extensive Documentation: Benefit from comprehensive [documentation](https://docs.ultralytics.com/) and a supportive community for your computer vision workflows.
|
||||
|
||||
### How can I improve the performance of my YOLO model?
|
||||
|
||||
Enhancing your YOLO model's performance can be achieved through several techniques:
|
||||
|
||||
1. [Hyperparameter Tuning](https://www.ultralytics.com/glossary/hyperparameter-tuning): Experiment with different hyperparameters using the [Hyperparameter Tuning Guide](https://docs.ultralytics.com/guides/hyperparameter-tuning/) to optimize model performance.
|
||||
2. [Data Augmentation](https://www.ultralytics.com/glossary/data-augmentation): Implement techniques like flip, scale, rotate, and color adjustments to enhance your training dataset and improve model generalization.
|
||||
3. [Transfer Learning](https://www.ultralytics.com/glossary/transfer-learning): Leverage pretrained models and fine-tune them on your specific dataset using the [Train guide](../modes/train.md).
|
||||
4. Export to Efficient Formats: Convert your model to optimized formats like TensorRT or ONNX for faster inference using the [Export guide](../modes/export.md).
|
||||
5. Benchmarking: Utilize the [Benchmark Mode](https://docs.ultralytics.com/modes/benchmark/) to measure and improve inference speed and accuracy systematically.
|
||||
|
||||
### Can I deploy Ultralytics YOLO models on mobile and edge devices?
|
||||
|
||||
Yes, Ultralytics YOLO models are designed for versatile deployment, including mobile and edge devices:
|
||||
|
||||
- Mobile: Convert models to TFLite or CoreML for seamless integration into Android or iOS apps. Refer to the [TFLite Integration Guide](https://docs.ultralytics.com/integrations/tflite/) and [CoreML Integration Guide](https://docs.ultralytics.com/integrations/coreml/) for platform-specific instructions.
|
||||
- Edge Devices: Optimize inference on devices like NVIDIA Jetson or other edge hardware using TensorRT or ONNX. The [Edge TPU Integration Guide](https://docs.ultralytics.com/integrations/edge-tpu/) provides detailed steps for edge deployment.
|
||||
|
||||
For a comprehensive overview of deployment strategies across various platforms, consult the [deployment options guide](https://docs.ultralytics.com/guides/model-deployment-options/).
|
||||
|
||||
### How can I perform inference using a trained Ultralytics YOLO model?
|
||||
|
||||
Performing inference with a trained Ultralytics YOLO model is straightforward:
|
||||
|
||||
1. Load the Model:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("path/to/your/model.pt")
|
||||
```
|
||||
|
||||
2. Run Inference:
|
||||
|
||||
```python
|
||||
results = model("path/to/image.jpg")
|
||||
|
||||
for r in results:
|
||||
print(r.boxes) # print bounding box predictions
|
||||
print(r.masks) # print mask predictions
|
||||
print(r.probs) # print class probabilities
|
||||
```
|
||||
|
||||
For advanced inference techniques, including batch processing, video inference, and custom preprocessing, refer to the detailed [prediction guide](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
### Where can I find examples and tutorials for using Ultralytics?
|
||||
|
||||
Ultralytics provides a wealth of resources to help you get started and master their tools:
|
||||
|
||||
- 📚 [Official documentation](https://docs.ultralytics.com/): Comprehensive guides, API references, and best practices.
|
||||
- 💻 [GitHub repository](https://github.com/ultralytics/ultralytics): Source code, example scripts, and community contributions.
|
||||
- ✍️ [Ultralytics blog](https://www.ultralytics.com/blog): In-depth articles, use cases, and technical insights.
|
||||
- 💬 [Community forums](https://community.ultralytics.com/): Connect with other users, ask questions, and share your experiences.
|
||||
- 🎥 [YouTube channel](https://www.youtube.com/ultralytics?sub_confirmation=1): Video tutorials, demos, and webinars on various Ultralytics topics.
|
||||
|
||||
These resources provide code examples, real-world use cases, and step-by-step guides for various tasks using Ultralytics models.
|
||||
|
||||
If you need further assistance, consult the Ultralytics documentation or reach out to the community through [GitHub Issues](https://github.com/ultralytics/ultralytics/issues) or the official [discussion forum](https://github.com/orgs/ultralytics/discussions).
|
||||
107
algorithms/dms_yolo/code/docs/en/help/code-of-conduct.md
Normal file
107
algorithms/dms_yolo/code/docs/en/help/code-of-conduct.md
Normal file
@@ -0,0 +1,107 @@
|
||||
---
|
||||
comments: true
|
||||
description: Join our welcoming community! Learn about the Ultralytics Code of Conduct to ensure a harassment-free experience for all participants.
|
||||
keywords: Ultralytics, Contributor Covenant, Code of Conduct, community guidelines, harassment-free, inclusive community, diversity, enforcement policy
|
||||
---
|
||||
|
||||
# Ultralytics Contributor Covenant Code of Conduct
|
||||
|
||||
## Our Pledge
|
||||
|
||||
We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
|
||||
|
||||
We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
|
||||
|
||||
## Our Standards
|
||||
|
||||
Examples of behavior that contributes to a positive environment for our community include:
|
||||
|
||||
- Demonstrating empathy and kindness toward other people
|
||||
- Being respectful of differing opinions, viewpoints, and experiences
|
||||
- Giving and gracefully accepting constructive feedback
|
||||
- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
|
||||
- Focusing on what is best not just for us as individuals, but for the overall community
|
||||
|
||||
Examples of unacceptable behavior include:
|
||||
|
||||
- The use of sexualized language or imagery, and sexual attention or advances of any kind
|
||||
- Trolling, insulting or derogatory comments, and personal or political attacks
|
||||
- Public or private harassment
|
||||
- Publishing others' private information, such as a physical or email address, without their explicit permission
|
||||
- Other conduct which could reasonably be considered inappropriate in a professional setting
|
||||
|
||||
## Enforcement Responsibilities
|
||||
|
||||
Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
|
||||
|
||||
Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
|
||||
|
||||
## Scope
|
||||
|
||||
This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
|
||||
|
||||
## Enforcement
|
||||
|
||||
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at hello@ultralytics.com. All complaints will be reviewed and investigated promptly and fairly.
|
||||
|
||||
All community leaders are obligated to respect the privacy and security of the reporter of any incident.
|
||||
|
||||
## Enforcement Guidelines
|
||||
|
||||
Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
|
||||
|
||||
### 1. Correction
|
||||
|
||||
**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
|
||||
|
||||
**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
|
||||
|
||||
### 2. Warning
|
||||
|
||||
**Community Impact**: A violation through a single incident or series of actions.
|
||||
|
||||
**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
|
||||
|
||||
### 3. Temporary Ban
|
||||
|
||||
**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
|
||||
|
||||
**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
|
||||
|
||||
### 4. Permanent Ban
|
||||
|
||||
**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
|
||||
|
||||
**Consequence**: A permanent ban from any sort of public interaction within the community.
|
||||
|
||||
## Attribution
|
||||
|
||||
This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/), version 2.0, available in the [Contributor Covenant code of conduct](https://www.contributor-covenant.org/version/2/0/code_of_conduct/).
|
||||
|
||||
Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/inclusion).
|
||||
|
||||
For answers to common questions about this code of conduct, see the [Contributor Covenant FAQ](https://www.contributor-covenant.org/faq/). Translations are available in the [Contributor Covenant translations](https://www.contributor-covenant.org/translations/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Ultralytics Contributor Covenant Code of Conduct?
|
||||
|
||||
The Ultralytics Contributor Covenant Code of Conduct aims to create a harassment-free experience for everyone participating in the Ultralytics community. It applies to all community interactions, including online and offline activities. The code details expected behaviors, unacceptable behaviors, and the enforcement responsibilities of community leaders. For more detailed information, see the [Enforcement Responsibilities](#enforcement-responsibilities) section.
|
||||
|
||||
### How does the enforcement process work for the Ultralytics Code of Conduct?
|
||||
|
||||
Enforcement of the Ultralytics Code of Conduct is managed by community leaders who can take appropriate action in response to any behavior deemed inappropriate. This could range from a private warning to a permanent ban, depending on the severity of the violation. Instances of misconduct can be reported to hello@ultralytics.com for investigation. Learn more about the enforcement steps in the [Enforcement Guidelines](#enforcement-guidelines) section.
|
||||
|
||||
### Why is diversity and inclusion important in the Ultralytics community?
|
||||
|
||||
Ultralytics values diversity and inclusion as fundamental aspects for fostering innovation and creativity within its community. A diverse and inclusive environment allows different perspectives and experiences to contribute to an open, welcoming, and healthy community. This commitment is reflected in our [Pledge](#our-pledge) to ensure a harassment-free experience for everyone regardless of their background.
|
||||
|
||||
### How can I contribute to Ultralytics while adhering to the Code of Conduct?
|
||||
|
||||
Contributing to Ultralytics means engaging positively and respectfully with other community members. You can contribute by demonstrating empathy, offering and accepting constructive feedback, and taking responsibility for any mistakes. Always aim to contribute in a way that benefits the entire community. For more details on acceptable behaviors, refer to the [Our Standards](#our-standards) section.
|
||||
|
||||
### Where can I find additional information about the Ultralytics Code of Conduct?
|
||||
|
||||
For more comprehensive details about the Ultralytics Code of Conduct, including reporting guidelines and enforcement policies, you can visit the [Contributor Covenant homepage](https://www.contributor-covenant.org/version/2/0/code_of_conduct/) or check the [FAQ section of Contributor Covenant](https://www.contributor-covenant.org/faq/). Learn more about Ultralytics' goals and initiatives on [our brand page](https://www.ultralytics.com/brand) and [about page](https://www.ultralytics.com/about).
|
||||
|
||||
Should you have more questions or need further assistance, check our [Help Center](../help/FAQ.md) and [Contributing Guide](../help/contributing.md) for more information.
|
||||
318
algorithms/dms_yolo/code/docs/en/help/contributing.md
Normal file
318
algorithms/dms_yolo/code/docs/en/help/contributing.md
Normal file
@@ -0,0 +1,318 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn how to contribute to Ultralytics YOLO open-source repositories. Follow guidelines for pull requests, code of conduct, and bug reporting.
|
||||
keywords: Ultralytics, YOLO, open-source, contribution, pull request, code of conduct, bug reporting, GitHub, CLA, Google-style docstrings, AGPL-3.0
|
||||
---
|
||||
|
||||
# Contributing to Ultralytics Open-Source Projects
|
||||
|
||||
Welcome! We're thrilled that you're considering contributing to our [Ultralytics](https://www.ultralytics.com/) [open-source](https://github.com/ultralytics) projects. Your involvement not only helps enhance the quality of our repositories but also benefits the entire [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. This guide provides clear guidelines and best practices to help you get started.
|
||||
|
||||
[](https://github.com/ultralytics/ultralytics/graphs/contributors)
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/yMR7BgwHQ3g"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Contribute to Ultralytics Repository | Ultralytics Models, Datasets and Documentation 🚀
|
||||
</p>
|
||||
|
||||
## 🤝 Code of Conduct
|
||||
|
||||
To ensure a welcoming and inclusive environment for everyone, all contributors must adhere to our [Code of Conduct](https://docs.ultralytics.com/help/code-of-conduct/). **Respect**, **kindness**, and **professionalism** are at the heart of our community.
|
||||
|
||||
## 🚀 Contributing via Pull Requests
|
||||
|
||||
We greatly appreciate contributions in the form of [pull requests (PRs)](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests). To make the review process as smooth as possible, please follow these steps:
|
||||
|
||||
1. **[Fork the repository](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo):** Start by forking the relevant Ultralytics repository (e.g., [ultralytics/ultralytics](https://github.com/ultralytics/ultralytics)) to your GitHub account.
|
||||
2. **[Create a branch](https://docs.github.com/en/desktop/making-changes-in-a-branch/managing-branches-in-github-desktop):** Create a new branch in your forked repository with a clear, descriptive name reflecting your changes (e.g., `fix-issue-123`, `add-feature-xyz`).
|
||||
3. **Make your changes:** Implement your improvements or fixes. Ensure your code adheres to the project's style guidelines and doesn't introduce new errors or warnings.
|
||||
4. **Test your changes:** Before submitting, test your changes locally to confirm they work as expected and don't cause [regressions](https://en.wikipedia.org/wiki/Software_regression). Add tests if you're introducing new functionality.
|
||||
5. **[Commit your changes](https://docs.github.com/en/desktop/making-changes-in-a-branch/committing-and-reviewing-changes-to-your-project-in-github-desktop):** Commit your changes with concise and descriptive commit messages. If your changes address a specific issue, include the issue number (e.g., `Fix #123: Corrected calculation error.`).
|
||||
6. **[Create a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request):** Submit a pull request from your branch to the `main` branch of the original Ultralytics repository. Provide a clear title and a detailed description explaining the purpose and scope of your changes.
|
||||
|
||||
### 📝 CLA Signing
|
||||
|
||||
Before we can merge your pull request, you must sign our [Contributor License Agreement (CLA)](https://docs.ultralytics.com/help/CLA/). This legal agreement ensures that your contributions are properly licensed, allowing the project to continue being distributed under the [AGPL-3.0 license](https://www.ultralytics.com/legal/agpl-3-0-software-license).
|
||||
|
||||
After submitting your pull request, the CLA bot will guide you through the signing process. To sign the CLA, simply add a comment in your PR stating:
|
||||
|
||||
```text
|
||||
I have read the CLA Document and I sign the CLA
|
||||
```
|
||||
|
||||
### ✍️ Google-Style Docstrings
|
||||
|
||||
When adding new functions or classes, include [Google-style docstrings](https://google.github.io/styleguide/pyguide.html) for clear, standardized documentation. Always enclose both input and output `types` in parentheses (e.g., `(bool)`, `(np.ndarray)`).
|
||||
|
||||
!!! example "Example Docstrings"
|
||||
|
||||
=== "Google-style"
|
||||
|
||||
This example illustrates the standard Google-style docstring format. Note how it clearly separates the function description, arguments, return value, and examples for maximum readability.
|
||||
|
||||
```python
|
||||
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
|
||||
```
|
||||
|
||||
=== "Google-style named-returns"
|
||||
|
||||
This example demonstrates how to document named return variables. Using named returns can make your code more self-documenting and easier to understand, especially for complex functions.
|
||||
|
||||
```python
|
||||
def example_function(arg1, arg2=4):
|
||||
"""Example function demonstrating Google-style docstrings.
|
||||
|
||||
Args:
|
||||
arg1 (int): The first argument.
|
||||
arg2 (int): The second argument.
|
||||
|
||||
Returns:
|
||||
equals (bool): True if arguments are equal, False otherwise.
|
||||
|
||||
Examples:
|
||||
>>> example_function(4, 4) # True
|
||||
"""
|
||||
equals = arg1 == arg2
|
||||
return equals
|
||||
```
|
||||
|
||||
=== "Google-style multiple returns"
|
||||
|
||||
This example shows how to document functions that return multiple values. Each return value should be documented separately with its own type and description for clarity.
|
||||
|
||||
```python
|
||||
def example_function(arg1, arg2=4):
|
||||
"""Example function demonstrating Google-style docstrings.
|
||||
|
||||
Args:
|
||||
arg1 (int): The first argument.
|
||||
arg2 (int): The second argument.
|
||||
|
||||
Returns:
|
||||
equals (bool): True if arguments are equal, False otherwise.
|
||||
added (int): Sum of both input arguments.
|
||||
|
||||
Examples:
|
||||
>>> equals, added = example_function(2, 2) # True, 4
|
||||
"""
|
||||
equals = arg1 == arg2
|
||||
added = arg1 + arg2
|
||||
return equals, added
|
||||
```
|
||||
|
||||
Note: Even though Python returns multiple values as a tuple (e.g., `return masks, scores`), always document each value separately for clarity and better tool integration. When documenting functions that return multiple values:
|
||||
|
||||
✅ Good - Document each return value separately:
|
||||
```
|
||||
Returns:
|
||||
(np.ndarray): Predicted masks with shape HxWxN.
|
||||
(list): Confidence scores for each instance.
|
||||
```
|
||||
|
||||
❌ Bad - Don't document as a tuple with nested elements:
|
||||
```
|
||||
Returns:
|
||||
(tuple): Tuple containing:
|
||||
- (np.ndarray): Predicted masks with shape HxWxN.
|
||||
- (list): Confidence scores for each instance.
|
||||
```
|
||||
|
||||
=== "Google-style with type hints"
|
||||
|
||||
This example combines Google-style docstrings with Python type hints. When using type hints, you can omit the type information in the docstring arguments section, as it's already specified in the function signature.
|
||||
|
||||
```python
|
||||
def example_function(arg1: int, arg2: int = 4) -> bool:
|
||||
"""Example function demonstrating Google-style docstrings.
|
||||
|
||||
Args:
|
||||
arg1: The first argument.
|
||||
arg2: The second argument.
|
||||
|
||||
Returns:
|
||||
True if arguments are equal, False otherwise.
|
||||
|
||||
Examples:
|
||||
>>> example_function(1, 1) # True
|
||||
"""
|
||||
return arg1 == arg2
|
||||
```
|
||||
|
||||
=== "Single-line"
|
||||
|
||||
For smaller or simpler functions, a single-line docstring may be sufficient. These should be concise but complete sentences that start with a capital letter and end with a period.
|
||||
|
||||
```python
|
||||
def example_small_function(arg1: int, arg2: int = 4) -> bool:
|
||||
"""Example function with a single-line docstring."""
|
||||
return arg1 == arg2
|
||||
```
|
||||
|
||||
### ✅ GitHub Actions CI Tests
|
||||
|
||||
All pull requests must pass the [GitHub Actions](https://github.com/features/actions) [Continuous Integration](https://docs.ultralytics.com/help/CI/) (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.
|
||||
|
||||
## ✨ Best Practices for Code Contributions
|
||||
|
||||
When contributing code to Ultralytics projects, keep these best practices in mind:
|
||||
|
||||
- **Avoid code duplication:** Reuse existing code wherever possible and minimize unnecessary arguments.
|
||||
- **Make smaller, focused changes:** Focus on targeted modifications rather than large-scale changes.
|
||||
- **Simplify when possible:** Look for opportunities to simplify the code or remove unnecessary parts.
|
||||
- **Consider compatibility:** Before making changes, consider whether they might break existing code using Ultralytics.
|
||||
- **Use consistent formatting:** Tools like [Ruff Formatter](https://github.com/astral-sh/ruff) can help maintain stylistic consistency.
|
||||
- **Add appropriate tests:** Include [tests](https://docs.ultralytics.com/guides/model-testing/) for new features to ensure they work as expected.
|
||||
|
||||
## 👀 Reviewing Pull Requests
|
||||
|
||||
Reviewing pull requests is another valuable way to contribute. When reviewing PRs:
|
||||
|
||||
- **Check for unit tests:** Verify that the PR includes tests for new features or changes.
|
||||
- **Review documentation updates:** Ensure [documentation](https://docs.ultralytics.com/) is updated to reflect changes.
|
||||
- **Evaluate performance impact:** Consider how changes might affect [performance](https://docs.ultralytics.com/guides/yolo-performance-metrics/).
|
||||
- **Verify CI tests:** Confirm all [Continuous Integration tests](https://docs.ultralytics.com/help/CI/) are passing.
|
||||
- **Provide constructive feedback:** Offer specific, clear feedback about any issues or concerns.
|
||||
- **Recognize effort:** Acknowledge the author's work to maintain a positive collaborative atmosphere.
|
||||
|
||||
## 🐞 Reporting Bugs
|
||||
|
||||
We highly value bug reports as they help us improve the quality and reliability of our projects. When reporting a bug via [GitHub Issues](https://github.com/ultralytics/ultralytics/issues):
|
||||
|
||||
- **Check existing issues:** Search first to see if the bug has already been reported.
|
||||
- **Provide a [Minimum Reproducible Example](https://docs.ultralytics.com/help/minimum-reproducible-example/):** Create a small, self-contained code snippet that consistently reproduces the issue. This is crucial for efficient debugging.
|
||||
- **Describe the environment:** Specify your operating system, Python version, relevant library versions (e.g., [`torch`](https://pytorch.org/), [`ultralytics`](https://github.com/ultralytics/ultralytics)), and hardware ([CPU](https://en.wikipedia.org/wiki/Central_processing_unit)/[GPU](https://www.ultralytics.com/glossary/gpu-graphics-processing-unit)).
|
||||
- **Explain expected vs. actual behavior:** Clearly state what you expected to happen and what actually occurred. Include any error messages or tracebacks.
|
||||
|
||||
## 📜 License
|
||||
|
||||
Ultralytics uses the [GNU Affero General Public License v3.0 (AGPL-3.0)](https://www.ultralytics.com/legal/agpl-3-0-software-license) for its repositories. This license promotes [openness](https://en.wikipedia.org/wiki/Openness), [transparency](https://www.ultralytics.com/glossary/transparency-in-ai), and [collaborative improvement](https://en.wikipedia.org/wiki/Collaborative_software) in software development. It ensures that all users have the freedom to use, modify, and share the software, fostering a strong community of collaboration and innovation.
|
||||
|
||||
We encourage all contributors to familiarize themselves with the terms of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3) to contribute effectively and ethically to the Ultralytics open-source community.
|
||||
|
||||
## 🌍 Open-Sourcing Your YOLO Project Under AGPL-3.0
|
||||
|
||||
Using Ultralytics YOLO models or code in your project? The [AGPL-3.0 license](https://opensource.org/license/agpl-v3) requires that your entire derivative work also be open-sourced under AGPL-3.0. This ensures modifications and larger projects built upon open-source foundations remain open.
|
||||
|
||||
### Why AGPL-3.0 Compliance Matters
|
||||
|
||||
- **Keeps Software Open:** Ensures that improvements and derivative works benefit the community.
|
||||
- **Legal Requirement:** Using AGPL-3.0 licensed code binds your project to its terms.
|
||||
- **Fosters Collaboration:** Encourages sharing and transparency.
|
||||
|
||||
If you prefer not to open-source your project, consider obtaining an [Enterprise License](https://www.ultralytics.com/license).
|
||||
|
||||
### How to Comply with AGPL-3.0
|
||||
|
||||
Complying means making the **complete corresponding source code** of your project publicly available under the AGPL-3.0 license.
|
||||
|
||||
1. **Choose Your Starting Point:**
|
||||
- **Fork Ultralytics YOLO:** Directly fork the [Ultralytics YOLO repository](https://github.com/ultralytics/ultralytics) if building closely upon it.
|
||||
- **Use Ultralytics Template:** Start with the [Ultralytics template repository](https://github.com/ultralytics/template) for a clean, modular setup integrating YOLO.
|
||||
|
||||
2. **License Your Project:**
|
||||
- Add a `LICENSE` file containing the full text of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3).
|
||||
- Add a notice at the top of each source file indicating the license.
|
||||
|
||||
3. **Publish Your Source Code:**
|
||||
- Make your **entire project's source code** publicly accessible (e.g., on GitHub). This includes:
|
||||
- The complete larger application or system that incorporates the YOLO model or code.
|
||||
- Any modifications made to the original Ultralytics YOLO code.
|
||||
- Scripts for training, validation, and inference.
|
||||
- [Model weights](https://www.ultralytics.com/glossary/model-weights) if modified or fine-tuned.
|
||||
- [Configuration files](https://docs.ultralytics.com/usage/cfg/), environment setups (`requirements.txt`, [`Dockerfiles`](https://docs.docker.com/reference/dockerfile/)).
|
||||
- Backend and frontend code if it's part of a [web application](https://en.wikipedia.org/wiki/Web_application).
|
||||
- Any [third-party libraries](<https://en.wikipedia.org/wiki/Library_(computing)#Third-party>) you've modified.
|
||||
- [Training data](https://www.ultralytics.com/glossary/training-data) if required to run/retrain _and_ redistributable.
|
||||
|
||||
4. **Document Clearly:**
|
||||
- Update your `README.md` to state that the project is licensed under AGPL-3.0.
|
||||
- Include clear instructions on how to set up, build, and run your project from the source code.
|
||||
- Attribute Ultralytics YOLO appropriately, linking back to the [original repository](https://github.com/ultralytics/ultralytics). Example:
|
||||
```markdown
|
||||
This project utilizes code from [Ultralytics YOLO](https://github.com/ultralytics/ultralytics), licensed under AGPL-3.0.
|
||||
```
|
||||
|
||||
### Example Repository Structure
|
||||
|
||||
Refer to the [Ultralytics Template Repository](https://github.com/ultralytics/template) for a practical example structure:
|
||||
|
||||
```
|
||||
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
|
||||
```
|
||||
|
||||
By following these guidelines, you ensure compliance with AGPL-3.0, supporting the open-source ecosystem that enables powerful tools like Ultralytics YOLO.
|
||||
|
||||
## Conclusion
|
||||
|
||||
Thank you for your interest in contributing to [Ultralytics](https://www.ultralytics.com/) [open-source](https://github.com/ultralytics) 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.
|
||||
|
||||
We're excited to see your ideas come to life and appreciate your commitment to advancing [object detection](https://www.ultralytics.com/glossary/object-detection) technology. Together, let's continue to grow and innovate in this exciting open-source journey.
|
||||
|
||||
## FAQ
|
||||
|
||||
### Why should I contribute to Ultralytics YOLO open-source repositories?
|
||||
|
||||
Contributing to Ultralytics YOLO open-source repositories improves the software, making it more robust and feature-rich for the entire community. Contributions can include code enhancements, bug fixes, documentation improvements, and new feature implementations. Additionally, contributing allows you to collaborate with other skilled developers and experts in the field, enhancing your own skills and reputation. For details on how to get started, refer to the [Contributing via Pull Requests](#contributing-via-pull-requests) section.
|
||||
|
||||
### How do I sign the Contributor License Agreement (CLA) for Ultralytics YOLO?
|
||||
|
||||
To sign the Contributor License Agreement (CLA), follow the instructions provided by the CLA bot after submitting your pull request. This process ensures that your contributions are properly licensed under the AGPL-3.0 license, maintaining the legal integrity of the open-source project. Add a comment in your pull request stating:
|
||||
|
||||
```text
|
||||
I have read the CLA Document and I sign the CLA
|
||||
```
|
||||
|
||||
For more information, see the [CLA Signing](#cla-signing) section.
|
||||
|
||||
### What are Google-style docstrings, and why are they required for Ultralytics YOLO contributions?
|
||||
|
||||
Google-style docstrings provide clear, concise documentation for functions and classes, improving code readability and maintainability. These docstrings outline the function's purpose, arguments, and return values with specific formatting rules. When contributing to Ultralytics YOLO, following Google-style docstrings ensures that your additions are well-documented and easily understood. For examples and guidelines, visit the [Google-Style Docstrings](#google-style-docstrings) section.
|
||||
|
||||
### How can I ensure my changes pass the GitHub Actions CI tests?
|
||||
|
||||
Before your pull request can be merged, it must pass all GitHub Actions Continuous Integration (CI) tests. These tests include linting, unit tests, and other checks to ensure the code meets the project's quality standards. Review the CI output and fix any issues. For detailed information on the CI process and troubleshooting tips, see the [GitHub Actions CI Tests](#github-actions-ci-tests) section.
|
||||
|
||||
### How do I report a bug in Ultralytics YOLO repositories?
|
||||
|
||||
To report a bug, provide a clear and concise [Minimum Reproducible Example](https://docs.ultralytics.com/help/minimum-reproducible-example/) along with your bug report. This helps developers quickly identify and fix the issue. Ensure your example is minimal yet sufficient to replicate the problem. For more detailed steps on reporting bugs, refer to the [Reporting Bugs](#reporting-bugs) section.
|
||||
|
||||
### What does the AGPL-3.0 license mean if I use Ultralytics YOLO in my own project?
|
||||
|
||||
If you use Ultralytics YOLO code or models (licensed under AGPL-3.0) in your project, the AGPL-3.0 license requires that your entire project (the derivative work) must also be licensed under AGPL-3.0 and its complete source code must be made publicly available. This ensures that the open-source nature of the software is preserved throughout its derivatives. If you cannot meet these requirements, you need to obtain an [Enterprise License](https://www.ultralytics.com/license). See the [Open-Sourcing Your Project](#open-sourcing-your-yolo-project-under-agpl-30) section for details.
|
||||
@@ -0,0 +1,63 @@
|
||||
---
|
||||
comments: false
|
||||
description: Explore Ultralytics' commitment to Environmental, Health, and Safety (EHS) policies. Learn about our measures to ensure safety, compliance, and sustainability.
|
||||
keywords: Ultralytics, EHS policy, safety, sustainability, environmental impact, health and safety, risk management, compliance, continuous improvement
|
||||
---
|
||||
|
||||
# Ultralytics Environmental, Health, and Safety (EHS) Policy
|
||||
|
||||
At Ultralytics, we recognize that the long-term success of our company relies not only on the products and services we offer, but also the manner in which we conduct our business. We are committed to ensuring the safety and well-being of our employees, stakeholders, and the environment, and we will continuously strive to mitigate our impact on the environment while promoting health and safety.
|
||||
|
||||
## Policy Principles
|
||||
|
||||
1. **Compliance**: We will comply with all applicable laws, regulations, and standards related to EHS, and we will strive to exceed these standards where possible.
|
||||
|
||||
2. **Prevention**: We will work to prevent accidents, injuries, and environmental harm by implementing [risk management measures](https://docs.ultralytics.com/help/security/) and ensuring all our operations and procedures are safe.
|
||||
|
||||
3. **Continuous Improvement**: We will continuously improve our EHS performance by setting measurable objectives, monitoring our performance, auditing our operations, and revising our policies and procedures as needed.
|
||||
|
||||
4. **Communication**: We will communicate openly about our EHS performance and will engage with stakeholders to understand and address their concerns and expectations.
|
||||
|
||||
5. **Education and Training**: We will educate and train our employees and contractors in appropriate EHS procedures and practices.
|
||||
|
||||
## Implementation Measures
|
||||
|
||||
1. **Responsibility and Accountability**: Every employee and contractor working at or with Ultralytics is responsible for adhering to this policy. Managers and supervisors are accountable for ensuring this policy is implemented within their areas of control.
|
||||
|
||||
2. **Risk Management**: We will identify, assess, and manage EHS risks associated with our operations and activities to prevent accidents, injuries, and environmental harm.
|
||||
|
||||
3. **Resource Allocation**: We will allocate the necessary resources to ensure the effective implementation of our EHS policy, including the necessary equipment, personnel, and training.
|
||||
|
||||
4. **Emergency Preparedness and Response**: We will develop, maintain, and test emergency preparedness and response plans to ensure we can respond effectively to EHS incidents.
|
||||
|
||||
5. **Monitoring and Review**: We will monitor and review our EHS performance regularly to identify opportunities for improvement and ensure we are meeting our objectives.
|
||||
|
||||
This policy reflects our commitment to [minimizing our environmental footprint](https://www.ultralytics.com/blog/greener-future-through-vision-ai-and-ultralytics-yolo), ensuring the safety and well-being of our employees, and continuously improving our performance.
|
||||
|
||||
Please remember that the implementation of an effective EHS policy requires the involvement and commitment of everyone working at or with Ultralytics. We encourage you to take personal responsibility for your safety and the safety of others, and to take care of the environment in which we live and work.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is Ultralytics' Environmental, Health, and Safety (EHS) policy?
|
||||
|
||||
Ultralytics' Environmental, Health, and Safety (EHS) policy is a comprehensive framework designed to ensure the safety and well-being of employees, stakeholders, and the environment. It emphasizes compliance with relevant laws, accident prevention through risk management, continuous improvement through measurable objectives, open communication, and education and training for employees. By following these principles, Ultralytics aims to minimize its environmental footprint and promote sustainable practices. [Learn more about Ultralytics' commitment to EHS](https://www.ultralytics.com/about).
|
||||
|
||||
### How does Ultralytics ensure compliance with EHS regulations?
|
||||
|
||||
Ultralytics ensures compliance with EHS regulations by adhering to all applicable laws, regulations, and standards. The company not only strives to meet these requirements but often exceeds them by implementing stringent internal policies. Regular audits, monitoring, and reviews are conducted to ensure ongoing compliance. Managers and supervisors are also accountable for ensuring these standards are maintained within their areas of control. For more details, refer to the [Policy Principles section](#policy-principles) on the documentation page.
|
||||
|
||||
### Why is continuous improvement a key principle in Ultralytics' EHS policy?
|
||||
|
||||
Continuous improvement is essential in Ultralytics' EHS policy because it ensures the company consistently enhances its performance in environmental, health, and safety areas. By setting measurable objectives, monitoring performance, and revising policies and procedures as needed, Ultralytics can adapt to new challenges and optimize its processes. This approach not only mitigates risks but also demonstrates Ultralytics' commitment to sustainability and excellence. For practical examples of continuous improvement, check the [Implementation Measures section](#implementation-measures).
|
||||
|
||||
### What are the roles and responsibilities of employees in implementing the EHS policy at Ultralytics?
|
||||
|
||||
Every employee and contractor at Ultralytics is responsible for adhering to the EHS policy. This includes following safety protocols, participating in necessary training, and taking personal responsibility for their safety and the safety of others. Managers and supervisors have an added responsibility of ensuring the EHS policy is effectively implemented within their areas of control, which involves risk assessments and resource allocation. For more information about responsibility and accountability, see the [Implementation Measures section](#implementation-measures).
|
||||
|
||||
### How does Ultralytics handle emergency preparedness and response in its EHS policy?
|
||||
|
||||
Ultralytics handles emergency preparedness and response by developing, maintaining, and regularly testing emergency plans to address potential EHS incidents effectively. These plans ensure that the company can respond swiftly and efficiently to minimize harm to employees, the environment, and property. Regular training and drills are conducted to keep the response teams prepared for various emergency scenarios. For additional context, refer to the [emergency preparedness and response measure](#implementation-measures).
|
||||
|
||||
### How does Ultralytics engage with stakeholders regarding its EHS performance?
|
||||
|
||||
Ultralytics communicates openly with stakeholders about its EHS performance by sharing relevant information and addressing any concerns or expectations. This engagement includes regular reporting on EHS activities, performance metrics, and improvement initiatives. Stakeholders are also encouraged to provide feedback, which helps Ultralytics to refine its policies and practices continually. Learn more about this commitment in the [Communication principle](#policy-principles) section.
|
||||
51
algorithms/dms_yolo/code/docs/en/help/index.md
Normal file
51
algorithms/dms_yolo/code/docs/en/help/index.md
Normal file
@@ -0,0 +1,51 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics Help Center with guides, FAQs, CI processes, and policies to support your YOLO model experience and contributions.
|
||||
keywords: Ultralytics, YOLO, help center, documentation, guides, FAQ, contributing, CI, MRE, CLA, code of conduct, security policy, privacy policy
|
||||
---
|
||||
|
||||
# Help
|
||||
|
||||
Welcome to the Ultralytics Help page. This page brings together practical guides, policies, and FAQs to support your work with Ultralytics YOLO models and repositories.
|
||||
|
||||
- [Frequently Asked Questions (FAQ)](FAQ.md): Find answers to common questions and issues encountered by the community of Ultralytics YOLO users and contributors.
|
||||
- [Contributing Guide](contributing.md): Discover the protocols for making contributions, including how to submit pull requests, report bugs, and more.
|
||||
- [Continuous Integration (CI) Guide](CI.md): Gain insights into the CI processes we employ, complete with status reports for each Ultralytics repository.
|
||||
- [Contributor License Agreement (CLA)](CLA.md): Review the CLA to understand the rights and responsibilities associated with contributing to Ultralytics projects.
|
||||
- [Minimum Reproducible Example (MRE) Guide](minimum-reproducible-example.md): Learn the process for creating an MRE, which is crucial for the timely and effective resolution of bug reports.
|
||||
- [Code of Conduct](code-of-conduct.md): Our community guidelines support a respectful and open atmosphere for all collaborators.
|
||||
- [Environmental, Health, and Safety (EHS) Policy](environmental-health-safety.md): Delve into our commitment to sustainability and the well-being of all our stakeholders.
|
||||
- [Security Policy](security.md): Familiarize yourself with our security protocols and the procedure for reporting vulnerabilities.
|
||||
- [Privacy Policy](privacy.md): Read our privacy policy to understand how we protect your data and respect your privacy in all our services and operations.
|
||||
|
||||
We encourage you to review these resources for a smooth and productive experience. If you need additional support, reach out via [GitHub Issues](https://github.com/ultralytics/ultralytics/issues) or the [Ultralytics Community](https://community.ultralytics.com/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is Ultralytics YOLO and how does it benefit my [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) projects?
|
||||
|
||||
Ultralytics YOLO (You Only Look Once) is a state-of-the-art, real-time [object detection](https://www.ultralytics.com/glossary/object-detection) model. Its latest version, YOLO26, delivers faster, lighter, end-to-end NMS-free inference optimized for edge and low-power devices, making it ideal for a wide range of applications, from real-time video analytics to advanced machine learning research. YOLO's efficiency in detecting objects in images and videos has made it the go-to solution for businesses and researchers looking to integrate robust [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) capabilities into their projects.
|
||||
|
||||
For more details on YOLO26, visit the [YOLO26 documentation](../models/yolo26.md).
|
||||
|
||||
### How do I contribute to Ultralytics YOLO repositories?
|
||||
|
||||
Contributing to Ultralytics YOLO repositories is straightforward. Start by reviewing the [Contributing Guide](contributing.md) to understand the protocols for submitting pull requests, reporting bugs, and more. You'll also need to sign the [Contributor License Agreement (CLA)](CLA.md) to ensure your contributions are legally recognized. For effective bug reporting, refer to the [Minimum Reproducible Example (MRE) Guide](minimum-reproducible-example.md).
|
||||
|
||||
### Why should I use Ultralytics Platform for my machine learning projects?
|
||||
|
||||
Ultralytics Platform offers a seamless, no-code solution for managing your machine learning projects. It enables you to generate, train, and deploy AI models like YOLO26 effortlessly. Unique features include cloud training, real-time tracking, and intuitive dataset management. Ultralytics Platform simplifies the entire workflow, from data processing to [model deployment](https://www.ultralytics.com/glossary/model-deployment), making it an indispensable tool for both beginners and advanced users.
|
||||
|
||||
To get started, visit [Ultralytics Platform Quickstart](../platform/quickstart.md).
|
||||
|
||||
### What is Continuous Integration (CI) in Ultralytics, and how does it ensure high-quality code?
|
||||
|
||||
Continuous Integration (CI) in Ultralytics involves automated processes that ensure the integrity and quality of the codebase. Our CI setup includes Docker deployment, broken link checks, [CodeQL analysis](https://github.com/github/codeql), and PyPI publishing. These processes help maintain stable and secure repositories by automatically running tests and checks on new code submissions.
|
||||
|
||||
Learn more in the [Continuous Integration (CI) Guide](CI.md).
|
||||
|
||||
### How is [data privacy](https://www.ultralytics.com/glossary/data-privacy) handled by Ultralytics?
|
||||
|
||||
Ultralytics takes data privacy seriously. Our [Privacy Policy](privacy.md) outlines how we collect and use anonymized data to improve the YOLO package while prioritizing user privacy and control. We adhere to strict data protection regulations to ensure your information is secure at all times.
|
||||
|
||||
For more information, review our [Privacy Policy](privacy.md).
|
||||
@@ -0,0 +1,139 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn how to create effective Minimum Reproducible Examples (MRE) for bug reports in Ultralytics YOLO repositories. Follow our guide for efficient issue resolution.
|
||||
keywords: Ultralytics, YOLO, Minimum Reproducible Example, MRE, bug report, issue resolution, machine learning, deep learning
|
||||
---
|
||||
|
||||
# Creating a Minimum Reproducible Example for Bug Reports
|
||||
|
||||
When submitting a bug report for [Ultralytics](https://www.ultralytics.com/) [YOLO](https://github.com/ultralytics) repositories, it's essential to provide a [Minimum Reproducible Example (MRE)](https://stackoverflow.com/help/minimal-reproducible-example). An MRE is a small, self-contained piece of code that demonstrates the problem you're experiencing. Providing an MRE helps maintainers and contributors understand the issue and work on a fix more efficiently. This guide explains how to create an MRE when submitting bug reports to Ultralytics YOLO repositories.
|
||||
|
||||
## 1. Isolate the Problem
|
||||
|
||||
The first step in creating an MRE is to isolate the problem. Remove any unnecessary code or dependencies that are not directly related to the issue. Focus on the specific part of the code that is causing the problem and eliminate any irrelevant sections.
|
||||
|
||||
## 2. Use Public Models and Datasets
|
||||
|
||||
When creating an MRE, use publicly available models and datasets to reproduce the issue. For example, use the `yolo26n.pt` model and the `coco8.yaml` dataset. This ensures that the maintainers and contributors can easily run your example and investigate the problem without needing access to proprietary data or custom models.
|
||||
|
||||
## 3. Include All Necessary Dependencies
|
||||
|
||||
Ensure all necessary dependencies are included in your MRE. If your code relies on external libraries, specify the required packages and their versions. Ideally, list the dependencies in your bug report using `yolo checks` if you have `ultralytics` installed or `pip list` for other tools.
|
||||
|
||||
## 4. Write a Clear Description of the Issue
|
||||
|
||||
Provide a clear and concise description of the issue you're experiencing. Explain the expected behavior and the actual behavior you're encountering. If applicable, include any relevant error messages or logs.
|
||||
|
||||
## 5. Format Your Code Properly
|
||||
|
||||
Format your code properly using code blocks in the issue description. This makes it easier for others to read and understand your code. In GitHub, you can create a code block by wrapping your code with triple backticks (\```) and specifying the language:
|
||||
|
||||
````bash
|
||||
```python
|
||||
# Your Python code goes here
|
||||
```
|
||||
````
|
||||
|
||||
## 6. Test Your MRE
|
||||
|
||||
Before submitting your MRE, test it to ensure that it accurately reproduces the issue. Make sure that others can run your example without any issues or modifications.
|
||||
|
||||
## Example of an MRE
|
||||
|
||||
Here's an example of an MRE for a hypothetical bug report:
|
||||
|
||||
**Bug description:**
|
||||
|
||||
When running inference on a 0-channel image, I get an error related to the dimensions of the input tensor.
|
||||
|
||||
**MRE:**
|
||||
|
||||
```python
|
||||
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)
|
||||
```
|
||||
|
||||
**Error message:**
|
||||
|
||||
```
|
||||
RuntimeError: Expected input[1, 0, 640, 640] to have 3 channels, but got 0 channels instead
|
||||
```
|
||||
|
||||
**Dependencies:**
|
||||
|
||||
- `torch==2.3.0`
|
||||
- `ultralytics==8.2.0`
|
||||
|
||||
In this example, the MRE demonstrates the issue with a minimal amount of code, uses a public model (`"yolo26n.pt"`), includes all necessary dependencies, and provides a clear description of the problem along with the error message.
|
||||
|
||||
By following these guidelines, you'll help the maintainers and [contributors](https://github.com/ultralytics/ultralytics/graphs/contributors) of Ultralytics YOLO repositories to understand and resolve your issue more efficiently.
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I create an effective Minimum Reproducible Example (MRE) for bug reports in Ultralytics YOLO repositories?
|
||||
|
||||
To create an effective Minimum Reproducible Example (MRE) for bug reports in Ultralytics YOLO repositories, follow these steps:
|
||||
|
||||
1. **Isolate the Problem**: Remove any code or dependencies that are not directly related to the issue.
|
||||
2. **Use Public Models and Datasets**: Utilize public resources like `yolo26n.pt` and `coco8.yaml` for easier reproducibility.
|
||||
3. **Include All Necessary Dependencies**: Specify required packages and their versions. You can list dependencies using `yolo checks` if you have `ultralytics` installed or `pip list`.
|
||||
4. **Write a Clear Description of the Issue**: Explain the expected and actual behavior, including any error messages or logs.
|
||||
5. **Format Your Code Properly**: Use code blocks to format your code, making it easier to read.
|
||||
6. **Test Your MRE**: Ensure your MRE reproduces the issue without modifications.
|
||||
|
||||
For a detailed guide, see [Creating a Minimum Reproducible Example](#creating-a-minimum-reproducible-example-for-bug-reports).
|
||||
|
||||
### Why should I use publicly available models and datasets in my MRE for Ultralytics YOLO bug reports?
|
||||
|
||||
Using publicly available models and datasets in your MRE ensures that maintainers can easily run your example without needing access to proprietary data. This allows for quicker and more efficient issue resolution. For instance, using the `yolo26n.pt` model and `coco8.yaml` dataset helps standardize and simplify the debugging process. Learn more about public models and datasets in the [Use Public Models and Datasets](#2-use-public-models-and-datasets) section.
|
||||
|
||||
### What information should I include in my bug report for Ultralytics YOLO?
|
||||
|
||||
A comprehensive bug report for Ultralytics YOLO should include:
|
||||
|
||||
- **Clear Description**: Explain the issue, expected behavior, and actual behavior.
|
||||
- **Error Messages**: Include any relevant error messages or logs.
|
||||
- **Dependencies**: List required dependencies and their versions.
|
||||
- **MRE**: Provide a Minimum Reproducible Example.
|
||||
- **Steps to Reproduce**: Outline the steps needed to reproduce the issue.
|
||||
|
||||
For a complete checklist, refer to the [Write a Clear Description of the Issue](#4-write-a-clear-description-of-the-issue) section.
|
||||
|
||||
### How can I format my code properly when submitting a bug report on GitHub?
|
||||
|
||||
To format your code properly when submitting a bug report on GitHub:
|
||||
|
||||
- Use triple backticks (\```) to create code blocks.
|
||||
- Specify the programming language for syntax highlighting, e.g., \```python.
|
||||
- Ensure your code is indented correctly for readability.
|
||||
|
||||
Example:
|
||||
|
||||
````bash
|
||||
```python
|
||||
# Your Python code goes here
|
||||
```
|
||||
````
|
||||
|
||||
For more tips on code formatting, see [Format Your Code Properly](#5-format-your-code-properly).
|
||||
|
||||
### What are some common errors to check before submitting my MRE for a bug report?
|
||||
|
||||
Before submitting your MRE, make sure to:
|
||||
|
||||
- Verify the issue is reproducible.
|
||||
- Ensure all dependencies are listed and correct.
|
||||
- Remove any unnecessary code.
|
||||
- Test the MRE to ensure it reproduces the issue without modifications.
|
||||
|
||||
For a detailed checklist, visit the [Test Your MRE](#6-test-your-mre) section.
|
||||
217
algorithms/dms_yolo/code/docs/en/help/privacy.md
Normal file
217
algorithms/dms_yolo/code/docs/en/help/privacy.md
Normal file
@@ -0,0 +1,217 @@
|
||||
---
|
||||
description: Discover how Ultralytics collects and uses anonymized data to enhance the YOLO Python package while prioritizing user privacy and control.
|
||||
keywords: Ultralytics, data collection, YOLO, Python package, Google Analytics, Sentry, privacy, anonymized data, user control, crash reporting
|
||||
---
|
||||
|
||||
# Data Collection for Ultralytics Python Package
|
||||
|
||||
## Overview
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) is dedicated to the continuous enhancement of the user experience and the capabilities of our Python package, including the advanced YOLO models we develop. Our approach involves the gathering of anonymized usage statistics and crash reports, helping us identify opportunities for improvement and ensuring the reliability of our software. This transparency document outlines what data we collect, its purpose, and the choice you have regarding this data collection.
|
||||
|
||||
## Anonymized Google Analytics
|
||||
|
||||
[Google Analytics](https://developers.google.com/analytics) is a web analytics service offered by Google that tracks and reports website traffic. It allows us to collect data about how our Python package is used, which is crucial for making informed decisions about design and functionality.
|
||||
|
||||
### What We Collect
|
||||
|
||||
- **Usage Metrics**: These metrics help us understand how frequently and in what ways the package is utilized, what features are favored, and the typical command-line arguments that are used.
|
||||
- **System Information**: We collect general non-identifiable information about your computing environment to ensure our package performs well across various systems.
|
||||
- **Performance Data**: Understanding the performance of our models during training, validation, and inference helps us in identifying optimization opportunities.
|
||||
|
||||
For more information about Google Analytics and [data privacy](https://www.ultralytics.com/glossary/data-privacy), visit [Google Analytics Privacy](https://support.google.com/analytics/answer/6004245).
|
||||
|
||||
### How We Use This Data
|
||||
|
||||
- **Feature Improvement**: Insights from usage metrics guide us in enhancing user satisfaction and interface design.
|
||||
- **Optimization**: Performance data assist us in fine-tuning our models for better efficiency and speed across diverse hardware and software configurations.
|
||||
- **Trend Analysis**: By studying usage trends, we can predict and respond to the evolving needs of our community.
|
||||
|
||||
### Privacy Considerations
|
||||
|
||||
We take several measures to ensure the privacy and security of the data you entrust to us:
|
||||
|
||||
- **Anonymization**: We configure Google Analytics to anonymize the data collected, which means no personally identifiable information (PII) is gathered. You can use our services with the assurance that your personal details remain private.
|
||||
- **Aggregation**: Data is analyzed only in aggregate form. This practice ensures that patterns can be observed without revealing any individual user's activity.
|
||||
- **No Image Data Collection**: Ultralytics does not collect, process, or view any training or inference images.
|
||||
|
||||
## Sentry Crash Reporting
|
||||
|
||||
[Sentry](https://sentry.io/welcome/) is a developer-centric error tracking software that aids in identifying, diagnosing, and resolving issues in real-time, ensuring the robustness and reliability of applications. Within our package, it plays a crucial role by providing insights through crash reporting, significantly contributing to the stability and ongoing refinement of our software.
|
||||
|
||||
!!! note
|
||||
|
||||
Crash reporting via Sentry is activated only if the `sentry-sdk` Python package is pre-installed on your system. This package isn't included in the `ultralytics` prerequisites and won't be installed automatically by Ultralytics.
|
||||
|
||||
### What We Collect
|
||||
|
||||
If the `sentry-sdk` Python package is pre-installed on your system a crash event may send the following information:
|
||||
|
||||
- **Crash Logs**: Detailed reports on the application's condition at the time of a crash, which are vital for our debugging efforts.
|
||||
- **Error Messages**: We record error messages generated during the operation of our package to understand and resolve potential issues quickly.
|
||||
|
||||
To learn more about how Sentry handles data, please visit [Sentry's Privacy Policy](https://sentry.io/privacy/).
|
||||
|
||||
### How We Use This Data
|
||||
|
||||
- **Debugging**: Analyzing crash logs and error messages enables us to swiftly identify and correct software bugs.
|
||||
- **Stability Metrics**: By constantly monitoring for crashes, we aim to improve the stability and reliability of our package.
|
||||
|
||||
### Privacy Considerations
|
||||
|
||||
- **Sensitive Information**: We ensure that crash logs are scrubbed of any personally identifiable or sensitive user data, safeguarding the confidentiality of your information.
|
||||
- **Controlled Collection**: Our crash reporting mechanism is meticulously calibrated to gather only what is essential for troubleshooting while respecting user privacy.
|
||||
|
||||
By detailing the tools used for data collection and offering additional background information with URLs to their respective privacy pages, users are provided with a comprehensive view of our practices, emphasizing transparency and respect for user privacy.
|
||||
|
||||
## Disabling Data Collection
|
||||
|
||||
We believe in providing our users with full control over their data. By default, our package is configured to collect analytics and crash reports to help improve the experience for all users. However, we respect that some users may prefer to opt out of this data collection.
|
||||
|
||||
To opt out of sending analytics and crash reports, you can simply set `sync=False` in your YOLO settings. This ensures that no data is transmitted from your machine to our analytics tools.
|
||||
|
||||
### Inspecting Settings
|
||||
|
||||
To gain insight into the current configuration of your settings, you can view them directly:
|
||||
|
||||
!!! example "View settings"
|
||||
|
||||
=== "Python"
|
||||
|
||||
You can use Python to view your settings. Start by importing the `settings` object from the `ultralytics` module. Print and return settings using the following commands:
|
||||
```python
|
||||
from ultralytics import settings
|
||||
|
||||
# View all settings
|
||||
print(settings)
|
||||
|
||||
# Return analytics and crash reporting setting
|
||||
value = settings["sync"]
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Alternatively, the command-line interface allows you to check your settings with a simple command:
|
||||
```bash
|
||||
yolo settings
|
||||
```
|
||||
|
||||
### Modifying Settings
|
||||
|
||||
Ultralytics allows users to easily modify their settings. Changes can be performed in the following ways:
|
||||
|
||||
!!! example "Update settings"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Within the Python environment, call the `update` method on the `settings` object to change your settings:
|
||||
```python
|
||||
from ultralytics import settings
|
||||
|
||||
# Disable analytics and crash reporting
|
||||
settings.update({"sync": False})
|
||||
|
||||
# Reset settings to default values
|
||||
settings.reset()
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
If you prefer using the command-line interface, the following commands will allow you to modify your settings:
|
||||
```bash
|
||||
# Disable analytics and crash reporting
|
||||
yolo settings sync=False
|
||||
|
||||
# Reset settings to default values
|
||||
yolo settings reset
|
||||
```
|
||||
|
||||
The `sync=False` setting will prevent any data from being sent to Google Analytics or Sentry. Your settings will be respected across all sessions using the Ultralytics package and saved to disk for future sessions.
|
||||
|
||||
## Commitment to Privacy
|
||||
|
||||
Ultralytics takes user privacy seriously. We design our data collection practices with the following principles:
|
||||
|
||||
- **Transparency**: We are open about the data we collect and how it is used.
|
||||
- **Control**: We give users full control over their data.
|
||||
- **Security**: We employ industry-standard security measures to protect the data we collect.
|
||||
|
||||
## Questions or Concerns
|
||||
|
||||
If you have any questions or concerns about our data collection practices, please reach out to us via our [contact form](https://www.ultralytics.com/contact) or via [support@ultralytics.com](mailto:support@ultralytics.com). We are dedicated to ensuring our users feel informed and confident in their privacy when using our package.
|
||||
|
||||
## FAQ
|
||||
|
||||
### How does Ultralytics ensure the privacy of the data it collects?
|
||||
|
||||
Ultralytics prioritizes user privacy through several key measures. First, all data collected via Google Analytics and Sentry is anonymized to ensure that no personally identifiable information (PII) is gathered. Secondly, data is analyzed in aggregate form, allowing us to observe patterns without identifying individual user activities. Finally, we do not collect any training or inference images, further protecting user data. These measures align with our commitment to transparency and privacy. For more details, visit our [Privacy Considerations](#privacy-considerations) section.
|
||||
|
||||
### What types of data does Ultralytics collect with Google Analytics?
|
||||
|
||||
Ultralytics collects three primary types of data using Google Analytics:
|
||||
|
||||
- **Usage Metrics**: These include how often and in what ways the YOLO Python package is used, preferred features, and typical command-line arguments.
|
||||
- **System Information**: General non-identifiable information about the computing environments where the package is run.
|
||||
- **Performance Data**: Metrics related to the performance of models during training, validation, and inference.
|
||||
|
||||
This data helps us enhance user experience and optimize software performance. Learn more in the [Anonymized Google Analytics](#anonymized-google-analytics) section.
|
||||
|
||||
### How can I disable data collection in the Ultralytics YOLO package?
|
||||
|
||||
To opt out of data collection, you can simply set `sync=False` in your YOLO settings. This action stops the transmission of any analytics or crash reports. You can disable data collection using Python or CLI methods:
|
||||
|
||||
!!! example "Update settings"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import settings
|
||||
|
||||
# Disable analytics and crash reporting
|
||||
settings.update({"sync": False})
|
||||
|
||||
# Reset settings to default values
|
||||
settings.reset()
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Disable analytics and crash reporting
|
||||
yolo settings sync=False
|
||||
|
||||
# Reset settings to default values
|
||||
yolo settings reset
|
||||
```
|
||||
|
||||
For more details on modifying your settings, refer to the [Modifying Settings](#modifying-settings) section.
|
||||
|
||||
### How does crash reporting with Sentry work in Ultralytics YOLO?
|
||||
|
||||
If the `sentry-sdk` package is pre-installed, Sentry collects detailed crash logs and error messages whenever a crash event occurs. This data helps us diagnose and resolve issues promptly, improving the robustness and reliability of the YOLO Python package. The collected crash logs are scrubbed of any personally identifiable information to protect user privacy. For more information, check the [Sentry Crash Reporting](#sentry-crash-reporting) section.
|
||||
|
||||
### Can I inspect my current data collection settings in Ultralytics YOLO?
|
||||
|
||||
Yes, you can easily view your current settings to understand the configuration of your data collection preferences. Use the following methods to inspect these settings:
|
||||
|
||||
!!! example "View settings"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import settings
|
||||
|
||||
# View all settings
|
||||
print(settings)
|
||||
|
||||
# Return analytics and crash reporting setting
|
||||
value = settings["sync"]
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo settings
|
||||
```
|
||||
|
||||
For further details, refer to the [Inspecting Settings](#inspecting-settings) section.
|
||||
74
algorithms/dms_yolo/code/docs/en/help/security.md
Normal file
74
algorithms/dms_yolo/code/docs/en/help/security.md
Normal file
@@ -0,0 +1,74 @@
|
||||
---
|
||||
description: Learn about the security measures and tools used by Ultralytics to protect user data and systems. Discover how we address vulnerabilities with Snyk, CodeQL, Dependabot, and more.
|
||||
keywords: Ultralytics security policy, Snyk scanning, CodeQL scanning, Dependabot alerts, secret scanning, vulnerability reporting, GitHub security, open-source security
|
||||
---
|
||||
|
||||
# Ultralytics Security Policy
|
||||
|
||||
At [Ultralytics](https://www.ultralytics.com/), the security of our users' data and systems is of utmost importance. To ensure the safety and security of our [open-source projects](https://github.com/ultralytics), we have implemented several measures to detect and prevent security vulnerabilities.
|
||||
|
||||
## Snyk Scanning
|
||||
|
||||
We utilize [Snyk](https://snyk.io/advisor/python/ultralytics) to conduct comprehensive security scans on Ultralytics repositories. Snyk's robust scanning capabilities extend beyond dependency checks; it also examines our code and Dockerfiles for various vulnerabilities. By identifying and addressing these issues proactively, we ensure a higher level of security and reliability for our users.
|
||||
|
||||
[](https://snyk.io/advisor/python/ultralytics)
|
||||
|
||||
## GitHub CodeQL Scanning
|
||||
|
||||
Our security strategy includes GitHub's [CodeQL](https://docs.github.com/en/code-security/code-scanning/introduction-to-code-scanning/about-code-scanning-with-codeql) scanning. CodeQL delves deep into our codebase, identifying complex vulnerabilities like SQL injection and XSS by analyzing the code's semantic structure. This advanced level of analysis ensures early detection and resolution of potential security risks.
|
||||
|
||||
[](https://github.com/ultralytics/ultralytics/actions/workflows/github-code-scanning/codeql)
|
||||
|
||||
## GitHub Dependabot Alerts
|
||||
|
||||
[Dependabot](https://docs.github.com/en/code-security/dependabot) is integrated into our workflow to monitor dependencies for known vulnerabilities. When a vulnerability is identified in one of our dependencies, Dependabot alerts us, allowing for swift and informed remediation actions.
|
||||
|
||||
## GitHub Secret Scanning Alerts
|
||||
|
||||
We employ GitHub [secret scanning](https://docs.github.com/en/code-security/secret-scanning/managing-alerts-from-secret-scanning) alerts to detect sensitive data, such as credentials and private keys, accidentally pushed to our repositories. This early detection mechanism helps prevent potential security breaches and data exposures.
|
||||
|
||||
## Private Vulnerability Reporting
|
||||
|
||||
We enable private vulnerability reporting, allowing users to discreetly report potential security issues. This approach facilitates responsible disclosure, ensuring vulnerabilities are handled securely and efficiently.
|
||||
|
||||
If you suspect or discover a security vulnerability in any of our repositories, please let us know immediately. You can reach out to us directly via our [contact form](https://www.ultralytics.com/contact) or via [security@ultralytics.com](mailto:security@ultralytics.com). Our security team will investigate and respond as soon as possible.
|
||||
|
||||
We appreciate your help in keeping all Ultralytics open-source projects secure and safe for everyone.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What are the security measures implemented by Ultralytics to protect user data?
|
||||
|
||||
Ultralytics employs a comprehensive security strategy to protect user data and systems. Key measures include:
|
||||
|
||||
- **Snyk Scanning**: Conducts security scans to detect vulnerabilities in code and Dockerfiles.
|
||||
- **GitHub CodeQL**: Analyzes code semantics to detect complex vulnerabilities such as SQL injection.
|
||||
- **Dependabot Alerts**: Monitors dependencies for known vulnerabilities and sends alerts for swift remediation.
|
||||
- **Secret Scanning**: Detects sensitive data like credentials or private keys in code repositories to prevent data breaches.
|
||||
- **Private Vulnerability Reporting**: Offers a secure channel for users to report potential security issues discreetly.
|
||||
|
||||
These tools ensure proactive identification and resolution of security issues, enhancing overall system security. For more details, explore the sections above or contact the security team with any questions.
|
||||
|
||||
### How does Ultralytics use Snyk for security scanning?
|
||||
|
||||
Ultralytics utilizes [Snyk](https://snyk.io/advisor/python/ultralytics) to conduct thorough security scans on its repositories. Snyk extends beyond basic dependency checks, examining the code and Dockerfiles for various vulnerabilities. By proactively identifying and resolving potential security issues, Snyk helps ensure that Ultralytics' open-source projects remain secure and reliable.
|
||||
|
||||
To see the Snyk badge and learn more about its deployment, check the [Snyk Scanning section](#snyk-scanning).
|
||||
|
||||
### What is CodeQL and how does it enhance security for Ultralytics?
|
||||
|
||||
[CodeQL](https://docs.github.com/en/code-security/code-scanning/introduction-to-code-scanning/about-code-scanning-with-codeql) is a security analysis tool integrated into Ultralytics' workflow via GitHub. It delves deep into the codebase to identify complex vulnerabilities such as SQL injection and Cross-Site Scripting (XSS). CodeQL analyzes the semantic structure of the code to provide an advanced level of security, ensuring early detection and mitigation of potential risks.
|
||||
|
||||
For more information on how CodeQL is used, visit the [GitHub CodeQL Scanning section](#github-codeql-scanning).
|
||||
|
||||
### How does Dependabot help maintain Ultralytics' code security?
|
||||
|
||||
[Dependabot](https://docs.github.com/en/code-security/dependabot) is an automated tool that monitors and manages dependencies for known vulnerabilities. When Dependabot detects a vulnerability in an Ultralytics project dependency, it sends an alert, allowing the team to quickly address and mitigate the issue. This ensures that dependencies are kept secure and up-to-date, minimizing potential security risks.
|
||||
|
||||
For more details, explore the [GitHub Dependabot Alerts section](#github-dependabot-alerts).
|
||||
|
||||
### How does Ultralytics handle private vulnerability reporting?
|
||||
|
||||
Ultralytics encourages users to report potential security issues through private channels. Users can report vulnerabilities discreetly via the [contact form](https://www.ultralytics.com/contact) or by emailing [security@ultralytics.com](mailto:security@ultralytics.com). This ensures responsible disclosure and allows the security team to investigate and address vulnerabilities securely and efficiently.
|
||||
|
||||
For more information on private vulnerability reporting, refer to the [Private Vulnerability Reporting section](#private-vulnerability-reporting).
|
||||
Reference in New Issue
Block a user