Delete yolov10

yolov10/.gitignore

@@ -1,166 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other info into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-mlruns/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# Profiling
-*.pclprof
-
-# pyenv
-.python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-.idea
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# VSCode project settings
-.vscode/
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-mkdocs_github_authors.yaml
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# datasets and projects
-datasets/
-runs/
-wandb/
-tests/
-.DS_Store
-
-# Neural Network weights -----------------------------------------------------------------------------------------------
-weights/
-*.weights
-*.pt
-*.pb
-*.onnx
-*.engine
-*.mlmodel
-*.mlpackage
-*.torchscript
-*.tflite
-*.h5
-*_saved_model/
-*_web_model/
-*_openvino_model/
-*_paddle_model/
-pnnx*
-
-# Autogenerated files for tests
-/ultralytics/assets/

yolov10/.pre-commit-config.yaml

@@ -1,86 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Pre-commit hooks. For more information see https://github.com/pre-commit/pre-commit-hooks/blob/main/README.md
-# Optionally remove from local hooks with 'rm .git/hooks/pre-commit'
-
-# Define bot property if installed via https://github.com/marketplace/pre-commit-ci
-ci:
-  autofix_prs: true
-  autoupdate_commit_msg: "[pre-commit.ci] pre-commit suggestions"
-  autoupdate_schedule: monthly
-  submodules: true
-
-# Exclude directories (optional)
-# exclude: 'docs/'
-
-# Define repos to run
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
-    hooks:
-      - id: end-of-file-fixer
-      - id: trailing-whitespace
-      - id: check-case-conflict
-      # - id: check-yaml
-      - id: check-docstring-first
-      - id: detect-private-key
-
-  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.15.0
-    hooks:
-      - id: pyupgrade
-        name: Upgrade code
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.11
-    hooks:
-      - id: ruff
-        args: [--fix]
-
-  - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.17
-    hooks:
-      - id: mdformat
-        name: MD formatting
-        additional_dependencies:
-          - mdformat-gfm
-          - mdformat-frontmatter
-          - mdformat-mkdocs
-        args:
-          - --wrap=no
-          - --number
-        exclude: 'docs/.*\.md'
-        # exclude: "README.md|README.zh-CN.md|CONTRIBUTING.md"
-
-  - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.6
-    hooks:
-      - id: codespell
-        exclude: "docs/de|docs/fr|docs/pt|docs/es|docs/mkdocs_de.yml"
-        args:
-          - --ignore-words-list=crate,nd,ned,strack,dota,ane,segway,fo,gool,winn,commend,bloc,nam,afterall
-
-  - repo: https://github.com/hadialqattan/pycln
-    rev: v2.4.0
-    hooks:
-      - id: pycln
-        args: [--all]
-#
-#  - repo: https://github.com/PyCQA/docformatter
-#    rev: v1.7.5
-#    hooks:
-#      - id: docformatter
-
-#  - repo: https://github.com/asottile/yesqa
-#    rev: v1.4.0
-#    hooks:
-#      - id: yesqa
-
-#  - repo: https://github.com/asottile/dead
-#    rev: v1.5.0
-#    hooks:
-#    -   id: dead
-
-#  - repo: https://github.com/ultralytics/pre-commit
-#    rev: bd60a414f80a53fb8f593d3bfed4701fc47e4b23
-#    hooks:
-#      - id: capitalize-comments

yolov10/CONTRIBUTING.md

@@ -1,96 +0,0 @@
-# Contributing to YOLOv8 🚀
-
-We love your input! We want to make contributing to YOLOv8 as easy and transparent as possible, whether it's:
-
-- Reporting a bug
-- Discussing the current state of the code
-- Submitting a fix
-- Proposing a new feature
-- Becoming a maintainer
-
-YOLOv8 works so well due to our combined community effort, and for every small improvement you contribute you will be helping push the frontiers of what's possible in AI 😃!
-
-## Submitting a Pull Request (PR) 🛠️
-
-Submitting a PR is easy! This example shows how to submit a PR for updating `requirements.txt` in 4 steps:
-
-### 1. Select File to Update
-
-Select `requirements.txt` to update by clicking on it in GitHub.
-
-<p align="center"><img width="800" alt="PR_step1" src="https://user-images.githubusercontent.com/26833433/122260847-08be2600-ced4-11eb-828b-8287ace4136c.png"></p>
-
-### 2. Click 'Edit this file'
-
-Button is in top-right corner.
-
-<p align="center"><img width="800" alt="PR_step2" src="https://user-images.githubusercontent.com/26833433/122260844-06f46280-ced4-11eb-9eec-b8a24be519ca.png"></p>
-
-### 3. Make Changes
-
-Change `matplotlib` version from `3.2.2` to `3.3`.
-
-<p align="center"><img width="800" alt="PR_step3" src="https://user-images.githubusercontent.com/26833433/122260853-0a87e980-ced4-11eb-9fd2-3650fb6e0842.png"></p>
-
-### 4. Preview Changes and Submit PR
-
-Click on the **Preview changes** tab to verify your updates. At the bottom of the screen select 'Create a **new branch** for this commit', assign your branch a descriptive name such as `fix/matplotlib_version` and click the green **Propose changes** button. All done, your PR is now submitted to YOLOv8 for review and approval 😃!
-
-<p align="center"><img width="800" alt="PR_step4" src="https://user-images.githubusercontent.com/26833433/122260856-0b208000-ced4-11eb-8e8e-77b6151cbcc3.png"></p>
-
-### PR recommendations
-
-To allow your work to be integrated as seamlessly as possible, we advise you to:
-
-- ✅ Verify your PR is **up-to-date** with `ultralytics/ultralytics` `main` branch. If your PR is behind you can update your code by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
-
-<p align="center"><img width="751" alt="PR recommendation 1" src="https://user-images.githubusercontent.com/26833433/187295893-50ed9f44-b2c9-4138-a614-de69bd1753d7.png"></p>
-
-- ✅ Verify all YOLOv8 Continuous Integration (CI) **checks are passing**.
-
-<p align="center"><img width="751" alt="PR recommendation 2" src="https://user-images.githubusercontent.com/26833433/187296922-545c5498-f64a-4d8c-8300-5fa764360da6.png"></p>
-
-- ✅ Reduce changes to the absolute **minimum** required for your bug fix or feature addition. _"It is not daily increase but daily decrease, hack away the unessential. The closer to the source, the less wastage there is."_ — Bruce Lee
-
-### Docstrings
-
-Not all functions or classes require docstrings but when they do, we follow [google-style docstrings format](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings). Here is an example:
-
-```python
-"""
-    What the function does. Performs NMS on given detection predictions.
-
-    Args:
-        arg1: The description of the 1st argument
-        arg2: The description of the 2nd argument
-
-    Returns:
-        What the function returns. Empty if nothing is returned.
-
-    Raises:
-        Exception Class: When and why this exception can be raised by the function.
-"""
-```
-
-## Submitting a Bug Report 🐛
-
-If you spot a problem with YOLOv8 please submit a Bug Report!
-
-For us to start investigating a possible problem we need to be able to reproduce it ourselves first. We've created a few short guidelines below to help users provide what we need in order to get started.
-
-When asking a question, people will be better able to provide help if you provide **code** that they can easily understand and use to **reproduce** the problem. This is referred to by community members as creating a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/). Your code that reproduces the problem should be:
-
-- ✅ **Minimal** – Use as little code as possible that still produces the same problem
-- ✅ **Complete** – Provide **all** parts someone else needs to reproduce your problem in the question itself
-- ✅ **Reproducible** – Test the code you're about to provide to make sure it reproduces the problem
-
-In addition to the above requirements, for [Ultralytics](https://ultralytics.com/) to provide assistance your code should be:
-
-- ✅ **Current** – Verify that your code is up-to-date with current GitHub [main](https://github.com/ultralytics/ultralytics/tree/main) branch, and if necessary `git pull` or `git clone` a new copy to ensure your problem has not already been resolved by previous commits.
-- ✅ **Unmodified** – Your problem must be reproducible without any modifications to the codebase in this repository. [Ultralytics](https://ultralytics.com/) does not provide support for custom code ⚠️.
-
-If you believe your problem meets all of the above criteria, please close this issue and raise a new one using the 🐛 **Bug Report** [template](https://github.com/ultralytics/ultralytics/issues/new/choose) and providing a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/) to help us better understand and diagnose your problem.
-
-## License
-
-By contributing, you agree that your contributions will be licensed under the [AGPL-3.0 license](https://choosealicense.com/licenses/agpl-3.0/)

yolov10/LICENSE

@@ -1,661 +0,0 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.

yolov10/README.md

@@ -1,181 +0,0 @@
-# [YOLOv10: Real-Time End-to-End Object Detection](https://arxiv.org/abs/2405.14458)
-
-
-Official PyTorch implementation of **YOLOv10**.
-
-<p align="center">
-  <img src="figures/latency.svg" width=48%>
-  <img src="figures/params.svg" width=48%> <br>
-  Comparisons with others in terms of latency-accuracy (left) and size-accuracy (right) trade-offs.
-</p>
-
-[YOLOv10: Real-Time End-to-End Object Detection](https://arxiv.org/abs/2405.14458).\
-Ao Wang, Hui Chen, Lihao Liu, Kai Chen, Zijia Lin, Jungong Han, and Guiguang Ding\
-[![arXiv](https://img.shields.io/badge/arXiv-2405.14458-b31b1b.svg)](https://arxiv.org/abs/2405.14458) <a href="https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-yolov10-object-detection-on-custom-dataset.ipynb#scrollTo=SaKTSzSWnG7s"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Models-blue)](https://huggingface.co/collections/jameslahm/yolov10-665b0d90b0b5bb85129460c2) [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/jameslahm/YOLOv10)  [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/kadirnar/Yolov10)  [![Transformers.js Demo](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Transformers.js-blue)](https://huggingface.co/spaces/Xenova/yolov10-web) [![LearnOpenCV](https://img.shields.io/badge/BlogPost-blue?logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAMAAAC67D%2BPAAAALVBMVEX%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F6%2Bfn6%2Bvq3y%2BJ8rOFSne9Jm%2FQcOlr5DJ7GAAAAB3RSTlMAB2LM94H1yMxlvwAAADNJREFUCFtjZGAEAob%2FQMDIyAJl%2FmFkYmEGM%2F%2F%2BYWRmYWYCMv8BmSxYmUgKkLQhGYawAgApySgfFDPqowAAAABJRU5ErkJggg%3D%3D&logoColor=black&labelColor=gray)](https://learnopencv.com/yolov10/) [![Openbayes Demo](https://img.shields.io/static/v1?label=Demo&message=OpenBayes%E8%B4%9D%E5%BC%8F%E8%AE%A1%E7%AE%97&color=green)](https://openbayes.com/console/public/tutorials/im29uYrnIoz) 
-
-
-<details>
-  <summary>
-  <font size="+1">Abstract</font>
-  </summary>
-Over the past years, YOLOs have emerged as the predominant paradigm in the field of real-time object detection owing to their effective balance between computational cost and detection performance. Researchers have explored the architectural designs, optimization objectives, data augmentation strategies, and others for YOLOs, achieving notable progress. However, the reliance on the non-maximum suppression (NMS) for post-processing hampers the end-to-end deployment of YOLOs and adversely impacts the inference latency. Besides, the design of various components in YOLOs lacks the comprehensive and thorough inspection, resulting in noticeable computational redundancy and limiting the model's capability. It renders the suboptimal efficiency, along with considerable potential for performance improvements. In this work, we aim to further advance the performance-efficiency boundary of YOLOs from both the post-processing and the model architecture. To this end, we first present the consistent dual assignments for NMS-free training of YOLOs, which brings the competitive performance and low inference latency simultaneously. Moreover, we introduce the holistic efficiency-accuracy driven model design strategy for YOLOs. We comprehensively optimize various components of YOLOs from both the efficiency and accuracy perspectives, which greatly reduces the computational overhead and enhances the capability. The outcome of our effort is a new generation of YOLO series for real-time end-to-end object detection, dubbed YOLOv10. Extensive experiments show that YOLOv10 achieves the state-of-the-art performance and efficiency across various model scales. For example, our YOLOv10-S is 1.8$\times$ faster than RT-DETR-R18 under the similar AP on COCO, meanwhile enjoying 2.8$\times$ smaller number of parameters and FLOPs. Compared with YOLOv9-C, YOLOv10-B has 46\% less latency and 25\% fewer parameters for the same performance.
-</details>
-
-## Notes
-- 2024/05/31: Please use the [exported format](https://github.com/THU-MIG/yolov10?tab=readme-ov-file#export) for benchmark. In the non-exported format, e.g., pytorch, the speed of YOLOv10 is biased because the unnecessary `cv2` and `cv3` operations in the `v10Detect` are executed during inference.
-- 2024/05/30: We provide [some clarifications and suggestions](https://github.com/THU-MIG/yolov10/issues/136) for detecting smaller objects or objects in the distance with YOLOv10. Thanks to [SkalskiP](https://github.com/SkalskiP)!
-- 2024/05/27: We have updated the [checkpoints](https://huggingface.co/collections/jameslahm/yolov10-665b0d90b0b5bb85129460c2) with class names, for ease of use.
-
-## UPDATES 🔥
-- 2024/06/01: Thanks to [ErlanggaYudiPradana](https://github.com/rlggyp) for the integration with [C++ | OpenVINO | OpenCV](https://github.com/rlggyp/YOLOv10-OpenVINO-CPP-Inference)
-- 2024/06/01: Thanks to [NielsRogge](https://github.com/NielsRogge) and [AK](https://x.com/_akhaliq) for hosting the models on the HuggingFace Hub!
-- 2024/05/31: Build [yolov10-jetson](https://github.com/Seeed-Projects/jetson-examples/blob/main/reComputer/scripts/yolov10/README.md) docker image by [youjiang](https://github.com/yuyoujiang)!
-- 2024/05/31: Thanks to [mohamedsamirx](https://github.com/mohamedsamirx) for the integration with [BoTSORT, DeepOCSORT, OCSORT, HybridSORT, ByteTrack, StrongSORT using BoxMOT library](https://colab.research.google.com/drive/1-QV2TNfqaMsh14w5VxieEyanugVBG14V?usp=sharing)!
-- 2024/05/31: Thanks to [kaylorchen](https://github.com/kaylorchen) for the integration with [rk3588](https://github.com/kaylorchen/rk3588-yolo-demo)!
-- 2024/05/30: Thanks to [eaidova](https://github.com/eaidova) for the integration with [OpenVINO™](https://github.com/openvinotoolkit/openvino_notebooks/blob/0ba3c0211bcd49aa860369feddffdf7273a73c64/notebooks/yolov10-optimization/yolov10-optimization.ipynb)!
-- 2024/05/29: Add the gradio demo for running the models locally. Thanks to [AK](https://x.com/_akhaliq)!
-- 2024/05/27: Thanks to [sujanshresstha](sujanshresstha) for the integration with [DeepSORT](https://github.com/sujanshresstha/YOLOv10_DeepSORT.git)!
-- 2024/05/26: Thanks to [CVHub520](https://github.com/CVHub520) for the integration into [X-AnyLabeling](https://github.com/CVHub520/X-AnyLabeling)!
-- 2024/05/26: Thanks to [DanielSarmiento04](https://github.com/DanielSarmiento04) for integrate in [c++ | ONNX | OPENCV](https://github.com/DanielSarmiento04/yolov10cpp)!
-- 2024/05/25: Add [Transformers.js demo](https://huggingface.co/spaces/Xenova/yolov10-web) and onnx weights(yolov10[n](https://huggingface.co/onnx-community/yolov10n)/[s](https://huggingface.co/onnx-community/yolov10s)/[m](https://huggingface.co/onnx-community/yolov10m)/[b](https://huggingface.co/onnx-community/yolov10b)/[l](https://huggingface.co/onnx-community/yolov10l)/[x](https://huggingface.co/onnx-community/yolov10x)). Thanks to [xenova](https://github.com/xenova)!
-- 2024/05/25: Add [colab demo](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-yolov10-object-detection-on-custom-dataset.ipynb#scrollTo=SaKTSzSWnG7s), [HuggingFace Demo](https://huggingface.co/spaces/kadirnar/Yolov10), and [HuggingFace Model Page](https://huggingface.co/kadirnar/Yolov10). Thanks to [SkalskiP](https://github.com/SkalskiP) and [kadirnar](https://github.com/kadirnar)! 
-
-## Performance
-COCO
-
-| Model | Test Size | #Params | FLOPs | AP<sup>val</sup> | Latency |
-|:---------------|:----:|:---:|:--:|:--:|:--:|
-| [YOLOv10-N](https://huggingface.co/jameslahm/yolov10n) |   640  |     2.3M    |   6.7G   |     38.5%     | 1.84ms |
-| [YOLOv10-S](https://huggingface.co/jameslahm/yolov10s) |   640  |     7.2M    |   21.6G  |     46.3%     | 2.49ms |
-| [YOLOv10-M](https://huggingface.co/jameslahm/yolov10m) |   640  |     15.4M   |   59.1G  |     51.1%     | 4.74ms |
-| [YOLOv10-B](https://huggingface.co/jameslahm/yolov10b) |   640  |     19.1M   |  92.0G |     52.5%     | 5.74ms |
-| [YOLOv10-L](https://huggingface.co/jameslahm/yolov10l) |   640  |     24.4M   |  120.3G   |     53.2%     | 7.28ms |
-| [YOLOv10-X](https://huggingface.co/jameslahm/yolov10x) |   640  |     29.5M    |   160.4G   |     54.4%     | 10.70ms |
-
-## Installation
-`conda` virtual environment is recommended. 
-```
-conda create -n yolov10 python=3.9
-conda activate yolov10
-pip install -r requirements.txt
-pip install -e .
-```
-## Demo
-```
-python app.py
-# Please visit http://127.0.0.1:7860
-```
-
-## Validation
-[`yolov10n`](https://huggingface.co/jameslahm/yolov10n)  [`yolov10s`](https://huggingface.co/jameslahm/yolov10s)  [`yolov10m`](https://huggingface.co/jameslahm/yolov10m)  [`yolov10b`](https://huggingface.co/jameslahm/yolov10b)  [`yolov10l`](https://huggingface.co/jameslahm/yolov10l)  [`yolov10x`](https://huggingface.co/jameslahm/yolov10x)  
-```
-yolo val model=jameslahm/yolov10{n/s/m/b/l/x} data=coco.yaml batch=256
-```
-
-Or
-```python
-from ultralytics import YOLOv10
-
-model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
-# or
-# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
-model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
-
-model.val(data='coco.yaml', batch=256)
-```
-
-
-## Training 
-```
-yolo detect train data=coco.yaml model=yolov10n/s/m/b/l/x.yaml epochs=500 batch=256 imgsz=640 device=0,1,2,3,4,5,6,7
-```
-
-Or
-```python
-from ultralytics import YOLOv10
-
-model = YOLOv10()
-# If you want to finetune the model with pretrained weights, you could load the 
-# pretrained weights like below
-# model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
-# or
-# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
-# model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
-
-model.train(data='coco.yaml', epochs=500, batch=256, imgsz=640)
-```
-
-## Push to hub to 🤗
-
-Optionally, you can push your fine-tuned model to the [Hugging Face hub](https://huggingface.co/) as a public or private model:
-
-```python
-# let's say you have fine-tuned a model for crop detection
-model.push_to_hub("<your-hf-username-or-organization/yolov10-finetuned-crop-detection")
-
-# you can also pass `private=True` if you don't want everyone to see your model
-model.push_to_hub("<your-hf-username-or-organization/yolov10-finetuned-crop-detection", private=True)
-```
-
-## Prediction
-Note that a smaller confidence threshold can be set to detect smaller objects or objects in the distance. Please refer to [here](https://github.com/THU-MIG/yolov10/issues/136) for details.
-```
-yolo predict model=jameslahm/yolov10{n/s/m/b/l/x}
-```
-
-Or
-```python
-from ultralytics import YOLOv10
-
-model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
-# or
-# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
-model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
-
-model.predict()
-```
-
-## Export
-```
-# End-to-End ONNX
-yolo export model=jameslahm/yolov10{n/s/m/b/l/x} format=onnx opset=13 simplify
-# Predict with ONNX
-yolo predict model=yolov10n/s/m/b/l/x.onnx
-
-# End-to-End TensorRT
-yolo export model=jameslahm/yolov10{n/s/m/b/l/x} format=engine half=True simplify opset=13 workspace=16
-# or
-trtexec --onnx=yolov10n/s/m/b/l/x.onnx --saveEngine=yolov10n/s/m/b/l/x.engine --fp16
-# Predict with TensorRT
-yolo predict model=yolov10n/s/m/b/l/x.engine
-```
-
-Or
-```python
-from ultralytics import YOLOv10
-
-model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
-# or
-# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
-model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
-
-model.export(...)
-```
-
-## Acknowledgement
-
-The code base is built with [ultralytics](https://github.com/ultralytics/ultralytics) and [RT-DETR](https://github.com/lyuwenyu/RT-DETR).
-
-Thanks for the great implementations! 
-
-## Citation
-
-If our code or models help your work, please cite our paper:
-```BibTeX
-@article{wang2024yolov10,
-  title={YOLOv10: Real-Time End-to-End Object Detection},
-  author={Wang, Ao and Chen, Hui and Liu, Lihao and Chen, Kai and Lin, Zijia and Han, Jungong and Ding, Guiguang},
-  journal={arXiv preprint arXiv:2405.14458},
-  year={2024}
-}
-```

yolov10/app.py

@@ -1,162 +0,0 @@
-import gradio as gr
-import cv2
-import tempfile
-from ultralytics import YOLOv10
-
-
-def yolov10_inference(image, video, model_id, image_size, conf_threshold):
-    #model = YOLOv10.from_pretrained(f'jameslahm/{model_id}')
-    model = YOLOv10("/ddn/imu_tch1/project/yolov10/yolov10-1.0/runs/detect/train9/weights/best.pt")
-    if image:
-        results = model.predict(source=image, imgsz=image_size, conf=conf_threshold)
-        annotated_image = results[0].plot()
-        return annotated_image[:, :, ::-1], None
-    else:
-        video_path = tempfile.mktemp(suffix=".webm")
-        with open(video_path, "wb") as f:
-            with open(video, "rb") as g:
-                f.write(g.read())
-
-        cap = cv2.VideoCapture(video_path)
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-        output_video_path = tempfile.mktemp(suffix=".webm")
-        out = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*'vp80'), fps, (frame_width, frame_height))
-
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-
-            results = model.predict(source=frame, imgsz=image_size, conf=conf_threshold)
-            annotated_frame = results[0].plot()
-            out.write(annotated_frame)
-
-        cap.release()
-        out.release()
-
-        return None, output_video_path
-
-
-def yolov10_inference_for_examples(image, model_path, image_size, conf_threshold):
-    annotated_image, _ = yolov10_inference(image, None, model_path, image_size, conf_threshold)
-    return annotated_image
-
-
-def app():
-    with gr.Blocks():
-        with gr.Row():
-            with gr.Column():
-                image = gr.Image(type="pil", label="Image", visible=True)
-                video = gr.Video(label="Video", visible=False)
-                input_type = gr.Radio(
-                    choices=["Image", "Video"],
-                    value="Image",
-                    label="Input Type",
-                )
-                model_id = gr.Dropdown(
-                    label="Model",
-                    choices=[
-                        "yolov10n",
-                        "yolov10s",
-                        "yolov10m",
-                        "yolov10b",
-                        "yolov10l",
-                        "yolov10x",
-                    ],
-                    value="yolov10m",
-                )
-                image_size = gr.Slider(
-                    label="Image Size",
-                    minimum=320,
-                    maximum=1280,
-                    step=32,
-                    value=640,
-                )
-                conf_threshold = gr.Slider(
-                    label="Confidence Threshold",
-                    minimum=0.0,
-                    maximum=1.0,
-                    step=0.05,
-                    value=0.25,
-                )
-                yolov10_infer = gr.Button(value="Detect Objects")
-
-            with gr.Column():
-                output_image = gr.Image(type="numpy", label="Annotated Image", visible=True)
-                output_video = gr.Video(label="Annotated Video", visible=False)
-
-        def update_visibility(input_type):
-            image = gr.update(visible=True) if input_type == "Image" else gr.update(visible=False)
-            video = gr.update(visible=False) if input_type == "Image" else gr.update(visible=True)
-            output_image = gr.update(visible=True) if input_type == "Image" else gr.update(visible=False)
-            output_video = gr.update(visible=False) if input_type == "Image" else gr.update(visible=True)
-
-            return image, video, output_image, output_video
-
-        input_type.change(
-            fn=update_visibility,
-            inputs=[input_type],
-            outputs=[image, video, output_image, output_video],
-        )
-
-        def run_inference(image, video, model_id, image_size, conf_threshold, input_type):
-            if input_type == "Image":
-                return yolov10_inference(image, None, model_id, image_size, conf_threshold)
-            else:
-                return yolov10_inference(None, video, model_id, image_size, conf_threshold)
-
-
-        yolov10_infer.click(
-            fn=run_inference,
-            inputs=[image, video, model_id, image_size, conf_threshold, input_type],
-            outputs=[output_image, output_video],
-        )
-
-        gr.Examples(
-            examples=[
-                [
-                    "ultralytics/assets/bus.jpg",
-                    "yolov10s",
-                    640,
-                    0.25,
-                ],
-                [
-                    "ultralytics/assets/zidane.jpg",
-                    "yolov10s",
-                    640,
-                    0.25,
-                ],
-            ],
-            fn=yolov10_inference_for_examples,
-            inputs=[
-                image,
-                model_id,
-                image_size,
-                conf_threshold,
-            ],
-            outputs=[output_image],
-            cache_examples='lazy',
-        )
-
-gradio_app = gr.Blocks()
-with gradio_app:
-    gr.HTML(
-        """
-    <h1 style='text-align: center'>
-    YOLOv10: Real-Time End-to-End Object Detection
-    </h1>
-    """)
-    gr.HTML(
-        """
-        <h3 style='text-align: center'>
-        <a href='https://arxiv.org/abs/2405.14458' target='_blank'>arXiv</a> | <a href='https://github.com/THU-MIG/yolov10' target='_blank'>github</a>
-        </h3>
-        """)
-    with gr.Row():
-        with gr.Column():
-            app()
-if __name__ == '__main__':
-    gradio_app.launch()

yolov10/docker/Dockerfile

@@ -1,85 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Builds ultralytics/ultralytics:latest image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
-# Image is CUDA-optimized for YOLOv8 single/multi-GPU training and inference
-
-# Start FROM PyTorch image https://hub.docker.com/r/pytorch/pytorch or nvcr.io/nvidia/pytorch:23.03-py3
-FROM pytorch/pytorch:2.2.0-cuda12.1-cudnn8-runtime
-RUN pip install --no-cache nvidia-tensorrt --index-url https://pypi.ngc.nvidia.com
-
-# Downloads to user config dir
-ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
-    /root/.config/Ultralytics/
-
-# Install linux packages
-# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
-RUN apt update \
-    && apt install --no-install-recommends -y gcc git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
-
-# Security updates
-# https://security.snyk.io/vuln/SNYK-UBUNTU1804-OPENSSL-3314796
-RUN apt upgrade --no-install-recommends -y openssl tar
-
-# Create working directory
-WORKDIR /usr/src/ultralytics
-
-# Copy contents
-# COPY . /usr/src/ultralytics  # git permission issues inside container
-RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
-ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
-
-# Install pip packages
-RUN python3 -m pip install --upgrade pip wheel
-RUN pip install --no-cache -e ".[export]" albumentations comet pycocotools
-
-# Run exports to AutoInstall packages
-# Edge TPU export fails the first time so is run twice here
-RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32 || yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
-RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
-# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
-RUN pip install --no-cache paddlepaddle>=2.6.0 x2paddle
-# Fix error: `np.bool` was a deprecated alias for the builtin `bool` segmentation error in Tests
-RUN pip install --no-cache numpy==1.23.5
-# Remove exported models
-RUN rm -rf tmp
-
-# Set environment variables
-ENV OMP_NUM_THREADS=1
-# Avoid DDP error "MKL_THREADING_LAYER=INTEL is incompatible with libgomp.so.1 library" https://github.com/pytorch/pytorch/issues/37377
-ENV MKL_THREADING_LAYER=GNU
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/ultralytics:latest && sudo docker build -f docker/Dockerfile -t $t . && sudo docker push $t
-
-# Pull and Run with access to all GPUs
-# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all $t
-
-# Pull and Run with access to GPUs 2 and 3 (inside container CUDA devices will appear as 0 and 1)
-# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus '"device=2,3"' $t
-
-# Pull and Run with local directory access
-# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/datasets:/usr/src/datasets $t
-
-# Kill all
-# sudo docker kill $(sudo docker ps -q)
-
-# Kill all image-based
-# sudo docker kill $(sudo docker ps -qa --filter ancestor=ultralytics/ultralytics:latest)
-
-# DockerHub tag update
-# t=ultralytics/ultralytics:latest tnew=ultralytics/ultralytics:v6.2 && sudo docker pull $t && sudo docker tag $t $tnew && sudo docker push $tnew
-
-# Clean up
-# sudo docker system prune -a --volumes
-
-# Update Ubuntu drivers
-# https://www.maketecheasier.com/install-nvidia-drivers-ubuntu/
-
-# DDP test
-# python -m torch.distributed.run --nproc_per_node 2 --master_port 1 train.py --epochs 3
-
-# GCP VM from Image
-# docker.io/ultralytics/ultralytics:latest

yolov10/docker/Dockerfile-arm64

@@ -1,51 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Builds ultralytics/ultralytics:latest-arm64 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
-# Image is aarch64-compatible for Apple M1, M2, M3, Raspberry Pi and other ARM architectures
-
-# Start FROM Ubuntu image https://hub.docker.com/_/ubuntu with "FROM arm64v8/ubuntu:22.04" (deprecated)
-# Start FROM Debian image for arm64v8 https://hub.docker.com/r/arm64v8/debian (new)
-FROM arm64v8/debian:bookworm-slim
-
-# Downloads to user config dir
-ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
-    /root/.config/Ultralytics/
-
-# Install linux packages
-# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
-# cmake and build-essential is needed to build onnxsim when exporting to tflite
-RUN apt update \
-    && apt install --no-install-recommends -y python3-pip git zip curl htop gcc libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0 build-essential
-
-# Create working directory
-WORKDIR /usr/src/ultralytics
-
-# Copy contents
-# COPY . /usr/src/ultralytics  # git permission issues inside container
-RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
-ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
-
-# Remove python3.11/EXTERNALLY-MANAGED to avoid 'externally-managed-environment' issue, Debian 12 Bookworm error
-RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
-
-# Install pip packages
-RUN python3 -m pip install --upgrade pip wheel
-RUN pip install --no-cache -e ".[export]"
-
-# Creates a symbolic link to make 'python' point to 'python3'
-RUN ln -sf /usr/bin/python3 /usr/bin/python
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/ultralytics:latest-arm64 && sudo docker build --platform linux/arm64 -f docker/Dockerfile-arm64 -t $t . && sudo docker push $t
-
-# Run
-# t=ultralytics/ultralytics:latest-arm64 && sudo docker run -it --ipc=host $t
-
-# Pull and Run
-# t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t
-
-# Pull and Run with local volume mounted
-# t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

yolov10/docker/Dockerfile-conda

@@ -1,40 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Builds ultralytics/ultralytics:latest-conda image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
-# Image is optimized for Ultralytics Anaconda (https://anaconda.org/conda-forge/ultralytics) installation and usage
-
-# Start FROM miniconda3 image https://hub.docker.com/r/continuumio/miniconda3
-FROM continuumio/miniconda3:latest
-
-# Downloads to user config dir
-ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
-    /root/.config/Ultralytics/
-
-# Install linux packages
-RUN apt update \
-    && apt install --no-install-recommends -y libgl1
-
-# Copy contents
-ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt .
-
-# Install conda packages
-# mkl required to fix 'OSError: libmkl_intel_lp64.so.2: cannot open shared object file: No such file or directory'
-RUN conda config --set solver libmamba && \
-    conda install pytorch torchvision pytorch-cuda=11.8 -c pytorch -c nvidia && \
-    conda install -c conda-forge ultralytics mkl
-    # conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics mkl
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/ultralytics:latest-conda && sudo docker build -f docker/Dockerfile-cpu -t $t . && sudo docker push $t
-
-# Run
-# t=ultralytics/ultralytics:latest-conda && sudo docker run -it --ipc=host $t
-
-# Pull and Run
-# t=ultralytics/ultralytics:latest-conda && sudo docker pull $t && sudo docker run -it --ipc=host $t
-
-# Pull and Run with local volume mounted
-# t=ultralytics/ultralytics:latest-conda && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

yolov10/docker/Dockerfile-cpu

@@ -1,57 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Builds ultralytics/ultralytics:latest-cpu image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
-# Image is CPU-optimized for ONNX, OpenVINO and PyTorch YOLOv8 deployments
-
-# Start FROM Ubuntu image https://hub.docker.com/_/ubuntu
-FROM ubuntu:23.10
-
-# Downloads to user config dir
-ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
-    /root/.config/Ultralytics/
-
-# Install linux packages
-# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
-RUN apt update \
-    && apt install --no-install-recommends -y python3-pip git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
-
-# Create working directory
-WORKDIR /usr/src/ultralytics
-
-# Copy contents
-# COPY . /usr/src/ultralytics  # git permission issues inside container
-RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
-ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
-
-# Remove python3.11/EXTERNALLY-MANAGED or use 'pip install --break-system-packages' avoid 'externally-managed-environment' Ubuntu nightly error
-RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
-
-# Install pip packages
-RUN python3 -m pip install --upgrade pip wheel
-RUN pip install --no-cache -e ".[export]" --extra-index-url https://download.pytorch.org/whl/cpu
-
-# Run exports to AutoInstall packages
-RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
-RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
-# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
-# RUN pip install --no-cache paddlepaddle>=2.6.0 x2paddle
-# Remove exported models
-RUN rm -rf tmp
-
-# Creates a symbolic link to make 'python' point to 'python3'
-RUN ln -sf /usr/bin/python3 /usr/bin/python
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/ultralytics:latest-cpu && sudo docker build -f docker/Dockerfile-cpu -t $t . && sudo docker push $t
-
-# Run
-# t=ultralytics/ultralytics:latest-cpu && sudo docker run -it --ipc=host --name NAME $t
-
-# Pull and Run
-# t=ultralytics/ultralytics:latest-cpu && sudo docker pull $t && sudo docker run -it --ipc=host --name NAME $t
-
-# Pull and Run with local volume mounted
-# t=ultralytics/ultralytics:latest-cpu && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

yolov10/docker/Dockerfile-jetson

@@ -1,50 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Builds ultralytics/ultralytics:jetson image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
-# Supports JetPack for YOLOv8 on Jetson Nano, TX1/TX2, Xavier NX, AGX Xavier, AGX Orin, and Orin NX
-
-# Start FROM https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-pytorch
-FROM nvcr.io/nvidia/l4t-pytorch:r35.2.1-pth2.0-py3
-
-# Downloads to user config dir
-ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
-    /root/.config/Ultralytics/
-
-# Install linux packages
-# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
-RUN apt update \
-    && apt install --no-install-recommends -y gcc git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
-
-# Create working directory
-WORKDIR /usr/src/ultralytics
-
-# Copy contents
-# COPY . /usr/src/ultralytics  # git permission issues inside container
-RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
-ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
-
-# Remove opencv-python from Ultralytics dependencies as it conflicts with opencv-python installed in base image
-RUN grep -v "opencv-python" pyproject.toml > temp.toml && mv temp.toml pyproject.toml
-
-# Install pip packages manually for TensorRT compatibility https://github.com/NVIDIA/TensorRT/issues/2567
-RUN python3 -m pip install --upgrade pip wheel
-RUN pip install --no-cache tqdm matplotlib pyyaml psutil pandas onnx "numpy==1.23"
-RUN pip install --no-cache -e .
-
-# Set environment variables
-ENV OMP_NUM_THREADS=1
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/ultralytics:latest-jetson && sudo docker build --platform linux/arm64 -f docker/Dockerfile-jetson -t $t . && sudo docker push $t
-
-# Run
-# t=ultralytics/ultralytics:latest-jetson && sudo docker run -it --ipc=host $t
-
-# Pull and Run
-# t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host $t
-
-# Pull and Run with NVIDIA runtime
-# t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t

yolov10/docker/Dockerfile-python

@@ -1,54 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Builds ultralytics/ultralytics:latest-cpu image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
-# Image is CPU-optimized for ONNX, OpenVINO and PyTorch YOLOv8 deployments
-
-# Use the official Python 3.10 slim-bookworm as base image
-FROM python:3.10-slim-bookworm
-
-# Downloads to user config dir
-ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
-    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
-    /root/.config/Ultralytics/
-
-# Install linux packages
-# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
-RUN apt update \
-    && apt install --no-install-recommends -y python3-pip git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
-
-# Create working directory
-WORKDIR /usr/src/ultralytics
-
-# Copy contents
-# COPY . /usr/src/ultralytics  # git permission issues inside container
-RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
-ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
-
-# Remove python3.11/EXTERNALLY-MANAGED or use 'pip install --break-system-packages' avoid 'externally-managed-environment' Ubuntu nightly error
-# RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
-
-# Install pip packages
-RUN python3 -m pip install --upgrade pip wheel
-RUN pip install --no-cache -e ".[export]" --extra-index-url https://download.pytorch.org/whl/cpu
-
-# Run exports to AutoInstall packages
-RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
-RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
-# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
-RUN pip install --no-cache paddlepaddle>=2.6.0 x2paddle
-# Remove exported models
-RUN rm -rf tmp
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/ultralytics:latest-python && sudo docker build -f docker/Dockerfile-python -t $t . && sudo docker push $t
-
-# Run
-# t=ultralytics/ultralytics:latest-python && sudo docker run -it --ipc=host $t
-
-# Pull and Run
-# t=ultralytics/ultralytics:latest-python && sudo docker pull $t && sudo docker run -it --ipc=host $t
-
-# Pull and Run with local volume mounted
-# t=ultralytics/ultralytics:latest-python && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

yolov10/docker/Dockerfile-runner

@@ -1,38 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-# Builds GitHub actions CI runner image for deployment to DockerHub https://hub.docker.com/r/ultralytics/ultralytics
-# Image is CUDA-optimized for YOLOv8 single/multi-GPU training and inference tests
-
-# Start FROM Ultralytics GPU image
-FROM ultralytics/ultralytics:latest
-
-# Set the working directory
-WORKDIR /actions-runner
-
-# Download and unpack the latest runner from https://github.com/actions/runner
-RUN FILENAME=actions-runner-linux-x64-2.309.0.tar.gz && \
-    curl -o $FILENAME -L https://github.com/actions/runner/releases/download/v2.309.0/$FILENAME && \
-    tar xzf $FILENAME && \
-    rm $FILENAME
-
-# Install runner dependencies
-ENV RUNNER_ALLOW_RUNASROOT=1
-ENV DEBIAN_FRONTEND=noninteractive
-RUN ./bin/installdependencies.sh && \
-    apt-get -y install libicu-dev
-
-# Inline ENTRYPOINT command to configure and start runner with default TOKEN and NAME
-ENTRYPOINT sh -c './config.sh --url https://github.com/ultralytics/ultralytics \
-                              --token ${GITHUB_RUNNER_TOKEN:-TOKEN} \
-                              --name ${GITHUB_RUNNER_NAME:-NAME} \
-                              --labels gpu-latest \
-                              --replace && \
-                  ./run.sh'
-
-
-# Usage Examples -------------------------------------------------------------------------------------------------------
-
-# Build and Push
-# t=ultralytics/ultralytics:latest-runner && sudo docker build -f docker/Dockerfile-runner -t $t . && sudo docker push $t
-
-# Pull and Run in detached mode with access to GPUs 0 and 1
-# t=ultralytics/ultralytics:latest-runner && sudo docker run -d -e GITHUB_RUNNER_TOKEN=TOKEN -e GITHUB_RUNNER_NAME=NAME --ipc=host --gpus '"device=0,1"' $t

yolov10/docs/README.md

@@ -1,140 +0,0 @@
-<br>
-<img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320">
-
-# 📚 Ultralytics Docs
-
-Ultralytics Docs are the gateway to understanding and utilizing our cutting-edge machine learning tools. These documents are deployed to [https://docs.ultralytics.com](https://docs.ultralytics.com) for your convenience.
-
-[![pages-build-deployment](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment) [![Check Broken links](https://github.com/ultralytics/docs/actions/workflows/links.yml/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/links.yml) [![Check Domains](https://github.com/ultralytics/docs/actions/workflows/check_domains.yml/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/check_domains.yml) [![Ultralytics Actions](https://github.com/ultralytics/docs/actions/workflows/format.yml/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/format.yml) <a href="https://ultralytics.com/discord"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
-
-## 🛠️ Installation
-
-[![PyPI version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
-
-To install the ultralytics package in developer mode, ensure you have Git and Python 3 installed on your system. Then, follow these steps:
-
-1. Clone the ultralytics repository to your local machine using Git:
-
-   ```bash
-   git clone https://github.com/ultralytics/ultralytics.git
-   ```
-
-2. Navigate to the cloned repository's root directory:
-
-   ```bash
-   cd ultralytics
-   ```
-
-3. Install the package in developer mode using pip (or pip3 for Python 3):
-
-   ```bash
-   pip install -e '.[dev]'
-   ```
-
-- This command installs the ultralytics package along with all development dependencies, allowing you to modify the package code and have the changes immediately reflected in your Python environment.
-
-## 🚀 Building and Serving Locally
-
-The `mkdocs serve` command builds and serves a local version of your MkDocs documentation, ideal for development and testing:
-
-```bash
-mkdocs serve
-```
-
-- #### Command Breakdown:
-
-  - `mkdocs` is the main MkDocs command-line interface.
-  - `serve` is the subcommand to build and locally serve your documentation.
-
-- 🧐 Note:
-
-  - Grasp changes to the docs in real-time as `mkdocs serve` supports live reloading.
-  - To stop the local server, press `CTRL+C`.
-
-## 🌍 Building and Serving Multi-Language
-
-Supporting multi-language documentation? Follow these steps:
-
-1. Stage all new language \*.md files with Git:
-
-   ```bash
-   git add docs/**/*.md -f
-   ```
-
-2. Build all languages to the `/site` folder, ensuring relevant root-level files are present:
-
-   ```bash
-   # Clear existing /site directory
-   rm -rf site
-
-   # Loop through each language config file and build
-   mkdocs build -f docs/mkdocs.yml
-   for file in docs/mkdocs_*.yml; do
-     echo "Building MkDocs site with $file"
-     mkdocs build -f "$file"
-   done
-   ```
-
-3. To preview your site, initiate a simple HTTP server:
-
-   ```bash
-   cd site
-   python -m http.server
-   # Open in your preferred browser
-   ```
-
-- 🖥️ Access the live site at `http://localhost:8000`.
-
-## 📤 Deploying Your Documentation Site
-
-Choose a hosting provider and deployment method for your MkDocs documentation:
-
-- Configure `mkdocs.yml` with deployment settings.
-- Use `mkdocs deploy` to build and deploy your site.
-
-* ### GitHub Pages Deployment Example:
-  ```bash
-  mkdocs gh-deploy
-  ```
-
-- Update the "Custom domain" in your repository's settings for a personalized URL.
-
-![196814117-fc16e711-d2be-4722-9536-b7c6d78fd167](https://user-images.githubusercontent.com/26833433/210150206-9e86dcd7-10af-43e4-9eb2-9518b3799eac.png)
-
-- For detailed deployment guidance, consult the [MkDocs documentation](https://www.mkdocs.org/user-guide/deploying-your-docs/).
-
-## 💡 Contribute
-
-We cherish the community's input as it drives Ultralytics open-source initiatives. Dive into the [Contributing Guide](https://docs.ultralytics.com/help/contributing) and share your thoughts via our [Survey](https://ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey). A heartfelt thank you 🙏 to each contributor!
-
-<!-- Pictorial representation of our dedicated contributor community -->
-
-![Ultralytics open-source contributors](https://github.com/ultralytics/assets/raw/main/im/image-contributors.png)
-
-## 📜 License
-
-Ultralytics presents two licensing options:
-
-- **AGPL-3.0 License**: Perfect for academia and open collaboration. Details are in the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file.
-- **Enterprise License**: Tailored for commercial usage, offering a seamless blend of Ultralytics technology in your products. Learn more at [Ultralytics Licensing](https://ultralytics.com/license).
-
-## ✉️ Contact
-
-For bug reports and feature requests, navigate to [GitHub Issues](https://github.com/ultralytics/docs/issues). Engage with peers and the Ultralytics team on [Discord](https://ultralytics.com/discord) for enriching conversations!
-
-<br>
-<div align="center">
-  <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
-  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
-  <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
-  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
-  <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
-  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
-  <a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
-  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
-  <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
-  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
-  <a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Ultralytics Instagram"></a>
-  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
-  <a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
-</div>

yolov10/docs/build_docs.py

@@ -1,141 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-"""
-This Python script is designed to automate the building and post-processing of MkDocs documentation, particularly for
-projects with multilingual content. It streamlines the workflow for generating localized versions of the documentation
-and updating HTML links to ensure they are correctly formatted.
-
-Key Features:
-- Automated building of MkDocs documentation: The script compiles both the main documentation and
-  any localized versions specified in separate MkDocs configuration files.
-- Post-processing of generated HTML files: After the documentation is built, the script updates all
-  HTML files to remove the '.md' extension from internal links. This ensures that links in the built
-  HTML documentation correctly point to other HTML pages rather than Markdown files, which is crucial
-  for proper navigation within the web-based documentation.
-
-Usage:
-- Run the script from the root directory of your MkDocs project.
-- Ensure that MkDocs is installed and that all MkDocs configuration files (main and localized versions)
-  are present in the project directory.
-- The script first builds the documentation using MkDocs, then scans the generated HTML files in the 'site'
-  directory to update the internal links.
-- It's ideal for projects where the documentation is written in Markdown and needs to be served as a static website.
-
-Note:
-- This script is built to be run in an environment where Python and MkDocs are installed and properly configured.
-"""
-
-import os
-import re
-import shutil
-import subprocess
-from pathlib import Path
-
-from tqdm import tqdm
-
-DOCS = Path(__file__).parent.resolve()
-SITE = DOCS.parent / "site"
-
-
-def build_docs(clone_repos=True):
-    """Build docs using mkdocs."""
-    if SITE.exists():
-        print(f"Removing existing {SITE}")
-        shutil.rmtree(SITE)
-
-    # Get hub-sdk repo
-    if clone_repos:
-        repo = "https://github.com/ultralytics/hub-sdk"
-        local_dir = DOCS.parent / Path(repo).name
-        if not local_dir.exists():
-            os.system(f"git clone {repo} {local_dir}")
-        os.system(f"git -C {local_dir} pull")  # update repo
-        shutil.rmtree(DOCS / "en/hub/sdk", ignore_errors=True)  # delete if exists
-        shutil.copytree(local_dir / "docs", DOCS / "en/hub/sdk")  # for docs
-        shutil.rmtree(DOCS.parent / "hub_sdk", ignore_errors=True)  # delete if exists
-        shutil.copytree(local_dir / "hub_sdk", DOCS.parent / "hub_sdk")  # for mkdocstrings
-        print(f"Cloned/Updated {repo} in {local_dir}")
-
-    # Build the main documentation
-    print(f"Building docs from {DOCS}")
-    subprocess.run(f"mkdocs build -f {DOCS.parent}/mkdocs.yml", check=True, shell=True)
-    print(f"Site built at {SITE}")
-
-
-def update_page_title(file_path: Path, new_title: str):
-    """Update the title of an HTML file."""
-
-    # Read the content of the file
-    with open(file_path, encoding="utf-8") as file:
-        content = file.read()
-
-    # Replace the existing title with the new title
-    updated_content = re.sub(r"<title>.*?</title>", f"<title>{new_title}</title>", content)
-
-    # Write the updated content back to the file
-    with open(file_path, "w", encoding="utf-8") as file:
-        file.write(updated_content)
-
-
-def update_html_head(script=""):
-    """Update the HTML head section of each file."""
-    html_files = Path(SITE).rglob("*.html")
-    for html_file in tqdm(html_files, desc="Processing HTML files"):
-        with html_file.open("r", encoding="utf-8") as file:
-            html_content = file.read()
-
-        if script in html_content:  # script already in HTML file
-            return
-
-        head_end_index = html_content.lower().rfind("</head>")
-        if head_end_index != -1:
-            # Add the specified JavaScript to the HTML file just before the end of the head tag.
-            new_html_content = html_content[:head_end_index] + script + html_content[head_end_index:]
-            with html_file.open("w", encoding="utf-8") as file:
-                file.write(new_html_content)
-
-
-def update_subdir_edit_links(subdir="", docs_url=""):
-    """Update the HTML head section of each file."""
-    from bs4 import BeautifulSoup
-
-    if str(subdir[0]) == "/":
-        subdir = str(subdir[0])[1:]
-    html_files = (SITE / subdir).rglob("*.html")
-    for html_file in tqdm(html_files, desc="Processing subdir files"):
-        with html_file.open("r", encoding="utf-8") as file:
-            soup = BeautifulSoup(file, "html.parser")
-
-        # Find the anchor tag and update its href attribute
-        a_tag = soup.find("a", {"class": "md-content__button md-icon"})
-        if a_tag and a_tag["title"] == "Edit this page":
-            a_tag["href"] = f"{docs_url}{a_tag['href'].split(subdir)[-1]}"
-
-        # Write the updated HTML back to the file
-        with open(html_file, "w", encoding="utf-8") as file:
-            file.write(str(soup))
-
-
-def main():
-    """Builds docs, updates titles and edit links, and prints local server command."""
-    build_docs()
-
-    # Update titles
-    update_page_title(SITE / "404.html", new_title="Ultralytics Docs - Not Found")
-
-    # Update edit links
-    update_subdir_edit_links(
-        subdir="hub/sdk/",  # do not use leading slash
-        docs_url="https://github.com/ultralytics/hub-sdk/tree/develop/docs/",
-    )
-
-    # Update HTML file head section
-    script = ""
-    if any(script):
-        update_html_head(script)
-
-    # Show command to serve built website
-    print('Serve site at http://localhost:8000 with "python -m http.server --directory site"')
-
-
-if __name__ == "__main__":
-    main()

yolov10/docs/build_reference.py

@@ -1,130 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-"""
-Helper file to build Ultralytics Docs reference section. Recursively walks through ultralytics dir and builds an MkDocs
-reference section of *.md files composed of classes and functions, and also creates a nav menu for use in mkdocs.yaml.
-
-Note: Must be run from repository root directory. Do not run from docs directory.
-"""
-
-import re
-from collections import defaultdict
-from pathlib import Path
-
-# Get package root i.e. /Users/glennjocher/PycharmProjects/ultralytics/ultralytics
-from ultralytics.utils import ROOT as PACKAGE_DIR
-
-# Constants
-REFERENCE_DIR = PACKAGE_DIR.parent / "docs/en/reference"
-GITHUB_REPO = "ultralytics/ultralytics"
-
-
-def extract_classes_and_functions(filepath: Path) -> tuple:
-    """Extracts class and function names from a given Python file."""
-    content = filepath.read_text()
-    class_pattern = r"(?:^|\n)class\s(\w+)(?:\(|:)"
-    func_pattern = r"(?:^|\n)def\s(\w+)\("
-
-    classes = re.findall(class_pattern, content)
-    functions = re.findall(func_pattern, content)
-
-    return classes, functions
-
-
-def create_markdown(py_filepath: Path, module_path: str, classes: list, functions: list):
-    """Creates a Markdown file containing the API reference for the given Python module."""
-    md_filepath = py_filepath.with_suffix(".md")
-
-    # Read existing content and keep header content between first two ---
-    header_content = ""
-    if md_filepath.exists():
-        existing_content = md_filepath.read_text()
-        header_parts = existing_content.split("---")
-        for part in header_parts:
-            if "description:" in part or "comments:" in part:
-                header_content += f"---{part}---\n\n"
-
-    module_name = module_path.replace(".__init__", "")
-    module_path = module_path.replace(".", "/")
-    url = f"https://github.com/{GITHUB_REPO}/blob/main/{module_path}.py"
-    edit = f"https://github.com/{GITHUB_REPO}/edit/main/{module_path}.py"
-    title_content = (
-        f"# Reference for `{module_path}.py`\n\n"
-        f"!!! Note\n\n"
-        f"    This file is available at [{url}]({url}). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request]({edit}) 🛠️. Thank you 🙏!\n\n"
-    )
-    md_content = ["<br><br>\n"] + [f"## ::: {module_name}.{class_name}\n\n<br><br>\n" for class_name in classes]
-    md_content.extend(f"## ::: {module_name}.{func_name}\n\n<br><br>\n" for func_name in functions)
-    md_content = header_content + title_content + "\n".join(md_content)
-    if not md_content.endswith("\n"):
-        md_content += "\n"
-
-    md_filepath.parent.mkdir(parents=True, exist_ok=True)
-    md_filepath.write_text(md_content)
-
-    return md_filepath.relative_to(PACKAGE_DIR.parent)
-
-
-def nested_dict() -> defaultdict:
-    """Creates and returns a nested defaultdict."""
-    return defaultdict(nested_dict)
-
-
-def sort_nested_dict(d: dict) -> dict:
-    """Sorts a nested dictionary recursively."""
-    return {key: sort_nested_dict(value) if isinstance(value, dict) else value for key, value in sorted(d.items())}
-
-
-def create_nav_menu_yaml(nav_items: list, save: bool = False):
-    """Creates a YAML file for the navigation menu based on the provided list of items."""
-    nav_tree = nested_dict()
-
-    for item_str in nav_items:
-        item = Path(item_str)
-        parts = item.parts
-        current_level = nav_tree["reference"]
-        for part in parts[2:-1]:  # skip the first two parts (docs and reference) and the last part (filename)
-            current_level = current_level[part]
-
-        md_file_name = parts[-1].replace(".md", "")
-        current_level[md_file_name] = item
-
-    nav_tree_sorted = sort_nested_dict(nav_tree)
-
-    def _dict_to_yaml(d, level=0):
-        """Converts a nested dictionary to a YAML-formatted string with indentation."""
-        yaml_str = ""
-        indent = "  " * level
-        for k, v in d.items():
-            if isinstance(v, dict):
-                yaml_str += f"{indent}- {k}:\n{_dict_to_yaml(v, level + 1)}"
-            else:
-                yaml_str += f"{indent}- {k}: {str(v).replace('docs/en/', '')}\n"
-        return yaml_str
-
-    # Print updated YAML reference section
-    print("Scan complete, new mkdocs.yaml reference section is:\n\n", _dict_to_yaml(nav_tree_sorted))
-
-    # Save new YAML reference section
-    if save:
-        (PACKAGE_DIR.parent / "nav_menu_updated.yml").write_text(_dict_to_yaml(nav_tree_sorted))
-
-
-def main():
-    """Main function to extract class and function names, create Markdown files, and generate a YAML navigation menu."""
-    nav_items = []
-
-    for py_filepath in PACKAGE_DIR.rglob("*.py"):
-        classes, functions = extract_classes_and_functions(py_filepath)
-
-        if classes or functions:
-            py_filepath_rel = py_filepath.relative_to(PACKAGE_DIR)
-            md_filepath = REFERENCE_DIR / py_filepath_rel
-            module_path = f"{PACKAGE_DIR.name}.{py_filepath_rel.with_suffix('').as_posix().replace('/', '.')}"
-            md_rel_filepath = create_markdown(md_filepath, module_path, classes, functions)
-            nav_items.append(str(md_rel_filepath))
-
-    create_nav_menu_yaml(nav_items)
-
-
-if __name__ == "__main__":
-    main()

yolov10/docs/coming_soon_template.md

@@ -1,34 +0,0 @@
----
-description: Discover what's next for Ultralytics with our under-construction page, previewing new, groundbreaking AI and ML features coming soon.
-keywords: Ultralytics, coming soon, under construction, new features, AI updates, ML advancements, YOLO, technology preview
----
-
-# Under Construction 🏗️🌟
-
-Welcome to the Ultralytics "Under Construction" page! Here, we're hard at work developing the next generation of AI and ML innovations. This page serves as a teaser for the exciting updates and new features we're eager to share with you!
-
-## Exciting New Features on the Way 🎉
-
-- **Innovative Breakthroughs:** Get ready for advanced features and services that will transform your AI and ML experience.
-- **New Horizons:** Anticipate novel products that redefine AI and ML capabilities.
-- **Enhanced Services:** We're upgrading our services for greater efficiency and user-friendliness.
-
-## Stay Updated 🚧
-
-This placeholder page is your first stop for upcoming developments. Keep an eye out for:
-
-- **Newsletter:** Subscribe [here](https://ultralytics.com/#newsletter) for the latest news.
-- **Social Media:** Follow us [here](https://www.linkedin.com/company/ultralytics) for updates and teasers.
-- **Blog:** Visit our [blog](https://ultralytics.com/blog) for detailed insights.
-
-## We Value Your Input 🗣️
-
-Your feedback shapes our future releases. Share your thoughts and suggestions [here](https://ultralytics.com/contact).
-
-## Thank You, Community! 🌍
-
-Your [contributions](https://docs.ultralytics.com/help/contributing) inspire our continuous [innovation](https://github.com/ultralytics/ultralytics). Stay tuned for the big reveal of what's next in AI and ML at Ultralytics!
-
----
-
-Excited for what's coming? Bookmark this page and get ready for a transformative AI and ML journey with Ultralytics! 🛠️🤖

yolov10/docs/en/CNAME

@@ -1 +0,0 @@
-docs.ultralytics.com

yolov10/docs/en/datasets/classify/caltech101.md

@@ -1,81 +0,0 @@
----
-comments: true
-description: Learn about the Caltech-101 dataset, its structure and uses in machine learning. Includes instructions to train a YOLO model using this dataset.
-keywords: Caltech-101, dataset, YOLO training, machine learning, object recognition, ultralytics
----
-
-# Caltech-101 Dataset
-
-The [Caltech-101](https://data.caltech.edu/records/mzrjq-6wc02) dataset is a widely used dataset for object recognition tasks, containing around 9,000 images from 101 object categories. The categories were chosen to reflect a variety of real-world objects, and the images themselves were carefully selected and annotated to provide a challenging benchmark for object recognition algorithms.
-
-## Key Features
-
-- The Caltech-101 dataset comprises around 9,000 color images divided into 101 categories.
-- The categories encompass a wide variety of objects, including animals, vehicles, household items, and people.
-- The number of images per category varies, with about 40 to 800 images in each category.
-- Images are of variable sizes, with most images being medium resolution.
-- Caltech-101 is widely used for training and testing in the field of machine learning, particularly for object recognition tasks.
-
-## Dataset Structure
-
-Unlike many other datasets, the Caltech-101 dataset is not formally split into training and testing sets. Users typically create their own splits based on their specific needs. However, a common practice is to use a random subset of images for training (e.g., 30 images per category) and the remaining images for testing.
-
-## Applications
-
-The Caltech-101 dataset is extensively used for training and evaluating deep learning models in object recognition tasks, such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning algorithms. Its wide variety of categories and high-quality images make it an excellent dataset for research and development in the field of machine learning and computer vision.
-
-## Usage
-
-To train a YOLO model on the Caltech-101 dataset for 100 epochs, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='caltech101', epochs=100, imgsz=416)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=caltech101 model=yolov8n-cls.pt epochs=100 imgsz=416
-        ```
-
-## Sample Images and Annotations
-
-The Caltech-101 dataset contains high-quality color images of various objects, providing a well-structured dataset for object recognition tasks. Here are some examples of images from the dataset:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/239366386-44171121-b745-4206-9b59-a3be41e16089.png)
-
-The example showcases the variety and complexity of the objects in the Caltech-101 dataset, emphasizing the significance of a diverse dataset for training robust object recognition models.
-
-## Citations and Acknowledgments
-
-If you use the Caltech-101 dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{fei2007learning,
-          title={Learning generative visual models from few training examples: An incremental Bayesian approach tested on 101 object categories},
-          author={Fei-Fei, Li and Fergus, Rob and Perona, Pietro},
-          journal={Computer vision and Image understanding},
-          volume={106},
-          number={1},
-          pages={59--70},
-          year={2007},
-          publisher={Elsevier}
-        }
-        ```
-
-We would like to acknowledge Li Fei-Fei, Rob Fergus, and Pietro Perona for creating and maintaining the Caltech-101 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the Caltech-101 dataset and its creators, visit the [Caltech-101 dataset website](https://data.caltech.edu/records/mzrjq-6wc02).

yolov10/docs/en/datasets/classify/caltech256.md

@@ -1,78 +0,0 @@
----
-comments: true
-description: Explore the Caltech-256 dataset, a diverse collection of images used for object recognition tasks in machine learning. Learn to train a YOLO model on the dataset.
-keywords: Ultralytics, YOLO, Caltech-256, dataset, object recognition, machine learning, computer vision, deep learning
----
-
-# Caltech-256 Dataset
-
-The [Caltech-256](https://data.caltech.edu/records/nyy15-4j048) dataset is an extensive collection of images used for object classification tasks. It contains around 30,000 images divided into 257 categories (256 object categories and 1 background category). The images are carefully curated and annotated to provide a challenging and diverse benchmark for object recognition algorithms.
-
-## Key Features
-
-- The Caltech-256 dataset comprises around 30,000 color images divided into 257 categories.
-- Each category contains a minimum of 80 images.
-- The categories encompass a wide variety of real-world objects, including animals, vehicles, household items, and people.
-- Images are of variable sizes and resolutions.
-- Caltech-256 is widely used for training and testing in the field of machine learning, particularly for object recognition tasks.
-
-## Dataset Structure
-
-Like Caltech-101, the Caltech-256 dataset does not have a formal split between training and testing sets. Users typically create their own splits according to their specific needs. A common practice is to use a random subset of images for training and the remaining images for testing.
-
-## Applications
-
-The Caltech-256 dataset is extensively used for training and evaluating deep learning models in object recognition tasks, such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning algorithms. Its diverse set of categories and high-quality images make it an invaluable dataset for research and development in the field of machine learning and computer vision.
-
-## Usage
-
-To train a YOLO model on the Caltech-256 dataset for 100 epochs, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='caltech256', epochs=100, imgsz=416)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=caltech256 model=yolov8n-cls.pt epochs=100 imgsz=416
-        ```
-
-## Sample Images and Annotations
-
-The Caltech-256 dataset contains high-quality color images of various objects, providing a comprehensive dataset for object recognition tasks. Here are some examples of images from the dataset ([credit](https://ml4a.github.io/demos/tsne_viewer.html)):
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/239365061-1e5f7857-b1e8-44ca-b3d7-d0befbcd33f9.jpg)
-
-The example showcases the diversity and complexity of the objects in the Caltech-256 dataset, emphasizing the importance of a varied dataset for training robust object recognition models.
-
-## Citations and Acknowledgments
-
-If you use the Caltech-256 dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{griffin2007caltech,
-                 title={Caltech-256 object category dataset},
-                 author={Griffin, Gregory and Holub, Alex and Perona, Pietro},
-                 year={2007}
-        }
-        ```
-
-We would like to acknowledge Gregory Griffin, Alex Holub, and Pietro Perona for creating and maintaining the Caltech-256 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the
-
-Caltech-256 dataset and its creators, visit the [Caltech-256 dataset website](https://data.caltech.edu/records/nyy15-4j048).

yolov10/docs/en/datasets/classify/cifar10.md

@@ -1,80 +0,0 @@
----
-comments: true
-description: Explore the CIFAR-10 dataset, widely used for training in machine learning and computer vision, and learn how to use it with Ultralytics YOLO.
-keywords: CIFAR-10, dataset, machine learning, image classification, computer vision, YOLO, Ultralytics, training, testing, deep learning, Convolutional Neural Networks, Support Vector Machines
----
-
-# CIFAR-10 Dataset
-
-The [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) (Canadian Institute For Advanced Research) dataset is a collection of images used widely for machine learning and computer vision algorithms. It was developed by researchers at the CIFAR institute and consists of 60,000 32x32 color images in 10 different classes.
-
-## Key Features
-
-- The CIFAR-10 dataset consists of 60,000 images, divided into 10 classes.
-- Each class contains 6,000 images, split into 5,000 for training and 1,000 for testing.
-- The images are colored and of size 32x32 pixels.
-- The 10 different classes represent airplanes, cars, birds, cats, deer, dogs, frogs, horses, ships, and trucks.
-- CIFAR-10 is commonly used for training and testing in the field of machine learning and computer vision.
-
-## Dataset Structure
-
-The CIFAR-10 dataset is split into two subsets:
-
-1. **Training Set**: This subset contains 50,000 images used for training machine learning models.
-2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
-
-## Applications
-
-The CIFAR-10 dataset is widely used for training and evaluating deep learning models in image classification tasks, such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning algorithms. The diversity of the dataset in terms of classes and the presence of color images make it a well-rounded dataset for research and development in the field of machine learning and computer vision.
-
-## Usage
-
-To train a YOLO model on the CIFAR-10 dataset for 100 epochs with an image size of 32x32, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='cifar10', epochs=100, imgsz=32)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=cifar10 model=yolov8n-cls.pt epochs=100 imgsz=32
-        ```
-
-## Sample Images and Annotations
-
-The CIFAR-10 dataset contains color images of various objects, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
-
-![Dataset sample image](https://miro.medium.com/max/1100/1*SZnidBt7CQ4Xqcag6rd8Ew.png)
-
-The example showcases the variety and complexity of the objects in the CIFAR-10 dataset, highlighting the importance of a diverse dataset for training robust image classification models.
-
-## Citations and Acknowledgments
-
-If you use the CIFAR-10 dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @TECHREPORT{Krizhevsky09learningmultiple,
-                    author={Alex Krizhevsky},
-                    title={Learning multiple layers of features from tiny images},
-                    institution={},
-                    year={2009}
-        }
-        ```
-
-We would like to acknowledge Alex Krizhevsky for creating and maintaining the CIFAR-10 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the CIFAR-10 dataset and its creator, visit the [CIFAR-10 dataset website](https://www.cs.toronto.edu/~kriz/cifar.html).

yolov10/docs/en/datasets/classify/cifar100.md

@@ -1,80 +0,0 @@
----
-comments: true
-description: Discover how to leverage the CIFAR-100 dataset for machine learning and computer vision tasks with YOLO. Gain insights on its structure, use, and utilization for model training.
-keywords: Ultralytics, YOLO, CIFAR-100 dataset, image classification, machine learning, computer vision, YOLO model training
----
-
-# CIFAR-100 Dataset
-
-The [CIFAR-100](https://www.cs.toronto.edu/~kriz/cifar.html) (Canadian Institute For Advanced Research) dataset is a significant extension of the CIFAR-10 dataset, composed of 60,000 32x32 color images in 100 different classes. It was developed by researchers at the CIFAR institute, offering a more challenging dataset for more complex machine learning and computer vision tasks.
-
-## Key Features
-
-- The CIFAR-100 dataset consists of 60,000 images, divided into 100 classes.
-- Each class contains 600 images, split into 500 for training and 100 for testing.
-- The images are colored and of size 32x32 pixels.
-- The 100 different classes are grouped into 20 coarse categories for higher level classification.
-- CIFAR-100 is commonly used for training and testing in the field of machine learning and computer vision.
-
-## Dataset Structure
-
-The CIFAR-100 dataset is split into two subsets:
-
-1. **Training Set**: This subset contains 50,000 images used for training machine learning models.
-2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
-
-## Applications
-
-The CIFAR-100 dataset is extensively used for training and evaluating deep learning models in image classification tasks, such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning algorithms. The diversity of the dataset in terms of classes and the presence of color images make it a more challenging and comprehensive dataset for research and development in the field of machine learning and computer vision.
-
-## Usage
-
-To train a YOLO model on the CIFAR-100 dataset for 100 epochs with an image size of 32x32, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='cifar100', epochs=100, imgsz=32)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=cifar100 model=yolov8n-cls.pt epochs=100 imgsz=32
-        ```
-
-## Sample Images and Annotations
-
-The CIFAR-100 dataset contains color images of various objects, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/239363319-62ebf02f-7469-4178-b066-ccac3cd334db.jpg)
-
-The example showcases the variety and complexity of the objects in the CIFAR-100 dataset, highlighting the importance of a diverse dataset for training robust image classification models.
-
-## Citations and Acknowledgments
-
-If you use the CIFAR-100 dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @TECHREPORT{Krizhevsky09learningmultiple,
-                    author={Alex Krizhevsky},
-                    title={Learning multiple layers of features from tiny images},
-                    institution={},
-                    year={2009}
-        }
-        ```
-
-We would like to acknowledge Alex Krizhevsky for creating and maintaining the CIFAR-100 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the CIFAR-100 dataset and its creator, visit the [CIFAR-100 dataset website](https://www.cs.toronto.edu/~kriz/cifar.html).

yolov10/docs/en/datasets/classify/fashion-mnist.md

@@ -1,79 +0,0 @@
----
-comments: true
-description: Learn how to use the Fashion-MNIST dataset for image classification with the Ultralytics YOLO model. Covers dataset structure, labels, applications, and usage.
-keywords: Ultralytics, YOLO, Fashion-MNIST, dataset, image classification, machine learning, deep learning, neural networks, training, testing
----
-
-# Fashion-MNIST Dataset
-
-The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is a database of Zalando's article images—consisting of a training set of 60,000 examples and a test set of 10,000 examples. Each example is a 28x28 grayscale image, associated with a label from 10 classes. Fashion-MNIST is intended to serve as a direct drop-in replacement for the original MNIST dataset for benchmarking machine learning algorithms.
-
-## Key Features
-
-- Fashion-MNIST contains 60,000 training images and 10,000 testing images of Zalando's article images.
-- The dataset comprises grayscale images of size 28x28 pixels.
-- Each pixel has a single pixel-value associated with it, indicating the lightness or darkness of that pixel, with higher numbers meaning darker. This pixel-value is an integer between 0 and 255.
-- Fashion-MNIST is widely used for training and testing in the field of machine learning, especially for image classification tasks.
-
-## Dataset Structure
-
-The Fashion-MNIST dataset is split into two subsets:
-
-1. **Training Set**: This subset contains 60,000 images used for training machine learning models.
-2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
-
-## Labels
-
-Each training and test example is assigned to one of the following labels:
-
-0. T-shirt/top
-1. Trouser
-2. Pullover
-3. Dress
-4. Coat
-5. Sandal
-6. Shirt
-7. Sneaker
-8. Bag
-9. Ankle boot
-
-## Applications
-
-The Fashion-MNIST dataset is widely used for training and evaluating deep learning models in image classification tasks, such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning algorithms. The dataset's simple and well-structured format makes it an essential resource for researchers and practitioners in the field of machine learning and computer vision.
-
-## Usage
-
-To train a CNN model on the Fashion-MNIST dataset for 100 epochs with an image size of 28x28, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='fashion-mnist', epochs=100, imgsz=28)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=fashion-mnist model=yolov8n-cls.pt epochs=100 imgsz=28
-        ```
-
-## Sample Images and Annotations
-
-The Fashion-MNIST dataset contains grayscale images of Zalando's article images, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/239359139-ce0a434e-9056-43e0-a306-3214f193dcce.png)
-
-The example showcases the variety and complexity of the images in the Fashion-MNIST dataset, highlighting the importance of a diverse dataset for training robust image classification models.
-
-## Acknowledgments
-
-If you use the Fashion-MNIST dataset in your research or development work, please acknowledge the dataset by linking to the [GitHub repository](https://github.com/zalandoresearch/fashion-mnist). This dataset was made available by Zalando Research.

yolov10/docs/en/datasets/classify/imagenet.md

@@ -1,83 +0,0 @@
----
-comments: true
-description: Understand how to use ImageNet, an extensive annotated image dataset for object recognition research, with Ultralytics YOLO models. Learn about its structure, usage, and significance in computer vision.
-keywords: Ultralytics, YOLO, ImageNet, dataset, object recognition, deep learning, computer vision, machine learning, dataset training, model training, image classification, object detection
----
-
-# ImageNet Dataset
-
-[ImageNet](https://www.image-net.org/) is a large-scale database of annotated images designed for use in visual object recognition research. It contains over 14 million images, with each image annotated using WordNet synsets, making it one of the most extensive resources available for training deep learning models in computer vision tasks.
-
-## Key Features
-
-- ImageNet contains over 14 million high-resolution images spanning thousands of object categories.
-- The dataset is organized according to the WordNet hierarchy, with each synset representing a category.
-- ImageNet is widely used for training and benchmarking in the field of computer vision, particularly for image classification and object detection tasks.
-- The annual ImageNet Large Scale Visual Recognition Challenge (ILSVRC) has been instrumental in advancing computer vision research.
-
-## Dataset Structure
-
-The ImageNet dataset is organized using the WordNet hierarchy. Each node in the hierarchy represents a category, and each category is described by a synset (a collection of synonymous terms). The images in ImageNet are annotated with one or more synsets, providing a rich resource for training models to recognize various objects and their relationships.
-
-## ImageNet Large Scale Visual Recognition Challenge (ILSVRC)
-
-The annual [ImageNet Large Scale Visual Recognition Challenge (ILSVRC)](https://image-net.org/challenges/LSVRC/) has been an important event in the field of computer vision. It has provided a platform for researchers and developers to evaluate their algorithms and models on a large-scale dataset with standardized evaluation metrics. The ILSVRC has led to significant advancements in the development of deep learning models for image classification, object detection, and other computer vision tasks.
-
-## Applications
-
-The ImageNet dataset is widely used for training and evaluating deep learning models in various computer vision tasks, such as image classification, object detection, and object localization. Some popular deep learning architectures, such as AlexNet, VGG, and ResNet, were developed and benchmarked using the ImageNet dataset.
-
-## Usage
-
-To train a deep learning model on the ImageNet dataset for 100 epochs with an image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='imagenet', epochs=100, imgsz=224)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo train data=imagenet model=yolov8n-cls.pt epochs=100 imgsz=224
-        ```
-
-## Sample Images and Annotations
-
-The ImageNet dataset contains high-resolution images spanning thousands of object categories, providing a diverse and extensive dataset for training and evaluating computer vision models. Here are some examples of images from the dataset:
-
-![Dataset sample images](https://user-images.githubusercontent.com/26833433/239280348-3d8f30c7-6f05-4dda-9cfe-d62ad9faecc9.png)
-
-The example showcases the variety and complexity of the images in the ImageNet dataset, highlighting the importance of a diverse dataset for training robust computer vision models.
-
-## Citations and Acknowledgments
-
-If you use the ImageNet dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{ILSVRC15,
-                 author = {Olga Russakovsky and Jia Deng and Hao Su and Jonathan Krause and Sanjeev Satheesh and Sean Ma and Zhiheng Huang and Andrej Karpathy and Aditya Khosla and Michael Bernstein and Alexander C. Berg and Li Fei-Fei},
-                 title={ImageNet Large Scale Visual Recognition Challenge},
-                 year={2015},
-                 journal={International Journal of Computer Vision (IJCV)},
-                 volume={115},
-                 number={3},
-                 pages={211-252}
-        }
-        ```
-
-We would like to acknowledge the ImageNet team, led by Olga Russakovsky, Jia Deng, and Li Fei-Fei, for creating and maintaining the ImageNet dataset as a valuable resource for the machine learning and computer vision research community. For more information about the ImageNet dataset and its creators, visit the [ImageNet website](https://www.image-net.org/).

yolov10/docs/en/datasets/classify/imagenet10.md

@@ -1,77 +0,0 @@
----
-comments: true
-description: Explore the compact ImageNet10 Dataset developed by Ultralytics. Ideal for fast testing of computer vision training pipelines and CV model sanity checks.
-keywords: Ultralytics, YOLO, ImageNet10 Dataset, Image detection, Deep Learning, ImageNet, AI model testing, Computer vision, Machine learning
----
-
-# ImageNet10 Dataset
-
-The [ImageNet10](https://github.com/ultralytics/yolov5/releases/download/v1.0/imagenet10.zip) dataset is a small-scale subset of the [ImageNet](https://www.image-net.org/) database, developed by [Ultralytics](https://ultralytics.com) and designed for CI tests, sanity checks, and fast testing of training pipelines. This dataset is composed of the first image in the training set and the first image from the validation set of the first 10 classes in ImageNet. Although significantly smaller, it retains the structure and diversity of the original ImageNet dataset.
-
-## Key Features
-
-- ImageNet10 is a compact version of ImageNet, with 20 images representing the first 10 classes of the original dataset.
-- The dataset is organized according to the WordNet hierarchy, mirroring the structure of the full ImageNet dataset.
-- It is ideally suited for CI tests, sanity checks, and rapid testing of training pipelines in computer vision tasks.
-- Although not designed for model benchmarking, it can provide a quick indication of a model's basic functionality and correctness.
-
-## Dataset Structure
-
-The ImageNet10 dataset, like the original ImageNet, is organized using the WordNet hierarchy. Each of the 10 classes in ImageNet10 is described by a synset (a collection of synonymous terms). The images in ImageNet10 are annotated with one or more synsets, providing a compact resource for testing models to recognize various objects and their relationships.
-
-## Applications
-
-The ImageNet10 dataset is useful for quickly testing and debugging computer vision models and pipelines. Its small size allows for rapid iteration, making it ideal for continuous integration tests and sanity checks. It can also be used for fast preliminary testing of new models or changes to existing models before moving on to full-scale testing with the complete ImageNet dataset.
-
-## Usage
-
-To test a deep learning model on the ImageNet10 dataset with an image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Test Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='imagenet10', epochs=5, imgsz=224)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo train data=imagenet10 model=yolov8n-cls.pt epochs=5 imgsz=224
-        ```
-
-## Sample Images and Annotations
-
-The ImageNet10 dataset contains a subset of images from the original ImageNet dataset. These images are chosen to represent the first 10 classes in the dataset, providing a diverse yet compact dataset for quick testing and evaluation.
-
-![Dataset sample images](https://user-images.githubusercontent.com/26833433/239689723-16f9b4a7-becc-4deb-b875-d3e5c28eb03b.png) The example showcases the variety and complexity of the images in the ImageNet10 dataset, highlighting its usefulness for sanity checks and quick testing of computer vision models.
-
-## Citations and Acknowledgments
-
-If you use the ImageNet10 dataset in your research or development work, please cite the original ImageNet paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{ILSVRC15,
-                 author = {Olga Russakovsky and Jia Deng and Hao Su and Jonathan Krause and Sanjeev Satheesh and Sean Ma and Zhiheng Huang and Andrej Karpathy and Aditya Khosla and Michael Bernstein and Alexander C. Berg and Li Fei-Fei},
-                 title={ImageNet Large Scale Visual Recognition Challenge},
-                 year={2015},
-                 journal={International Journal of Computer Vision (IJCV)},
-                 volume={115},
-                 number={3},
-                 pages={211-252}
-        }
-        ```
-
-We would like to acknowledge the ImageNet team, led by Olga Russakovsky, Jia Deng, and Li Fei-Fei, for creating and maintaining the ImageNet dataset. The ImageNet10 dataset, while a compact subset, is a valuable resource for quick testing and debugging in the machine learning and computer vision research community. For more information about the ImageNet dataset and its creators, visit the [ImageNet website](https://www.image-net.org/).

yolov10/docs/en/datasets/classify/imagenette.md

@@ -1,113 +0,0 @@
----
-comments: true
-description: Learn about the ImageNette dataset and its usage in deep learning model training. Find code snippets for model training and explore ImageNette datatypes.
-keywords: ImageNette dataset, Ultralytics, YOLO, Image classification, Machine Learning, Deep learning, Training code snippets, CNN, ImageNette160, ImageNette320
----
-
-# ImageNette Dataset
-
-The [ImageNette](https://github.com/fastai/imagenette) dataset is a subset of the larger [Imagenet](https://www.image-net.org/) dataset, but it only includes 10 easily distinguishable classes. It was created to provide a quicker, easier-to-use version of Imagenet for software development and education.
-
-## Key Features
-
-- ImageNette contains images from 10 different classes such as tench, English springer, cassette player, chain saw, church, French horn, garbage truck, gas pump, golf ball, parachute.
-- The dataset comprises colored images of varying dimensions.
-- ImageNette is widely used for training and testing in the field of machine learning, especially for image classification tasks.
-
-## Dataset Structure
-
-The ImageNette dataset is split into two subsets:
-
-1. **Training Set**: This subset contains several thousands of images used for training machine learning models. The exact number varies per class.
-2. **Validation Set**: This subset consists of several hundreds of images used for validating and benchmarking the trained models. Again, the exact number varies per class.
-
-## Applications
-
-The ImageNette dataset is widely used for training and evaluating deep learning models in image classification tasks, such as Convolutional Neural Networks (CNNs), and various other machine learning algorithms. The dataset's straightforward format and well-chosen classes make it a handy resource for both beginner and experienced practitioners in the field of machine learning and computer vision.
-
-## Usage
-
-To train a model on the ImageNette dataset for 100 epochs with a standard image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='imagenette', epochs=100, imgsz=224)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=imagenette model=yolov8n-cls.pt epochs=100 imgsz=224
-        ```
-
-## Sample Images and Annotations
-
-The ImageNette dataset contains colored images of various objects and scenes, providing a diverse dataset for image classification tasks. Here are some examples of images from the dataset:
-
-![Dataset sample image](https://docs.fast.ai/22_tutorial.imagenette_files/figure-html/cell-21-output-1.png)
-
-The example showcases the variety and complexity of the images in the ImageNette dataset, highlighting the importance of a diverse dataset for training robust image classification models.
-
-## ImageNette160 and ImageNette320
-
-For faster prototyping and training, the ImageNette dataset is also available in two reduced sizes: ImageNette160 and ImageNette320. These datasets maintain the same classes and structure as the full ImageNette dataset, but the images are resized to a smaller dimension. As such, these versions of the dataset are particularly useful for preliminary model testing, or when computational resources are limited.
-
-To use these datasets, simply replace 'imagenette' with 'imagenette160' or 'imagenette320' in the training command. The following code snippets illustrate this:
-
-!!! Example "Train Example with ImageNette160"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model with ImageNette160
-        results = model.train(data='imagenette160', epochs=100, imgsz=160)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model with ImageNette160
-        yolo detect train data=imagenette160 model=yolov8n-cls.pt epochs=100 imgsz=160
-        ```
-
-!!! Example "Train Example with ImageNette320"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model with ImageNette320
-        results = model.train(data='imagenette320', epochs=100, imgsz=320)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model with ImageNette320
-        yolo detect train data=imagenette320 model=yolov8n-cls.pt epochs=100 imgsz=320
-        ```
-
-These smaller versions of the dataset allow for rapid iterations during the development process while still providing valuable and realistic image classification tasks.
-
-## Citations and Acknowledgments
-
-If you use the ImageNette dataset in your research or development work, please acknowledge it appropriately. For more information about the ImageNette dataset, visit the [ImageNette dataset GitHub page](https://github.com/fastai/imagenette).

yolov10/docs/en/datasets/classify/imagewoof.md

@@ -1,89 +0,0 @@
----
-comments: true
-description: Explore the ImageWoof dataset, designed for challenging dog breed classification. Train AI models with Ultralytics YOLO using this dataset.
-keywords: ImageWoof, image classification, dog breeds, machine learning, deep learning, Ultralytics, YOLO, dataset
----
-
-# ImageWoof Dataset
-
-The [ImageWoof](https://github.com/fastai/imagenette) dataset is a subset of the ImageNet consisting of 10 classes that are challenging to classify, since they're all dog breeds. It was created as a more difficult task for image classification algorithms to solve, aiming at encouraging development of more advanced models.
-
-## Key Features
-
-- ImageWoof contains images of 10 different dog breeds: Australian terrier, Border terrier, Samoyed, Beagle, Shih-Tzu, English foxhound, Rhodesian ridgeback, Dingo, Golden retriever, and Old English sheepdog.
-- The dataset provides images at various resolutions (full size, 320px, 160px), accommodating for different computational capabilities and research needs.
-- It also includes a version with noisy labels, providing a more realistic scenario where labels might not always be reliable.
-
-## Dataset Structure
-
-The ImageWoof dataset structure is based on the dog breed classes, with each breed having its own directory of images.
-
-## Applications
-
-The ImageWoof dataset is widely used for training and evaluating deep learning models in image classification tasks, especially when it comes to more complex and similar classes. The dataset's challenge lies in the subtle differences between the dog breeds, pushing the limits of model's performance and generalization.
-
-## Usage
-
-To train a CNN model on the ImageWoof dataset for 100 epochs with an image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='imagewoof', epochs=100, imgsz=224)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=imagewoof model=yolov8n-cls.pt epochs=100 imgsz=224
-        ```
-
-## Dataset Variants
-
-ImageWoof dataset comes in three different sizes to accommodate various research needs and computational capabilities:
-
-1. **Full Size (imagewoof)**: This is the original version of the ImageWoof dataset. It contains full-sized images and is ideal for final training and performance benchmarking.
-
-2. **Medium Size (imagewoof320)**: This version contains images resized to have a maximum edge length of 320 pixels. It's suitable for faster training without significantly sacrificing model performance.
-
-3. **Small Size (imagewoof160)**: This version contains images resized to have a maximum edge length of 160 pixels. It's designed for rapid prototyping and experimentation where training speed is a priority.
-
-To use these variants in your training, simply replace 'imagewoof' in the dataset argument with 'imagewoof320' or 'imagewoof160'. For example:
-
-```python
-from ultralytics import YOLO
-
-# Load a model
-model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-# For medium-sized dataset
-model.train(data='imagewoof320', epochs=100, imgsz=224)
-
-# For small-sized dataset
-model.train(data='imagewoof160', epochs=100, imgsz=224)
-```
-
-It's important to note that using smaller images will likely yield lower performance in terms of classification accuracy. However, it's an excellent way to iterate quickly in the early stages of model development and prototyping.
-
-## Sample Images and Annotations
-
-The ImageWoof dataset contains colorful images of various dog breeds, providing a challenging dataset for image classification tasks. Here are some examples of images from the dataset:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/239357533-ec833254-4351-491b-8cb3-59578ea5d0b2.png)
-
-The example showcases the subtle differences and similarities among the different dog breeds in the ImageWoof dataset, highlighting the complexity and difficulty of the classification task.
-
-## Citations and Acknowledgments
-
-If you use the ImageWoof dataset in your research or development work, please make sure to acknowledge the creators of the dataset by linking to the [official dataset repository](https://github.com/fastai/imagenette).
-
-We would like to acknowledge the FastAI team for creating and maintaining the ImageWoof dataset as a valuable resource for the machine learning and computer vision research community. For more information about the ImageWoof dataset, visit the [ImageWoof dataset repository](https://github.com/fastai/imagenette).

yolov10/docs/en/datasets/classify/index.md

@@ -1,120 +0,0 @@
----
-comments: true
-description: Explore image classification datasets supported by Ultralytics, learn the standard dataset format, and set up your own dataset for training models.
-keywords: Ultralytics, image classification, dataset, machine learning, CIFAR-10, ImageNet, MNIST, torchvision
----
-
-# Image Classification Datasets Overview
-
-## Dataset format
-
-The folder structure for classification datasets in torchvision typically follows a standard format:
-
-```
-root/
-|-- class1/
-|   |-- img1.jpg
-|   |-- img2.jpg
-|   |-- ...
-|
-|-- class2/
-|   |-- img1.jpg
-|   |-- img2.jpg
-|   |-- ...
-|
-|-- class3/
-|   |-- img1.jpg
-|   |-- img2.jpg
-|   |-- ...
-|
-|-- ...
-```
-
-In this folder structure, the `root` directory contains one subdirectory for each class in the dataset. Each subdirectory is named after the corresponding class and contains all the images for that class. Each image file is named uniquely and is typically in a common image file format such as JPEG or PNG.
-
-** Example **
-
-For example, in the CIFAR10 dataset, the folder structure would look like this:
-
-```
-cifar-10-/
-|
-|-- train/
-|   |-- airplane/
-|   |   |-- 10008_airplane.png
-|   |   |-- 10009_airplane.png
-|   |   |-- ...
-|   |
-|   |-- automobile/
-|   |   |-- 1000_automobile.png
-|   |   |-- 1001_automobile.png
-|   |   |-- ...
-|   |
-|   |-- bird/
-|   |   |-- 10014_bird.png
-|   |   |-- 10015_bird.png
-|   |   |-- ...
-|   |
-|   |-- ...
-|
-|-- test/
-|   |-- airplane/
-|   |   |-- 10_airplane.png
-|   |   |-- 11_airplane.png
-|   |   |-- ...
-|   |
-|   |-- automobile/
-|   |   |-- 100_automobile.png
-|   |   |-- 101_automobile.png
-|   |   |-- ...
-|   |
-|   |-- bird/
-|   |   |-- 1000_bird.png
-|   |   |-- 1001_bird.png
-|   |   |-- ...
-|   |
-|   |-- ...
-```
-
-In this example, the `train` directory contains subdirectories for each class in the dataset, and each class subdirectory contains all the images for that class. The `test` directory has a similar structure. The `root` directory also contains other files that are part of the CIFAR10 dataset.
-
-## Usage
-
-!!! Example
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='path/to/dataset', epochs=100, imgsz=640)
-        ```
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=path/to/data model=yolov8n-cls.pt epochs=100 imgsz=640
-        ```
-
-## Supported Datasets
-
-Ultralytics supports the following datasets with automatic download:
-
-- [Caltech 101](caltech101.md): A dataset containing images of 101 object categories for image classification tasks.
-- [Caltech 256](caltech256.md): An extended version of Caltech 101 with 256 object categories and more challenging images.
-- [CIFAR-10](cifar10.md): A dataset of 60K 32x32 color images in 10 classes, with 6K images per class.
-- [CIFAR-100](cifar100.md): An extended version of CIFAR-10 with 100 object categories and 600 images per class.
-- [Fashion-MNIST](fashion-mnist.md): A dataset consisting of 70,000 grayscale images of 10 fashion categories for image classification tasks.
-- [ImageNet](imagenet.md): A large-scale dataset for object detection and image classification with over 14 million images and 20,000 categories.
-- [ImageNet-10](imagenet10.md): A smaller subset of ImageNet with 10 categories for faster experimentation and testing.
-- [Imagenette](imagenette.md): A smaller subset of ImageNet that contains 10 easily distinguishable classes for quicker training and testing.
-- [Imagewoof](imagewoof.md): A more challenging subset of ImageNet containing 10 dog breed categories for image classification tasks.
-- [MNIST](mnist.md): A dataset of 70,000 grayscale images of handwritten digits for image classification tasks.
-
-### Adding your own dataset
-
-If you have your own dataset and would like to use it for training classification models with Ultralytics, ensure that it follows the format specified above under "Dataset format" and then point your `data` argument to the dataset directory.

yolov10/docs/en/datasets/classify/mnist.md

@@ -1,86 +0,0 @@
----
-comments: true
-description: Detailed guide on the MNIST Dataset, a benchmark in the machine learning community for image classification tasks. Learn about its structure, usage and application.
-keywords: MNIST dataset, Ultralytics, image classification, machine learning, computer vision, deep learning, AI, dataset guide
----
-
-# MNIST Dataset
-
-The [MNIST](http://yann.lecun.com/exdb/mnist/) (Modified National Institute of Standards and Technology) dataset is a large database of handwritten digits that is commonly used for training various image processing systems and machine learning models. It was created by "re-mixing" the samples from NIST's original datasets and has become a benchmark for evaluating the performance of image classification algorithms.
-
-## Key Features
-
-- MNIST contains 60,000 training images and 10,000 testing images of handwritten digits.
-- The dataset comprises grayscale images of size 28x28 pixels.
-- The images are normalized to fit into a 28x28 pixel bounding box and anti-aliased, introducing grayscale levels.
-- MNIST is widely used for training and testing in the field of machine learning, especially for image classification tasks.
-
-## Dataset Structure
-
-The MNIST dataset is split into two subsets:
-
-1. **Training Set**: This subset contains 60,000 images of handwritten digits used for training machine learning models.
-2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
-
-## Extended MNIST (EMNIST)
-
-Extended MNIST (EMNIST) is a newer dataset developed and released by NIST to be the successor to MNIST. While MNIST included images only of handwritten digits, EMNIST includes all the images from NIST Special Database 19, which is a large database of handwritten uppercase and lowercase letters as well as digits. The images in EMNIST were converted into the same 28x28 pixel format, by the same process, as were the MNIST images. Accordingly, tools that work with the older, smaller MNIST dataset will likely work unmodified with EMNIST.
-
-## Applications
-
-The MNIST dataset is widely used for training and evaluating deep learning models in image classification tasks, such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning algorithms. The dataset's simple and well-structured format makes it an essential resource for researchers and practitioners in the field of machine learning and computer vision.
-
-## Usage
-
-To train a CNN model on the MNIST dataset for 100 epochs with an image size of 32x32, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-cls.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='mnist', epochs=100, imgsz=32)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        cnn detect train data=mnist model=yolov8n-cls.pt epochs=100 imgsz=28
-        ```
-
-## Sample Images and Annotations
-
-The MNIST dataset contains grayscale images of handwritten digits, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
-
-![Dataset sample image](https://upload.wikimedia.org/wikipedia/commons/2/27/MnistExamples.png)
-
-The example showcases the variety and complexity of the handwritten digits in the MNIST dataset, highlighting the importance of a diverse dataset for training robust image classification models.
-
-## Citations and Acknowledgments
-
-If you use the MNIST dataset in your
-
-research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{lecun2010mnist,
-                 title={MNIST handwritten digit database},
-                 author={LeCun, Yann and Cortes, Corinna and Burges, CJ},
-                 journal={ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist},
-                 volume={2},
-                 year={2010}
-        }
-        ```
-
-We would like to acknowledge Yann LeCun, Corinna Cortes, and Christopher J.C. Burges for creating and maintaining the MNIST dataset as a valuable resource for the machine learning and computer vision research community. For more information about the MNIST dataset and its creators, visit the [MNIST dataset website](http://yann.lecun.com/exdb/mnist/).

yolov10/docs/en/datasets/detect/african-wildlife.md

@@ -1,92 +0,0 @@
----
-comments: true
-description: African Wildlife objects detection, a leading dataset for object detection in forests, integrates with Ultralytics. Discover ways to use it for training YOLO models.
-keywords: Ultralytics, African Wildlife dataset, object detection, YOLO, YOLO model training, object tracking, computer vision, deep learning models, forest research, animals tracking
----
-
-# African Wildlife Dataset
-
-This dataset showcases four common animal classes typically found in South African nature reserves. It includes images of African wildlife such as buffalo, elephant, rhino, and zebra, providing valuable insights into their characteristics. Essential for training computer vision algorithms, this dataset aids in identifying animals in various habitats, from zoos to forests, and supports wildlife research.
-
-## Dataset Structure
-
-The African wildlife objects detection dataset is split into three subsets:
-
-- **Training set**: Contains 1052 images, each with corresponding annotations.
-- **Validation set**: Includes 225 images, each with paired annotations.
-- **Testing set**: Comprises 227 images, each with paired annotations.
-
-## Applications
-
-This dataset can be applied in various computer vision tasks such as object detection, object tracking, and research. Specifically, it can be used to train and evaluate models for identifying African wildlife objects in images, which can have applications in wildlife conservation, ecological research, and monitoring efforts in natural reserves and protected areas. Additionally, it can serve as a valuable resource for educational purposes, enabling students and researchers to study and understand the characteristics and behaviors of different animal species.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file defines the dataset configuration, including paths, classes, and other pertinent details. For the African wildlife dataset, the `african-wildlife.yaml` file is located at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/african-wildlife.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/african-wildlife.yaml).
-
-!!! Example "ultralytics/cfg/datasets/african-wildlife.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/african-wildlife.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the African wildlife dataset for 100 epochs with an image size of 640, use the provided code samples. For a comprehensive list of available parameters, refer to the model's [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='african-wildlife.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=african-wildlife.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-!!! Example "Inference Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('path/to/best.pt')  # load a brain-tumor fine-tuned model
-
-        # Inference using the model
-        results = model.predict("https://ultralytics.com/assets/african-wildlife-sample.jpg")
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start prediction with a finetuned *.pt model
-        yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/african-wildlife-sample.jpg"
-        ```
-    
-
-## Sample Images and Annotations
-
-The African wildlife dataset comprises a wide variety of images showcasing diverse animal species and their natural habitats. Below are examples of images from the dataset, each accompanied by its corresponding annotations.
-
-![African wildlife dataset sample image](https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/919f8190-ccf3-4a96-a5f1-55d9eebc77ec)
-
-- **Mosaiced Image**: Here, we present a training batch consisting of mosaiced dataset images. Mosaicing, a training technique, combines multiple images into one, enriching batch diversity. This method helps enhance the model's ability to generalize across different object sizes, aspect ratios, and contexts.
-
-This example illustrates the variety and complexity of images in the African wildlife dataset, emphasizing the benefits of including mosaicing during the training process.
-
-## Citations and Acknowledgments
-
-The dataset has been released available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).

yolov10/docs/en/datasets/detect/argoverse.md

@@ -1,97 +0,0 @@
----
-comments: true
-description: Explore Argoverse, a comprehensive dataset for autonomous driving tasks including 3D tracking, motion forecasting and depth estimation used in YOLO.
-keywords: Argoverse dataset, autonomous driving, YOLO, 3D tracking, motion forecasting, LiDAR data, HD maps, ultralytics documentation
----
-
-# Argoverse Dataset
-
-The [Argoverse](https://www.argoverse.org/) dataset is a collection of data designed to support research in autonomous driving tasks, such as 3D tracking, motion forecasting, and stereo depth estimation. Developed by Argo AI, the dataset provides a wide range of high-quality sensor data, including high-resolution images, LiDAR point clouds, and map data.
-
-!!! Note
-
-    The Argoverse dataset `*.zip` file required for training was removed from Amazon S3 after the shutdown of Argo AI by Ford, but we have made it available for manual download on [Google Drive](https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link).
-
-## Key Features
-
-- Argoverse contains over 290K labeled 3D object tracks and 5 million object instances across 1,263 distinct scenes.
-- The dataset includes high-resolution camera images, LiDAR point clouds, and richly annotated HD maps.
-- Annotations include 3D bounding boxes for objects, object tracks, and trajectory information.
-- Argoverse provides multiple subsets for different tasks, such as 3D tracking, motion forecasting, and stereo depth estimation.
-
-## Dataset Structure
-
-The Argoverse dataset is organized into three main subsets:
-
-1. **Argoverse 3D Tracking**: This subset contains 113 scenes with over 290K labeled 3D object tracks, focusing on 3D object tracking tasks. It includes LiDAR point clouds, camera images, and sensor calibration information.
-2. **Argoverse Motion Forecasting**: This subset consists of 324K vehicle trajectories collected from 60 hours of driving data, suitable for motion forecasting tasks.
-3. **Argoverse Stereo Depth Estimation**: This subset is designed for stereo depth estimation tasks and includes over 10K stereo image pairs with corresponding LiDAR point clouds for ground truth depth estimation.
-
-## Applications
-
-The Argoverse dataset is widely used for training and evaluating deep learning models in autonomous driving tasks such as 3D object tracking, motion forecasting, and stereo depth estimation. The dataset's diverse set of sensor data, object annotations, and map information make it a valuable resource for researchers and practitioners in the field of autonomous driving.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the Argoverse dataset, the `Argoverse.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Argoverse.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Argoverse.yaml).
-
-!!! Example "ultralytics/cfg/datasets/Argoverse.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/Argoverse.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the Argoverse dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='Argoverse.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=Argoverse.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-The Argoverse dataset contains a diverse set of sensor data, including camera images, LiDAR point clouds, and HD map information, providing rich context for autonomous driving tasks. Here are some examples of data from the dataset, along with their corresponding annotations:
-
-![Dataset sample image](https://www.argoverse.org/assets/images/reference_images/av2_ground_height.png)
-
-- **Argoverse 3D Tracking**: This image demonstrates an example of 3D object tracking, where objects are annotated with 3D bounding boxes. The dataset provides LiDAR point clouds and camera images to facilitate the development of models for this task.
-
-The example showcases the variety and complexity of the data in the Argoverse dataset and highlights the importance of high-quality sensor data for autonomous driving tasks.
-
-## Citations and Acknowledgments
-
-If you use the Argoverse dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @inproceedings{chang2019argoverse,
-          title={Argoverse: 3D Tracking and Forecasting with Rich Maps},
-          author={Chang, Ming-Fang and Lambert, John and Sangkloy, Patsorn and Singh, Jagjeet and Bak, Slawomir and Hartnett, Andrew and Wang, Dequan and Carr, Peter and Lucey, Simon and Ramanan, Deva and others},
-          booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
-          pages={8748--8757},
-          year={2019}
-        }
-        ```
-
-We would like to acknowledge Argo AI for creating and maintaining the Argoverse dataset as a valuable resource for the autonomous driving research community. For more information about the Argoverse dataset and its creators, visit the [Argoverse dataset website](https://www.argoverse.org/).

yolov10/docs/en/datasets/detect/brain-tumor.md

@@ -1,91 +0,0 @@
----
-comments: true
-description: Brain tumor detection, a leading dataset for medical imaging, integrates with Ultralytics. Discover ways to use it for training YOLO models.
-keywords: Ultralytics, Brain Tumor dataset, object detection, YOLO, YOLO model training, object tracking, computer vision, deep learning models
----
-
-# Brain Tumor Dataset
-
-A brain tumor detection dataset consists of medical images from MRI or CT scans, containing information about brain tumor presence, location, and characteristics. This dataset is essential for training computer vision algorithms to automate brain tumor identification, aiding in early diagnosis and treatment planning.
-
-## Dataset Structure
-
-The brain tumor dataset is divided into two subsets:
-
-- **Training set**: Consisting of 893 images, each accompanied by corresponding annotations.
-- **Testing set**: Comprising 223 images, with annotations paired for each one.
-
-## Applications
-
-The application of brain tumor detection using computer vision enables early diagnosis, treatment planning, and monitoring of tumor progression. By analyzing medical imaging data like MRI or CT scans, computer vision systems assist in accurately identifying brain tumors, aiding in timely medical intervention and personalized treatment strategies.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the brain tumor dataset, the `brain-tumor.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/brain-tumor.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/brain-tumor.yaml).
-
-!!! Example "ultralytics/cfg/datasets/brain-tumor.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/brain-tumor.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the brain tumor dataset for 100 epochs with an image size of 640, utilize the provided code snippets. For a detailed list of available arguments, consult the model's [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='brain-tumor.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=brain-tumor.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-!!! Example "Inference Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('path/to/best.pt')  # load a brain-tumor fine-tuned model
-
-        # Inference using the model
-        results = model.predict("https://ultralytics.com/assets/brain-tumor-sample.jpg")
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start prediction with a finetuned *.pt model
-        yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/brain-tumor-sample.jpg"
-        ```
-    
-
-## Sample Images and Annotations
-
-The brain tumor dataset encompasses a wide array of images featuring diverse object categories and intricate scenes. Presented below are examples of images from the dataset, accompanied by their respective annotations
-
-![Brain tumor dataset sample image](https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/1741cbf5-2462-4e9a-b0b9-4a07d76cf7ef)
-
-- **Mosaiced Image**: Displayed here is a training batch comprising mosaiced dataset images. Mosaicing, a training technique, consolidates multiple images into one, enhancing batch diversity. This approach aids in improving the model's capacity to generalize across various object sizes, aspect ratios, and contexts.
-
-This example highlights the diversity and intricacy of images within the brain tumor dataset, underscoring the advantages of incorporating mosaicing during the training phase.
-
-## Citations and Acknowledgments
-
-The dataset has been released available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).

yolov10/docs/en/datasets/detect/coco.md

@@ -1,105 +0,0 @@
----
-comments: true
-description: Learn how COCO, a leading dataset for object detection and segmentation, integrates with Ultralytics. Discover ways to use it for training YOLO models.
-keywords: Ultralytics, COCO dataset, object detection, YOLO, YOLO model training, image segmentation, computer vision, deep learning models
----
-
-# COCO Dataset
-
-The [COCO](https://cocodataset.org/#home) (Common Objects in Context) dataset is a large-scale object detection, segmentation, and captioning dataset. It is designed to encourage research on a wide variety of object categories and is commonly used for benchmarking computer vision models. It is an essential dataset for researchers and developers working on object detection, segmentation, and pose estimation tasks.
-
-<p align="center">
-  <br>
-  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/uDrn9QZJ2lk"
-    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> Ultralytics COCO Dataset Overview
-</p>
-
-## Key Features
-
-- COCO contains 330K images, with 200K images having annotations for object detection, segmentation, and captioning tasks.
-- The dataset comprises 80 object categories, including common objects like cars, bicycles, and animals, as well as more specific categories such as umbrellas, handbags, and sports equipment.
-- Annotations include object bounding boxes, segmentation masks, and captions for each image.
-- COCO provides standardized evaluation metrics like mean Average Precision (mAP) for object detection, and mean Average Recall (mAR) for segmentation tasks, making it suitable for comparing model performance.
-
-## Dataset Structure
-
-The COCO dataset is split into three subsets:
-
-1. **Train2017**: This subset contains 118K images for training object detection, segmentation, and captioning models.
-2. **Val2017**: This subset has 5K images used for validation purposes during model training.
-3. **Test2017**: This subset consists of 20K images used for testing and benchmarking the trained models. Ground truth annotations for this subset are not publicly available, and the results are submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7384) for performance evaluation.
-
-## Applications
-
-The COCO dataset is widely used for training and evaluating deep learning models in object detection (such as YOLO, Faster R-CNN, and SSD), instance segmentation (such as Mask R-CNN), and keypoint detection (such as OpenPose). The dataset's diverse set of object categories, large number of annotated images, and standardized evaluation metrics make it an essential resource for computer vision researchers and practitioners.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO dataset, the `coco.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
-
-!!! Example "ultralytics/cfg/datasets/coco.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/coco.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the COCO dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='coco.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=coco.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Images and Annotations
-
-The COCO dataset contains a diverse set of images with various object categories and complex scenes. Here are some examples of images from the dataset, along with their corresponding annotations:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/236811818-5b566576-1e92-42fa-9462-4b6a848abe89.jpg)
-
-- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
-
-The example showcases the variety and complexity of the images in the COCO dataset and the benefits of using mosaicing during the training process.
-
-## Citations and Acknowledgments
-
-If you use the COCO dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @misc{lin2015microsoft,
-              title={Microsoft COCO: Common Objects in Context},
-              author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
-              year={2015},
-              eprint={1405.0312},
-              archivePrefix={arXiv},
-              primaryClass={cs.CV}
-        }
-        ```
-
-We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).

yolov10/docs/en/datasets/detect/coco8.md

@@ -1,90 +0,0 @@
----
-comments: true
-description: Discover the benefits of using the practical and diverse COCO8 dataset for object detection model testing. Learn to configure and use it via Ultralytics HUB and YOLOv8.
-keywords: Ultralytics, COCO8 dataset, object detection, model testing, dataset configuration, detection approaches, sanity check, training pipelines, YOLOv8
----
-
-# COCO8 Dataset
-
-## Introduction
-
-[Ultralytics](https://ultralytics.com) COCO8 is a small, but versatile object detection dataset composed of the first 8 images of the COCO train 2017 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging object detection models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
-
-<p align="center">
-  <br>
-  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/uDrn9QZJ2lk"
-    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> Ultralytics COCO Dataset Overview
-</p>
-
-This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com) and [YOLOv8](https://github.com/ultralytics/ultralytics).
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO8 dataset, the `coco8.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8.yaml).
-
-!!! Example "ultralytics/cfg/datasets/coco8.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/coco8.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the COCO8 dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Images and Annotations
-
-Here are some examples of images from the COCO8 dataset, along with their corresponding annotations:
-
-<img src="https://user-images.githubusercontent.com/26833433/236818348-e6260a3d-0454-436b-83a9-de366ba07235.jpg" alt="Dataset sample image" width="800">
-
-- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
-
-The example showcases the variety and complexity of the images in the COCO8 dataset and the benefits of using mosaicing during the training process.
-
-## Citations and Acknowledgments
-
-If you use the COCO dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @misc{lin2015microsoft,
-              title={Microsoft COCO: Common Objects in Context},
-              author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
-              year={2015},
-              eprint={1405.0312},
-              archivePrefix={arXiv},
-              primaryClass={cs.CV}
-        }
-        ```
-
-We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).

yolov10/docs/en/datasets/detect/globalwheat2020.md

@@ -1,91 +0,0 @@
----
-comments: true
-description: Understand how to utilize the vast Global Wheat Head Dataset for building wheat head detection models. Features, structure, applications, usage, sample data, and citation.
-keywords: Ultralytics, YOLO, Global Wheat Head Dataset, wheat head detection, plant phenotyping, crop management, deep learning, outdoor images, annotations, YAML configuration
----
-
-# Global Wheat Head Dataset
-
-The [Global Wheat Head Dataset](https://www.global-wheat.com/) is a collection of images designed to support the development of accurate wheat head detection models for applications in wheat phenotyping and crop management. Wheat heads, also known as spikes, are the grain-bearing parts of the wheat plant. Accurate estimation of wheat head density and size is essential for assessing crop health, maturity, and yield potential. The dataset, created by a collaboration of nine research institutes from seven countries, covers multiple growing regions to ensure models generalize well across different environments.
-
-## Key Features
-
-- The dataset contains over 3,000 training images from Europe (France, UK, Switzerland) and North America (Canada).
-- It includes approximately 1,000 test images from Australia, Japan, and China.
-- Images are outdoor field images, capturing the natural variability in wheat head appearances.
-- Annotations include wheat head bounding boxes to support object detection tasks.
-
-## Dataset Structure
-
-The Global Wheat Head Dataset is organized into two main subsets:
-
-1. **Training Set**: This subset contains over 3,000 images from Europe and North America. The images are labeled with wheat head bounding boxes, providing ground truth for training object detection models.
-2. **Test Set**: This subset consists of approximately 1,000 images from Australia, Japan, and China. These images are used for evaluating the performance of trained models on unseen genotypes, environments, and observational conditions.
-
-## Applications
-
-The Global Wheat Head Dataset is widely used for training and evaluating deep learning models in wheat head detection tasks. The dataset's diverse set of images, capturing a wide range of appearances, environments, and conditions, make it a valuable resource for researchers and practitioners in the field of plant phenotyping and crop management.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the Global Wheat Head Dataset, the `GlobalWheat2020.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml).
-
-!!! Example "ultralytics/cfg/datasets/GlobalWheat2020.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/GlobalWheat2020.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the Global Wheat Head Dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='GlobalWheat2020.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=GlobalWheat2020.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-The Global Wheat Head Dataset contains a diverse set of outdoor field images, capturing the natural variability in wheat head appearances, environments, and conditions. Here are some examples of data from the dataset, along with their corresponding annotations:
-
-![Dataset sample image](https://i.ytimg.com/vi/yqvMuw-uedU/maxresdefault.jpg)
-
-- **Wheat Head Detection**: This image demonstrates an example of wheat head detection, where wheat heads are annotated with bounding boxes. The dataset provides a variety of images to facilitate the development of models for this task.
-
-The example showcases the variety and complexity of the data in the Global Wheat Head Dataset and highlights the importance of accurate wheat head detection for applications in wheat phenotyping and crop management.
-
-## Citations and Acknowledgments
-
-If you use the Global Wheat Head Dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{david2020global,
-                 title={Global Wheat Head Detection (GWHD) Dataset: A Large and Diverse Dataset of High-Resolution RGB-Labelled Images to Develop and Benchmark Wheat Head Detection Methods},
-                 author={David, Etienne and Madec, Simon and Sadeghi-Tehran, Pouria and Aasen, Helge and Zheng, Bangyou and Liu, Shouyang and Kirchgessner, Norbert and Ishikawa, Goro and Nagasawa, Koichi and Badhon, Minhajul and others},
-                 journal={arXiv preprint arXiv:2005.02162},
-                 year={2020}
-        }
-        ```
-
-We would like to acknowledge the researchers and institutions that contributed to the creation and maintenance of the Global Wheat Head Dataset as a valuable resource for the plant phenotyping and crop management research community. For more information about the dataset and its creators, visit the [Global Wheat Head Dataset website](https://www.global-wheat.com/).

yolov10/docs/en/datasets/detect/index.md

@@ -1,110 +0,0 @@
----
-comments: true
-description: Navigate through supported dataset formats, methods to utilize them and how to add your own datasets. Get insights on porting or converting label formats.
-keywords: Ultralytics, YOLO, datasets, object detection, dataset formats, label formats, data conversion
----
-
-# Object Detection Datasets Overview
-
-Training a robust and accurate object detection model requires a comprehensive dataset. This guide introduces various formats of datasets that are compatible with the Ultralytics YOLO model and provides insights into their structure, usage, and how to convert between different formats.
-
-## Supported Dataset Formats
-
-### Ultralytics YOLO format
-
-The Ultralytics YOLO format is a dataset configuration format that allows you to define the dataset root directory, the relative paths to training/validation/testing image directories or `*.txt` files containing image paths, and a dictionary of class names. Here is an example:
-
-```yaml
-# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
-path: ../datasets/coco8  # dataset root dir
-train: images/train  # train images (relative to 'path') 4 images
-val: images/val  # val images (relative to 'path') 4 images
-test:  # test images (optional)
-
-# Classes (80 COCO classes)
-names:
-  0: person
-  1: bicycle
-  2: car
-  # ...
-  77: teddy bear
-  78: hair drier
-  79: toothbrush
-```
-
-Labels for this format should be exported to YOLO format with one `*.txt` file per image. If there are no objects in an image, no `*.txt` file is required. The `*.txt` file should be formatted with one row per object in `class x_center y_center width height` format. Box coordinates must be in **normalized xywh** format (from 0 to 1). If your boxes are in pixels, you should divide `x_center` and `width` by image width, and `y_center` and `height` by image height. Class numbers should be zero-indexed (start with 0).
-
-<p align="center"><img width="750" src="https://user-images.githubusercontent.com/26833433/91506361-c7965000-e886-11ea-8291-c72b98c25eec.jpg" alt="Example labelled image"></p>
-
-The label file corresponding to the above image contains 2 persons (class `0`) and a tie (class `27`):
-
-<p align="center"><img width="428" src="https://user-images.githubusercontent.com/26833433/112467037-d2568c00-8d66-11eb-8796-55402ac0d62f.png" alt="Example label file"></p>
-
-When using the Ultralytics YOLO format, organize your training and validation images and labels as shown in the example below.
-
-<p align="center"><img width="700" src="https://user-images.githubusercontent.com/26833433/134436012-65111ad1-9541-4853-81a6-f19a3468b75f.png" alt="Example dataset directory structure"></p>
-
-## Usage
-
-Here's how you can use these formats to train your model:
-
-!!! Example
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-        ```
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Supported Datasets
-
-Here is a list of the supported datasets and a brief description for each:
-
-- [**Argoverse**](argoverse.md): A collection of sensor data collected from autonomous vehicles. It contains 3D tracking annotations for car objects.
-- [**COCO**](coco.md): Common Objects in Context (COCO) is a large-scale object detection, segmentation, and captioning dataset with 80 object categories.
-- [**COCO8**](coco8.md): A smaller subset of the COCO dataset, COCO8 is more lightweight and faster to train.
-- [**GlobalWheat2020**](globalwheat2020.md): A dataset containing images of wheat heads for the Global Wheat Challenge 2020.
-- [**Objects365**](objects365.md): A large-scale object detection dataset with 365 object categories and 600k images, aimed at advancing object detection research.
-- [**OpenImagesV7**](open-images-v7.md): A comprehensive dataset by Google with 1.7M train images and 42k validation images.
-- [**SKU-110K**](sku-110k.md): A dataset containing images of densely packed retail products, intended for retail environment object detection.
-- [**VisDrone**](visdrone.md): A dataset focusing on drone-based images, containing various object categories like cars, pedestrians, and cyclists.
-- [**VOC**](voc.md): PASCAL VOC is a popular object detection dataset with 20 object categories including vehicles, animals, and furniture.
-- [**xView**](xview.md): A dataset containing high-resolution satellite imagery, designed for the detection of various object classes in overhead views.
-- [**Brain-tumor**](brain-tumor.md): This dataset comprises MRI or CT scan images containing information about brain tumor presence, location, and characteristics. It plays a crucial role in training computer vision models to automate tumor identification, facilitating early diagnosis and treatment planning.
-- [**African-wildlife**](african-wildlife.md): Featuring images of African wildlife such as buffalo, elephant, rhino, and zebra, this dataset is instrumental in training computer vision models. It is indispensable for identifying animals across different habitats and contributes significantly to wildlife research endeavors.
-
-### Adding your own dataset
-
-If you have your own dataset and would like to use it for training detection models with Ultralytics YOLO format, ensure that it follows the format specified above under "Ultralytics YOLO format". Convert your annotations to the required format and specify the paths, number of classes, and class names in the YAML configuration file.
-
-## Port or Convert Label Formats
-
-### COCO Dataset Format to YOLO Format
-
-You can easily convert labels from the popular COCO dataset format to the YOLO format using the following code snippet:
-
-!!! Example
-
-    === "Python"
-
-        ```python
-        from ultralytics.data.converter import convert_coco
-
-        convert_coco(labels_dir='path/to/coco/annotations/')
-        ```
-
-This conversion tool can be used to convert the COCO dataset or any dataset in the COCO format to the Ultralytics YOLO format.
-
-Remember to double-check if the dataset you want to use is compatible with your model and follows the necessary format conventions. Properly formatted datasets are crucial for training successful object detection models.

yolov10/docs/en/datasets/detect/objects365.md

@@ -1,92 +0,0 @@
----
-comments: true
-description: Discover the Objects365 dataset, a wide-scale, high-quality resource for object detection research. Learn to use it with the Ultralytics YOLO model.
-keywords: Objects365, object detection, Ultralytics, dataset, YOLO, bounding boxes, annotations, computer vision, deep learning, training models
----
-
-# Objects365 Dataset
-
-The [Objects365](https://www.objects365.org/) dataset is a large-scale, high-quality dataset designed to foster object detection research with a focus on diverse objects in the wild. Created by a team of [Megvii](https://en.megvii.com/) researchers, the dataset offers a wide range of high-resolution images with a comprehensive set of annotated bounding boxes covering 365 object categories.
-
-## Key Features
-
-- Objects365 contains 365 object categories, with 2 million images and over 30 million bounding boxes.
-- The dataset includes diverse objects in various scenarios, providing a rich and challenging benchmark for object detection tasks.
-- Annotations include bounding boxes for objects, making it suitable for training and evaluating object detection models.
-- Objects365 pre-trained models significantly outperform ImageNet pre-trained models, leading to better generalization on various tasks.
-
-## Dataset Structure
-
-The Objects365 dataset is organized into a single set of images with corresponding annotations:
-
-- **Images**: The dataset includes 2 million high-resolution images, each containing a variety of objects across 365 categories.
-- **Annotations**: The images are annotated with over 30 million bounding boxes, providing comprehensive ground truth information for object detection tasks.
-
-## Applications
-
-The Objects365 dataset is widely used for training and evaluating deep learning models in object detection tasks. The dataset's diverse set of object categories and high-quality annotations make it a valuable resource for researchers and practitioners in the field of computer vision.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the Objects365 Dataset, the `Objects365.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Objects365.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Objects365.yaml).
-
-!!! Example "ultralytics/cfg/datasets/Objects365.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/Objects365.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the Objects365 dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='Objects365.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=Objects365.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-The Objects365 dataset contains a diverse set of high-resolution images with objects from 365 categories, providing rich context for object detection tasks. Here are some examples of the images in the dataset:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/238215467-caf757dd-0b87-4b0d-bb19-d94a547f7fbf.jpg)
-
-- **Objects365**: This image demonstrates an example of object detection, where objects are annotated with bounding boxes. The dataset provides a wide range of images to facilitate the development of models for this task.
-
-The example showcases the variety and complexity of the data in the Objects365 dataset and highlights the importance of accurate object detection for computer vision applications.
-
-## Citations and Acknowledgments
-
-If you use the Objects365 dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @inproceedings{shao2019objects365,
-          title={Objects365: A Large-scale, High-quality Dataset for Object Detection},
-          author={Shao, Shuai and Li, Zeming and Zhang, Tianyuan and Peng, Chao and Yu, Gang and Li, Jing and Zhang, Xiangyu and Sun, Jian},
-          booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
-          pages={8425--8434},
-          year={2019}
-        }
-        ```
-
-We would like to acknowledge the team of researchers who created and maintain the Objects365 dataset as a valuable resource for the computer vision research community. For more information about the Objects365 dataset and its creators, visit the [Objects365 dataset website](https://www.objects365.org/).

yolov10/docs/en/datasets/detect/open-images-v7.md

@@ -1,120 +0,0 @@
----
-comments: true
-description: Dive into Google's Open Images V7, a comprehensive dataset offering a broad scope for computer vision research. Understand its usage with deep learning models.
-keywords: Open Images V7, object detection, segmentation masks, visual relationships, localized narratives, computer vision, deep learning, annotations, bounding boxes
----
-
-# Open Images V7 Dataset
-
-[Open Images V7](https://storage.googleapis.com/openimages/web/index.html) is a versatile and expansive dataset championed by Google. Aimed at propelling research in the realm of computer vision, it boasts a vast collection of images annotated with a plethora of data, including image-level labels, object bounding boxes, object segmentation masks, visual relationships, and localized narratives.
-
-## Open Images V7 Pretrained Models
-
-| Model                                                                                     | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
-|-------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
-| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n-oiv7.pt) | 640                   | 18.4                 | 142.4                          | 1.21                                | 3.5                | 10.5              |
-| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640                   | 27.7                 | 183.1                          | 1.40                                | 11.4               | 29.7              |
-| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640                   | 33.6                 | 408.5                          | 2.26                                | 26.2               | 80.6              |
-| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640                   | 34.9                 | 596.9                          | 2.43                                | 44.1               | 167.4             |
-| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640                   | 36.3                 | 860.6                          | 3.56                                | 68.7               | 260.6             |
-
-![Open Images V7 classes visual](https://user-images.githubusercontent.com/26833433/258660358-2dc07771-ec08-4d11-b24a-f66e07550050.png)
-
-## Key Features
-
-- Encompasses ~9M images annotated in various ways to suit multiple computer vision tasks.
-- Houses a staggering 16M bounding boxes across 600 object classes in 1.9M images. These boxes are primarily hand-drawn by experts ensuring high precision.
-- Visual relationship annotations totaling 3.3M are available, detailing 1,466 unique relationship triplets, object properties, and human activities.
-- V5 introduced segmentation masks for 2.8M objects across 350 classes.
-- V6 introduced 675k localized narratives that amalgamate voice, text, and mouse traces highlighting described objects.
-- V7 introduced 66.4M point-level labels on 1.4M images, spanning 5,827 classes.
-- Encompasses 61.4M image-level labels across a diverse set of 20,638 classes.
-- Provides a unified platform for image classification, object detection, relationship detection, instance segmentation, and multimodal image descriptions.
-
-## Dataset Structure
-
-Open Images V7 is structured in multiple components catering to varied computer vision challenges:
-
-- **Images**: About 9 million images, often showcasing intricate scenes with an average of 8.3 objects per image.
-- **Bounding Boxes**: Over 16 million boxes that demarcate objects across 600 categories.
-- **Segmentation Masks**: These detail the exact boundary of 2.8M objects across 350 classes.
-- **Visual Relationships**: 3.3M annotations indicating object relationships, properties, and actions.
-- **Localized Narratives**: 675k descriptions combining voice, text, and mouse traces.
-- **Point-Level Labels**: 66.4M labels across 1.4M images, suitable for zero/few-shot semantic segmentation.
-
-## Applications
-
-Open Images V7 is a cornerstone for training and evaluating state-of-the-art models in various computer vision tasks. The dataset's broad scope and high-quality annotations make it indispensable for researchers and developers specializing in computer vision.
-
-## Dataset YAML
-
-Typically, datasets come with a YAML (Yet Another Markup Language) file that delineates the dataset's configuration. For the case of Open Images V7, a hypothetical `OpenImagesV7.yaml` might exist. For accurate paths and configurations, one should refer to the dataset's official repository or documentation.
-
-!!! Example "OpenImagesV7.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/open-images-v7.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the Open Images V7 dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Warning
-
-    The complete Open Images V7 dataset comprises 1,743,042 training images and 41,620 validation images, requiring approximately **561 GB of storage space** upon download.
-
-    Executing the commands provided below will trigger an automatic download of the full dataset if it's not already present locally. Before running the below example it's crucial to:
-
-    - Verify that your device has enough storage capacity.
-    - Ensure a robust and speedy internet connection.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a COCO-pretrained YOLOv8n model
-        model = YOLO('yolov8n.pt')
-
-        # Train the model on the Open Images V7 dataset
-        results = model.train(data='open-images-v7.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Train a COCO-pretrained YOLOv8n model on the Open Images V7 dataset
-        yolo detect train data=open-images-v7.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-Illustrations of the dataset help provide insights into its richness:
-
-![Dataset sample image](https://storage.googleapis.com/openimages/web/images/oidv7_all-in-one_example_ab.jpg)
-
-- **Open Images V7**: This image exemplifies the depth and detail of annotations available, including bounding boxes, relationships, and segmentation masks.
-
-Researchers can gain invaluable insights into the array of computer vision challenges that the dataset addresses, from basic object detection to intricate relationship identification.
-
-## Citations and Acknowledgments
-
-For those employing Open Images V7 in their work, it's prudent to cite the relevant papers and acknowledge the creators:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{OpenImages,
-          author = {Alina Kuznetsova and Hassan Rom and Neil Alldrin and Jasper Uijlings and Ivan Krasin and Jordi Pont-Tuset and Shahab Kamali and Stefan Popov and Matteo Malloci and Alexander Kolesnikov and Tom Duerig and Vittorio Ferrari},
-          title = {The Open Images Dataset V4: Unified image classification, object detection, and visual relationship detection at scale},
-          year = {2020},
-          journal = {IJCV}
-        }
-        ```
-
-A heartfelt acknowledgment goes out to the Google AI team for creating and maintaining the Open Images V7 dataset. For a deep dive into the dataset and its offerings, navigate to the [official Open Images V7 website](https://storage.googleapis.com/openimages/web/index.html).

yolov10/docs/en/datasets/detect/roboflow-100.md

@@ -1,80 +0,0 @@
----
-comments: true
-description: Get to know Roboflow 100, a comprehensive object detection benchmark that brings together 100 datasets from different domains.
-keywords: Ultralytics, YOLOv8, YOLO models, Roboflow 100, object detection, benchmark, computer vision, datasets, deep learning models
----
-
-# Roboflow 100 Dataset
-
-Roboflow 100, developed by [Roboflow](https://roboflow.com/?ref=ultralytics) and sponsored by Intel, is a groundbreaking [object detection](../../tasks/detect.md) benchmark. It includes 100 diverse datasets sampled from over 90,000 public datasets. This benchmark is designed to test the adaptability of models to various domains, including healthcare, aerial imagery, and video games.
-
-<p align="center">
-  <img width="640" src="https://user-images.githubusercontent.com/15908060/202452898-9ca6b8f7-4805-4e8e-949a-6e080d7b94d2.jpg" alt="Roboflow 100 Overview">
-</p>
-
-## Key Features
-
-- Includes 100 datasets across seven domains: Aerial, Video games, Microscopic, Underwater, Documents, Electromagnetic, and Real World.
-- The benchmark comprises 224,714 images across 805 classes, thanks to over 11,170 hours of labeling efforts.
-- All images are resized to 640x640 pixels, with a focus on eliminating class ambiguity and filtering out underrepresented classes.
-- Annotations include bounding boxes for objects, making it suitable for [training](../../modes/train.md) and evaluating object detection models.
-
-## Dataset Structure
-
-The Roboflow 100 dataset is organized into seven categories, each with a distinct set of datasets, images, and classes:
-
-- **Aerial**: Consists of 7 datasets with a total of 9,683 images, covering 24 distinct classes.
-- **Video Games**: Includes 7 datasets, featuring 11,579 images across 88 classes.
-- **Microscopic**: Comprises 11 datasets with 13,378 images, spanning 28 classes.
-- **Underwater**: Contains 5 datasets, encompassing 18,003 images in 39 classes.
-- **Documents**: Consists of 8 datasets with 24,813 images, divided into 90 classes.
-- **Electromagnetic**: Made up of 12 datasets, totaling 36,381 images in 41 classes.
-- **Real World**: The largest category with 50 datasets, offering 110,615 images across 495 classes.
-
-This structure enables a diverse and extensive testing ground for object detection models, reflecting real-world application scenarios.
-
-## Applications
-
-Roboflow 100 is invaluable for various applications related to computer vision and deep learning. Researchers and engineers can use this benchmark to:
-
-- Evaluate the performance of object detection models in a multi-domain context.
-- Test the adaptability of models to real-world scenarios beyond common object recognition.
-- Benchmark the capabilities of object detection models across diverse datasets, including those in healthcare, aerial imagery, and video games.
-
-For more ideas and inspiration on real-world applications, be sure to check out [our guides on real-world projects](../../guides/index.md).
-
-## Usage
-
-The Roboflow 100 dataset is available on both [GitHub](https://github.com/roboflow/roboflow-100-benchmark) and [Roboflow Universe](https://universe.roboflow.com/roboflow-100).
-
-You can access it directly from the Roboflow 100 GitHub repository. In addition, on Roboflow Universe, you have the flexibility to download individual datasets by simply clicking the export button within each dataset.
-
-## Sample Data and Annotations
-
-Roboflow 100 consists of datasets with diverse images and videos captured from various angles and domains. Here’s a look at examples of annotated images in the RF100 benchmark.
-
-<p align="center">
-  <img width="640" src="https://blog.roboflow.com/content/images/2022/11/image-2.png" alt="Sample Data and Annotations">
-</p>
-
-The diversity in the Roboflow 100 benchmark that can be seen above is a significant advancement from traditional benchmarks which often focus on optimizing a single metric within a limited domain.
-
-## Citations and Acknowledgments
-
-If you use the Roboflow 100 dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @misc{2211.13523,
-            Author = {Floriana Ciaglia and Francesco Saverio Zuppichini and Paul Guerrie and Mark McQuade and Jacob Solawetz},
-            Title = {Roboflow 100: A Rich, Multi-Domain Object Detection Benchmark},
-            Eprint = {arXiv:2211.13523},
-        }
-        ```
-
-Our thanks go to the Roboflow team and all the contributors for their hard work in creating and sustaining the Roboflow 100 dataset.
-
-If you are interested in exploring more datasets to enhance your object detection and machine learning projects, feel free to visit [our comprehensive dataset collection](../index.md).

yolov10/docs/en/datasets/detect/sku-110k.md

@@ -1,93 +0,0 @@
----
-comments: true
-description: Explore the SKU-110k dataset of densely packed retail shelf images for object detection research. Learn how to use it with Ultralytics.
-keywords: SKU-110k dataset, object detection, retail shelf images, Ultralytics, YOLO, computer vision, deep learning models
----
-
-# SKU-110k Dataset
-
-The [SKU-110k](https://github.com/eg4000/SKU110K_CVPR19) dataset is a collection of densely packed retail shelf images, designed to support research in object detection tasks. Developed by Eran Goldman et al., the dataset contains over 110,000 unique store keeping unit (SKU) categories with densely packed objects, often looking similar or even identical, positioned in close proximity.
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/277141199-e7cdd803-237e-4b4a-9171-f95cba9388f9.jpg)
-
-## Key Features
-
-- SKU-110k contains images of store shelves from around the world, featuring densely packed objects that pose challenges for state-of-the-art object detectors.
-- The dataset includes over 110,000 unique SKU categories, providing a diverse range of object appearances.
-- Annotations include bounding boxes for objects and SKU category labels.
-
-## Dataset Structure
-
-The SKU-110k dataset is organized into three main subsets:
-
-1. **Training set**: This subset contains images and annotations used for training object detection models.
-2. **Validation set**: This subset consists of images and annotations used for model validation during training.
-3. **Test set**: This subset is designed for the final evaluation of trained object detection models.
-
-## Applications
-
-The SKU-110k dataset is widely used for training and evaluating deep learning models in object detection tasks, especially in densely packed scenes such as retail shelf displays. The dataset's diverse set of SKU categories and densely packed object arrangements make it a valuable resource for researchers and practitioners in the field of computer vision.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the SKU-110K dataset, the `SKU-110K.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/SKU-110K.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/SKU-110K.yaml).
-
-!!! Example "ultralytics/cfg/datasets/SKU-110K.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/SKU-110K.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the SKU-110K dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='SKU-110K.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=SKU-110K.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-The SKU-110k dataset contains a diverse set of retail shelf images with densely packed objects, providing rich context for object detection tasks. Here are some examples of data from the dataset, along with their corresponding annotations:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/277141197-b63e4aa5-12f6-4673-96a7-9a5207363c59.jpg)
-
-- **Densely packed retail shelf image**: This image demonstrates an example of densely packed objects in a retail shelf setting. Objects are annotated with bounding boxes and SKU category labels.
-
-The example showcases the variety and complexity of the data in the SKU-110k dataset and highlights the importance of high-quality data for object detection tasks.
-
-## Citations and Acknowledgments
-
-If you use the SKU-110k dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @inproceedings{goldman2019dense,
-         author    = {Eran Goldman and Roei Herzig and Aviv Eisenschtat and Jacob Goldberger and Tal Hassner},
-         title     = {Precise Detection in Densely Packed Scenes},
-         booktitle = {Proc. Conf. Comput. Vision Pattern Recognition (CVPR)},
-         year      = {2019}
-        }
-        ```
-
-We would like to acknowledge Eran Goldman et al. for creating and maintaining the SKU-110k dataset as a valuable resource for the computer vision research community. For more information about the SKU-110k dataset and its creators, visit the [SKU-110k dataset GitHub repository](https://github.com/eg4000/SKU110K_CVPR19).

yolov10/docs/en/datasets/detect/visdrone.md

@@ -1,92 +0,0 @@
----
-comments: true
-description: Explore the VisDrone Dataset, a large-scale benchmark for drone-based image analysis, and learn how to train a YOLO model using it.
-keywords: VisDrone Dataset, Ultralytics, drone-based image analysis, YOLO model, object detection, object tracking, crowd counting
----
-
-# VisDrone Dataset
-
-The [VisDrone Dataset](https://github.com/VisDrone/VisDrone-Dataset) is a large-scale benchmark created by the AISKYEYE team at the Lab of Machine Learning and Data Mining, Tianjin University, China. It contains carefully annotated ground truth data for various computer vision tasks related to drone-based image and video analysis.
-
-VisDrone is composed of 288 video clips with 261,908 frames and 10,209 static images, captured by various drone-mounted cameras. The dataset covers a wide range of aspects, including location (14 different cities across China), environment (urban and rural), objects (pedestrians, vehicles, bicycles, etc.), and density (sparse and crowded scenes). The dataset was collected using various drone platforms under different scenarios and weather and lighting conditions. These frames are manually annotated with over 2.6 million bounding boxes of targets such as pedestrians, cars, bicycles, and tricycles. Attributes like scene visibility, object class, and occlusion are also provided for better data utilization.
-
-## Dataset Structure
-
-The VisDrone dataset is organized into five main subsets, each focusing on a specific task:
-
-1. **Task 1**: Object detection in images
-2. **Task 2**: Object detection in videos
-3. **Task 3**: Single-object tracking
-4. **Task 4**: Multi-object tracking
-5. **Task 5**: Crowd counting
-
-## Applications
-
-The VisDrone dataset is widely used for training and evaluating deep learning models in drone-based computer vision tasks such as object detection, object tracking, and crowd counting. The dataset's diverse set of sensor data, object annotations, and attributes make it a valuable resource for researchers and practitioners in the field of drone-based computer vision.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the Visdrone dataset, the `VisDrone.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VisDrone.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VisDrone.yaml).
-
-!!! Example "ultralytics/cfg/datasets/VisDrone.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/VisDrone.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the VisDrone dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='VisDrone.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=VisDrone.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-The VisDrone dataset contains a diverse set of images and videos captured by drone-mounted cameras. Here are some examples of data from the dataset, along with their corresponding annotations:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/238217600-df0b7334-4c9e-4c77-81a5-c70cd33429cc.jpg)
-
-- **Task 1**: Object detection in images - This image demonstrates an example of object detection in images, where objects are annotated with bounding boxes. The dataset provides a wide variety of images taken from different locations, environments, and densities to facilitate the development of models for this task.
-
-The example showcases the variety and complexity of the data in the VisDrone dataset and highlights the importance of high-quality sensor data for drone-based computer vision tasks.
-
-## Citations and Acknowledgments
-
-If you use the VisDrone dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @ARTICLE{9573394,
-          author={Zhu, Pengfei and Wen, Longyin and Du, Dawei and Bian, Xiao and Fan, Heng and Hu, Qinghua and Ling, Haibin},
-          journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
-          title={Detection and Tracking Meet Drones Challenge},
-          year={2021},
-          volume={},
-          number={},
-          pages={1-1},
-          doi={10.1109/TPAMI.2021.3119563}}
-        ```
-
-We would like to acknowledge the AISKYEYE team at the Lab of Machine Learning and Data Mining, Tianjin University, China, for creating and maintaining the VisDrone dataset as a valuable resource for the drone-based computer vision research community. For more information about the VisDrone dataset and its creators, visit the [VisDrone Dataset GitHub repository](https://github.com/VisDrone/VisDrone-Dataset).

yolov10/docs/en/datasets/detect/voc.md

@@ -1,94 +0,0 @@
----
-comments: true
-description: A complete guide to the PASCAL VOC dataset used for object detection, segmentation and classification tasks with relevance to YOLO model training.
-keywords: Ultralytics, PASCAL VOC dataset, object detection, segmentation, image classification, YOLO, model training, VOC.yaml, deep learning
----
-
-# VOC Dataset
-
-The [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) (Visual Object Classes) dataset is a well-known object detection, segmentation, and classification dataset. It is designed to encourage research on a wide variety of object categories and is commonly used for benchmarking computer vision models. It is an essential dataset for researchers and developers working on object detection, segmentation, and classification tasks.
-
-## Key Features
-
-- VOC dataset includes two main challenges: VOC2007 and VOC2012.
-- The dataset comprises 20 object categories, including common objects like cars, bicycles, and animals, as well as more specific categories such as boats, sofas, and dining tables.
-- Annotations include object bounding boxes and class labels for object detection and classification tasks, and segmentation masks for the segmentation tasks.
-- VOC provides standardized evaluation metrics like mean Average Precision (mAP) for object detection and classification, making it suitable for comparing model performance.
-
-## Dataset Structure
-
-The VOC dataset is split into three subsets:
-
-1. **Train**: This subset contains images for training object detection, segmentation, and classification models.
-2. **Validation**: This subset has images used for validation purposes during model training.
-3. **Test**: This subset consists of images used for testing and benchmarking the trained models. Ground truth annotations for this subset are not publicly available, and the results are submitted to the [PASCAL VOC evaluation server](http://host.robots.ox.ac.uk:8080/leaderboard/displaylb.php) for performance evaluation.
-
-## Applications
-
-The VOC dataset is widely used for training and evaluating deep learning models in object detection (such as YOLO, Faster R-CNN, and SSD), instance segmentation (such as Mask R-CNN), and image classification. The dataset's diverse set of object categories, large number of annotated images, and standardized evaluation metrics make it an essential resource for computer vision researchers and practitioners.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the VOC dataset, the `VOC.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml).
-
-!!! Example "ultralytics/cfg/datasets/VOC.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/VOC.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n model on the VOC dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='VOC.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=VOC.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Images and Annotations
-
-The VOC dataset contains a diverse set of images with various object categories and complex scenes. Here are some examples of images from the dataset, along with their corresponding annotations:
-
-![Dataset sample image](https://github.com/ultralytics/ultralytics/assets/26833433/7d4c18f4-774e-43f8-a5f3-9467cda7de4a)
-
-- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
-
-The example showcases the variety and complexity of the images in the VOC dataset and the benefits of using mosaicing during the training process.
-
-## Citations and Acknowledgments
-
-If you use the VOC dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @misc{everingham2010pascal,
-              title={The PASCAL Visual Object Classes (VOC) Challenge},
-              author={Mark Everingham and Luc Van Gool and Christopher K. I. Williams and John Winn and Andrew Zisserman},
-              year={2010},
-              eprint={0909.5206},
-              archivePrefix={arXiv},
-              primaryClass={cs.CV}
-        }
-        ```
-
-We would like to acknowledge the PASCAL VOC Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the VOC dataset and its creators, visit the [PASCAL VOC dataset website](http://host.robots.ox.ac.uk/pascal/VOC/).

yolov10/docs/en/datasets/detect/xview.md

@@ -1,97 +0,0 @@
----
-comments: true
-description: Explore xView, a large-scale, high resolution satellite imagery dataset for object detection. Dive into dataset structure, usage examples & its potential applications.
-keywords: Ultralytics, YOLO, computer vision, xView dataset, satellite imagery, object detection, overhead imagery, training, deep learning, dataset YAML
----
-
-# xView Dataset
-
-The [xView](http://xviewdataset.org/) dataset is one of the largest publicly available datasets of overhead imagery, containing images from complex scenes around the world annotated using bounding boxes. The goal of the xView dataset is to accelerate progress in four computer vision frontiers:
-
-1. Reduce minimum resolution for detection.
-2. Improve learning efficiency.
-3. Enable discovery of more object classes.
-4. Improve detection of fine-grained classes.
-
-xView builds on the success of challenges like Common Objects in Context (COCO) and aims to leverage computer vision to analyze the growing amount of available imagery from space in order to understand the visual world in new ways and address a range of important applications.
-
-## Key Features
-
-- xView contains over 1 million object instances across 60 classes.
-- The dataset has a resolution of 0.3 meters, providing higher resolution imagery than most public satellite imagery datasets.
-- xView features a diverse collection of small, rare, fine-grained, and multi-type objects with bounding box annotation.
-- Comes with a pre-trained baseline model using the TensorFlow object detection API and an example for PyTorch.
-
-## Dataset Structure
-
-The xView dataset is composed of satellite images collected from WorldView-3 satellites at a 0.3m ground sample distance. It contains over 1 million objects across 60 classes in over 1,400 km² of imagery.
-
-## Applications
-
-The xView dataset is widely used for training and evaluating deep learning models for object detection in overhead imagery. The dataset's diverse set of object classes and high-resolution imagery make it a valuable resource for researchers and practitioners in the field of computer vision, especially for satellite imagery analysis.
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the xView dataset, the `xView.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/xView.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/xView.yaml).
-
-!!! Example "ultralytics/cfg/datasets/xView.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/xView.yaml"
-    ```
-
-## Usage
-
-To train a model on the xView dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='xView.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo detect train data=xView.yaml model=yolov8n.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-The xView dataset contains high-resolution satellite images with a diverse set of objects annotated using bounding boxes. Here are some examples of data from the dataset, along with their corresponding annotations:
-
-![Dataset sample image](https://user-images.githubusercontent.com/26833433/277141257-ae6ba4de-5dcb-4c76-bc05-bc1e386361ba.jpg)
-
-- **Overhead Imagery**: This image demonstrates an example of object detection in overhead imagery, where objects are annotated with bounding boxes. The dataset provides high-resolution satellite images to facilitate the development of models for this task.
-
-The example showcases the variety and complexity of the data in the xView dataset and highlights the importance of high-quality satellite imagery for object detection tasks.
-
-## Citations and Acknowledgments
-
-If you use the xView dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @misc{lam2018xview,
-              title={xView: Objects in Context in Overhead Imagery},
-              author={Darius Lam and Richard Kuzma and Kevin McGee and Samuel Dooley and Michael Laielli and Matthew Klaric and Yaroslav Bulatov and Brendan McCord},
-              year={2018},
-              eprint={1802.07856},
-              archivePrefix={arXiv},
-              primaryClass={cs.CV}
-        }
-        ```
-
-We would like to acknowledge the [Defense Innovation Unit](https://www.diu.mil/) (DIU) and the creators of the xView dataset for their valuable contribution to the computer vision research community. For more information about the xView dataset and its creators, visit the [xView dataset website](http://xviewdataset.org/).

yolov10/docs/en/datasets/explorer/api.md

@@ -1,337 +0,0 @@
----
-comments: true
-description: Explore and analyze CV datasets with Ultralytics Explorer API, offering SQL, vector similarity, and semantic searches for efficient dataset insights.
-keywords: Ultralytics Explorer API, Dataset Exploration, SQL Queries, Vector Similarity Search, Semantic Search, Embeddings Table, Image Similarity, Python API for Datasets, CV Dataset Analysis, LanceDB Integration
----
-
-# Ultralytics Explorer API
-
-## Introduction
-
-<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/docs/en/datasets/explorer/explorer.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
-The Explorer API is a Python API for exploring your datasets. It supports filtering and searching your dataset using SQL queries, vector similarity search and semantic search.
-
-<p align="center">
-  <br>
-  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/3VryynorQeo?start=279"
-    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> Ultralytics Explorer API Overview
-</p>
-
-## Installation
-
-Explorer depends on external libraries for some of its functionality. These are automatically installed on usage. To manually install these dependencies, use the following command:
-
-```bash
-pip install ultralytics[explorer]
-```
-
-## Usage
-
-```python
-from ultralytics import Explorer
-
-# Create an Explorer object
-explorer = Explorer(data='coco128.yaml', model='yolov8n.pt')
-
-# Create embeddings for your dataset
-explorer.create_embeddings_table()
-
-# Search for similar images to a given image/images
-dataframe = explorer.get_similar(img='path/to/image.jpg')
-
-# Or search for similar images to a given index/indices
-dataframe = explorer.get_similar(idx=0)
-```
-
-!!! Tip "Note"
-
-    Embeddings table for a given dataset and model pair is only created once and reused. These use [LanceDB](https://lancedb.github.io/lancedb/) under the hood, which scales on-disk, so you can create and reuse embeddings for large datasets like COCO without running out of memory.
-
-In case you want to force update the embeddings table, you can pass `force=True` to `create_embeddings_table` method.
-You can directly access the LanceDB table object to perform advanced analysis. Learn more about it in [Working with table section](#4-advanced---working-with-embeddings-table)
-
-## 1. Similarity Search
-
-Similarity search is a technique for finding similar images to a given image. It is based on the idea that similar images will have similar embeddings. Once the embeddings table is built, you can get run semantic search in any of the following ways:
-
-- On a given index or list of indices in the dataset: `exp.get_similar(idx=[1,10], limit=10)`
-- On any image or list of images not in the dataset: `exp.get_similar(img=["path/to/img1", "path/to/img2"], limit=10)`
-
-In case of multiple inputs, the aggregate of their embeddings is used.
-
-You get a pandas dataframe with the `limit` number of most similar data points to the input, along with their distance in the embedding space. You can use this dataset to perform further filtering
-
-!!! Example "Semantic Search"
-
-    === "Using Images"
-
-        ```python
-        from ultralytics import Explorer
-
-        # create an Explorer object
-        exp = Explorer(data='coco128.yaml', model='yolov8n.pt')
-        exp.create_embeddings_table()
-
-        similar = exp.get_similar(img='https://ultralytics.com/images/bus.jpg', limit=10)
-        print(similar.head())
-
-        # Search using multiple indices
-        similar = exp.get_similar(
-                                img=['https://ultralytics.com/images/bus.jpg',
-                                     'https://ultralytics.com/images/bus.jpg'],
-                                limit=10
-                                )
-        print(similar.head())
-        ```
-
-    === "Using Dataset Indices"
-
-        ```python
-        from ultralytics import Explorer
-
-        # create an Explorer object
-        exp = Explorer(data='coco128.yaml', model='yolov8n.pt')
-        exp.create_embeddings_table()
-
-        similar = exp.get_similar(idx=1, limit=10)
-        print(similar.head())
-
-        # Search using multiple indices
-        similar = exp.get_similar(idx=[1,10], limit=10)
-        print(similar.head())
-        ```
-
-### Plotting Similar Images
-
-You can also plot the similar images using the `plot_similar` method. This method takes the same arguments as `get_similar` and plots the similar images in a grid.
-
-!!! Example "Plotting Similar Images"
-
-    === "Using Images"
-
-        ```python
-        from ultralytics import Explorer
-
-        # create an Explorer object
-        exp = Explorer(data='coco128.yaml', model='yolov8n.pt')
-        exp.create_embeddings_table()
-
-        plt = exp.plot_similar(img='https://ultralytics.com/images/bus.jpg', limit=10)
-        plt.show()
-        ```
-
-    === "Using Dataset Indices"
-
-        ```python
-        from ultralytics import Explorer
-
-        # create an Explorer object
-        exp = Explorer(data='coco128.yaml', model='yolov8n.pt')
-        exp.create_embeddings_table()
-
-        plt = exp.plot_similar(idx=1, limit=10)
-        plt.show()
-        ```
-
-## 2. Ask AI (Natural Language Querying)
-
-This allows you to write how you want to filter your dataset using natural language. You don't have to be proficient in writing SQL queries. Our AI powered query generator will automatically do that under the hood. For example - you can say - "show me 100 images with exactly one person and 2 dogs. There can be other objects too" and it'll internally generate the query and show you those results.
-Note: This works using LLMs under the hood so the results are probabilistic and might get things wrong sometimes
-
-!!! Example "Ask AI"
-
-    ```python
-    from ultralytics import Explorer
-    from ultralytics.data.explorer import plot_query_result
-
-
-    # create an Explorer object
-    exp = Explorer(data='coco128.yaml', model='yolov8n.pt')
-    exp.create_embeddings_table()
-
-    df = exp.ask_ai("show me 100 images with exactly one person and 2 dogs. There can be other objects too")
-    print(df.head())
-
-    # plot the results
-    plt = plot_query_result(df)
-    plt.show()
-    ```
-
-## 3. SQL Querying
-
-You can run SQL queries on your dataset using the `sql_query` method. This method takes a SQL query as input and returns a pandas dataframe with the results.
-
-!!! Example "SQL Query"
-
-    ```python
-    from ultralytics import Explorer
-
-    # create an Explorer object
-    exp = Explorer(data='coco128.yaml', model='yolov8n.pt')
-    exp.create_embeddings_table()
-
-    df = exp.sql_query("WHERE labels LIKE '%person%' AND labels LIKE '%dog%'")
-    print(df.head())
-    ```
-
-### Plotting SQL Query Results
-
-You can also plot the results of a SQL query using the `plot_sql_query` method. This method takes the same arguments as `sql_query` and plots the results in a grid.
-
-!!! Example "Plotting SQL Query Results"
-
-    ```python
-    from ultralytics import Explorer
-
-    # create an Explorer object
-    exp = Explorer(data='coco128.yaml', model='yolov8n.pt')
-    exp.create_embeddings_table()
-
-    # plot the SQL Query
-    exp.plot_sql_query("WHERE labels LIKE '%person%' AND labels LIKE '%dog%' LIMIT 10")
-    ```
-
-## 4. Advanced - Working with Embeddings Table
-
-You can also work with the embeddings table directly. Once the embeddings table is created, you can access it using the `Explorer.table`
-
-!!! Tip "Explorer works on [LanceDB](https://lancedb.github.io/lancedb/) tables internally. You can access this table directly, using `Explorer.table` object and run raw queries, push down pre- and post-filters, etc."
-
-    ```python
-    from ultralytics import Explorer
-
-    exp = Explorer()
-    exp.create_embeddings_table()
-    table = exp.table
-    ```
-
-Here are some examples of what you can do with the table:
-
-### Get raw Embeddings
-
-!!! Example
-
-    ```python
-    from ultralytics import Explorer
-
-    exp = Explorer()
-    exp.create_embeddings_table()
-    table = exp.table
-
-    embeddings = table.to_pandas()["vector"]
-    print(embeddings)
-    ```
-
-### Advanced Querying with pre- and post-filters
-
-!!! Example
-
-    ```python
-    from ultralytics import Explorer
-
-    exp = Explorer(model="yolov8n.pt")
-    exp.create_embeddings_table()
-    table = exp.table
-
-    # Dummy embedding
-    embedding = [i for i in range(256)]
-    rs = table.search(embedding).metric("cosine").where("").limit(10)
-    ```
-
-### Create Vector Index
-
-When using large datasets, you can also create a dedicated vector index for faster querying. This is done using the `create_index` method on LanceDB table.
-
-```python
-table.create_index(num_partitions=..., num_sub_vectors=...)
-```
-
-Find more details on the type vector indices available and parameters [here](https://lancedb.github.io/lancedb/ann_indexes/#types-of-index) In the future, we will add support for creating vector indices directly from Explorer API.
-
-## 5. Embeddings Applications
-
-You can use the embeddings table to perform a variety of exploratory analysis. Here are some examples:
-
-### Similarity Index
-
-Explorer comes with a `similarity_index` operation:
-
-- It tries to estimate how similar each data point is with the rest of the dataset.
-- It does that by counting how many image embeddings lie closer than `max_dist` to the current image in the generated embedding space, considering `top_k` similar images at a time.
-
-It returns a pandas dataframe with the following columns:
-
-- `idx`: Index of the image in the dataset
-- `im_file`: Path to the image file
-- `count`: Number of images in the dataset that are closer than `max_dist` to the current image
-- `sim_im_files`: List of paths to the `count` similar images
-
-!!! Tip
-
-    For a given dataset, model, `max_dist` & `top_k` the similarity index once generated will be reused. In case, your dataset has changed, or you simply need to regenerate the similarity index, you can pass `force=True`.
-
-!!! Example "Similarity Index"
-
-    ```python
-    from ultralytics import Explorer
-
-    exp = Explorer()
-    exp.create_embeddings_table()
-
-    sim_idx = exp.similarity_index()
-    ```
-
-You can use similarity index to build custom conditions to filter out the dataset. For example, you can filter out images that are not similar to any other image in the dataset using the following code:
-
-```python
-import numpy as np
-
-sim_count = np.array(sim_idx["count"])
-sim_idx['im_file'][sim_count > 30]
-```
-
-### Visualize Embedding Space
-
-You can also visualize the embedding space using the plotting tool of your choice. For example here is a simple example using matplotlib:
-
-```python
-import numpy as np
-from sklearn.decomposition import PCA
-import matplotlib.pyplot as plt
-from mpl_toolkits.mplot3d import Axes3D
-
-# Reduce dimensions using PCA to 3 components for visualization in 3D
-pca = PCA(n_components=3)
-reduced_data = pca.fit_transform(embeddings)
-
-# Create a 3D scatter plot using Matplotlib Axes3D
-fig = plt.figure(figsize=(8, 6))
-ax = fig.add_subplot(111, projection='3d')
-
-# Scatter plot
-ax.scatter(reduced_data[:, 0], reduced_data[:, 1], reduced_data[:, 2], alpha=0.5)
-ax.set_title('3D Scatter Plot of Reduced 256-Dimensional Data (PCA)')
-ax.set_xlabel('Component 1')
-ax.set_ylabel('Component 2')
-ax.set_zlabel('Component 3')
-
-plt.show()
-```
-
-Start creating your own CV dataset exploration reports using the Explorer API. For inspiration, check out the
-
-## Apps Built Using Ultralytics Explorer
-
-Try our GUI Demo based on Explorer API
-
-## Coming Soon
-
-- [ ] Merge specific labels from datasets. Example - Import all `person` labels from COCO and `car` labels from Cityscapes
-- [ ] Remove images that have a higher similarity index than the given threshold
-- [ ] Automatically persist new datasets after merging/removing entries
-- [ ] Advanced Dataset Visualizations

yolov10/docs/en/datasets/explorer/dashboard.md

@@ -1,73 +0,0 @@
----
-comments: true
-description: Learn about Ultralytics Explorer GUI for semantic search, SQL queries, and AI-powered natural language search in CV datasets.
-keywords: Ultralytics, Explorer GUI, semantic search, vector similarity search, AI queries, SQL queries, computer vision, dataset exploration, image search, OpenAI integration
----
-
-# Explorer GUI
-
-Explorer GUI is like a playground build using [Ultralytics Explorer API](api.md). It allows you to run semantic/vector similarity search, SQL queries and even search using natural language using our ask AI feature powered by LLMs.
-
-<p>
-    <img width="1709" alt="Explorer Dashboard Screenshot 1" src="https://github.com/ultralytics/ultralytics/assets/15766192/feb1fe05-58c5-4173-a9ff-e611e3bba3d0">
-</p>
-
-<p align="center">
-  <br>
-  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/3VryynorQeo?start=306"
-    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> Ultralytics Explorer Dashboard Overview
-</p>
-
-### Installation
-
-```bash
-pip install ultralytics[explorer]
-```
-
-!!! note "Note"
-
-    Ask AI feature works using OpenAI, so you'll be prompted to set the api key for OpenAI when you first run the GUI.
-    You can set it like this - `yolo settings openai_api_key="..."`
-
-## Semantic Search / Vector Similarity Search
-
-Semantic search is a technique for finding similar images to a given image. It is based on the idea that similar images will have similar embeddings. In the UI, you can select one of more images and search for the images similar to them. This can be useful when you want to find images similar to a given image or a set of images that don't perform as expected.
-
-For example:
-In this VOC Exploration dashboard, user selects a couple airplane images like this:
-<p>
-<img width="1710" alt="Explorer Dashboard Screenshot 2" src="https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/3becdc1d-45dc-43b7-88ff-84ff0b443894">
-</p>
-
-On performing similarity search, you should see a similar result:
-<p>
-<img width="1710" alt="Explorer Dashboard Screenshot 3" src="https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/aeea2e16-bc2b-41bb-9aef-4a33bfa1a800">
-</p>
-
-## Ask AI
-
-This allows you to write how you want to filter your dataset using natural language. You don't have to be proficient in writing SQL queries. Our AI powered query generator will automatically do that under the hood. For example - you can say - "show me 100 images with exactly one person and 2 dogs. There can be other objects too" and it'll internally generate the query and show you those results. Here's an example output when asked to "Show 10 images with exactly 5 persons" and you'll see a result like this:
-<p>
-<img width="1709" alt="Explorer Dashboard Screenshot 4" src="https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/55a67181-3b25-4d2f-b786-2a6a08a0cb6b">
-</p>
-
-Note: This works using LLMs under the hood so the results are probabilistic and might get things wrong sometimes
-
-## Run SQL queries on your CV datasets
-
-You can run SQL queries on your dataset to filter it. It also works if you only provide the WHERE clause. Example SQL query would show only the images that have at least one 1 person and 1 dog in them:
-
-```sql
-WHERE labels LIKE '%person%' AND labels LIKE '%dog%'
-```
-
-<p>
-<img width="1707" alt="Explorer Dashboard Screenshot 5" src="https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/14fbb237-0b2d-4b7c-8f62-2fca4e6cc26f">
-</p>
-
-This is a Demo build using the Explorer API. You can use the API to build your own exploratory notebooks or scripts to get insights into your datasets. Learn more about the Explorer API [here](api.md).

yolov10/docs/en/datasets/explorer/explorer.ipynb

@@ -1,601 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "id": "aa923c26-81c8-4565-9277-1cb686e3702e",
-      "metadata": {
-        "id": "aa923c26-81c8-4565-9277-1cb686e3702e"
-      },
-      "source": [
-        "# VOC Exploration Example\n",
-        "<div align=\"center\">\n",
-        "\n",
-        "  <a href=\"https://ultralytics.com/yolov8\" target=\"_blank\">\n",
-        "    <img width=\"1024\", src=\"https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png\"></a>\n",
-        "\n",
-        "  [中文](https://docs.ultralytics.com/zh/) | [한국어](https://docs.ultralytics.com/ko/) | [日本語](https://docs.ultralytics.com/ja/) | [Русский](https://docs.ultralytics.com/ru/) | [Deutsch](https://docs.ultralytics.com/de/) | [Français](https://docs.ultralytics.com/fr/) | [Español](https://docs.ultralytics.com/es/) | [Português](https://docs.ultralytics.com/pt/) | [हिन्दी](https://docs.ultralytics.com/hi/) | [العربية](https://docs.ultralytics.com/ar/)\n",
-        "\n",
-        "  <a href=\"https://console.paperspace.com/github/ultralytics/ultralytics\"><img src=\"https://assets.paperspace.io/img/gradient-badge.svg\" alt=\"Run on Gradient\"/></a>\n",
-        "  <a href=\"https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"></a>\n",
-        "  <a href=\"https://www.kaggle.com/ultralytics/yolov8\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" alt=\"Open In Kaggle\"></a>\n",
-        "\n",
-        "Welcome to the Ultralytics Explorer API notebook!  This notebook serves as the starting point for exploring the various resources available to help you get started with using Ultralytics to explore your datasets using with the power of semantic search. You can utilities out of the box that allow you to examine specific types of labels using vector search or even SQL queries.\n",
-        "\n",
-        "We hope that the resources in this notebook will help you get the most out of Ultralytics. Please browse the Explorer <a href=\"https://docs.ultralytics.com/\">Docs</a> for details, raise an issue on <a href=\"https://github.com/ultralytics/ultralytics\">GitHub</a> for support, and join our <a href=\"https://ultralytics.com/discord\">Discord</a> community for questions and discussions!\n",
-        "\n",
-        "Try `yolo explorer` powered by Exlorer API\n",
-        "\n",
-        "Simply `pip install ultralytics` and run `yolo explorer` in your terminal to run custom queries and semantic search on your datasets right inside your browser!\n",
-        "\n",
-        "</div>"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "2454d9ba-9db4-4b37-98e8-201ba285c92f",
-      "metadata": {
-        "id": "2454d9ba-9db4-4b37-98e8-201ba285c92f"
-      },
-      "source": [
-        "## Setup\n",
-        "Pip install `ultralytics` and [dependencies](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) and check software and hardware."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "433f3a4d-a914-42cb-b0b6-be84a84e5e41",
-      "metadata": {
-        "id": "433f3a4d-a914-42cb-b0b6-be84a84e5e41"
-      },
-      "outputs": [],
-      "source": [
-        "%pip install ultralytics[explorer] openai\n",
-        "import ultralytics\n",
-        "ultralytics.checks()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "ae602549-3419-4909-9f82-35cba515483f",
-      "metadata": {
-        "id": "ae602549-3419-4909-9f82-35cba515483f"
-      },
-      "outputs": [],
-      "source": [
-        "from ultralytics import Explorer"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "d8c06350-be8e-45cf-b3a6-b5017bbd943c",
-      "metadata": {
-        "id": "d8c06350-be8e-45cf-b3a6-b5017bbd943c"
-      },
-      "source": [
-        "## Similarity search\n",
-        "Utilize the power of vector similarity search to find the similar data points in your dataset along with their distance in the embedding space. Simply create an embeddings table for the given dataset-model pair. It is only needed once and it is reused automatically.\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "334619da-6deb-4b32-9fe0-74e0a79cee20",
-      "metadata": {
-        "id": "334619da-6deb-4b32-9fe0-74e0a79cee20"
-      },
-      "outputs": [],
-      "source": [
-        "exp = Explorer(\"VOC.yaml\", model=\"yolov8n.pt\")\n",
-        "exp.create_embeddings_table()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "b6c5e42d-bc7e-4b4c-bde0-643072a2165d",
-      "metadata": {
-        "id": "b6c5e42d-bc7e-4b4c-bde0-643072a2165d"
-      },
-      "source": [
-        "One the embeddings table is built, you can get run semantic search in any of the following ways:\n",
-        "- On a given index / list of indices in the dataset like - `exp.get_similar(idx=[1,10], limit=10)`\n",
-        "- On any image/ list of images not in the dataset  - `exp.get_similar(img=[\"path/to/img1\", \"path/to/img2\"], limit=10)`\n",
-        "In case of multiple inputs, the aggregade of their embeddings is used.\n",
-        "\n",
-        "You get a pandas dataframe with the `limit` number of most similar data points to the input, along with their distance in the embedding space. You can use this dataset to perform further filtering\n",
-        "<img width=\"1120\" alt=\"Screenshot 2024-01-06 at 9 45 42 PM\" src=\"https://github.com/AyushExel/assets/assets/15766192/7742ac57-e22a-4cea-a0f9-2b2a257483c5\">\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "b485f05b-d92d-42bc-8da7-5e361667b341",
-      "metadata": {
-        "id": "b485f05b-d92d-42bc-8da7-5e361667b341"
-      },
-      "outputs": [],
-      "source": [
-        "similar = exp.get_similar(idx=1, limit=10)\n",
-        "similar.head()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "acf4b489-2161-4176-a1fe-d1d067d8083d",
-      "metadata": {
-        "id": "acf4b489-2161-4176-a1fe-d1d067d8083d"
-      },
-      "source": [
-        "You can use the also plot the similar samples directly using the `plot_similar` util\n",
-        "<p>\n",
-        "\n",
-        " <img src=\"https://github.com/AyushExel/assets/assets/15766192/a3c9247b-9271-47df-aaa5-36d96c5034b1\" />\n",
-        "</p>\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "9dbfe7d0-8613-4529-adb6-6e0632d7cce7",
-      "metadata": {
-        "id": "9dbfe7d0-8613-4529-adb6-6e0632d7cce7"
-      },
-      "outputs": [],
-      "source": [
-        "exp.plot_similar(idx=6500, limit=20)\n",
-        "#exp.plot_similar(idx=[100,101], limit=10) # Can also pass list of idxs or imgs\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "260e09bf-4960-4089-a676-cb0e76ff3c0d",
-      "metadata": {
-        "id": "260e09bf-4960-4089-a676-cb0e76ff3c0d"
-      },
-      "outputs": [],
-      "source": [
-        "exp.plot_similar(img=\"https://ultralytics.com/images/bus.jpg\", limit=10, labels=False) # Can also pass any external images\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "faa0b7a7-6318-40e4-b0f4-45a8113bdc3a",
-      "metadata": {
-        "id": "faa0b7a7-6318-40e4-b0f4-45a8113bdc3a"
-      },
-      "source": [
-        "<p>\n",
-        "<img  src=\"https://github.com/AyushExel/assets/assets/15766192/8e011195-b0da-43ef-b3cd-5fb6f383037e\">\n",
-        "\n",
-        "</p>"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "0cea63f1-71f1-46da-af2b-b1b7d8f73553",
-      "metadata": {
-        "id": "0cea63f1-71f1-46da-af2b-b1b7d8f73553"
-      },
-      "source": [
-        "## 2. Ask AI: Search or filter with Natural Language\n",
-        "You can prompt the Explorer object with the kind of data points you want to see and it'll try to return a dataframe with those. Because it is powered by LLMs, it doesn't always get it right. In that case, it'll return None.\n",
-        "<p>\n",
-        "<img width=\"1131\" alt=\"Screenshot 2024-01-07 at 2 34 53 PM\" src=\"https://github.com/AyushExel/assets/assets/15766192/c4a69fd9-e54f-4d6a-aba5-dc9cfae1bc04\">\n",
-        "\n",
-        "</p>\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "92fb92ac-7f76-465a-a9ba-ea7492498d9c",
-      "metadata": {
-        "id": "92fb92ac-7f76-465a-a9ba-ea7492498d9c"
-      },
-      "outputs": [],
-      "source": [
-        "df = exp.ask_ai(\"show me images containing more than 10 objects with at least 2 persons\")\n",
-        "df.head(5)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "f2a7d26e-0ce5-4578-ad1a-b1253805280f",
-      "metadata": {
-        "id": "f2a7d26e-0ce5-4578-ad1a-b1253805280f"
-      },
-      "source": [
-        "for plotting these results you can use `plot_query_result` util\n",
-        "Example:\n",
-        "```\n",
-        "plt = plot_query_result(exp.ask_ai(\"show me 10 images containing exactly 2 persons\"))\n",
-        "Image.fromarray(plt)\n",
-        "```\n",
-        "<p>\n",
-        "    <img src=\"https://github.com/AyushExel/assets/assets/15766192/2cb780de-d05b-4412-a526-7f7f0f10e669\">\n",
-        "\n",
-        "</p>"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "b1cfab84-9835-4da0-8e9a-42b30cf84511",
-      "metadata": {
-        "id": "b1cfab84-9835-4da0-8e9a-42b30cf84511"
-      },
-      "outputs": [],
-      "source": [
-        "# plot\n",
-        "from ultralytics.data.explorer import plot_query_result\n",
-        "from PIL import Image\n",
-        "\n",
-        "plt = plot_query_result(exp.ask_ai(\"show me 10 images containing exactly 2 persons\"))\n",
-        "Image.fromarray(plt)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "35315ae6-d827-40e4-8813-279f97a83b34",
-      "metadata": {
-        "id": "35315ae6-d827-40e4-8813-279f97a83b34"
-      },
-      "source": [
-        "## 3. Run SQL queries on your Dataset!\n",
-        "Sometimes you might want to investigate a certain type of entries in your dataset. For this Explorer allows you to execute SQL queries.\n",
-        "It accepts either of the formats:\n",
-        "- Queries beginning with \"WHERE\" will automatically select all columns. This can be thought of as a short-hand query\n",
-        "- You can also write full queries where you can specify which columns to select\n",
-        "\n",
-        "This can be used to investigate model performance and specific data points. For example:\n",
-        "- let's say your model struggles on images that have humans and dogs. You can write a query like this to select the points that have at least 2 humans AND at least one dog.\n",
-        "\n",
-        "You can combine SQL query and semantic search to filter down to specific type of results\n",
-        "<img width=\"994\" alt=\"Screenshot 2024-01-06 at 9 47 30 PM\" src=\"https://github.com/AyushExel/assets/assets/15766192/92bc3178-c151-4cd5-8007-c76178deb113\">\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "8cd1072f-3100-4331-a0e3-4e2f6b1005bf",
-      "metadata": {
-        "id": "8cd1072f-3100-4331-a0e3-4e2f6b1005bf"
-      },
-      "outputs": [],
-      "source": [
-        "table = exp.sql_query(\"WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10\")\n",
-        "table"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "debf8a00-c9f6-448b-bd3b-454cf62f39ab",
-      "metadata": {
-        "id": "debf8a00-c9f6-448b-bd3b-454cf62f39ab"
-      },
-      "source": [
-        "Just like similarity search, you also get a util to directly plot the sql queries using `exp.plot_sql_query`\n",
-        "<img src=\"https://github.com/AyushExel/assets/assets/15766192/f8b66629-8dd0-419e-8f44-9837969ba678\">\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "18b977e7-d048-4b22-b8c4-084a03b04f23",
-      "metadata": {
-        "id": "18b977e7-d048-4b22-b8c4-084a03b04f23"
-      },
-      "outputs": [],
-      "source": [
-        "exp.plot_sql_query(\"WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10\", labels=True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "f26804c5-840b-4fd1-987f-e362f29e3e06",
-      "metadata": {
-        "id": "f26804c5-840b-4fd1-987f-e362f29e3e06"
-      },
-      "source": [
-        "## 3. Working with embeddings Table (Advanced)\n",
-        "Explorer works on [LanceDB](https://lancedb.github.io/lancedb/) tables internally. You can access this table directly, using `Explorer.table` object and run raw queries, push down pre and post filters, etc."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "ea69260a-3407-40c9-9f42-8b34a6e6af7a",
-      "metadata": {
-        "id": "ea69260a-3407-40c9-9f42-8b34a6e6af7a"
-      },
-      "outputs": [],
-      "source": [
-        "table = exp.table\n",
-        "table.schema"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "238db292-8610-40b3-9af7-dfd6be174892",
-      "metadata": {
-        "id": "238db292-8610-40b3-9af7-dfd6be174892"
-      },
-      "source": [
-        "### Run raw queries\n",
-        "Vector Search finds the nearest vectors from the database. In a recommendation system or search engine, you can find similar products from the one you searched. In LLM and other AI applications, each data point can be presented by the embeddings generated from some models, it returns the most relevant features.\n",
-        "\n",
-        "A search in high-dimensional vector space, is to find K-Nearest-Neighbors (KNN) of the query vector.\n",
-        "\n",
-        "Metric\n",
-        "In LanceDB, a Metric is the way to describe the distance between a pair of vectors. Currently, it supports the following metrics:\n",
-        "- L2\n",
-        "- Cosine\n",
-        "- Dot\n",
-        "Explorer's similarity search uses L2 by default. You can run queries on tables directly, or use the lance format to build custom utilities to manage datasets. More details on available LanceDB table ops in the [docs](https://lancedb.github.io/lancedb/)\n",
-        "\n",
-        "<img width=\"1015\" alt=\"Screenshot 2024-01-06 at 9 48 35 PM\" src=\"https://github.com/AyushExel/assets/assets/15766192/a2ccdaf3-8877-4f70-bf47-8a9bd2bb20c0\">\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "d74430fe-5aee-45a1-8863-3f2c31338792",
-      "metadata": {
-        "id": "d74430fe-5aee-45a1-8863-3f2c31338792"
-      },
-      "outputs": [],
-      "source": [
-        "dummy_img_embedding = [i for i in range(256)]\n",
-        "table.search(dummy_img_embedding).limit(5).to_pandas()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "587486b4-0d19-4214-b994-f032fb2e8eb5",
-      "metadata": {
-        "id": "587486b4-0d19-4214-b994-f032fb2e8eb5"
-      },
-      "source": [
-        "### Inter-conversion to popular data formats"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "bb2876ea-999b-4eba-96bc-c196ba02c41c",
-      "metadata": {
-        "id": "bb2876ea-999b-4eba-96bc-c196ba02c41c"
-      },
-      "outputs": [],
-      "source": [
-        "df = table.to_pandas()\n",
-        "pa_table = table.to_arrow()\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "42659d63-ad76-49d6-8dfc-78d77278db72",
-      "metadata": {
-        "id": "42659d63-ad76-49d6-8dfc-78d77278db72"
-      },
-      "source": [
-        "### Work with Embeddings\n",
-        "You can access the raw embedding from lancedb Table and analyse it. The image embeddings are stored in column `vector`"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "66d69e9b-046e-41c8-80d7-c0ee40be3bca",
-      "metadata": {
-        "id": "66d69e9b-046e-41c8-80d7-c0ee40be3bca"
-      },
-      "outputs": [],
-      "source": [
-        "import numpy as np\n",
-        "\n",
-        "embeddings = table.to_pandas()[\"vector\"].tolist()\n",
-        "embeddings = np.array(embeddings)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "e8df0a49-9596-4399-954b-b8ae1fd7a602",
-      "metadata": {
-        "id": "e8df0a49-9596-4399-954b-b8ae1fd7a602"
-      },
-      "source": [
-        "### Scatterplot\n",
-        "One of the preliminary steps in analysing embeddings is by plotting them in 2D space via dimensionality reduction. Let's try an example\n",
-        "\n",
-        "<img width=\"646\" alt=\"Screenshot 2024-01-06 at 9 48 58 PM\" src=\"https://github.com/AyushExel/assets/assets/15766192/9e1da25c-face-4426-abc0-2f64a4e4952c\">\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "d9a150e8-8092-41b3-82f8-2247f8187fc8",
-      "metadata": {
-        "id": "d9a150e8-8092-41b3-82f8-2247f8187fc8"
-      },
-      "outputs": [],
-      "source": [
-        "!pip install scikit-learn --q"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "196079c3-45a9-4325-81ab-af79a881e37a",
-      "metadata": {
-        "id": "196079c3-45a9-4325-81ab-af79a881e37a"
-      },
-      "outputs": [],
-      "source": [
-        "%matplotlib inline\n",
-        "import numpy as np\n",
-        "from sklearn.decomposition import PCA\n",
-        "import matplotlib.pyplot as plt\n",
-        "from mpl_toolkits.mplot3d import Axes3D\n",
-        "\n",
-        "# Reduce dimensions using PCA to 3 components for visualization in 3D\n",
-        "pca = PCA(n_components=3)\n",
-        "reduced_data = pca.fit_transform(embeddings)\n",
-        "\n",
-        "# Create a 3D scatter plot using Matplotlib's Axes3D\n",
-        "fig = plt.figure(figsize=(8, 6))\n",
-        "ax = fig.add_subplot(111, projection='3d')\n",
-        "\n",
-        "# Scatter plot\n",
-        "ax.scatter(reduced_data[:, 0], reduced_data[:, 1], reduced_data[:, 2], alpha=0.5)\n",
-        "ax.set_title('3D Scatter Plot of Reduced 256-Dimensional Data (PCA)')\n",
-        "ax.set_xlabel('Component 1')\n",
-        "ax.set_ylabel('Component 2')\n",
-        "ax.set_zlabel('Component 3')\n",
-        "\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "1c843c23-e3f2-490e-8d6c-212fa038a149",
-      "metadata": {
-        "id": "1c843c23-e3f2-490e-8d6c-212fa038a149"
-      },
-      "source": [
-        "## 4. Similarity Index\n",
-        "Here's a simple example of an operation powered by the embeddings table. Explorer comes with a `similarity_index` operation-\n",
-        "* It tries to estimate how similar each data point is with the rest of the dataset.\n",
-        "*  It does that by counting how many image embeddings lie closer than `max_dist` to the current image in the generated embedding space, considering `top_k` similar images at a time.\n",
-        "\n",
-        "For a given dataset, model, `max_dist` & `top_k` the similarity index once generated will be reused. In case, your dataset has changed, or you simply need to regenerate the similarity index, you can pass `force=True`.\n",
-        "Similar to vector and SQL search, this also comes with a util to directly plot it. Let's look at the plot first\n",
-        "<img width=\"633\" alt=\"Screenshot 2024-01-06 at 9 49 36 PM\" src=\"https://github.com/AyushExel/assets/assets/15766192/96a9d984-4a72-4784-ace1-428676ee2bdd\">\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "953c2a5f-1b61-4acf-a8e4-ed08547dbafc",
-      "metadata": {
-        "id": "953c2a5f-1b61-4acf-a8e4-ed08547dbafc"
-      },
-      "outputs": [],
-      "source": [
-        "exp.plot_similarity_index(max_dist=0.2, top_k=0.01)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "28228a9a-b727-45b5-8ca7-8db662c0b937",
-      "metadata": {
-        "id": "28228a9a-b727-45b5-8ca7-8db662c0b937"
-      },
-      "source": [
-        "Now let's look at the output of the operation"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "f4161aaa-20e6-4df0-8e87-d2293ee0530a",
-      "metadata": {
-        "id": "f4161aaa-20e6-4df0-8e87-d2293ee0530a"
-      },
-      "outputs": [],
-      "source": [
-        "import numpy as np\n",
-        "\n",
-        "sim_idx = exp.similarity_index(max_dist=0.2, top_k=0.01, force=False)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "b01d5b1a-9adb-4c3c-a873-217c71527c8d",
-      "metadata": {
-        "id": "b01d5b1a-9adb-4c3c-a873-217c71527c8d"
-      },
-      "outputs": [],
-      "source": [
-        "sim_idx"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "22b28e54-4fbb-400e-ad8c-7068cbba11c4",
-      "metadata": {
-        "id": "22b28e54-4fbb-400e-ad8c-7068cbba11c4"
-      },
-      "source": [
-        "Let's create a query to see what data points have similarity count of more than 30 and plot images similar to them."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "58d2557b-d401-43cf-937d-4f554c7bc808",
-      "metadata": {
-        "id": "58d2557b-d401-43cf-937d-4f554c7bc808"
-      },
-      "outputs": [],
-      "source": [
-        "import numpy as np\n",
-        "\n",
-        "sim_count = np.array(sim_idx[\"count\"])\n",
-        "sim_idx['im_file'][sim_count > 30]"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "a5ec8d76-271a-41ab-ac74-cf8c0084ba5e",
-      "metadata": {
-        "id": "a5ec8d76-271a-41ab-ac74-cf8c0084ba5e"
-      },
-      "source": [
-        "You should see something like this\n",
-        "<img src=\"https://github.com/AyushExel/assets/assets/15766192/649bc366-ca2d-46ea-bfd9-3097cf575584\">\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "3a7b2ee3-9f35-48a2-9c38-38379516f4d2",
-      "metadata": {
-        "id": "3a7b2ee3-9f35-48a2-9c38-38379516f4d2"
-      },
-      "outputs": [],
-      "source": [
-        "exp.plot_similar(idx=[7146, 14035]) # Using avg embeddings of 2 images"
-      ]
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "Python 3 (ipykernel)",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.9.6"
-    },
-    "colab": {
-      "provenance": []
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 5
-}

yolov10/docs/en/datasets/explorer/index.md

@@ -1,60 +0,0 @@
----
-comments: true
-description: Discover the Ultralytics Explorer, a versatile tool and Python API for CV dataset exploration, enabling semantic search, SQL queries, and vector similarity searches.
-keywords: Ultralytics Explorer, CV Dataset Tools, Semantic Search, SQL Dataset Queries, Vector Similarity, Python API, GUI Explorer, Dataset Analysis, YOLO Explorer, Data Insights
----
-
-# Ultralytics Explorer
-
-<p>
-    <img width="1709" alt="Ultralytics Explorer Screenshot 1" src="https://github.com/ultralytics/ultralytics/assets/15766192/feb1fe05-58c5-4173-a9ff-e611e3bba3d0">
-</p>
-
-<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/docs/en/datasets/explorer/explorer.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
-Ultralytics Explorer is a tool for exploring CV datasets using semantic search, SQL queries, vector similarity search and even using natural language. It is also a Python API for accessing the same functionality.
-
-<p align="center">
-  <br>
-  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/3VryynorQeo"
-    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> Ultralytics Explorer API | Semantic Search, SQL Queries & Ask AI Features
-</p>
-
-### Installation of optional dependencies
-
-Explorer depends on external libraries for some of its functionality. These are automatically installed on usage. To manually install these dependencies, use the following command:
-
-```bash
-pip install ultralytics[explorer]
-```
-
-!!! tip
-
-    Explorer works on embedding/semantic search & SQL querying and is powered by [LanceDB](https://lancedb.com/) serverless vector database. Unlike traditional in-memory DBs, it is persisted on disk without sacrificing performance, so you can scale locally to large datasets like COCO without running out of memory.
-
-### Explorer API
-
-This is a Python API for Exploring your datasets. It also powers the GUI Explorer. You can use this to create your own exploratory notebooks or scripts to get insights into your datasets.
-
-Learn more about the Explorer API [here](api.md).
-
-## GUI Explorer Usage
-
-The GUI demo runs in your browser allowing you to create embeddings for your dataset and search for similar images, run SQL queries and perform semantic search. It can be run using the following command:
-
-```bash
-yolo explorer
-```
-
-!!! note "Note"
-
-    Ask AI feature works using OpenAI, so you'll be prompted to set the api key for OpenAI when you first run the GUI.
-    You can set it like this - `yolo settings openai_api_key="..."`
-
-<p>
-    <img width="1709" alt="Ultralytics Explorer OpenAI Integration" src="https://github.com/AyushExel/assets/assets/15766192/1b5f3708-be3e-44c5-9ea3-adcd522dfc75">
-</p>

yolov10/docs/en/datasets/index.md

@@ -1,151 +0,0 @@
----
-comments: true
-description: Explore various computer vision datasets supported by Ultralytics for object detection, segmentation, pose estimation, image classification, and multi-object tracking.
-keywords: computer vision, datasets, Ultralytics, YOLO, object detection, instance segmentation, pose estimation, image classification, multi-object tracking
----
-
-# Datasets Overview
-
-Ultralytics provides support for various datasets to facilitate computer vision tasks such as detection, instance segmentation, pose estimation, classification, and multi-object tracking. Below is a list of the main Ultralytics datasets, followed by a summary of each computer vision task and the respective datasets.
-
-<p align="center">
-  <br>
-  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/YDXKa1EljmU"
-    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> Ultralytics Datasets Overview
-</p>
-
-## NEW 🚀 Ultralytics Explorer
-
-Create embeddings for your dataset, search for similar images, run SQL queries, perform semantic search and even search using natural language! You can get started with our GUI app or build your own using the API. Learn more [here](explorer/index.md).
-
-<p>
-<img alt="Ultralytics Explorer Screenshot" src="https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/d2ebaffd-e065-4d88-983a-33cb6f593785">
-</p>
-
-- Try the [GUI Demo](explorer/index.md)
-- Learn more about the [Explorer API](explorer/index.md)
-
-## [Detection Datasets](detect/index.md)
-
-Bounding box object detection is a computer vision technique that involves detecting and localizing objects in an image by drawing a bounding box around each object.
-
-- [Argoverse](detect/argoverse.md): A dataset containing 3D tracking and motion forecasting data from urban environments with rich annotations.
-- [COCO](detect/coco.md): A large-scale dataset designed for object detection, segmentation, and captioning with over 200K labeled images.
-- [COCO8](detect/coco8.md): Contains the first 4 images from COCO train and COCO val, suitable for quick tests.
-- [Global Wheat 2020](detect/globalwheat2020.md): A dataset of wheat head images collected from around the world for object detection and localization tasks.
-- [Objects365](detect/objects365.md): A high-quality, large-scale dataset for object detection with 365 object categories and over 600K annotated images.
-- [OpenImagesV7](detect/open-images-v7.md): A comprehensive dataset by Google with 1.7M train images and 42k validation images.
-- [SKU-110K](detect/sku-110k.md): A dataset featuring dense object detection in retail environments with over 11K images and 1.7 million bounding boxes.
-- [VisDrone](detect/visdrone.md): A dataset containing object detection and multi-object tracking data from drone-captured imagery with over 10K images and video sequences.
-- [VOC](detect/voc.md): The Pascal Visual Object Classes (VOC) dataset for object detection and segmentation with 20 object classes and over 11K images.
-- [xView](detect/xview.md): A dataset for object detection in overhead imagery with 60 object categories and over 1 million annotated objects.
-- [Roboflow 100](detect/roboflow-100.md): A diverse object detection benchmark with 100 datasets spanning seven imagery domains for comprehensive model evaluation.
-- [Brain-tumor](detect/brain-tumor.md): A dataset for detecting brain tumors includes MRI or CT scan images with details on tumor presence, location, and characteristics. It's vital for training computer vision models to automate tumor identification, aiding in early diagnosis and treatment planning.
-- [African-wildlife](detect/african-wildlife.md): A dataset featuring images of African wildlife, including buffalo, elephant, rhino, and zebra, aids in training computer vision models. Essential for identifying animals in various habitats, it supports wildlife research.
-
-## [Instance Segmentation Datasets](segment/index.md)
-
-Instance segmentation is a computer vision technique that involves identifying and localizing objects in an image at the pixel level.
-
-- [COCO](segment/coco.md): A large-scale dataset designed for object detection, segmentation, and captioning tasks with over 200K labeled images.
-- [COCO8-seg](segment/coco8-seg.md): A smaller dataset for instance segmentation tasks, containing a subset of 8 COCO images with segmentation annotations.
-- [Crack-seg](segment/crack-seg.md): Specifically crafted dataset for detecting cracks on roads and walls, applicable for both object detection and segmentation tasks.
-- [Package-seg](segment/package-seg.md): Tailored dataset for identifying packages in warehouses or industrial settings, suitable for both object detection and segmentation applications.
-- [Carparts-seg](segment/carparts-seg.md): Purpose-built dataset for identifying vehicle parts, catering to design, manufacturing, and research needs. It serves for both object detection and segmentation tasks.
-
-## [Pose Estimation](pose/index.md)
-
-Pose estimation is a technique used to determine the pose of the object relative to the camera or the world coordinate system.
-
-- [COCO](pose/coco.md): A large-scale dataset with human pose annotations designed for pose estimation tasks.
-- [COCO8-pose](pose/coco8-pose.md): A smaller dataset for pose estimation tasks, containing a subset of 8 COCO images with human pose annotations.
-- [Tiger-pose](pose/tiger-pose.md): A compact dataset consisting of 263 images focused on tigers, annotated with 12 keypoints per tiger for pose estimation tasks.
-
-## [Classification](classify/index.md)
-
-Image classification is a computer vision task that involves categorizing an image into one or more predefined classes or categories based on its visual content.
-
-- [Caltech 101](classify/caltech101.md): A dataset containing images of 101 object categories for image classification tasks.
-- [Caltech 256](classify/caltech256.md): An extended version of Caltech 101 with 256 object categories and more challenging images.
-- [CIFAR-10](classify/cifar10.md): A dataset of 60K 32x32 color images in 10 classes, with 6K images per class.
-- [CIFAR-100](classify/cifar100.md): An extended version of CIFAR-10 with 100 object categories and 600 images per class.
-- [Fashion-MNIST](classify/fashion-mnist.md): A dataset consisting of 70,000 grayscale images of 10 fashion categories for image classification tasks.
-- [ImageNet](classify/imagenet.md): A large-scale dataset for object detection and image classification with over 14 million images and 20,000 categories.
-- [ImageNet-10](classify/imagenet10.md): A smaller subset of ImageNet with 10 categories for faster experimentation and testing.
-- [Imagenette](classify/imagenette.md): A smaller subset of ImageNet that contains 10 easily distinguishable classes for quicker training and testing.
-- [Imagewoof](classify/imagewoof.md): A more challenging subset of ImageNet containing 10 dog breed categories for image classification tasks.
-- [MNIST](classify/mnist.md): A dataset of 70,000 grayscale images of handwritten digits for image classification tasks.
-
-## [Oriented Bounding Boxes (OBB)](obb/index.md)
-
-Oriented Bounding Boxes (OBB) is a method in computer vision for detecting angled objects in images using rotated bounding boxes, often applied to aerial and satellite imagery.
-
-- [DOTAv2](obb/dota-v2.md): A popular OBB aerial imagery dataset with 1.7 million instances and 11,268 images.
-
-## [Multi-Object Tracking](track/index.md)
-
-Multi-object tracking is a computer vision technique that involves detecting and tracking multiple objects over time in a video sequence.
-
-- [Argoverse](detect/argoverse.md): A dataset containing 3D tracking and motion forecasting data from urban environments with rich annotations for multi-object tracking tasks.
-- [VisDrone](detect/visdrone.md): A dataset containing object detection and multi-object tracking data from drone-captured imagery with over 10K images and video sequences.
-
-## Contribute New Datasets
-
-Contributing a new dataset involves several steps to ensure that it aligns well with the existing infrastructure. Below are the necessary steps:
-
-### Steps to Contribute a New Dataset
-
-1. **Collect Images**: Gather the images that belong to the dataset. These could be collected from various sources, such as public databases or your own collection.
-
-2. **Annotate Images**: Annotate these images with bounding boxes, segments, or keypoints, depending on the task.
-
-3. **Export Annotations**: Convert these annotations into the YOLO `*.txt` file format which Ultralytics supports.
-
-4. **Organize Dataset**: Arrange your dataset into the correct folder structure. You should have `train/` and `val/` top-level directories, and within each, an `images/` and `labels/` subdirectory.
-
-    ```
-    dataset/
-    ├── train/
-    │   ├── images/
-    │   └── labels/
-    └── val/
-        ├── images/
-        └── labels/
-    ```
-
-5. **Create a `data.yaml` File**: In your dataset's root directory, create a `data.yaml` file that describes the dataset, classes, and other necessary information.
-
-6. **Optimize Images (Optional)**: If you want to reduce the size of the dataset for more efficient processing, you can optimize the images using the code below. This is not required, but recommended for smaller dataset sizes and faster download speeds.
-
-7. **Zip Dataset**: Compress the entire dataset folder into a zip file.
-
-8. **Document and PR**: Create a documentation page describing your dataset and how it fits into the existing framework. After that, submit a Pull Request (PR). Refer to [Ultralytics Contribution Guidelines](https://docs.ultralytics.com/help/contributing) for more details on how to submit a PR.
-
-### Example Code to Optimize and Zip a Dataset
-
-!!! Example "Optimize and Zip a Dataset"
-
-    === "Python"
-
-    ```python
-    from pathlib import Path
-    from ultralytics.data.utils import compress_one_image
-    from ultralytics.utils.downloads import zip_directory
-
-    # Define dataset directory
-    path = Path('path/to/dataset')
-
-    # Optimize images in dataset (optional)
-    for f in path.rglob('*.jpg'):
-        compress_one_image(f)
-
-    # Zip dataset into 'path/to/dataset.zip'
-    zip_directory(path)
-    ```
-
-By following these steps, you can contribute a new dataset that integrates well with Ultralytics' existing structure.

yolov10/docs/en/datasets/obb/dota-v2.md

@@ -1,156 +0,0 @@
----
-comments: true
-description: Delve into DOTA, an Oriented Bounding Box (OBB) aerial imagery dataset with 1.7 million instances and 11,268 images.
-keywords: DOTA v1, DOTA v1.5, DOTA v2, object detection, aerial images, computer vision, deep learning, annotations, oriented bounding boxes, OBB
----
-
-# DOTA Dataset with OBB
-
-[DOTA](https://captain-whu.github.io/DOTA/index.html) stands as a specialized dataset, emphasizing object detection in aerial images. Originating from the DOTA series of datasets, it offers annotated images capturing a diverse array of aerial scenes with Oriented Bounding Boxes (OBB).
-
-![DOTA classes visual](https://user-images.githubusercontent.com/26833433/259461765-72fdd0d8-266b-44a9-8199-199329bf5ca9.jpg)
-
-## Key Features
-
-- Collection from various sensors and platforms, with image sizes ranging from 800 × 800 to 20,000 × 20,000 pixels.
-- Features more than 1.7M Oriented Bounding Boxes across 18 categories.
-- Encompasses multiscale object detection.
-- Instances are annotated by experts using arbitrary (8 d.o.f.) quadrilateral, capturing objects of different scales, orientations, and shapes.
-
-## Dataset Versions
-
-### DOTA-v1.0
-
-- Contains 15 common categories.
-- Comprises 2,806 images with 188,282 instances.
-- Split ratios: 1/2 for training, 1/6 for validation, and 1/3 for testing.
-
-### DOTA-v1.5
-
-- Incorporates the same images as DOTA-v1.0.
-- Very small instances (less than 10 pixels) are also annotated.
-- Addition of a new category: "container crane".
-- A total of 403,318 instances.
-- Released for the DOAI Challenge 2019 on Object Detection in Aerial Images.
-
-### DOTA-v2.0
-
-- Collections from Google Earth, GF-2 Satellite, and other aerial images.
-- Contains 18 common categories.
-- Comprises 11,268 images with a whopping 1,793,658 instances.
-- New categories introduced: "airport" and "helipad".
-- Image splits:
-    - Training: 1,830 images with 268,627 instances.
-    - Validation: 593 images with 81,048 instances.
-    - Test-dev: 2,792 images with 353,346 instances.
-    - Test-challenge: 6,053 images with 1,090,637 instances.
-
-## Dataset Structure
-
-DOTA exhibits a structured layout tailored for OBB object detection challenges:
-
-- **Images**: A vast collection of high-resolution aerial images capturing diverse terrains and structures.
-- **Oriented Bounding Boxes**: Annotations in the form of rotated rectangles encapsulating objects irrespective of their orientation, ideal for capturing objects like airplanes, ships, and buildings.
-
-## Applications
-
-DOTA serves as a benchmark for training and evaluating models specifically tailored for aerial image analysis. With the inclusion of OBB annotations, it provides a unique challenge, enabling the development of specialized object detection models that cater to aerial imagery's nuances.
-
-## Dataset YAML
-
-Typically, datasets incorporate a YAML (Yet Another Markup Language) file detailing the dataset's configuration. For DOTA v1 and DOTA v1.5, Ultralytics provides `DOTAv1.yaml` and `DOTAv1.5.yaml` files. For additional details on these as well as DOTA v2 please consult DOTA's official repository and documentation.
-
-!!! Example "DOTAv1.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/DOTAv1.yaml"
-    ```
-
-## Split DOTA images
-
-To train DOTA dataset, we split original DOTA images with high-resolution into images with 1024x1024 resolution in multiscale way.
-
-!!! Example "Split images"
-
-    === "Python"
-
-        ```python
-        from ultralytics.data.split_dota import split_trainval, split_test
-
-        # split train and val set, with labels.
-        split_trainval(
-            data_root='path/to/DOTAv1.0/',
-            save_dir='path/to/DOTAv1.0-split/',
-            rates=[0.5, 1.0, 1.5],    # multiscale
-            gap=500
-        )
-        # split test set, without labels.
-        split_test(
-            data_root='path/to/DOTAv1.0/',
-            save_dir='path/to/DOTAv1.0-split/',
-            rates=[0.5, 1.0, 1.5],    # multiscale
-            gap=500
-        )
-        ```
-
-## Usage
-
-To train a model on the DOTA v1 dataset, you can utilize the following code snippets. Always refer to your model's documentation for a thorough list of available arguments.
-
-!!! Warning
-
-    Please note that all images and associated annotations in the DOTAv1 dataset can be used for academic purposes, but commercial use is prohibited. Your understanding and respect for the dataset creators' wishes are greatly appreciated!
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Create a new YOLOv8n-OBB model from scratch
-        model = YOLO('yolov8n-obb.yaml')
-
-        # Train the model on the DOTAv2 dataset
-        results = model.train(data='DOTAv1.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Train a new YOLOv8n-OBB model on the DOTAv2 dataset
-        yolo obb train data=DOTAv1.yaml model=yolov8n-obb.pt epochs=100 imgsz=640
-        ```
-
-## Sample Data and Annotations
-
-Having a glance at the dataset illustrates its depth:
-
-![Dataset sample image](https://captain-whu.github.io/DOTA/images/instances-DOTA.jpg)
-
-- **DOTA examples**: This snapshot underlines the complexity of aerial scenes and the significance of Oriented Bounding Box annotations, capturing objects in their natural orientation.
-
-The dataset's richness offers invaluable insights into object detection challenges exclusive to aerial imagery.
-
-## Citations and Acknowledgments
-
-For those leveraging DOTA in their endeavors, it's pertinent to cite the relevant research papers:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{9560031,
-          author={Ding, Jian and Xue, Nan and Xia, Gui-Song and Bai, Xiang and Yang, Wen and Yang, Michael and Belongie, Serge and Luo, Jiebo and Datcu, Mihai and Pelillo, Marcello and Zhang, Liangpei},
-          journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
-          title={Object Detection in Aerial Images: A Large-Scale Benchmark and Challenges},
-          year={2021},
-          volume={},
-          number={},
-          pages={1-1},
-          doi={10.1109/TPAMI.2021.3117983}
-        }
-        ```
-
-A special note of gratitude to the team behind the DOTA datasets for their commendable effort in curating this dataset. For an exhaustive understanding of the dataset and its nuances, please visit the [official DOTA website](https://captain-whu.github.io/DOTA/index.html).

yolov10/docs/en/datasets/obb/dota8.md

@@ -1,81 +0,0 @@
----
-comments: true
-description: Discover the versatile DOTA8 dataset, perfect for testing and debugging oriented detection models. Learn how to get started with YOLOv8-obb model training.
-keywords: Ultralytics, YOLOv8, oriented detection, DOTA8 dataset, dataset, model training, YAML
----
-
-# DOTA8 Dataset
-
-## Introduction
-
-[Ultralytics](https://ultralytics.com) DOTA8 is a small, but versatile oriented object detection dataset composed of the first 8 images of 8 images of the split DOTAv1 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging object detection models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
-
-This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com) and [YOLOv8](https://github.com/ultralytics/ultralytics).
-
-## Dataset YAML
-
-A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the DOTA8 dataset, the `dota8.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dota8.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dota8.yaml).
-
-!!! Example "ultralytics/cfg/datasets/dota8.yaml"
-
-    ```yaml
-    --8<-- "ultralytics/cfg/datasets/dota8.yaml"
-    ```
-
-## Usage
-
-To train a YOLOv8n-obb model on the DOTA8 dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
-
-!!! Example "Train Example"
-
-    === "Python"
-
-        ```python
-        from ultralytics import YOLO
-
-        # Load a model
-        model = YOLO('yolov8n-obb.pt')  # load a pretrained model (recommended for training)
-
-        # Train the model
-        results = model.train(data='dota8.yaml', epochs=100, imgsz=640)
-        ```
-
-    === "CLI"
-
-        ```bash
-        # Start training from a pretrained *.pt model
-        yolo obb train data=dota8.yaml model=yolov8n-obb.pt epochs=100 imgsz=640
-        ```
-
-## Sample Images and Annotations
-
-Here are some examples of images from the DOTA8 dataset, along with their corresponding annotations:
-
-<img src="https://github.com/Laughing-q/assets/assets/61612323/965d3ff7-5b9b-4add-b62e-9795921b60de" alt="Dataset sample image" width="800">
-
-- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
-
-The example showcases the variety and complexity of the images in the DOTA8 dataset and the benefits of using mosaicing during the training process.
-
-## Citations and Acknowledgments
-
-If you use the DOTA dataset in your research or development work, please cite the following paper:
-
-!!! Quote ""
-
-    === "BibTeX"
-
-        ```bibtex
-        @article{9560031,
-          author={Ding, Jian and Xue, Nan and Xia, Gui-Song and Bai, Xiang and Yang, Wen and Yang, Michael and Belongie, Serge and Luo, Jiebo and Datcu, Mihai and Pelillo, Marcello and Zhang, Liangpei},
-          journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
-          title={Object Detection in Aerial Images: A Large-Scale Benchmark and Challenges},
-          year={2021},
-          volume={},
-          number={},
-          pages={1-1},
-          doi={10.1109/TPAMI.2021.3117983}
-        }
-        ```
-
-A special note of gratitude to the team behind the DOTA datasets for their commendable effort in curating this dataset. For an exhaustive understanding of the dataset and its nuances, please visit the [official DOTA website](https://captain-whu.github.io/DOTA/index.html).