Upload 392 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ultralytics/assets/bus.jpg filter=lfs diff=lfs merge=lfs -text
+ultralytics/data/__pycache__/augment.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+ultralytics/nn/modules/__pycache__/block.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,661 @@
+                    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/>.

README.md

@@ -1,19 +1,141 @@
 ---
-title: Tunnel Defext
-emoji: 🚀
-colorFrom: red
+title: Tunnel Crack Detection
+emoji: 🔍
+colorFrom: blue
 colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+sdk: streamlit
+sdk_version: 1.28.0
+app_file: app.py
 pinned: false
-short_description: Tunnel segment defect
+license: agpl-3.0
 ---
 
-# Welcome to Streamlit!
+# 🔍 Tunnel Crack Detection
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+A state-of-the-art web application for detecting cracks and defects in tunnel infrastructure using YOLOv12-DINO deep learning model. Deployed on Hugging Face Spaces for easy access and sharing.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Features
+
+- 🔍 **Real-time crack detection** using YOLOv12-DINO
+- 🖼️ **Interactive web interface** built with Streamlit
+- 📊 **Detailed analysis** with charts and detection tables
+- 📁 **Large file support** (up to 5GB model weights)
+- 📈 **Detection history** and results export
+- 🎯 **Configurable parameters** (confidence, IoU thresholds)
+
+## 🚀 Quick Start
+
+This application is deployed on Hugging Face Spaces. Simply:
+
+1. **Upload your YOLOv12-DINO model weights** (.pt file) using the sidebar
+2. **Upload a tunnel image** for analysis  
+3. **Click "Analyze for Cracks"** to get instant results!
+
+## 🛠️ Local Setup
+
+### Prerequisites
+
+- Python 3.8 or higher
+- YOLOv12-DINO trained model weights (.pt file)
+
+### Installation
+
+1. **Clone or navigate to the project directory:**
+   ```bash
+   cd /Users/sompoteyouwai/env/deploy_tunnel_crack
+   ```
+
+2. **Create a virtual environment (recommended):**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+### Running the Application
+
+1. **Start the Streamlit app:**
+   ```bash
+   streamlit run streamlit_app.py
+   ```
+
+2. **Open your browser** and navigate to `http://localhost:8501`
+
+3. **Load the model:**
+   - If the default model exists at `/Users/sompoteyouwai/env/model_weight/segment_defect.pt`, click "Load Default Model"
+   - Alternatively, upload your own model weights (.pt file)
+
+4. **Upload an image** and click "Detect Cracks" to analyze
+
+## Usage
+
+### Model Loading
+- **Default Model**: The app automatically detects if the default model is available
+- **Custom Model**: Upload your own YOLOv12-DINO trained weights
+- **Device Selection**: Choose between CPU, CUDA (GPU), or MPS (Apple Silicon)
+
+### Detection Parameters
+- **Confidence Threshold**: Minimum confidence score for detections (0.01-1.0)
+- **IoU Threshold**: Intersection over Union threshold for Non-Maximum Suppression (0.01-1.0)
+- **Image Size**: Input resolution for the model (320-1280 pixels)
+
+### Results
+- **Annotated Images**: View detected cracks with bounding boxes
+- **Detection Summary**: Count and classification of detected defects
+- **Interactive Charts**: Pie charts and confidence distributions
+- **Detailed Table**: Exportable CSV with detection coordinates and metadata
+- **History**: Track multiple detection sessions
+
+## File Structure
+
+```
+deploy_tunnel_crack/
+├── streamlit_app.py      # Main Streamlit application
+├── inference.py          # YOLOv12-DINO inference engine
+├── requirements.txt      # Python dependencies
+├── README.md            # This file
+└── run.sh               # Quick start script
+```
+
+## Model Information
+
+The application expects a YOLOv12-DINO model trained for crack/defect detection. The default model path is:
+```
+/Users/sompoteyouwai/env/model_weight/segment_defect.pt
+```
+
+### Supported Model Features:
+- Object detection and segmentation
+- Multiple defect classes
+- Configurable inference parameters
+- GPU acceleration support
+
+## Troubleshooting
+
+### Common Issues:
+
+1. **Model not found**: Ensure the model file exists at the specified path or upload a custom model
+2. **CUDA errors**: Install appropriate PyTorch version for your GPU
+3. **Memory issues**: Reduce image size or use CPU device for large images
+4. **Import errors**: Ensure all dependencies are installed: `pip install -r requirements.txt`
+
+### Performance Tips:
+- Use GPU (CUDA/MPS) for faster inference
+- Optimize image size based on your hardware capabilities
+- Adjust confidence threshold to filter false positives
+
+## Development
+
+To modify or extend the application:
+
+1. **Streamlit App**: Edit `streamlit_app.py` for UI changes
+2. **Inference Engine**: Modify `inference.py` for model-related changes
+3. **Dependencies**: Update `requirements.txt` for new packages
+
+## License
+
+This project is for tunnel infrastructure monitoring and maintenance applications.

app.py

@@ -0,0 +1,692 @@
+#!/usr/bin/env python3
+"""
+Tunnel Crack Detection - Hugging Face Spaces App
+
+A Streamlit-based web interface for tunnel crack detection using YOLOv12-DINO.
+Deployed on Hugging Face Spaces for easy access and sharing.
+"""
+
+import streamlit as st
+import cv2
+import numpy as np
+import pandas as pd
+from pathlib import Path
+import tempfile
+import os
+import sys
+from typing import Dict, List, Tuple
+import time
+from PIL import Image
+import plotly.express as px
+import plotly.graph_objects as go
+import requests
+from io import BytesIO
+
+# Add the current directory to the Python path
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
+
+try:
+    from inference import YOLOInference
+except ImportError as e:
+    st.error(f"Error importing inference module: {e}")
+    st.stop()
+
+# Page configuration
+st.set_page_config(
+    page_title="🔍 Tunnel Crack Detection",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        color: #1e88e5;
+        text-align: center;
+        margin-bottom: 2rem;
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
+    }
+    .sub-header {
+        text-align: center;
+        color: #666;
+        margin-bottom: 3rem;
+        font-size: 1.2rem;
+    }
+    .metric-card {
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        padding: 1.5rem;
+        border-radius: 1rem;
+        margin: 0.5rem 0;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    }
+    .detection-box {
+        border: 2px solid #1e88e5;
+        border-radius: 1rem;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    }
+    .success-box {
+        border: 2px solid #4caf50;
+        border-radius: 1rem;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        background: linear-gradient(135deg, #f1f8e9 0%, #dcedc8 100%);
+        box-shadow: 0 4px 8px rgba(76, 175, 80, 0.2);
+    }
+    .error-box {
+        border: 2px solid #f44336;
+        border-radius: 1rem;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        background: linear-gradient(135deg, #ffebee 0%, #ffcdd2 100%);
+        box-shadow: 0 4px 8px rgba(244, 67, 54, 0.2);
+    }
+    .warning-box {
+        border: 2px solid #ff9800;
+        border-radius: 1rem;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        background: linear-gradient(135deg, #fff3e0 0%, #ffe0b2 100%);
+        box-shadow: 0 4px 8px rgba(255, 152, 0, 0.2);
+    }
+    .info-box {
+        border: 2px solid #2196f3;
+        border-radius: 1rem;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
+        box-shadow: 0 4px 8px rgba(33, 150, 243, 0.2);
+    }
+    .stButton > button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border: none;
+        border-radius: 0.5rem;
+        padding: 0.5rem 2rem;
+        font-weight: bold;
+        transition: all 0.3s ease;
+    }
+    .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.2);
+    }
+    .sidebar .stSelectbox > div > div {
+        background-color: #f8f9fa;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'model_loaded' not in st.session_state:
+    st.session_state.model_loaded = False
+if 'model_instance' not in st.session_state:
+    st.session_state.model_instance = None
+if 'detection_history' not in st.session_state:
+    st.session_state.detection_history = []
+
+# Model download URL (you'll need to replace this with actual model URL or use HF Hub)
+MODEL_URL = "https://huggingface.co/spaces/YOUR_USERNAME/tunnel-crack-detection/resolve/main/segment_defect.pt"
+
+@st.cache_resource
+def download_model():
+    """Download model from Hugging Face Hub or URL."""
+    model_path = "segment_defect.pt"
+    
+    if not os.path.exists(model_path):
+        st.info("🔄 Downloading model weights... This may take a few minutes.")
+        try:
+            # Try to download from URL (you may need to adjust this)
+            # For HF Spaces, you might want to use huggingface_hub library
+            response = requests.get(MODEL_URL, stream=True)
+            response.raise_for_status()
+            
+            with open(model_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            
+            st.success("✅ Model downloaded successfully!")
+        except Exception as e:
+            st.error(f"❌ Failed to download model: {e}")
+            return None
+    
+    return model_path
+
+def load_model(weights_path: str, device: str = "cpu") -> Tuple[bool, str]:
+    """Load the YOLO model with specified weights."""
+    try:
+        if not Path(weights_path).exists():
+            return False, f"❌ Model file not found: {weights_path}"
+        
+        with st.spinner("🚀 Loading tunnel crack detection model..."):
+            st.session_state.model_instance = YOLOInference(
+                weights=weights_path,
+                conf=0.25,
+                iou=0.7,
+                imgsz=640,
+                device=device,
+                verbose=True
+            )
+        
+        st.session_state.model_loaded = True
+        
+        # Get model information
+        model_info = f"✅ Model loaded successfully\n"
+        model_info += f"📋 Task: {st.session_state.model_instance.model.task}\n"
+        
+        if hasattr(st.session_state.model_instance.model.model, 'names'):
+            class_names = list(st.session_state.model_instance.model.model.names.values())
+            model_info += f"🏷️ Classes ({len(class_names)}): {', '.join(class_names)}"
+            
+        return True, model_info
+        
+    except Exception as e:
+        return False, f"❌ Error loading model: {str(e)}"
+
+def perform_detection(
+    image: np.ndarray,
+    conf_threshold: float,
+    iou_threshold: float,
+    image_size: int
+) -> Tuple[np.ndarray, Dict, str]:
+    """Perform crack detection using the loaded model."""
+    
+    if st.session_state.model_instance is None:
+        return None, {}, "❌ No model loaded"
+    
+    try:
+        # Update model parameters
+        st.session_state.model_instance.conf = conf_threshold
+        st.session_state.model_instance.iou = iou_threshold
+        st.session_state.model_instance.imgsz = image_size
+        
+        # Save image to temporary file
+        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp_file:
+            # Convert RGB to BGR for OpenCV
+            image_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+            cv2.imwrite(tmp_file.name, image_bgr)
+            tmp_path = tmp_file.name
+        
+        start_time = time.time()
+        
+        try:
+            # Use the exact same method as inference.py
+            results = st.session_state.model_instance.predict_single(
+                source=tmp_path,
+                save=False,
+                show=False,
+                save_txt=False,
+                save_conf=False,
+                save_crop=False,
+                output_dir=None
+            )
+            
+            inference_time = time.time() - start_time
+            
+            if not results:
+                return image, {}, "❌ No results returned from model"
+            
+            result = results[0]
+            
+            # Get annotated image
+            annotated_img = result.plot()
+            annotated_img = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)
+            
+            # Process detection results
+            detection_data = process_detection_results(result, inference_time)
+            
+            # Generate summary text
+            summary_text = generate_detection_summary(result, detection_data, inference_time)
+            
+            return annotated_img, detection_data, summary_text
+            
+        finally:
+            # Clean up temporary file
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+                
+    except Exception as e:
+        return None, {}, f"❌ Error during detection: {str(e)}"
+
+def process_detection_results(result, inference_time: float) -> Dict:
+    """Process detection results into structured data."""
+    
+    if result.boxes is None or len(result.boxes) == 0:
+        return {
+            'total_detections': 0,
+            'class_counts': {},
+            'detections': [],
+            'inference_time': inference_time
+        }
+    
+    detections = result.boxes
+    
+    # Get class names
+    if hasattr(st.session_state.model_instance.model.model, 'names'):
+        class_names = st.session_state.model_instance.model.model.names
+    else:
+        class_names = getattr(result, 'names', {i: f"Class_{i}" for i in range(100)})
+    
+    # Process each detection
+    detection_list = []
+    class_counts = {}
+    
+    for i, (box, conf, cls) in enumerate(zip(detections.xyxy, detections.conf, detections.cls)):
+        cls_id = int(cls)
+        cls_name = class_names.get(cls_id, f"Class_{cls_id}")
+        confidence = float(conf)
+        
+        x1, y1, x2, y2 = box.tolist()
+        
+        detection_list.append({
+            'id': i + 1,
+            'class': cls_name,
+            'confidence': confidence,
+            'x1': int(x1),
+            'y1': int(y1),
+            'x2': int(x2),
+            'y2': int(y2),
+            'width': int(x2 - x1),
+            'height': int(y2 - y1),
+            'area': int((x2 - x1) * (y2 - y1))
+        })
+        
+        class_counts[cls_name] = class_counts.get(cls_name, 0) + 1
+    
+    return {
+        'total_detections': len(detection_list),
+        'class_counts': class_counts,
+        'detections': detection_list,
+        'inference_time': inference_time
+    }
+
+def generate_detection_summary(result, detection_data: Dict, inference_time: float) -> str:
+    """Generate detection summary text."""
+    
+    total_detections = detection_data['total_detections']
+    
+    if total_detections == 0:
+        return "🔍 No cracks or defects detected in the image."
+    
+    summary = f"✅ **Detection Results:**\n\n"
+    summary += f"📊 **Images processed:** 1\n"
+    summary += f"📊 **Total detections:** {total_detections}\n"
+    summary += f"⏱️ **Inference time:** {inference_time:.3f}s\n\n"
+    
+    summary += "📋 **Detections by class:**\n"
+    for cls_name, count in sorted(detection_data['class_counts'].items()):
+        summary += f"   • {cls_name}: {count}\n"
+    
+    return summary
+
+def create_detection_chart(detection_data: Dict):
+    """Create interactive charts for detection results."""
+    
+    if detection_data['total_detections'] == 0:
+        st.info("📊 No detections to visualize")
+        return
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Class distribution pie chart
+        class_counts = detection_data['class_counts']
+        
+        fig_pie = px.pie(
+            values=list(class_counts.values()),
+            names=list(class_counts.keys()),
+            title="🥧 Detection Distribution by Class",
+            color_discrete_sequence=px.colors.qualitative.Set3
+        )
+        fig_pie.update_layout(height=400)
+        
+        st.plotly_chart(fig_pie, use_container_width=True)
+    
+    with col2:
+        # Confidence distribution
+        confidences = [det['confidence'] for det in detection_data['detections']]
+        classes = [det['class'] for det in detection_data['detections']]
+        
+        fig_conf = px.box(
+            x=classes,
+            y=confidences,
+            title="📈 Confidence Distribution by Class",
+            color=classes
+        )
+        fig_conf.update_layout(height=400)
+        fig_conf.update_xaxes(title="Class")
+        fig_conf.update_yaxes(title="Confidence Score")
+        
+        st.plotly_chart(fig_conf, use_container_width=True)
+
+def create_detection_table(detection_data: Dict):
+    """Create detailed detection table."""
+    
+    if detection_data['total_detections'] == 0:
+        st.info("📋 No detections to display")
+        return
+    
+    # Convert to DataFrame
+    df = pd.DataFrame(detection_data['detections'])
+    
+    # Format confidence as percentage
+    df['confidence_pct'] = df['confidence'].apply(lambda x: f"{x:.1%}")
+    
+    # Reorder columns for better display
+    display_columns = ['id', 'class', 'confidence_pct', 'x1', 'y1', 'x2', 'y2', 'width', 'height', 'area']
+    df_display = df[display_columns].copy()
+    
+    # Rename columns for better readability
+    df_display.columns = ['ID', 'Class', 'Confidence', 'X1', 'Y1', 'X2', 'Y2', 'Width', 'Height', 'Area']
+    
+    st.dataframe(df_display, use_container_width=True, height=300)
+    
+    # Download button for results
+    csv = df_display.to_csv(index=False)
+    st.download_button(
+        label="📥 Download Detection Results (CSV)",
+        data=csv,
+        file_name=f"crack_detection_results_{int(time.time())}.csv",
+        mime="text/csv",
+        use_container_width=True
+    )
+
+def main():
+    """Main Streamlit application."""
+    
+    # Header
+    st.markdown('<h1 class="main-header">🔍 Tunnel Crack Detection</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">AI-powered crack and defect detection for tunnel infrastructure using YOLOv12-DINO</p>', unsafe_allow_html=True)
+    
+    # Info about the model
+    st.markdown("""
+    <div class="info-box">
+        <h4>🤖 About This Model</h4>
+        <p>This application uses YOLOv12-DINO, a state-of-the-art deep learning model that combines:</p>
+        <ul>
+            <li><strong>YOLOv12</strong>: Latest version of the YOLO object detection architecture</li>
+            <li><strong>DINOv3</strong>: Vision Transformer backbone for enhanced feature extraction</li>
+            <li><strong>Specialized Training</strong>: Fine-tuned specifically for tunnel crack and defect detection</li>
+        </ul>
+        <p><em>Perfect for infrastructure monitoring and maintenance applications!</em></p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Auto-load model on startup
+    if not st.session_state.model_loaded:
+        with st.spinner("🔄 Initializing model..."):
+            # For HF Spaces, you might want to have the model pre-loaded or use a different approach
+            # model_path = download_model()
+            # if model_path:
+            #     success, message = load_model(model_path, "cpu")
+            #     if success:
+            #         st.success("🚀 Model ready for inference!")
+            pass
+    
+    # Sidebar for configuration
+    with st.sidebar:
+        st.header("🛠️ Configuration")
+        
+        # Model loading section
+        st.subheader("📁 Model")
+        
+        if not st.session_state.model_loaded:
+            st.markdown('<div class="warning-box">⚠️ Upload a model to get started</div>', unsafe_allow_html=True)
+            
+            uploaded_file = st.file_uploader(
+                "Upload Model Weights (.pt file)",
+                type=['pt'],
+                help="Upload your trained YOLOv12-DINO model weights",
+                label_visibility="visible"
+            )
+            
+            if uploaded_file is not None:
+                # Show file info
+                file_size_mb = uploaded_file.size / (1024 * 1024)
+                st.success(f"📁 File uploaded: {uploaded_file.name} ({file_size_mb:.1f} MB)")
+                
+                if st.button("🚀 Load Model", type="primary"):
+                    # Show progress for file processing
+                    progress_bar = st.progress(0)
+                    status_text = st.empty()
+                    
+                    try:
+                        # Save uploaded file temporarily
+                        status_text.text("💾 Processing uploaded file...")
+                        progress_bar.progress(25)
+                        
+                        with tempfile.NamedTemporaryFile(delete=False, suffix='.pt') as tmp_file:
+                            tmp_file.write(uploaded_file.read())
+                            tmp_path = tmp_file.name
+                        
+                        progress_bar.progress(50)
+                        status_text.text("🚀 Loading model...")
+                        
+                        success, message = load_model(tmp_path, "cpu")
+                        
+                        progress_bar.progress(100)
+                        status_text.text("✅ Model loading complete!")
+                        
+                        if success:
+                            st.success(message)
+                            st.rerun()
+                        else:
+                            st.error(message)
+                            
+                        # Clean up progress indicators
+                        time.sleep(1)
+                        progress_bar.empty()
+                        status_text.empty()
+                        
+                    except Exception as e:
+                        st.error(f"❌ Error processing file: {str(e)}")
+                        progress_bar.empty()
+                        status_text.empty()
+        else:
+            st.markdown('<div class="success-box">✅ Model loaded and ready!</div>', unsafe_allow_html=True)
+        
+        # Detection parameters
+        st.subheader("⚙️ Detection Parameters")
+        
+        conf_threshold = st.slider(
+            "Confidence Threshold",
+            min_value=0.01,
+            max_value=1.0,
+            value=0.25,
+            step=0.01,
+            help="Minimum confidence for detection"
+        )
+        
+        iou_threshold = st.slider(
+            "IoU Threshold",
+            min_value=0.01,
+            max_value=1.0,
+            value=0.7,
+            step=0.01,
+            help="IoU threshold for Non-Maximum Suppression"
+        )
+        
+        image_size = st.selectbox(
+            "Image Size",
+            options=[320, 416, 512, 640, 832, 1024],
+            index=3,
+            help="Input image size for model"
+        )
+        
+        # Statistics
+        if st.session_state.detection_history:
+            st.subheader("📊 Session Stats")
+            total_detections = sum([h['detections'] for h in st.session_state.detection_history])
+            st.metric("Images Processed", len(st.session_state.detection_history))
+            st.metric("Total Detections", total_detections)
+    
+    # Main content area
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.header("🖼️ Input Image")
+        
+        # Image upload
+        image_file = st.file_uploader(
+            "Upload Image for Analysis",
+            type=['jpg', 'jpeg', 'png', 'bmp'],
+            help="Upload a tunnel image for crack detection"
+        )
+        
+        if image_file is not None:
+            # Load and display image
+            try:
+                image = Image.open(image_file)
+                image_np = np.array(image)
+                
+                # Display image
+                st.image(image, caption="📷 Input Image", use_column_width=True)
+                
+                # Image info
+                st.info(f"📊 Image size: {image.width} × {image.height} pixels")
+                
+            except Exception as e:
+                st.error(f"❌ Error loading image: {str(e)}")
+                return
+            
+            # Detection button
+            detect_button = st.button(
+                "🔍 Analyze for Cracks", 
+                type="primary", 
+                disabled=not st.session_state.model_loaded,
+                use_container_width=True
+            )
+            
+            if detect_button:
+                if st.session_state.model_loaded:
+                    with st.spinner("🔍 Analyzing image for cracks and defects..."):
+                        annotated_img, detection_data, summary_text = perform_detection(
+                            image_np, conf_threshold, iou_threshold, image_size
+                        )
+                        
+                        # Store results in session state
+                        st.session_state.last_detection = {
+                            'annotated_img': annotated_img,
+                            'detection_data': detection_data,
+                            'summary_text': summary_text,
+                            'timestamp': time.time()
+                        }
+                        
+                        # Add to history
+                        st.session_state.detection_history.append({
+                            'filename': image_file.name,
+                            'detections': detection_data['total_detections'],
+                            'timestamp': time.time()
+                        })
+                        
+                        st.rerun()
+                else:
+                    st.error("❌ Please upload and load a model first")
+        else:
+            st.markdown("""
+            <div class="info-box">
+                <h4>🚀 Get Started</h4>
+                <ol>
+                    <li>Upload your YOLOv12-DINO model weights in the sidebar</li>
+                    <li>Upload a tunnel image above</li>
+                    <li>Click "Analyze for Cracks" to detect defects</li>
+                </ol>
+            </div>
+            """, unsafe_allow_html=True)
+    
+    with col2:
+        st.header("🎯 Detection Results")
+        
+        if 'last_detection' in st.session_state:
+            detection_result = st.session_state.last_detection
+            
+            # Display annotated image
+            if detection_result['annotated_img'] is not None:
+                try:
+                    st.image(
+                        detection_result['annotated_img'],
+                        caption="🎯 Detection Results",
+                        use_column_width=True
+                    )
+                except Exception as e:
+                    st.error(f"Error displaying result image: {str(e)}")
+            
+            # Display summary
+            st.markdown(f'<div class="detection-box">{detection_result["summary_text"]}</div>', 
+                       unsafe_allow_html=True)
+            
+        else:
+            st.markdown("""
+            <div class="info-box">
+                <h4>📊 Results will appear here</h4>
+                <p>Upload an image and click 'Analyze for Cracks' to see detection results with:</p>
+                <ul>
+                    <li>🎯 Annotated image with detected cracks</li>
+                    <li>📊 Detection statistics and confidence scores</li>
+                    <li>📋 Detailed analysis tables</li>
+                    <li>📈 Interactive charts and visualizations</li>
+                </ul>
+            </div>
+            """, unsafe_allow_html=True)
+    
+    # Additional tabs for detailed analysis
+    if 'last_detection' in st.session_state and st.session_state.last_detection['detection_data']['total_detections'] > 0:
+        
+        st.markdown("---")
+        st.header("📊 Detailed Analysis")
+        
+        tab1, tab2, tab3 = st.tabs(["📈 Visualizations", "📋 Detection Table", "📜 Session History"])
+        
+        with tab1:
+            create_detection_chart(st.session_state.last_detection['detection_data'])
+        
+        with tab2:
+            create_detection_table(st.session_state.last_detection['detection_data'])
+        
+        with tab3:
+            if st.session_state.detection_history:
+                st.subheader("📜 Analysis History")
+                history_df = pd.DataFrame(st.session_state.detection_history)
+                history_df['timestamp'] = pd.to_datetime(history_df['timestamp'], unit='s')
+                history_df.columns = ['Filename', 'Detections', 'Timestamp']
+                
+                st.dataframe(history_df, use_container_width=True, height=300)
+                
+                col1, col2 = st.columns(2)
+                with col1:
+                    if st.button("🗑️ Clear History", use_container_width=True):
+                        st.session_state.detection_history = []
+                        st.rerun()
+                with col2:
+                    if len(st.session_state.detection_history) > 0:
+                        csv = history_df.to_csv(index=False)
+                        st.download_button(
+                            label="📥 Download History",
+                            data=csv,
+                            file_name=f"detection_history_{int(time.time())}.csv",
+                            mime="text/csv",
+                            use_container_width=True
+                        )
+            else:
+                st.info("📜 No analysis history yet. Start by uploading and analyzing images!")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style='text-align: center; color: #666; padding: 2rem;'>
+        <h4>🔍 Tunnel Crack Detection System</h4>
+        <p>
+            Powered by <strong>YOLOv12-DINO</strong> • Built with <strong>Streamlit</strong> • 
+            Deployed on <strong>🤗 Hugging Face Spaces</strong>
+        </p>
+        <p><em>Advanced AI for Infrastructure Monitoring and Maintenance</em></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

inference.py

@@ -0,0 +1,453 @@
+#!/usr/bin/env python3
+"""
+YOLOv12-DINO Inference Script
+
+This script performs object detection on images using trained YOLOv12-DINO model weights.
+It can process single images, image directories, or image lists and generate annotated outputs.
+
+Usage:
+    python inference.py --weights path/to/model.pt --source path/to/images --output path/to/output
+    python inference.py --weights runs/detect/train/weights/best.pt --source test_images/ --output results/
+    python inference.py --weights best.pt --source image.jpg --conf 0.5 --iou 0.7 --save --show
+
+Features:
+    - Supports multiple input formats (single image, directory, image list)
+    - Configurable confidence and IoU thresholds
+    - Optional visualization and saving of annotated images
+    - Batch processing for efficient inference
+    - Support for various image formats (jpg, png, bmp, etc.)
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import List, Union
+import time
+
+# Add the current directory to the Python path
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
+
+try:
+    from ultralytics import YOLO
+    from ultralytics.utils import LOGGER, colorstr
+    from ultralytics.utils.checks import check_file, check_imgsz
+    from ultralytics.utils.files import increment_path
+except ImportError as e:
+    print(f"Error importing ultralytics: {e}")
+    print("Please ensure ultralytics is properly installed")
+    sys.exit(1)
+
+
+class YOLOInference:
+    """YOLOv12-DINO inference class for object detection on images."""
+
+    def __init__(
+        self,
+        weights: Union[str, Path],
+        conf: float = 0.25,
+        iou: float = 0.7,
+        imgsz: int = 640,
+        device: str = "",
+        verbose: bool = True
+    ):
+        """
+        Initialize the YOLOv12-DINO inference model.
+
+        Args:
+            weights (str | Path): Path to the trained model weights (.pt file)
+            conf (float): Confidence threshold for detection (0.0-1.0)
+            iou (float): IoU threshold for Non-Maximum Suppression (0.0-1.0)
+            imgsz (int): Input image size for inference
+            device (str): Device to run inference on ('cpu', 'cuda', 'mps', etc.)
+            verbose (bool): Enable verbose output
+        """
+        self.weights = Path(weights)
+        self.conf = conf
+        self.iou = iou
+        self.imgsz = check_imgsz(imgsz)
+        self.device = device
+        self.verbose = verbose
+
+        # Validate weights file
+        if not self.weights.exists():
+            raise FileNotFoundError(f"Model weights not found: {self.weights}")
+
+        # Load model
+        if self.verbose:
+            LOGGER.info(f"Loading YOLOv12-DINO model from {self.weights}")
+        
+        self.model = YOLO(str(self.weights), verbose=self.verbose)
+        
+        if self.verbose:
+            LOGGER.info(f"Model loaded successfully")
+            LOGGER.info(f"Model task: {self.model.task}")
+            if hasattr(self.model.model, 'names'):
+                LOGGER.info(f"Classes: {list(self.model.model.names.values())}")
+
+    def predict_single(
+        self,
+        source: Union[str, Path],
+        save: bool = False,
+        show: bool = False,
+        save_txt: bool = False,
+        save_conf: bool = False,
+        save_crop: bool = False,
+        output_dir: Union[str, Path] = None
+    ):
+        """
+        Perform inference on a single image source.
+
+        Args:
+            source (str | Path): Path to image file
+            save (bool): Save annotated images
+            show (bool): Display results
+            save_txt (bool): Save detection results to txt files
+            save_conf (bool): Save confidence scores in txt files
+            save_crop (bool): Save cropped detection images
+            output_dir (str | Path): Output directory for saved results
+
+        Returns:
+            List of Results objects containing detection results
+        """
+        # Prepare prediction arguments
+        predict_args = {
+            'source': str(source),
+            'conf': self.conf,
+            'iou': self.iou,
+            'imgsz': self.imgsz,
+            'save': save,
+            'show': show,
+            'save_txt': save_txt,
+            'save_conf': save_conf,
+            'save_crop': save_crop,
+            'verbose': self.verbose
+        }
+
+        if self.device:
+            predict_args['device'] = self.device
+
+        if output_dir:
+            predict_args['project'] = str(Path(output_dir).parent)
+            predict_args['name'] = Path(output_dir).name
+
+        # Run inference
+        results = self.model.predict(**predict_args)
+        return results
+
+    def predict_batch(
+        self,
+        source_dir: Union[str, Path],
+        save: bool = True,
+        show: bool = False,
+        save_txt: bool = False,
+        save_conf: bool = False,
+        save_crop: bool = False,
+        output_dir: Union[str, Path] = None,
+        extensions: tuple = ('.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif')
+    ):
+        """
+        Perform batch inference on all images in a directory.
+
+        Args:
+            source_dir (str | Path): Directory containing images
+            save (bool): Save annotated images
+            show (bool): Display results
+            save_txt (bool): Save detection results to txt files
+            save_conf (bool): Save confidence scores in txt files
+            save_crop (bool): Save cropped detection images
+            output_dir (str | Path): Output directory for saved results
+            extensions (tuple): Supported image file extensions
+
+        Returns:
+            List of Results objects containing detection results for all images
+        """
+        source_dir = Path(source_dir)
+        if not source_dir.exists():
+            raise FileNotFoundError(f"Source directory not found: {source_dir}")
+
+        # Find all image files
+        image_files = []
+        for ext in extensions:
+            image_files.extend(source_dir.glob(f"*{ext}"))
+            image_files.extend(source_dir.glob(f"*{ext.upper()}"))
+
+        if not image_files:
+            raise ValueError(f"No images found in {source_dir} with extensions {extensions}")
+
+        if self.verbose:
+            LOGGER.info(f"Found {len(image_files)} images in {source_dir}")
+
+        # Prepare prediction arguments
+        predict_args = {
+            'source': str(source_dir),
+            'conf': self.conf,
+            'iou': self.iou,
+            'imgsz': self.imgsz,
+            'save': save,
+            'show': show,
+            'save_txt': save_txt,
+            'save_conf': save_conf,
+            'save_crop': save_crop,
+            'verbose': self.verbose
+        }
+
+        if self.device:
+            predict_args['device'] = self.device
+
+        if output_dir:
+            predict_args['project'] = str(Path(output_dir).parent)
+            predict_args['name'] = Path(output_dir).name
+
+        # Run batch inference
+        results = self.model.predict(**predict_args)
+        return results
+
+    def predict_from_list(
+        self,
+        image_list: List[Union[str, Path]],
+        save: bool = True,
+        show: bool = False,
+        save_txt: bool = False,
+        save_conf: bool = False,
+        save_crop: bool = False,
+        output_dir: Union[str, Path] = None
+    ):
+        """
+        Perform inference on a list of image paths.
+
+        Args:
+            image_list (List[str | Path]): List of image file paths
+            save (bool): Save annotated images
+            show (bool): Display results
+            save_txt (bool): Save detection results to txt files
+            save_conf (bool): Save confidence scores in txt files
+            save_crop (bool): Save cropped detection images
+            output_dir (str | Path): Output directory for saved results
+
+        Returns:
+            List of Results objects containing detection results for all images
+        """
+        all_results = []
+
+        for image_path in image_list:
+            if not Path(image_path).exists():
+                LOGGER.warning(f"Image not found: {image_path}")
+                continue
+
+            results = self.predict_single(
+                source=image_path,
+                save=save,
+                show=show,
+                save_txt=save_txt,
+                save_conf=save_conf,
+                save_crop=save_crop,
+                output_dir=output_dir
+            )
+            all_results.extend(results)
+
+        return all_results
+
+    def print_results_summary(self, results, source_info: str = ""):
+        """Print a summary of detection results."""
+        if not results:
+            LOGGER.info(f"No results to display{f' for {source_info}' if source_info else ''}")
+            return
+
+        total_detections = sum(len(r.boxes) if r.boxes is not None else 0 for r in results)
+        
+        if self.verbose:
+            LOGGER.info(f"\n{colorstr('Results Summary')}{f' for {source_info}' if source_info else ''}:")
+            LOGGER.info(f"  Images processed: {len(results)}")
+            LOGGER.info(f"  Total detections: {total_detections}")
+
+            if hasattr(self.model.model, 'names') and total_detections > 0:
+                # Count detections per class
+                class_counts = {}
+                for result in results:
+                    if result.boxes is not None:
+                        for cls in result.boxes.cls:
+                            cls_name = self.model.model.names[int(cls)]
+                            class_counts[cls_name] = class_counts.get(cls_name, 0) + 1
+                
+                LOGGER.info("  Detections by class:")
+                for cls_name, count in sorted(class_counts.items()):
+                    LOGGER.info(f"    {cls_name}: {count}")
+
+
+def parse_arguments():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="YOLOv12-DINO Inference Script",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Single image inference
+    python inference.py --weights best.pt --source image.jpg --save --show
+
+    # Batch inference on directory
+    python inference.py --weights runs/detect/train/weights/best.pt --source test_images/ --output results/
+
+    # Custom thresholds and save options
+    python inference.py --weights model.pt --source images/ --conf 0.5 --iou 0.7 --save-txt --save-crop
+        """
+    )
+
+    parser.add_argument(
+        '--weights', '-w',
+        type=str,
+        required=True,
+        help='Path to trained model weights (.pt file)'
+    )
+
+    parser.add_argument(
+        '--source', '-s',
+        type=str,
+        required=True,
+        help='Source for inference (image file, directory, or list of images)'
+    )
+
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default=None,
+        help='Output directory for results (default: runs/detect/predict)'
+    )
+
+    parser.add_argument(
+        '--conf',
+        type=float,
+        default=0.25,
+        help='Confidence threshold for detection (default: 0.25)'
+    )
+
+    parser.add_argument(
+        '--iou',
+        type=float,
+        default=0.7,
+        help='IoU threshold for NMS (default: 0.7)'
+    )
+
+    parser.add_argument(
+        '--imgsz',
+        type=int,
+        default=640,
+        help='Input image size (default: 640)'
+    )
+
+    parser.add_argument(
+        '--device',
+        type=str,
+        default='',
+        help='Device to run on (cpu, cuda, mps, etc.) (default: auto-detect)'
+    )
+
+    parser.add_argument(
+        '--save',
+        action='store_true',
+        help='Save annotated images'
+    )
+
+    parser.add_argument(
+        '--show',
+        action='store_true',
+        help='Display results'
+    )
+
+    parser.add_argument(
+        '--save-txt',
+        action='store_true',
+        help='Save detection results to txt files'
+    )
+
+    parser.add_argument(
+        '--save-conf',
+        action='store_true',
+        help='Save confidence scores in txt files'
+    )
+
+    parser.add_argument(
+        '--save-crop',
+        action='store_true',
+        help='Save cropped detection images'
+    )
+
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        default=True,
+        help='Enable verbose output'
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    """Main inference function."""
+    args = parse_arguments()
+
+    try:
+        # Initialize inference model
+        inference = YOLOInference(
+            weights=args.weights,
+            conf=args.conf,
+            iou=args.iou,
+            imgsz=args.imgsz,
+            device=args.device,
+            verbose=args.verbose
+        )
+
+        # Determine source type and run inference
+        source_path = Path(args.source)
+        start_time = time.time()
+
+        if source_path.is_file():
+            # Single image inference
+            if args.verbose:
+                LOGGER.info(f"Running inference on single image: {source_path}")
+            
+            results = inference.predict_single(
+                source=source_path,
+                save=args.save,
+                show=args.show,
+                save_txt=args.save_txt,
+                save_conf=args.save_conf,
+                save_crop=args.save_crop,
+                output_dir=args.output
+            )
+            
+            inference.print_results_summary(results, str(source_path))
+
+        elif source_path.is_dir():
+            # Directory batch inference
+            if args.verbose:
+                LOGGER.info(f"Running batch inference on directory: {source_path}")
+            
+            results = inference.predict_batch(
+                source_dir=source_path,
+                save=args.save,
+                show=args.show,
+                save_txt=args.save_txt,
+                save_conf=args.save_conf,
+                save_crop=args.save_crop,
+                output_dir=args.output
+            )
+            
+            inference.print_results_summary(results, str(source_path))
+
+        else:
+            raise FileNotFoundError(f"Source not found: {source_path}")
+
+        # Print timing information
+        end_time = time.time()
+        if args.verbose:
+            LOGGER.info(f"\nInference completed in {end_time - start_time:.2f} seconds")
+
+    except Exception as e:
+        LOGGER.error(f"Error during inference: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

packages.txt

@@ -0,0 +1,2 @@
+libgl1-mesa-glx
+libglib2.0-0

pyproject.toml

@@ -0,0 +1,186 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Overview:
+# This pyproject.toml file manages the build, packaging, and distribution of the Ultralytics library.
+# It defines essential project metadata, dependencies, and settings used to develop and deploy the library.
+
+# Key Sections:
+# - [build-system]: Specifies the build requirements and backend (e.g., setuptools, wheel).
+# - [project]: Includes details like name, version, description, authors, dependencies and more.
+# - [project.optional-dependencies]: Provides additional, optional packages for extended features.
+# - [tool.*]: Configures settings for various tools (pytest, yapf, etc.) used in the project.
+
+# Installation:
+# The Ultralytics library can be installed using the command: 'pip install ultralytics'
+# For development purposes, you can install the package in editable mode with: 'pip install -e .'
+# This approach allows for real-time code modifications without the need for re-installation.
+
+# Documentation:
+# For comprehensive documentation and usage instructions, visit: https://docs.ultralytics.com
+
+[build-system]
+requires = ["setuptools>=70.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+# Project settings -----------------------------------------------------------------------------------------------------
+[project]
+name = "ultralytics"
+dynamic = ["version"]
+description = "Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { "text" = "AGPL-3.0" }
+keywords = ["machine-learning", "deep-learning", "computer-vision", "ML", "DL", "AI", "YOLO", "YOLOv3", "YOLOv5", "YOLOv8", "YOLOv9", "YOLOv10", "YOLO11", "HUB", "Ultralytics"]
+authors = [
+    { name = "Glenn Jocher", email = "[email protected]" },
+    { name = "Jing Qiu", email = "[email protected]" },
+]
+maintainers = [
+    { name = "Ultralytics", email = "[email protected]" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+]
+
+# Required dependencies ------------------------------------------------------------------------------------------------
+dependencies = [
+    "numpy>=1.23.0",
+    "numpy<2.0.0; sys_platform == 'darwin'", # macOS OpenVINO errors https://github.com/ultralytics/ultralytics/pull/17221
+    "matplotlib>=3.3.0",
+    "opencv-python>=4.6.0",
+    "pillow>=7.1.2",
+    "pyyaml>=5.3.1",
+    "requests>=2.23.0",
+    "scipy>=1.4.1",
+    "torch>=1.8.0",
+    "torch>=1.8.0,!=2.4.0; sys_platform == 'win32'", # Windows CPU errors w/ 2.4.0 https://github.com/ultralytics/ultralytics/issues/15049
+    "torchvision>=0.9.0",
+    "tqdm>=4.64.0", # progress bars
+    "psutil", # system utilization
+    "py-cpuinfo", # display CPU info
+    "pandas>=1.1.4",
+    "seaborn>=0.11.0", # plotting
+    "ultralytics-thop>=2.0.0", # FLOPs computation https://github.com/ultralytics/thop
+]
+
+# Optional dependencies ------------------------------------------------------------------------------------------------
+[project.optional-dependencies]
+dev = [
+    "ipython",
+    "pytest",
+    "pytest-cov",
+    "coverage[toml]",
+    "mkdocs>=1.6.0",
+    "mkdocs-material>=9.5.9",
+    "mkdocstrings[python]",
+    "mkdocs-redirects", # 301 redirects
+    "mkdocs-ultralytics-plugin>=0.1.8", # for meta descriptions and images, dates and authors
+    "mkdocs-macros-plugin>=1.0.5"  # duplicating content (i.e. export tables) in multiple places
+]
+export = [
+    "onnx>=1.12.0", # ONNX export
+    "coremltools>=7.0; platform_system != 'Windows' and python_version <= '3.11'", # CoreML supported on macOS and Linux
+    "scikit-learn>=1.3.2; platform_system != 'Windows' and python_version <= '3.11'", # CoreML k-means quantization
+    "openvino>=2024.0.0", # OpenVINO export
+    "tensorflow>=2.0.0", # TF bug https://github.com/ultralytics/ultralytics/issues/5161
+    "tensorflowjs>=3.9.0", # TF.js export, automatically installs tensorflow
+    "tensorstore>=0.1.63; platform_machine == 'aarch64' and python_version >= '3.9'", # for TF Raspberry Pi exports
+    "keras", # not installed automatically by tensorflow>=2.16
+    "flatbuffers>=23.5.26,<100; platform_machine == 'aarch64'", # update old 'flatbuffers' included inside tensorflow package
+    "numpy==1.23.5; platform_machine == 'aarch64'", # fix error: `np.bool` was a deprecated alias for the builtin `bool` when using TensorRT models on NVIDIA Jetson
+    "h5py!=3.11.0; platform_machine == 'aarch64'", # fix h5py build issues due to missing aarch64 wheels in 3.11 release
+]
+solutions = [
+    "shapely>=2.0.0",    # shapely for point and polygon data matching
+    "streamlit",    # for live inference on web browser i.e `yolo streamlit-predict`
+]
+logging = [
+    "comet", # https://docs.ultralytics.com/integrations/comet/
+    "tensorboard>=2.13.0",
+    "dvclive>=2.12.0",
+]
+extra = [
+    "hub-sdk>=0.0.12", # Ultralytics HUB
+    "ipython", # interactive notebook
+    "albumentations>=1.4.6", # training augmentations
+    "pycocotools>=2.0.7", # COCO mAP
+]
+
+[project.urls]
+"Homepage" = "https://ultralytics.com"
+"Source" = "https://github.com/ultralytics/ultralytics"
+"Documentation" = "https://docs.ultralytics.com"
+"Bug Reports" = "https://github.com/ultralytics/ultralytics/issues"
+"Changelog" = "https://github.com/ultralytics/ultralytics/releases"
+
+[project.scripts]
+yolo = "ultralytics.cfg:entrypoint"
+ultralytics = "ultralytics.cfg:entrypoint"
+
+# Tools settings -------------------------------------------------------------------------------------------------------
+[tool.setuptools]  # configuration specific to the `setuptools` build backend.
+packages = { find = { where = ["."], include = ["ultralytics", "ultralytics.*"] } }
+package-data = { "ultralytics" = ["**/*.yaml", "../tests/*.py"], "ultralytics.assets" = ["*.jpg"] }
+
+[tool.setuptools.dynamic]
+version = { attr = "ultralytics.__version__" }
+
+[tool.pytest.ini_options]
+addopts = "--doctest-modules --durations=30 --color=yes"
+markers = [
+    "slow: skip slow tests unless --slow is set",
+]
+norecursedirs = [".git", "dist", "build"]
+
+[tool.coverage.run]
+source = ["ultralytics/"]
+data_file = "tests/.coverage"
+omit = ["ultralytics/utils/callbacks/*"]
+
+[tool.isort]
+line_length = 120
+multi_line_output = 0
+
+[tool.yapf]
+based_on_style = "pep8"
+spaces_before_comment = 2
+column_limit = 120
+coalesce_brackets = true
+spaces_around_power_operator = true
+space_between_ending_comma_and_closing_bracket = true
+split_before_closing_bracket = false
+split_before_first_argument = false
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.docformatter]
+wrap-summaries = 120
+wrap-descriptions = 120
+pre-summary-newline = true
+close-quotes-on-newline = true
+in-place = true
+
+[tool.codespell]
+ignore-words-list = "crate,nd,ned,strack,dota,ane,segway,fo,gool,winn,commend,bloc,nam,afterall"
+skip = '*.pt,*.pth,*.torchscript,*.onnx,*.tflite,*.pb,*.bin,*.param,*.mlmodel,*.engine,*.npy,*.data*,*.csv,*pnnx*,*venv*,*translat*,__pycache__*,*.ico,*.jpg,*.png,*.mp4,*.mov,/runs,/.git,./docs/??/*.md,./docs/mkdocs_??.yml'

requirements.txt

@@ -1,3 +1,35 @@
-altair
-pandas
-streamlit
+# Core ML and Computer Vision
+torch>=2.0.0
+torchvision>=0.15.0
+ultralytics>=8.0.0
+transformers>=4.30.0
+
+# Streamlit and Web Interface
+streamlit>=1.28.0
+plotly>=5.15.0
+
+# Image Processing and Utilities
+opencv-python-headless>=4.8.0
+Pillow>=9.5.0
+numpy>=1.23.0,<2.0.0
+
+# Data Processing and Analysis
+pandas>=2.0.0
+matplotlib>=3.3.0
+seaborn>=0.11.0
+
+# Additional Dependencies for YOLOv12-DINO
+PyYAML>=5.3.1
+scipy>=1.4.1
+tqdm>=4.64.0
+psutil
+py-cpuinfo
+requests>=2.23.0
+ultralytics-thop>=2.0.0
+
+# Hugging Face Integration
+huggingface_hub
+
+# Optional: For enhanced performance on GPU
+# flash-attn>=2.7.0
+# timm>=1.0.14

run.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+# Tunnel Crack Detection App Launcher
+echo "🔍 Starting Tunnel Crack Detection App..."
+
+# Check if virtual environment exists
+if [ -d "venv" ]; then
+    echo "📦 Activating virtual environment..."
+    source venv/bin/activate
+else
+    echo "⚠️  Virtual environment not found. Consider creating one:"
+    echo "   python -m venv venv"
+    echo "   source venv/bin/activate"
+    echo "   pip install -r requirements.txt"
+    echo ""
+fi
+
+# Check if default model exists
+DEFAULT_MODEL="/Users/sompoteyouwai/env/model_weight/segment_defect.pt"
+if [ -f "$DEFAULT_MODEL" ]; then
+    echo "✅ Default model found: $DEFAULT_MODEL"
+else
+    echo "⚠️  Default model not found at: $DEFAULT_MODEL"
+    echo "   You can still upload a custom model through the web interface"
+fi
+
+# Check if requirements are installed
+echo "🔧 Checking dependencies..."
+python -c "import streamlit, torch, ultralytics" 2>/dev/null
+if [ $? -eq 0 ]; then
+    echo "✅ Dependencies verified"
+else
+    echo "❌ Missing dependencies. Installing..."
+    pip install -r requirements.txt
+fi
+
+echo ""
+echo "🚀 Launching Streamlit app..."
+echo "📱 Open your browser to: http://localhost:8501"
+echo "⏹️  Press Ctrl+C to stop the server"
+echo ""
+
+# Launch Streamlit
+streamlit run streamlit_app.py --server.port 8501 --server.address localhost

streamlit_app.py

@@ -0,0 +1,599 @@
+#!/usr/bin/env python3
+"""
+Tunnel Crack Detection Streamlit App
+
+A Streamlit-based web interface for tunnel crack detection using YOLOv12-DINO.
+Upload images and get real-time crack detection results with interactive controls.
+"""
+
+import streamlit as st
+import cv2
+import numpy as np
+import pandas as pd
+from pathlib import Path
+import tempfile
+import os
+import sys
+from typing import Dict, List, Tuple
+import time
+from PIL import Image
+import plotly.express as px
+import plotly.graph_objects as go
+
+# Add the current directory to the Python path
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
+
+try:
+    from inference import YOLOInference
+except ImportError as e:
+    st.error(f"Error importing inference module: {e}")
+    st.stop()
+
+# Page configuration
+st.set_page_config(
+    page_title="Tunnel Crack Detection",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Configure large file uploads
+import streamlit.web.bootstrap
+try:
+    # Set large upload size (5GB in MB)
+    if hasattr(st, '_config'):
+        st._config.set_option('server.maxUploadSize', 5000)
+    else:
+        # For newer Streamlit versions
+        from streamlit import config
+        config.set_option('server.maxUploadSize', 5000)
+        config.set_option('server.maxMessageSize', 5000)
+except Exception:
+    pass
+
+# Set environment variable for large files (5GB in MB)
+os.environ['STREAMLIT_SERVER_MAX_UPLOAD_SIZE'] = '5000'
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        color: #1e88e5;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-card {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin: 0.5rem 0;
+    }
+    .detection-box {
+        border: 2px solid #1e88e5;
+        border-radius: 0.5rem;
+        padding: 1rem;
+        margin: 1rem 0;
+        background-color: #f8f9fa;
+    }
+    .success-box {
+        border: 2px solid #4caf50;
+        border-radius: 0.5rem;
+        padding: 1rem;
+        margin: 1rem 0;
+        background-color: #f1f8e9;
+    }
+    .error-box {
+        border: 2px solid #f44336;
+        border-radius: 0.5rem;
+        padding: 1rem;
+        margin: 1rem 0;
+        background-color: #ffebee;
+    }
+    .warning-box {
+        border: 2px solid #ff9800;
+        border-radius: 0.5rem;
+        padding: 1rem;
+        margin: 1rem 0;
+        background-color: #fff3e0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'model_loaded' not in st.session_state:
+    st.session_state.model_loaded = False
+if 'model_instance' not in st.session_state:
+    st.session_state.model_instance = None
+if 'detection_history' not in st.session_state:
+    st.session_state.detection_history = []
+
+# Default model weight path
+DEFAULT_WEIGHTS_PATH = "/Users/sompoteyouwai/env/model_weight/segment_defect.pt"
+
+def load_model(weights_path: str, device: str = "cpu") -> Tuple[bool, str]:
+    """Load the YOLO model with specified weights."""
+    try:
+        if not Path(weights_path).exists():
+            return False, f"❌ Model file not found: {weights_path}"
+        
+        with st.spinner("Loading tunnel crack detection model..."):
+            st.session_state.model_instance = YOLOInference(
+                weights=weights_path,
+                conf=0.25,
+                iou=0.7,
+                imgsz=640,
+                device=device,
+                verbose=True
+            )
+        
+        st.session_state.model_loaded = True
+        
+        # Get model information
+        model_info = f"✅ Model loaded successfully\n"
+        model_info += f"📋 Task: {st.session_state.model_instance.model.task}\n"
+        
+        if hasattr(st.session_state.model_instance.model.model, 'names'):
+            class_names = list(st.session_state.model_instance.model.model.names.values())
+            model_info += f"🏷️ Classes ({len(class_names)}): {', '.join(class_names)}"
+            
+        return True, model_info
+        
+    except Exception as e:
+        return False, f"❌ Error loading model: {str(e)}"
+
+def perform_detection(
+    image: np.ndarray,
+    conf_threshold: float,
+    iou_threshold: float,
+    image_size: int
+) -> Tuple[np.ndarray, Dict, str]:
+    """Perform crack detection using the loaded model."""
+    
+    if st.session_state.model_instance is None:
+        return None, {}, "❌ No model loaded"
+    
+    try:
+        # Update model parameters
+        st.session_state.model_instance.conf = conf_threshold
+        st.session_state.model_instance.iou = iou_threshold
+        st.session_state.model_instance.imgsz = image_size
+        
+        # Save image to temporary file
+        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp_file:
+            # Convert RGB to BGR for OpenCV
+            image_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+            cv2.imwrite(tmp_file.name, image_bgr)
+            tmp_path = tmp_file.name
+        
+        start_time = time.time()
+        
+        try:
+            # Use the exact same method as inference.py
+            results = st.session_state.model_instance.predict_single(
+                source=tmp_path,
+                save=False,
+                show=False,
+                save_txt=False,
+                save_conf=False,
+                save_crop=False,
+                output_dir=None
+            )
+            
+            inference_time = time.time() - start_time
+            
+            if not results:
+                return image, {}, "❌ No results returned from model"
+            
+            result = results[0]
+            
+            # Get annotated image
+            annotated_img = result.plot()
+            annotated_img = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)
+            
+            # Process detection results
+            detection_data = process_detection_results(result, inference_time)
+            
+            # Generate summary text
+            summary_text = generate_detection_summary(result, detection_data, inference_time)
+            
+            return annotated_img, detection_data, summary_text
+            
+        finally:
+            # Clean up temporary file
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+                
+    except Exception as e:
+        return None, {}, f"❌ Error during detection: {str(e)}"
+
+def process_detection_results(result, inference_time: float) -> Dict:
+    """Process detection results into structured data."""
+    
+    if result.boxes is None or len(result.boxes) == 0:
+        return {
+            'total_detections': 0,
+            'class_counts': {},
+            'detections': [],
+            'inference_time': inference_time
+        }
+    
+    detections = result.boxes
+    
+    # Get class names
+    if hasattr(st.session_state.model_instance.model.model, 'names'):
+        class_names = st.session_state.model_instance.model.model.names
+    else:
+        class_names = getattr(result, 'names', {i: f"Class_{i}" for i in range(100)})
+    
+    # Process each detection
+    detection_list = []
+    class_counts = {}
+    
+    for i, (box, conf, cls) in enumerate(zip(detections.xyxy, detections.conf, detections.cls)):
+        cls_id = int(cls)
+        cls_name = class_names.get(cls_id, f"Class_{cls_id}")
+        confidence = float(conf)
+        
+        x1, y1, x2, y2 = box.tolist()
+        
+        detection_list.append({
+            'id': i + 1,
+            'class': cls_name,
+            'confidence': confidence,
+            'x1': int(x1),
+            'y1': int(y1),
+            'x2': int(x2),
+            'y2': int(y2),
+            'width': int(x2 - x1),
+            'height': int(y2 - y1),
+            'area': int((x2 - x1) * (y2 - y1))
+        })
+        
+        class_counts[cls_name] = class_counts.get(cls_name, 0) + 1
+    
+    return {
+        'total_detections': len(detection_list),
+        'class_counts': class_counts,
+        'detections': detection_list,
+        'inference_time': inference_time
+    }
+
+def generate_detection_summary(result, detection_data: Dict, inference_time: float) -> str:
+    """Generate detection summary text."""
+    
+    total_detections = detection_data['total_detections']
+    
+    if total_detections == 0:
+        return "🔍 No cracks or defects detected in the image."
+    
+    summary = f"✅ **Detection Results:**\n\n"
+    summary += f"📊 **Images processed:** 1\n"
+    summary += f"📊 **Total detections:** {total_detections}\n"
+    summary += f"⏱️ **Inference time:** {inference_time:.3f}s\n\n"
+    
+    summary += "📋 **Detections by class:**\n"
+    for cls_name, count in sorted(detection_data['class_counts'].items()):
+        summary += f"   • {cls_name}: {count}\n"
+    
+    return summary
+
+def create_detection_chart(detection_data: Dict):
+    """Create interactive charts for detection results."""
+    
+    if detection_data['total_detections'] == 0:
+        st.info("No detections to visualize")
+        return
+    
+    # Class distribution pie chart
+    class_counts = detection_data['class_counts']
+    
+    fig_pie = px.pie(
+        values=list(class_counts.values()),
+        names=list(class_counts.keys()),
+        title="Detection Distribution by Class",
+        color_discrete_sequence=px.colors.qualitative.Set3
+    )
+    fig_pie.update_layout(height=400)
+    
+    st.plotly_chart(fig_pie, use_container_width=True)
+    
+    # Confidence distribution
+    confidences = [det['confidence'] for det in detection_data['detections']]
+    classes = [det['class'] for det in detection_data['detections']]
+    
+    fig_conf = px.box(
+        x=classes,
+        y=confidences,
+        title="Confidence Distribution by Class",
+        color=classes
+    )
+    fig_conf.update_layout(height=400)
+    fig_conf.update_xaxes(title="Class")
+    fig_conf.update_yaxes(title="Confidence Score")
+    
+    st.plotly_chart(fig_conf, use_container_width=True)
+
+def create_detection_table(detection_data: Dict):
+    """Create detailed detection table."""
+    
+    if detection_data['total_detections'] == 0:
+        st.info("No detections to display")
+        return
+    
+    # Convert to DataFrame
+    df = pd.DataFrame(detection_data['detections'])
+    
+    # Format confidence as percentage
+    df['confidence_pct'] = df['confidence'].apply(lambda x: f"{x:.1%}")
+    
+    # Reorder columns for better display
+    display_columns = ['id', 'class', 'confidence_pct', 'x1', 'y1', 'x2', 'y2', 'width', 'height', 'area']
+    df_display = df[display_columns].copy()
+    
+    # Rename columns for better readability
+    df_display.columns = ['ID', 'Class', 'Confidence', 'X1', 'Y1', 'X2', 'Y2', 'Width', 'Height', 'Area']
+    
+    st.dataframe(df_display, use_container_width=True)
+    
+    # Download button for results
+    csv = df_display.to_csv(index=False)
+    st.download_button(
+        label="📥 Download Detection Results (CSV)",
+        data=csv,
+        file_name=f"crack_detection_results_{int(time.time())}.csv",
+        mime="text/csv"
+    )
+
+def main():
+    """Main Streamlit application."""
+    
+    # Header
+    st.markdown('<h1 class="main-header">🔍 Tunnel Crack Detection</h1>', unsafe_allow_html=True)
+    st.markdown("**AI-powered crack and defect detection for tunnel infrastructure using YOLOv12-DINO**")
+    
+    # Sidebar for model configuration
+    with st.sidebar:
+        st.header("🛠️ Model Configuration")
+        
+        # Model loading section
+        st.subheader("📁 Load Model")
+        
+        # Check if default model exists
+        default_exists = Path(DEFAULT_WEIGHTS_PATH).exists()
+        
+        if default_exists:
+            st.success(f"✅ Default model found: `segment_defect.pt`")
+            if st.button("🚀 Load Default Model", type="primary"):
+                device = st.selectbox(
+                    "Device",
+                    options=["cpu", "cuda", "mps"],
+                    index=0,
+                    help="Select computation device",
+                    key="device_default"
+                )
+                success, message = load_model(DEFAULT_WEIGHTS_PATH, device)
+                if success:
+                    st.success(message)
+                else:
+                    st.error(message)
+        else:
+            st.markdown(f'<div class="warning-box">⚠️ Default model not found at:<br><code>{DEFAULT_WEIGHTS_PATH}</code></div>', 
+                       unsafe_allow_html=True)
+        
+        st.markdown("---")
+        
+        # Alternative model upload
+        st.info("💡 **Alternative:** Upload a custom model (up to 5GB)")
+        uploaded_file = st.file_uploader(
+            "Upload Model Weights (.pt file)",
+            type=['pt'],
+            help="Upload your trained YOLOv12-DINO model weights",
+            label_visibility="visible"
+        )
+        
+        device = st.selectbox(
+            "Device",
+            options=["cpu", "cuda", "mps"],
+            index=0,
+            help="Select computation device",
+            key="device_upload"
+        )
+        
+        if uploaded_file is not None:
+            # Show file info
+            file_size_mb = uploaded_file.size / (1024 * 1024)
+            st.success(f"📁 File uploaded: {uploaded_file.name} ({file_size_mb:.1f} MB)")
+            
+            if st.button("🔄 Load Uploaded Model", type="secondary"):
+                # Show progress for large file processing
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                try:
+                    # Save uploaded file temporarily with progress indication
+                    status_text.text("💾 Saving uploaded file...")
+                    progress_bar.progress(25)
+                    
+                    with tempfile.NamedTemporaryFile(delete=False, suffix='.pt') as tmp_file:
+                        tmp_file.write(uploaded_file.read())
+                        tmp_path = tmp_file.name
+                    
+                    progress_bar.progress(50)
+                    status_text.text("🚀 Loading model...")
+                    
+                    success, message = load_model(tmp_path, device)
+                    
+                    progress_bar.progress(100)
+                    status_text.text("✅ Model loading complete!")
+                    
+                    if success:
+                        st.success(message)
+                    else:
+                        st.error(message)
+                        
+                    # Clean up progress indicators
+                    time.sleep(1)
+                    progress_bar.empty()
+                    status_text.empty()
+                    
+                except Exception as e:
+                    st.error(f"❌ Error processing file: {str(e)}")
+                    progress_bar.empty()
+                    status_text.empty()
+        
+        # Detection parameters
+        st.subheader("⚙️ Detection Parameters")
+        
+        conf_threshold = st.slider(
+            "Confidence Threshold",
+            min_value=0.01,
+            max_value=1.0,
+            value=0.25,
+            step=0.01,
+            help="Minimum confidence for detection"
+        )
+        
+        iou_threshold = st.slider(
+            "IoU Threshold",
+            min_value=0.01,
+            max_value=1.0,
+            value=0.7,
+            step=0.01,
+            help="IoU threshold for Non-Maximum Suppression"
+        )
+        
+        image_size = st.selectbox(
+            "Image Size",
+            options=[320, 416, 512, 640, 832, 1024, 1280],
+            index=3,
+            help="Input image size for model"
+        )
+        
+        # Model status
+        if st.session_state.model_loaded:
+            st.markdown('<div class="success-box">✅ Model loaded and ready</div>', unsafe_allow_html=True)
+        else:
+            st.markdown('<div class="warning-box">⚠️ Please load a model first</div>', unsafe_allow_html=True)
+    
+    # Main content area
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.header("🖼️ Input Image")
+        
+        # Image upload
+        image_file = st.file_uploader(
+            "Upload Image",
+            type=['jpg', 'jpeg', 'png', 'bmp'],
+            help="Upload a tunnel image for crack detection"
+        )
+        
+        if image_file is not None:
+            # Load and display image
+            try:
+                image = Image.open(image_file)
+                image_np = np.array(image)
+                
+                # Display image
+                st.image(image, caption="Input Image", width=None)
+                
+                # Image info
+                st.info(f"📊 Image size: {image.width} × {image.height} pixels")
+                
+            except Exception as e:
+                st.error(f"❌ Error loading image: {str(e)}")
+                return
+            
+            # Detection button
+            if st.button("🔍 Detect Cracks", type="primary", disabled=not st.session_state.model_loaded):
+                if st.session_state.model_loaded:
+                    with st.spinner("Analyzing image for cracks and defects..."):
+                        annotated_img, detection_data, summary_text = perform_detection(
+                            image_np, conf_threshold, iou_threshold, image_size
+                        )
+                        
+                        # Store results in session state
+                        st.session_state.last_detection = {
+                            'annotated_img': annotated_img,
+                            'detection_data': detection_data,
+                            'summary_text': summary_text,
+                            'timestamp': time.time()
+                        }
+                        
+                        # Add to history
+                        st.session_state.detection_history.append({
+                            'filename': image_file.name,
+                            'detections': detection_data['total_detections'],
+                            'timestamp': time.time()
+                        })
+                else:
+                    st.error("❌ Please load a model first")
+    
+    with col2:
+        st.header("🎯 Detection Results")
+        
+        if 'last_detection' in st.session_state:
+            detection_result = st.session_state.last_detection
+            
+            # Display annotated image
+            if detection_result['annotated_img'] is not None:
+                try:
+                    st.image(
+                        detection_result['annotated_img'],
+                        caption="Crack Detection Results",
+                        width=None
+                    )
+                except Exception as e:
+                    st.error(f"Error displaying result image: {str(e)}")
+            
+            # Display summary
+            st.markdown(f'<div class="detection-box">{detection_result["summary_text"]}</div>', 
+                       unsafe_allow_html=True)
+            
+        else:
+            st.info("🔍 Upload an image and click 'Detect Cracks' to see results")
+    
+    # Additional tabs for detailed analysis
+    if 'last_detection' in st.session_state and st.session_state.last_detection['detection_data']['total_detections'] > 0:
+        
+        st.header("📊 Detailed Analysis")
+        
+        tab1, tab2, tab3 = st.tabs(["📈 Charts", "📋 Detection Table", "📜 History"])
+        
+        with tab1:
+            create_detection_chart(st.session_state.last_detection['detection_data'])
+        
+        with tab2:
+            create_detection_table(st.session_state.last_detection['detection_data'])
+        
+        with tab3:
+            if st.session_state.detection_history:
+                history_df = pd.DataFrame(st.session_state.detection_history)
+                history_df['timestamp'] = pd.to_datetime(history_df['timestamp'], unit='s')
+                history_df.columns = ['Filename', 'Detections', 'Timestamp']
+                
+                st.dataframe(history_df, use_container_width=True)
+                
+                # Clear history button
+                if st.button("🗑️ Clear History"):
+                    st.session_state.detection_history = []
+                    st.rerun()
+            else:
+                st.info("No detection history yet")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        """
+        <div style='text-align: center; color: #666; padding: 1rem;'>
+            🔍 <strong>Tunnel Crack Detection System</strong> | 
+            Powered by <strong>Streamlit</strong> + <strong>YOLOv12-DINO</strong>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+if __name__ == "__main__":
+    main()

ultralytics/__init__.py

@@ -0,0 +1,29 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+__version__ = "8.3.63"
+
+import os
+
+# Set ENV variables (place before imports)
+if not os.environ.get("OMP_NUM_THREADS"):
+    os.environ["OMP_NUM_THREADS"] = "1"  # default for reduced CPU utilization during training
+
+from ultralytics.models import NAS, RTDETR, SAM, YOLO, FastSAM, YOLOWorld
+from ultralytics.utils import ASSETS, SETTINGS
+from ultralytics.utils.checks import check_yolo as checks
+from ultralytics.utils.downloads import download
+
+settings = SETTINGS
+__all__ = (
+    "__version__",
+    "ASSETS",
+    "YOLO",
+    "YOLOWorld",
+    "NAS",
+    "SAM",
+    "FastSAM",
+    "RTDETR",
+    "checks",
+    "download",
+    "settings",
+)

ultralytics/cfg/__init__.py

@@ -0,0 +1,1025 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Dict, List, Union
+
+import cv2
+
+from ultralytics.utils import (
+    ASSETS,
+    DEFAULT_CFG,
+    DEFAULT_CFG_DICT,
+    DEFAULT_CFG_PATH,
+    DEFAULT_SOL_DICT,
+    IS_VSCODE,
+    LOGGER,
+    RANK,
+    ROOT,
+    RUNS_DIR,
+    SETTINGS,
+    SETTINGS_FILE,
+    TESTS_RUNNING,
+    IterableSimpleNamespace,
+    __version__,
+    checks,
+    colorstr,
+    deprecation_warn,
+    vscode_msg,
+    yaml_load,
+    yaml_print,
+)
+
+# Define valid solutions
+SOLUTION_MAP = {
+    "count": ("ObjectCounter", "count"),
+    "heatmap": ("Heatmap", "generate_heatmap"),
+    "queue": ("QueueManager", "process_queue"),
+    "speed": ("SpeedEstimator", "estimate_speed"),
+    "workout": ("AIGym", "monitor"),
+    "analytics": ("Analytics", "process_data"),
+    "trackzone": ("TrackZone", "trackzone"),
+    "inference": ("Inference", "inference"),
+    "help": None,
+}
+
+# Define valid tasks and modes
+MODES = {"train", "val", "predict", "export", "track", "benchmark"}
+TASKS = {"detect", "segment", "classify", "pose", "obb"}
+TASK2DATA = {
+    "detect": "coco8.yaml",
+    "segment": "coco8-seg.yaml",
+    "classify": "imagenet10",
+    "pose": "coco8-pose.yaml",
+    "obb": "dota8.yaml",
+}
+TASK2MODEL = {
+    "detect": "yolo11n.pt",
+    "segment": "yolo11n-seg.pt",
+    "classify": "yolo11n-cls.pt",
+    "pose": "yolo11n-pose.pt",
+    "obb": "yolo11n-obb.pt",
+}
+TASK2METRIC = {
+    "detect": "metrics/mAP50-95(B)",
+    "segment": "metrics/mAP50-95(M)",
+    "classify": "metrics/accuracy_top1",
+    "pose": "metrics/mAP50-95(P)",
+    "obb": "metrics/mAP50-95(B)",
+}
+MODELS = {TASK2MODEL[task] for task in TASKS}
+
+ARGV = sys.argv or ["", ""]  # sometimes sys.argv = []
+SOLUTIONS_HELP_MSG = f"""
+    Arguments received: {str(["yolo"] + ARGV[1:])}. Ultralytics 'yolo solutions' usage overview:
+
+        yolo solutions SOLUTION ARGS
+
+        Where SOLUTION (optional) is one of {list(SOLUTION_MAP.keys())[:-1]}
+              ARGS (optional) are any number of custom 'arg=value' pairs like 'show_in=True' that override defaults 
+                  at https://docs.ultralytics.com/usage/cfg
+                
+    1. Call object counting solution
+        yolo solutions count source="path/to/video/file.mp4" region=[(20, 400), (1080, 400), (1080, 360), (20, 360)]
+
+    2. Call heatmaps solution
+        yolo solutions heatmap colormap=cv2.COLORMAP_PARULA model=yolo11n.pt
+
+    3. Call queue management solution
+        yolo solutions queue region=[(20, 400), (1080, 400), (1080, 360), (20, 360)] model=yolo11n.pt
+
+    4. Call workouts monitoring solution for push-ups
+        yolo solutions workout model=yolo11n-pose.pt kpts=[6, 8, 10]
+
+    5. Generate analytical graphs
+        yolo solutions analytics analytics_type="pie"
+    
+    6. Track objects within specific zones
+        yolo solutions trackzone source="path/to/video/file.mp4" region=[(150, 150), (1130, 150), (1130, 570), (150, 570)]
+        
+    7. Streamlit real-time webcam inference GUI
+        yolo streamlit-predict
+    """
+CLI_HELP_MSG = f"""
+    Arguments received: {str(["yolo"] + ARGV[1:])}. Ultralytics 'yolo' commands use the following syntax:
+
+        yolo TASK MODE ARGS
+
+        Where   TASK (optional) is one of {TASKS}
+                MODE (required) is one of {MODES}
+                ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
+                    See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
+
+    1. Train a detection model for 10 epochs with an initial learning_rate of 0.01
+        yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
+
+    2. Predict a YouTube video using a pretrained segmentation model at image size 320:
+        yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+
+    3. Val a pretrained detection model at batch-size 1 and image size 640:
+        yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
+
+    4. Export a YOLO11n classification model to ONNX format at image size 224 by 128 (no TASK required)
+        yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
+
+    5. Ultralytics solutions usage
+        yolo solutions count or in {list(SOLUTION_MAP.keys())[1:-1]} source="path/to/video/file.mp4"
+
+    6. Run special commands:
+        yolo help
+        yolo checks
+        yolo version
+        yolo settings
+        yolo copy-cfg
+        yolo cfg
+        yolo solutions help
+
+    Docs: https://docs.ultralytics.com
+    Solutions: https://docs.ultralytics.com/solutions/
+    Community: https://community.ultralytics.com
+    GitHub: https://github.com/ultralytics/ultralytics
+    """
+
+# Define keys for arg type checks
+CFG_FLOAT_KEYS = {  # integer or float arguments, i.e. x=2 and x=2.0
+    "warmup_epochs",
+    "box",
+    "cls",
+    "dfl",
+    "degrees",
+    "shear",
+    "time",
+    "workspace",
+    "batch",
+}
+CFG_FRACTION_KEYS = {  # fractional float arguments with 0.0<=values<=1.0
+    "dropout",
+    "lr0",
+    "lrf",
+    "momentum",
+    "weight_decay",
+    "warmup_momentum",
+    "warmup_bias_lr",
+    "hsv_h",
+    "hsv_s",
+    "hsv_v",
+    "translate",
+    "scale",
+    "perspective",
+    "flipud",
+    "fliplr",
+    "bgr",
+    "mosaic",
+    "mixup",
+    "copy_paste",
+    "conf",
+    "iou",
+    "fraction",
+}
+CFG_INT_KEYS = {  # integer-only arguments
+    "epochs",
+    "patience",
+    "workers",
+    "seed",
+    "close_mosaic",
+    "mask_ratio",
+    "max_det",
+    "vid_stride",
+    "line_width",
+    "nbs",
+    "save_period",
+}
+CFG_BOOL_KEYS = {  # boolean-only arguments
+    "save",
+    "exist_ok",
+    "verbose",
+    "deterministic",
+    "single_cls",
+    "rect",
+    "cos_lr",
+    "overlap_mask",
+    "val",
+    "save_json",
+    "save_hybrid",
+    "half",
+    "dnn",
+    "plots",
+    "show",
+    "save_txt",
+    "save_conf",
+    "save_crop",
+    "save_frames",
+    "show_labels",
+    "show_conf",
+    "visualize",
+    "augment",
+    "agnostic_nms",
+    "retina_masks",
+    "show_boxes",
+    "keras",
+    "optimize",
+    "int8",
+    "dynamic",
+    "simplify",
+    "nms",
+    "profile",
+    "multi_scale",
+}
+
+
+def cfg2dict(cfg):
+    """
+    Converts a configuration object to a dictionary.
+
+    Args:
+        cfg (str | Path | Dict | SimpleNamespace): Configuration object to be converted. Can be a file path,
+            a string, a dictionary, or a SimpleNamespace object.
+
+    Returns:
+        (Dict): Configuration object in dictionary format.
+
+    Examples:
+        Convert a YAML file path to a dictionary:
+        >>> config_dict = cfg2dict("config.yaml")
+
+        Convert a SimpleNamespace to a dictionary:
+        >>> from types import SimpleNamespace
+        >>> config_sn = SimpleNamespace(param1="value1", param2="value2")
+        >>> config_dict = cfg2dict(config_sn)
+
+        Pass through an already existing dictionary:
+        >>> config_dict = cfg2dict({"param1": "value1", "param2": "value2"})
+
+    Notes:
+        - If cfg is a path or string, it's loaded as YAML and converted to a dictionary.
+        - If cfg is a SimpleNamespace object, it's converted to a dictionary using vars().
+        - If cfg is already a dictionary, it's returned unchanged.
+    """
+    if isinstance(cfg, (str, Path)):
+        cfg = yaml_load(cfg)  # load dict
+    elif isinstance(cfg, SimpleNamespace):
+        cfg = vars(cfg)  # convert to dict
+    return cfg
+
+
+def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, overrides: Dict = None):
+    """
+    Load and merge configuration data from a file or dictionary, with optional overrides.
+
+    Args:
+        cfg (str | Path | Dict | SimpleNamespace): Configuration data source. Can be a file path, dictionary, or
+            SimpleNamespace object.
+        overrides (Dict | None): Dictionary containing key-value pairs to override the base configuration.
+
+    Returns:
+        (SimpleNamespace): Namespace containing the merged configuration arguments.
+
+    Examples:
+        >>> from ultralytics.cfg import get_cfg
+        >>> config = get_cfg()  # Load default configuration
+        >>> config_with_overrides = get_cfg("path/to/config.yaml", overrides={"epochs": 50, "batch_size": 16})
+
+    Notes:
+        - If both `cfg` and `overrides` are provided, the values in `overrides` will take precedence.
+        - Special handling ensures alignment and correctness of the configuration, such as converting numeric
+          `project` and `name` to strings and validating configuration keys and values.
+        - The function performs type and value checks on the configuration data.
+    """
+    cfg = cfg2dict(cfg)
+
+    # Merge overrides
+    if overrides:
+        overrides = cfg2dict(overrides)
+        if "save_dir" not in cfg:
+            overrides.pop("save_dir", None)  # special override keys to ignore
+        check_dict_alignment(cfg, overrides)
+        cfg = {**cfg, **overrides}  # merge cfg and overrides dicts (prefer overrides)
+
+    # Special handling for numeric project/name
+    for k in "project", "name":
+        if k in cfg and isinstance(cfg[k], (int, float)):
+            cfg[k] = str(cfg[k])
+    if cfg.get("name") == "model":  # assign model to 'name' arg
+        cfg["name"] = str(cfg.get("model", "")).split(".")[0]
+        LOGGER.warning(f"WARNING ⚠️ 'name=model' automatically updated to 'name={cfg['name']}'.")
+
+    # Type and Value checks
+    check_cfg(cfg)
+
+    # Return instance
+    return IterableSimpleNamespace(**cfg)
+
+
+def check_cfg(cfg, hard=True):
+    """
+    Checks configuration argument types and values for the Ultralytics library.
+
+    This function validates the types and values of configuration arguments, ensuring correctness and converting
+    them if necessary. It checks for specific key types defined in global variables such as CFG_FLOAT_KEYS,
+    CFG_FRACTION_KEYS, CFG_INT_KEYS, and CFG_BOOL_KEYS.
+
+    Args:
+        cfg (Dict): Configuration dictionary to validate.
+        hard (bool): If True, raises exceptions for invalid types and values; if False, attempts to convert them.
+
+    Examples:
+        >>> config = {
+        ...     "epochs": 50,  # valid integer
+        ...     "lr0": 0.01,  # valid float
+        ...     "momentum": 1.2,  # invalid float (out of 0.0-1.0 range)
+        ...     "save": "true",  # invalid bool
+        ... }
+        >>> check_cfg(config, hard=False)
+        >>> print(config)
+        {'epochs': 50, 'lr0': 0.01, 'momentum': 1.2, 'save': False}  # corrected 'save' key
+
+    Notes:
+        - The function modifies the input dictionary in-place.
+        - None values are ignored as they may be from optional arguments.
+        - Fraction keys are checked to be within the range [0.0, 1.0].
+    """
+    for k, v in cfg.items():
+        if v is not None:  # None values may be from optional args
+            if k in CFG_FLOAT_KEYS and not isinstance(v, (int, float)):
+                if hard:
+                    raise TypeError(
+                        f"'{k}={v}' is of invalid type {type(v).__name__}. "
+                        f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
+                    )
+                cfg[k] = float(v)
+            elif k in CFG_FRACTION_KEYS:
+                if not isinstance(v, (int, float)):
+                    if hard:
+                        raise TypeError(
+                            f"'{k}={v}' is of invalid type {type(v).__name__}. "
+                            f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
+                        )
+                    cfg[k] = v = float(v)
+                if not (0.0 <= v <= 1.0):
+                    raise ValueError(f"'{k}={v}' is an invalid value. Valid '{k}' values are between 0.0 and 1.0.")
+            elif k in CFG_INT_KEYS and not isinstance(v, int):
+                if hard:
+                    raise TypeError(
+                        f"'{k}={v}' is of invalid type {type(v).__name__}. '{k}' must be an int (i.e. '{k}=8')"
+                    )
+                cfg[k] = int(v)
+            elif k in CFG_BOOL_KEYS and not isinstance(v, bool):
+                if hard:
+                    raise TypeError(
+                        f"'{k}={v}' is of invalid type {type(v).__name__}. "
+                        f"'{k}' must be a bool (i.e. '{k}=True' or '{k}=False')"
+                    )
+                cfg[k] = bool(v)
+
+
+def get_save_dir(args, name=None):
+    """
+    Returns the directory path for saving outputs, derived from arguments or default settings.
+
+    Args:
+        args (SimpleNamespace): Namespace object containing configurations such as 'project', 'name', 'task',
+            'mode', and 'save_dir'.
+        name (str | None): Optional name for the output directory. If not provided, it defaults to 'args.name'
+            or the 'args.mode'.
+
+    Returns:
+        (Path): Directory path where outputs should be saved.
+
+    Examples:
+        >>> from types import SimpleNamespace
+        >>> args = SimpleNamespace(project="my_project", task="detect", mode="train", exist_ok=True)
+        >>> save_dir = get_save_dir(args)
+        >>> print(save_dir)
+        my_project/detect/train
+    """
+    if getattr(args, "save_dir", None):
+        save_dir = args.save_dir
+    else:
+        from ultralytics.utils.files import increment_path
+
+        project = args.project or (ROOT.parent / "tests/tmp/runs" if TESTS_RUNNING else RUNS_DIR) / args.task
+        name = name or args.name or f"{args.mode}"
+        save_dir = increment_path(Path(project) / name, exist_ok=args.exist_ok if RANK in {-1, 0} else True)
+
+    return Path(save_dir)
+
+
+def _handle_deprecation(custom):
+    """
+    Handles deprecated configuration keys by mapping them to current equivalents with deprecation warnings.
+
+    Args:
+        custom (Dict): Configuration dictionary potentially containing deprecated keys.
+
+    Examples:
+        >>> custom_config = {"boxes": True, "hide_labels": "False", "line_thickness": 2}
+        >>> _handle_deprecation(custom_config)
+        >>> print(custom_config)
+        {'show_boxes': True, 'show_labels': True, 'line_width': 2}
+
+    Notes:
+        This function modifies the input dictionary in-place, replacing deprecated keys with their current
+        equivalents. It also handles value conversions where necessary, such as inverting boolean values for
+        'hide_labels' and 'hide_conf'.
+    """
+    for key in custom.copy().keys():
+        if key == "boxes":
+            deprecation_warn(key, "show_boxes")
+            custom["show_boxes"] = custom.pop("boxes")
+        if key == "hide_labels":
+            deprecation_warn(key, "show_labels")
+            custom["show_labels"] = custom.pop("hide_labels") == "False"
+        if key == "hide_conf":
+            deprecation_warn(key, "show_conf")
+            custom["show_conf"] = custom.pop("hide_conf") == "False"
+        if key == "line_thickness":
+            deprecation_warn(key, "line_width")
+            custom["line_width"] = custom.pop("line_thickness")
+        if key == "label_smoothing":
+            deprecation_warn(key)
+            custom.pop("label_smoothing")
+
+    return custom
+
+
+def check_dict_alignment(base: Dict, custom: Dict, e=None):
+    """
+    Checks alignment between custom and base configuration dictionaries, handling deprecated keys and providing error
+    messages for mismatched keys.
+
+    Args:
+        base (Dict): The base configuration dictionary containing valid keys.
+        custom (Dict): The custom configuration dictionary to be checked for alignment.
+        e (Exception | None): Optional error instance passed by the calling function.
+
+    Raises:
+        SystemExit: If mismatched keys are found between the custom and base dictionaries.
+
+    Examples:
+        >>> base_cfg = {"epochs": 50, "lr0": 0.01, "batch_size": 16}
+        >>> custom_cfg = {"epoch": 100, "lr": 0.02, "batch_size": 32}
+        >>> try:
+        ...     check_dict_alignment(base_cfg, custom_cfg)
+        ... except SystemExit:
+        ...     print("Mismatched keys found")
+
+    Notes:
+        - Suggests corrections for mismatched keys based on similarity to valid keys.
+        - Automatically replaces deprecated keys in the custom configuration with updated equivalents.
+        - Prints detailed error messages for each mismatched key to help users correct their configurations.
+    """
+    custom = _handle_deprecation(custom)
+    base_keys, custom_keys = (set(x.keys()) for x in (base, custom))
+    if mismatched := [k for k in custom_keys if k not in base_keys]:
+        from difflib import get_close_matches
+
+        string = ""
+        for x in mismatched:
+            matches = get_close_matches(x, base_keys)  # key list
+            matches = [f"{k}={base[k]}" if base.get(k) is not None else k for k in matches]
+            match_str = f"Similar arguments are i.e. {matches}." if matches else ""
+            string += f"'{colorstr('red', 'bold', x)}' is not a valid YOLO argument. {match_str}\n"
+        raise SyntaxError(string + CLI_HELP_MSG) from e
+
+
+def merge_equals_args(args: List[str]) -> List[str]:
+    """
+    Merges arguments around isolated '=' in a list of strings and joins fragments with brackets.
+
+    This function handles the following cases:
+    1. ['arg', '=', 'val'] becomes ['arg=val']
+    2. ['arg=', 'val'] becomes ['arg=val']
+    3. ['arg', '=val'] becomes ['arg=val']
+    4. Joins fragments with brackets, e.g., ['imgsz=[3,', '640,', '640]'] becomes ['imgsz=[3,640,640]']
+
+    Args:
+        args (List[str]): A list of strings where each element represents an argument or fragment.
+
+    Returns:
+        List[str]: A list of strings where the arguments around isolated '=' are merged and fragments with brackets are joined.
+
+    Examples:
+        >>> args = ["arg1", "=", "value", "arg2=", "value2", "arg3", "=value3", "imgsz=[3,", "640,", "640]"]
+        >>> merge_and_join_args(args)
+        ['arg1=value', 'arg2=value2', 'arg3=value3', 'imgsz=[3,640,640]']
+    """
+    new_args = []
+    current = ""
+    depth = 0
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        # Handle equals sign merging
+        if arg == "=" and 0 < i < len(args) - 1:  # merge ['arg', '=', 'val']
+            new_args[-1] += f"={args[i + 1]}"
+            i += 2
+            continue
+        elif arg.endswith("=") and i < len(args) - 1 and "=" not in args[i + 1]:  # merge ['arg=', 'val']
+            new_args.append(f"{arg}{args[i + 1]}")
+            i += 2
+            continue
+        elif arg.startswith("=") and i > 0:  # merge ['arg', '=val']
+            new_args[-1] += arg
+            i += 1
+            continue
+
+        # Handle bracket joining
+        depth += arg.count("[") - arg.count("]")
+        current += arg
+        if depth == 0:
+            new_args.append(current)
+            current = ""
+
+        i += 1
+
+    # Append any remaining current string
+    if current:
+        new_args.append(current)
+
+    return new_args
+
+
+def handle_yolo_hub(args: List[str]) -> None:
+    """
+    Handles Ultralytics HUB command-line interface (CLI) commands for authentication.
+
+    This function processes Ultralytics HUB CLI commands such as login and logout. It should be called when executing a
+    script with arguments related to HUB authentication.
+
+    Args:
+        args (List[str]): A list of command line arguments. The first argument should be either 'login'
+            or 'logout'. For 'login', an optional second argument can be the API key.
+
+    Examples:
+        ```bash
+        yolo login YOUR_API_KEY
+        ```
+
+    Notes:
+        - The function imports the 'hub' module from ultralytics to perform login and logout operations.
+        - For the 'login' command, if no API key is provided, an empty string is passed to the login function.
+        - The 'logout' command does not require any additional arguments.
+    """
+    from ultralytics import hub
+
+    if args[0] == "login":
+        key = args[1] if len(args) > 1 else ""
+        # Log in to Ultralytics HUB using the provided API key
+        hub.login(key)
+    elif args[0] == "logout":
+        # Log out from Ultralytics HUB
+        hub.logout()
+
+
+def handle_yolo_settings(args: List[str]) -> None:
+    """
+    Handles YOLO settings command-line interface (CLI) commands.
+
+    This function processes YOLO settings CLI commands such as reset and updating individual settings. It should be
+    called when executing a script with arguments related to YOLO settings management.
+
+    Args:
+        args (List[str]): A list of command line arguments for YOLO settings management.
+
+    Examples:
+        >>> handle_yolo_settings(["reset"])  # Reset YOLO settings
+        >>> handle_yolo_settings(["default_cfg_path=yolo11n.yaml"])  # Update a specific setting
+
+    Notes:
+        - If no arguments are provided, the function will display the current settings.
+        - The 'reset' command will delete the existing settings file and create new default settings.
+        - Other arguments are treated as key-value pairs to update specific settings.
+        - The function will check for alignment between the provided settings and the existing ones.
+        - After processing, the updated settings will be displayed.
+        - For more information on handling YOLO settings, visit:
+          https://docs.ultralytics.com/quickstart/#ultralytics-settings
+    """
+    url = "https://docs.ultralytics.com/quickstart/#ultralytics-settings"  # help URL
+    try:
+        if any(args):
+            if args[0] == "reset":
+                SETTINGS_FILE.unlink()  # delete the settings file
+                SETTINGS.reset()  # create new settings
+                LOGGER.info("Settings reset successfully")  # inform the user that settings have been reset
+            else:  # save a new setting
+                new = dict(parse_key_value_pair(a) for a in args)
+                check_dict_alignment(SETTINGS, new)
+                SETTINGS.update(new)
+
+        print(SETTINGS)  # print the current settings
+        LOGGER.info(f"💡 Learn more about Ultralytics Settings at {url}")
+    except Exception as e:
+        LOGGER.warning(f"WARNING ⚠️ settings error: '{e}'. Please see {url} for help.")
+
+
+def handle_yolo_solutions(args: List[str]) -> None:
+    """
+    Processes YOLO solutions arguments and runs the specified computer vision solutions pipeline.
+
+    Args:
+        args (List[str]): Command-line arguments for configuring and running the Ultralytics YOLO
+            solutions: https://docs.ultralytics.com/solutions/, It can include solution name, source,
+            and other configuration parameters.
+
+    Returns:
+        None: The function processes video frames and saves the output but doesn't return any value.
+
+    Examples:
+        Run people counting solution with default settings:
+        >>> handle_yolo_solutions(["count"])
+
+        Run analytics with custom configuration:
+        >>> handle_yolo_solutions(["analytics", "conf=0.25", "source=path/to/video/file.mp4"])
+
+        Run inference with custom configuration, requires Streamlit version 1.29.0 or higher.
+        >>> handle_yolo_solutions(["inference", "model=yolo11n.pt"])
+
+    Notes:
+        - Default configurations are merged from DEFAULT_SOL_DICT and DEFAULT_CFG_DICT
+        - Arguments can be provided in the format 'key=value' or as boolean flags
+        - Available solutions are defined in SOLUTION_MAP with their respective classes and methods
+        - If an invalid solution is provided, defaults to 'count' solution
+        - Output videos are saved in 'runs/solution/{solution_name}' directory
+        - For 'analytics' solution, frame numbers are tracked for generating analytical graphs
+        - Video processing can be interrupted by pressing 'q'
+        - Processes video frames sequentially and saves output in .avi format
+        - If no source is specified, downloads and uses a default sample video\
+        - The inference solution will be launched using the 'streamlit run' command.
+        - The Streamlit app file is located in the Ultralytics package directory.
+    """
+    full_args_dict = {**DEFAULT_SOL_DICT, **DEFAULT_CFG_DICT}  # arguments dictionary
+    overrides = {}
+
+    # check dictionary alignment
+    for arg in merge_equals_args(args):
+        arg = arg.lstrip("-").rstrip(",")
+        if "=" in arg:
+            try:
+                k, v = parse_key_value_pair(arg)
+                overrides[k] = v
+            except (NameError, SyntaxError, ValueError, AssertionError) as e:
+                check_dict_alignment(full_args_dict, {arg: ""}, e)
+        elif arg in full_args_dict and isinstance(full_args_dict.get(arg), bool):
+            overrides[arg] = True
+    check_dict_alignment(full_args_dict, overrides)  # dict alignment
+
+    # Get solution name
+    if args and args[0] in SOLUTION_MAP:
+        if args[0] != "help":
+            s_n = args.pop(0)  # Extract the solution name directly
+        else:
+            LOGGER.info(SOLUTIONS_HELP_MSG)
+    else:
+        LOGGER.warning(
+            f"⚠️ No valid solution provided. Using default 'count'. Available: {', '.join(SOLUTION_MAP.keys())}"
+        )
+        s_n = "count"  # Default solution if none provided
+
+    if args and args[0] == "help":  # Add check for return if user call `yolo solutions help`
+        return
+
+    if s_n == "inference":
+        checks.check_requirements("streamlit>=1.29.0")
+        LOGGER.info("💡 Loading Ultralytics live inference app...")
+        subprocess.run(
+            [  # Run subprocess with Streamlit custom argument
+                "streamlit",
+                "run",
+                str(ROOT / "solutions/streamlit_inference.py"),
+                "--server.headless",
+                "true",
+                overrides.pop("model", "yolo11n.pt"),
+            ]
+        )
+    else:
+        cls, method = SOLUTION_MAP[s_n]  # solution class name, method name and default source
+
+        from ultralytics import solutions  # import ultralytics solutions
+
+        solution = getattr(solutions, cls)(IS_CLI=True, **overrides)  # get solution class i.e ObjectCounter
+        process = getattr(
+            solution, method
+        )  # get specific function of class for processing i.e, count from ObjectCounter
+
+        cap = cv2.VideoCapture(solution.CFG["source"])  # read the video file
+
+        # extract width, height and fps of the video file, create save directory and initialize video writer
+        import os  # for directory creation
+        from pathlib import Path
+
+        from ultralytics.utils.files import increment_path  # for output directory path update
+
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+        if s_n == "analytics":  # analytical graphs follow fixed shape for output i.e w=1920, h=1080
+            w, h = 1920, 1080
+        save_dir = increment_path(Path("runs") / "solutions" / "exp", exist_ok=False)
+        save_dir.mkdir(parents=True, exist_ok=True)  # create the output directory
+        vw = cv2.VideoWriter(os.path.join(save_dir, "solution.avi"), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
+
+        try:  # Process video frames
+            f_n = 0  # frame number, required for analytical graphs
+            while cap.isOpened():
+                success, frame = cap.read()
+                if not success:
+                    break
+                frame = process(frame, f_n := f_n + 1) if s_n == "analytics" else process(frame)
+                vw.write(frame)
+                if cv2.waitKey(1) & 0xFF == ord("q"):
+                    break
+        finally:
+            cap.release()
+
+
+def parse_key_value_pair(pair: str = "key=value"):
+    """
+    Parses a key-value pair string into separate key and value components.
+
+    Args:
+        pair (str): A string containing a key-value pair in the format "key=value".
+
+    Returns:
+        key (str): The parsed key.
+        value (str): The parsed value.
+
+    Raises:
+        AssertionError: If the value is missing or empty.
+
+    Examples:
+        >>> key, value = parse_key_value_pair("model=yolo11n.pt")
+        >>> print(f"Key: {key}, Value: {value}")
+        Key: model, Value: yolo11n.pt
+
+        >>> key, value = parse_key_value_pair("epochs=100")
+        >>> print(f"Key: {key}, Value: {value}")
+        Key: epochs, Value: 100
+
+    Notes:
+        - The function splits the input string on the first '=' character.
+        - Leading and trailing whitespace is removed from both key and value.
+        - An assertion error is raised if the value is empty after stripping.
+    """
+    k, v = pair.split("=", 1)  # split on first '=' sign
+    k, v = k.strip(), v.strip()  # remove spaces
+    assert v, f"missing '{k}' value"
+    return k, smart_value(v)
+
+
+def smart_value(v):
+    """
+    Converts a string representation of a value to its appropriate Python type.
+
+    This function attempts to convert a given string into a Python object of the most appropriate type. It handles
+    conversions to None, bool, int, float, and other types that can be evaluated safely.
+
+    Args:
+        v (str): The string representation of the value to be converted.
+
+    Returns:
+        (Any): The converted value. The type can be None, bool, int, float, or the original string if no conversion
+            is applicable.
+
+    Examples:
+        >>> smart_value("42")
+        42
+        >>> smart_value("3.14")
+        3.14
+        >>> smart_value("True")
+        True
+        >>> smart_value("None")
+        None
+        >>> smart_value("some_string")
+        'some_string'
+
+    Notes:
+        - The function uses a case-insensitive comparison for boolean and None values.
+        - For other types, it attempts to use Python's eval() function, which can be unsafe if used on untrusted input.
+        - If no conversion is possible, the original string is returned.
+    """
+    v_lower = v.lower()
+    if v_lower == "none":
+        return None
+    elif v_lower == "true":
+        return True
+    elif v_lower == "false":
+        return False
+    else:
+        try:
+            return eval(v)
+        except Exception:
+            return v
+
+
+def entrypoint(debug=""):
+    """
+    Ultralytics entrypoint function for parsing and executing command-line arguments.
+
+    This function serves as the main entry point for the Ultralytics CLI, parsing command-line arguments and
+    executing the corresponding tasks such as training, validation, prediction, exporting models, and more.
+
+    Args:
+        debug (str): Space-separated string of command-line arguments for debugging purposes.
+
+    Examples:
+        Train a detection model for 10 epochs with an initial learning_rate of 0.01:
+        >>> entrypoint("train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01")
+
+        Predict a YouTube video using a pretrained segmentation model at image size 320:
+        >>> entrypoint("predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320")
+
+        Validate a pretrained detection model at batch-size 1 and image size 640:
+        >>> entrypoint("val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640")
+
+    Notes:
+        - If no arguments are passed, the function will display the usage help message.
+        - For a list of all available commands and their arguments, see the provided help messages and the
+          Ultralytics documentation at https://docs.ultralytics.com.
+    """
+    args = (debug.split(" ") if debug else ARGV)[1:]
+    if not args:  # no arguments passed
+        LOGGER.info(CLI_HELP_MSG)
+        return
+
+    special = {
+        "help": lambda: LOGGER.info(CLI_HELP_MSG),
+        "checks": checks.collect_system_info,
+        "version": lambda: LOGGER.info(__version__),
+        "settings": lambda: handle_yolo_settings(args[1:]),
+        "cfg": lambda: yaml_print(DEFAULT_CFG_PATH),
+        "hub": lambda: handle_yolo_hub(args[1:]),
+        "login": lambda: handle_yolo_hub(args),
+        "logout": lambda: handle_yolo_hub(args),
+        "copy-cfg": copy_default_cfg,
+        "solutions": lambda: handle_yolo_solutions(args[1:]),
+    }
+    full_args_dict = {**DEFAULT_CFG_DICT, **{k: None for k in TASKS}, **{k: None for k in MODES}, **special}
+
+    # Define common misuses of special commands, i.e. -h, -help, --help
+    special.update({k[0]: v for k, v in special.items()})  # singular
+    special.update({k[:-1]: v for k, v in special.items() if len(k) > 1 and k.endswith("s")})  # singular
+    special = {**special, **{f"-{k}": v for k, v in special.items()}, **{f"--{k}": v for k, v in special.items()}}
+
+    overrides = {}  # basic overrides, i.e. imgsz=320
+    for a in merge_equals_args(args):  # merge spaces around '=' sign
+        if a.startswith("--"):
+            LOGGER.warning(f"WARNING ⚠️ argument '{a}' does not require leading dashes '--', updating to '{a[2:]}'.")
+            a = a[2:]
+        if a.endswith(","):
+            LOGGER.warning(f"WARNING ⚠️ argument '{a}' does not require trailing comma ',', updating to '{a[:-1]}'.")
+            a = a[:-1]
+        if "=" in a:
+            try:
+                k, v = parse_key_value_pair(a)
+                if k == "cfg" and v is not None:  # custom.yaml passed
+                    LOGGER.info(f"Overriding {DEFAULT_CFG_PATH} with {v}")
+                    overrides = {k: val for k, val in yaml_load(checks.check_yaml(v)).items() if k != "cfg"}
+                else:
+                    overrides[k] = v
+            except (NameError, SyntaxError, ValueError, AssertionError) as e:
+                check_dict_alignment(full_args_dict, {a: ""}, e)
+
+        elif a in TASKS:
+            overrides["task"] = a
+        elif a in MODES:
+            overrides["mode"] = a
+        elif a.lower() in special:
+            special[a.lower()]()
+            return
+        elif a in DEFAULT_CFG_DICT and isinstance(DEFAULT_CFG_DICT[a], bool):
+            overrides[a] = True  # auto-True for default bool args, i.e. 'yolo show' sets show=True
+        elif a in DEFAULT_CFG_DICT:
+            raise SyntaxError(
+                f"'{colorstr('red', 'bold', a)}' is a valid YOLO argument but is missing an '=' sign "
+                f"to set its value, i.e. try '{a}={DEFAULT_CFG_DICT[a]}'\n{CLI_HELP_MSG}"
+            )
+        else:
+            check_dict_alignment(full_args_dict, {a: ""})
+
+    # Check keys
+    check_dict_alignment(full_args_dict, overrides)
+
+    # Mode
+    mode = overrides.get("mode")
+    if mode is None:
+        mode = DEFAULT_CFG.mode or "predict"
+        LOGGER.warning(f"WARNING ⚠️ 'mode' argument is missing. Valid modes are {MODES}. Using default 'mode={mode}'.")
+    elif mode not in MODES:
+        raise ValueError(f"Invalid 'mode={mode}'. Valid modes are {MODES}.\n{CLI_HELP_MSG}")
+
+    # Task
+    task = overrides.pop("task", None)
+    if task:
+        if task == "classify" and mode == "track":
+            raise ValueError(
+                f"❌ Classification doesn't support 'mode=track'. Valid modes for classification are"
+                f" {MODES - {'track'}}.\n{CLI_HELP_MSG}"
+            )
+        elif task not in TASKS:
+            if task == "track":
+                LOGGER.warning(
+                    "WARNING ⚠️ invalid 'task=track', setting 'task=detect' and 'mode=track'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}."
+                )
+                task, mode = "detect", "track"
+            else:
+                raise ValueError(f"Invalid 'task={task}'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}")
+        if "model" not in overrides:
+            overrides["model"] = TASK2MODEL[task]
+
+    # Model
+    model = overrides.pop("model", DEFAULT_CFG.model)
+    if model is None:
+        model = "yolo11n.pt"
+        LOGGER.warning(f"WARNING ⚠️ 'model' argument is missing. Using default 'model={model}'.")
+    overrides["model"] = model
+    stem = Path(model).stem.lower()
+    if "rtdetr" in stem:  # guess architecture
+        from ultralytics import RTDETR
+
+        model = RTDETR(model)  # no task argument
+    elif "fastsam" in stem:
+        from ultralytics import FastSAM
+
+        model = FastSAM(model)
+    elif "sam_" in stem or "sam2_" in stem or "sam2.1_" in stem:
+        from ultralytics import SAM
+
+        model = SAM(model)
+    else:
+        from ultralytics import YOLO
+
+        model = YOLO(model, task=task)
+    if isinstance(overrides.get("pretrained"), str):
+        model.load(overrides["pretrained"])
+
+    # Task Update
+    if task != model.task:
+        if task:
+            LOGGER.warning(
+                f"WARNING ⚠️ conflicting 'task={task}' passed with 'task={model.task}' model. "
+                f"Ignoring 'task={task}' and updating to 'task={model.task}' to match model."
+            )
+        task = model.task
+
+    # Mode
+    if mode in {"predict", "track"} and "source" not in overrides:
+        overrides["source"] = (
+            "https://ultralytics.com/images/boats.jpg" if task == "obb" else DEFAULT_CFG.source or ASSETS
+        )
+        LOGGER.warning(f"WARNING ⚠️ 'source' argument is missing. Using default 'source={overrides['source']}'.")
+    elif mode in {"train", "val"}:
+        if "data" not in overrides and "resume" not in overrides:
+            overrides["data"] = DEFAULT_CFG.data or TASK2DATA.get(task or DEFAULT_CFG.task, DEFAULT_CFG.data)
+            LOGGER.warning(f"WARNING ⚠️ 'data' argument is missing. Using default 'data={overrides['data']}'.")
+    elif mode == "export":
+        if "format" not in overrides:
+            overrides["format"] = DEFAULT_CFG.format or "torchscript"
+            LOGGER.warning(f"WARNING ⚠️ 'format' argument is missing. Using default 'format={overrides['format']}'.")
+
+    # Run command in python
+    getattr(model, mode)(**overrides)  # default args from model
+
+    # Show help
+    LOGGER.info(f"💡 Learn more at https://docs.ultralytics.com/modes/{mode}")
+
+    # Recommend VS Code extension
+    if IS_VSCODE and SETTINGS.get("vscode_msg", True):
+        LOGGER.info(vscode_msg())
+
+
+# Special modes --------------------------------------------------------------------------------------------------------
+def copy_default_cfg():
+    """
+    Copies the default configuration file and creates a new one with '_copy' appended to its name.
+
+    This function duplicates the existing default configuration file (DEFAULT_CFG_PATH) and saves it
+    with '_copy' appended to its name in the current working directory. It provides a convenient way
+    to create a custom configuration file based on the default settings.
+
+    Examples:
+        >>> copy_default_cfg()
+        # Output: default.yaml copied to /path/to/current/directory/default_copy.yaml
+        # Example YOLO command with this new custom cfg:
+        #   yolo cfg='/path/to/current/directory/default_copy.yaml' imgsz=320 batch=8
+
+    Notes:
+        - The new configuration file is created in the current working directory.
+        - After copying, the function prints a message with the new file's location and an example
+          YOLO command demonstrating how to use the new configuration file.
+        - This function is useful for users who want to modify the default configuration without
+          altering the original file.
+    """
+    new_file = Path.cwd() / DEFAULT_CFG_PATH.name.replace(".yaml", "_copy.yaml")
+    shutil.copy2(DEFAULT_CFG_PATH, new_file)
+    LOGGER.info(
+        f"{DEFAULT_CFG_PATH} copied to {new_file}\n"
+        f"Example YOLO command with this new custom cfg:\n    yolo cfg='{new_file}' imgsz=320 batch=8"
+    )
+
+
+if __name__ == "__main__":
+    # Example: entrypoint(debug='yolo predict model=yolo11n.pt')
+    entrypoint(debug="")

ultralytics/cfg/datasets/Argoverse.yaml

@@ -0,0 +1,75 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Argoverse-HD dataset (ring-front-center camera) https://www.cs.cmu.edu/~mengtial/proj/streaming/ by Argo AI
+# Documentation: https://docs.ultralytics.com/datasets/detect/argoverse/
+# Example usage: yolo train data=Argoverse.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── Argoverse  ← downloads here (31.5 GB)
+
+# 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/Argoverse # dataset root dir
+train: Argoverse-1.1/images/train/ # train images (relative to 'path') 39384 images
+val: Argoverse-1.1/images/val/ # val images (relative to 'path') 15062 images
+test: Argoverse-1.1/images/test/ # test images (optional) https://eval.ai/web/challenges/challenge-page/800/overview
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: bus
+  5: truck
+  6: traffic_light
+  7: stop_sign
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import json
+  from tqdm import tqdm
+  from ultralytics.utils.downloads import download
+  from pathlib import Path
+
+  def argoverse2yolo(set):
+      labels = {}
+      a = json.load(open(set, "rb"))
+      for annot in tqdm(a['annotations'], desc=f"Converting {set} to YOLOv5 format..."):
+          img_id = annot['image_id']
+          img_name = a['images'][img_id]['name']
+          img_label_name = f'{img_name[:-3]}txt'
+
+          cls = annot['category_id']  # instance class id
+          x_center, y_center, width, height = annot['bbox']
+          x_center = (x_center + width / 2) / 1920.0  # offset and scale
+          y_center = (y_center + height / 2) / 1200.0  # offset and scale
+          width /= 1920.0  # scale
+          height /= 1200.0  # scale
+
+          img_dir = set.parents[2] / 'Argoverse-1.1' / 'labels' / a['seq_dirs'][a['images'][annot['image_id']]['sid']]
+          if not img_dir.exists():
+              img_dir.mkdir(parents=True, exist_ok=True)
+
+          k = str(img_dir / img_label_name)
+          if k not in labels:
+              labels[k] = []
+          labels[k].append(f"{cls} {x_center} {y_center} {width} {height}\n")
+
+      for k in labels:
+          with open(k, "w") as f:
+              f.writelines(labels[k])
+
+
+  # Download 'https://argoverse-hd.s3.us-east-2.amazonaws.com/Argoverse-HD-Full.zip' (deprecated S3 link)
+  dir = Path(yaml['path'])  # dataset root dir
+  urls = ['https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link']
+  print("\n\nWARNING: Argoverse dataset MUST be downloaded manually, autodownload will NOT work.")
+  print(f"WARNING: Manually download Argoverse dataset '{urls[0]}' to '{dir}' and re-run your command.\n\n")
+  # download(urls, dir=dir)
+
+  # Convert
+  annotations_dir = 'Argoverse-HD/annotations/'
+  (dir / 'Argoverse-1.1' / 'tracking').rename(dir / 'Argoverse-1.1' / 'images')  # rename 'tracking' to 'images'
+  for d in "train.json", "val.json":
+      argoverse2yolo(dir / annotations_dir / d)  # convert Argoverse annotations to YOLO labels

ultralytics/cfg/datasets/DOTAv1.5.yaml

@@ -0,0 +1,37 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DOTA 1.5 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
+# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
+# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.5.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dota1.5  ← downloads here (2GB)
+
+# 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/DOTAv1.5 # dataset root dir
+train: images/train # train images (relative to 'path') 1411 images
+val: images/val # val images (relative to 'path') 458 images
+test: images/test # test images (optional) 937 images
+
+# Classes for DOTA 1.5
+names:
+  0: plane
+  1: ship
+  2: storage tank
+  3: baseball diamond
+  4: tennis court
+  5: basketball court
+  6: ground track field
+  7: harbor
+  8: bridge
+  9: large vehicle
+  10: small vehicle
+  11: helicopter
+  12: roundabout
+  13: soccer ball field
+  14: swimming pool
+  15: container crane
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.5.zip

ultralytics/cfg/datasets/DOTAv1.yaml

@@ -0,0 +1,36 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DOTA 1.0 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
+# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
+# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dota1  ← downloads here (2GB)
+
+# 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/DOTAv1 # dataset root dir
+train: images/train # train images (relative to 'path') 1411 images
+val: images/val # val images (relative to 'path') 458 images
+test: images/test # test images (optional) 937 images
+
+# Classes for DOTA 1.0
+names:
+  0: plane
+  1: ship
+  2: storage tank
+  3: baseball diamond
+  4: tennis court
+  5: basketball court
+  6: ground track field
+  7: harbor
+  8: bridge
+  9: large vehicle
+  10: small vehicle
+  11: helicopter
+  12: roundabout
+  13: soccer ball field
+  14: swimming pool
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.zip

ultralytics/cfg/datasets/GlobalWheat2020.yaml

@@ -0,0 +1,54 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Global Wheat 2020 dataset https://www.global-wheat.com/ by University of Saskatchewan
+# Documentation: https://docs.ultralytics.com/datasets/detect/globalwheat2020/
+# Example usage: yolo train data=GlobalWheat2020.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── GlobalWheat2020  ← downloads here (7.0 GB)
+
+# 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/GlobalWheat2020 # dataset root dir
+train: # train images (relative to 'path') 3422 images
+  - images/arvalis_1
+  - images/arvalis_2
+  - images/arvalis_3
+  - images/ethz_1
+  - images/rres_1
+  - images/inrae_1
+  - images/usask_1
+val: # val images (relative to 'path') 748 images (WARNING: train set contains ethz_1)
+  - images/ethz_1
+test: # test images (optional) 1276 images
+  - images/utokyo_1
+  - images/utokyo_2
+  - images/nau_1
+  - images/uq_1
+
+# Classes
+names:
+  0: wheat_head
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  from ultralytics.utils.downloads import download
+  from pathlib import Path
+
+  # Download
+  dir = Path(yaml['path'])  # dataset root dir
+  urls = ['https://zenodo.org/record/4298502/files/global-wheat-codalab-official.zip',
+          'https://github.com/ultralytics/assets/releases/download/v0.0.0/GlobalWheat2020_labels.zip']
+  download(urls, dir=dir)
+
+  # Make Directories
+  for p in 'annotations', 'images', 'labels':
+      (dir / p).mkdir(parents=True, exist_ok=True)
+
+  # Move
+  for p in 'arvalis_1', 'arvalis_2', 'arvalis_3', 'ethz_1', 'rres_1', 'inrae_1', 'usask_1', \
+           'utokyo_1', 'utokyo_2', 'nau_1', 'uq_1':
+      (dir / 'global-wheat-codalab-official' / p).rename(dir / 'images' / p)  # move to /images
+      f = (dir / 'global-wheat-codalab-official' / p).with_suffix('.json')  # json file
+      if f.exists():
+          f.rename((dir / 'annotations' / p).with_suffix('.json'))  # move to /annotations

ultralytics/cfg/datasets/ImageNet.yaml

@@ -0,0 +1,2025 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# ImageNet-1k dataset https://www.image-net.org/index.php by Stanford University
+# Simplified class names from https://github.com/anishathalye/imagenet-simple-labels
+# Documentation: https://docs.ultralytics.com/datasets/classify/imagenet/
+# Example usage: yolo train task=classify data=imagenet
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── imagenet  ← downloads here (144 GB)
+
+# 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/imagenet # dataset root dir
+train: train # train images (relative to 'path') 1281167 images
+val: val # val images (relative to 'path') 50000 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: tench
+  1: goldfish
+  2: great white shark
+  3: tiger shark
+  4: hammerhead shark
+  5: electric ray
+  6: stingray
+  7: cock
+  8: hen
+  9: ostrich
+  10: brambling
+  11: goldfinch
+  12: house finch
+  13: junco
+  14: indigo bunting
+  15: American robin
+  16: bulbul
+  17: jay
+  18: magpie
+  19: chickadee
+  20: American dipper
+  21: kite
+  22: bald eagle
+  23: vulture
+  24: great grey owl
+  25: fire salamander
+  26: smooth newt
+  27: newt
+  28: spotted salamander
+  29: axolotl
+  30: American bullfrog
+  31: tree frog
+  32: tailed frog
+  33: loggerhead sea turtle
+  34: leatherback sea turtle
+  35: mud turtle
+  36: terrapin
+  37: box turtle
+  38: banded gecko
+  39: green iguana
+  40: Carolina anole
+  41: desert grassland whiptail lizard
+  42: agama
+  43: frilled-necked lizard
+  44: alligator lizard
+  45: Gila monster
+  46: European green lizard
+  47: chameleon
+  48: Komodo dragon
+  49: Nile crocodile
+  50: American alligator
+  51: triceratops
+  52: worm snake
+  53: ring-necked snake
+  54: eastern hog-nosed snake
+  55: smooth green snake
+  56: kingsnake
+  57: garter snake
+  58: water snake
+  59: vine snake
+  60: night snake
+  61: boa constrictor
+  62: African rock python
+  63: Indian cobra
+  64: green mamba
+  65: sea snake
+  66: Saharan horned viper
+  67: eastern diamondback rattlesnake
+  68: sidewinder
+  69: trilobite
+  70: harvestman
+  71: scorpion
+  72: yellow garden spider
+  73: barn spider
+  74: European garden spider
+  75: southern black widow
+  76: tarantula
+  77: wolf spider
+  78: tick
+  79: centipede
+  80: black grouse
+  81: ptarmigan
+  82: ruffed grouse
+  83: prairie grouse
+  84: peacock
+  85: quail
+  86: partridge
+  87: grey parrot
+  88: macaw
+  89: sulphur-crested cockatoo
+  90: lorikeet
+  91: coucal
+  92: bee eater
+  93: hornbill
+  94: hummingbird
+  95: jacamar
+  96: toucan
+  97: duck
+  98: red-breasted merganser
+  99: goose
+  100: black swan
+  101: tusker
+  102: echidna
+  103: platypus
+  104: wallaby
+  105: koala
+  106: wombat
+  107: jellyfish
+  108: sea anemone
+  109: brain coral
+  110: flatworm
+  111: nematode
+  112: conch
+  113: snail
+  114: slug
+  115: sea slug
+  116: chiton
+  117: chambered nautilus
+  118: Dungeness crab
+  119: rock crab
+  120: fiddler crab
+  121: red king crab
+  122: American lobster
+  123: spiny lobster
+  124: crayfish
+  125: hermit crab
+  126: isopod
+  127: white stork
+  128: black stork
+  129: spoonbill
+  130: flamingo
+  131: little blue heron
+  132: great egret
+  133: bittern
+  134: crane (bird)
+  135: limpkin
+  136: common gallinule
+  137: American coot
+  138: bustard
+  139: ruddy turnstone
+  140: dunlin
+  141: common redshank
+  142: dowitcher
+  143: oystercatcher
+  144: pelican
+  145: king penguin
+  146: albatross
+  147: grey whale
+  148: killer whale
+  149: dugong
+  150: sea lion
+  151: Chihuahua
+  152: Japanese Chin
+  153: Maltese
+  154: Pekingese
+  155: Shih Tzu
+  156: King Charles Spaniel
+  157: Papillon
+  158: toy terrier
+  159: Rhodesian Ridgeback
+  160: Afghan Hound
+  161: Basset Hound
+  162: Beagle
+  163: Bloodhound
+  164: Bluetick Coonhound
+  165: Black and Tan Coonhound
+  166: Treeing Walker Coonhound
+  167: English foxhound
+  168: Redbone Coonhound
+  169: borzoi
+  170: Irish Wolfhound
+  171: Italian Greyhound
+  172: Whippet
+  173: Ibizan Hound
+  174: Norwegian Elkhound
+  175: Otterhound
+  176: Saluki
+  177: Scottish Deerhound
+  178: Weimaraner
+  179: Staffordshire Bull Terrier
+  180: American Staffordshire Terrier
+  181: Bedlington Terrier
+  182: Border Terrier
+  183: Kerry Blue Terrier
+  184: Irish Terrier
+  185: Norfolk Terrier
+  186: Norwich Terrier
+  187: Yorkshire Terrier
+  188: Wire Fox Terrier
+  189: Lakeland Terrier
+  190: Sealyham Terrier
+  191: Airedale Terrier
+  192: Cairn Terrier
+  193: Australian Terrier
+  194: Dandie Dinmont Terrier
+  195: Boston Terrier
+  196: Miniature Schnauzer
+  197: Giant Schnauzer
+  198: Standard Schnauzer
+  199: Scottish Terrier
+  200: Tibetan Terrier
+  201: Australian Silky Terrier
+  202: Soft-coated Wheaten Terrier
+  203: West Highland White Terrier
+  204: Lhasa Apso
+  205: Flat-Coated Retriever
+  206: Curly-coated Retriever
+  207: Golden Retriever
+  208: Labrador Retriever
+  209: Chesapeake Bay Retriever
+  210: German Shorthaired Pointer
+  211: Vizsla
+  212: English Setter
+  213: Irish Setter
+  214: Gordon Setter
+  215: Brittany
+  216: Clumber Spaniel
+  217: English Springer Spaniel
+  218: Welsh Springer Spaniel
+  219: Cocker Spaniels
+  220: Sussex Spaniel
+  221: Irish Water Spaniel
+  222: Kuvasz
+  223: Schipperke
+  224: Groenendael
+  225: Malinois
+  226: Briard
+  227: Australian Kelpie
+  228: Komondor
+  229: Old English Sheepdog
+  230: Shetland Sheepdog
+  231: collie
+  232: Border Collie
+  233: Bouvier des Flandres
+  234: Rottweiler
+  235: German Shepherd Dog
+  236: Dobermann
+  237: Miniature Pinscher
+  238: Greater Swiss Mountain Dog
+  239: Bernese Mountain Dog
+  240: Appenzeller Sennenhund
+  241: Entlebucher Sennenhund
+  242: Boxer
+  243: Bullmastiff
+  244: Tibetan Mastiff
+  245: French Bulldog
+  246: Great Dane
+  247: St. Bernard
+  248: husky
+  249: Alaskan Malamute
+  250: Siberian Husky
+  251: Dalmatian
+  252: Affenpinscher
+  253: Basenji
+  254: pug
+  255: Leonberger
+  256: Newfoundland
+  257: Pyrenean Mountain Dog
+  258: Samoyed
+  259: Pomeranian
+  260: Chow Chow
+  261: Keeshond
+  262: Griffon Bruxellois
+  263: Pembroke Welsh Corgi
+  264: Cardigan Welsh Corgi
+  265: Toy Poodle
+  266: Miniature Poodle
+  267: Standard Poodle
+  268: Mexican hairless dog
+  269: grey wolf
+  270: Alaskan tundra wolf
+  271: red wolf
+  272: coyote
+  273: dingo
+  274: dhole
+  275: African wild dog
+  276: hyena
+  277: red fox
+  278: kit fox
+  279: Arctic fox
+  280: grey fox
+  281: tabby cat
+  282: tiger cat
+  283: Persian cat
+  284: Siamese cat
+  285: Egyptian Mau
+  286: cougar
+  287: lynx
+  288: leopard
+  289: snow leopard
+  290: jaguar
+  291: lion
+  292: tiger
+  293: cheetah
+  294: brown bear
+  295: American black bear
+  296: polar bear
+  297: sloth bear
+  298: mongoose
+  299: meerkat
+  300: tiger beetle
+  301: ladybug
+  302: ground beetle
+  303: longhorn beetle
+  304: leaf beetle
+  305: dung beetle
+  306: rhinoceros beetle
+  307: weevil
+  308: fly
+  309: bee
+  310: ant
+  311: grasshopper
+  312: cricket
+  313: stick insect
+  314: cockroach
+  315: mantis
+  316: cicada
+  317: leafhopper
+  318: lacewing
+  319: dragonfly
+  320: damselfly
+  321: red admiral
+  322: ringlet
+  323: monarch butterfly
+  324: small white
+  325: sulphur butterfly
+  326: gossamer-winged butterfly
+  327: starfish
+  328: sea urchin
+  329: sea cucumber
+  330: cottontail rabbit
+  331: hare
+  332: Angora rabbit
+  333: hamster
+  334: porcupine
+  335: fox squirrel
+  336: marmot
+  337: beaver
+  338: guinea pig
+  339: common sorrel
+  340: zebra
+  341: pig
+  342: wild boar
+  343: warthog
+  344: hippopotamus
+  345: ox
+  346: water buffalo
+  347: bison
+  348: ram
+  349: bighorn sheep
+  350: Alpine ibex
+  351: hartebeest
+  352: impala
+  353: gazelle
+  354: dromedary
+  355: llama
+  356: weasel
+  357: mink
+  358: European polecat
+  359: black-footed ferret
+  360: otter
+  361: skunk
+  362: badger
+  363: armadillo
+  364: three-toed sloth
+  365: orangutan
+  366: gorilla
+  367: chimpanzee
+  368: gibbon
+  369: siamang
+  370: guenon
+  371: patas monkey
+  372: baboon
+  373: macaque
+  374: langur
+  375: black-and-white colobus
+  376: proboscis monkey
+  377: marmoset
+  378: white-headed capuchin
+  379: howler monkey
+  380: titi
+  381: Geoffroy's spider monkey
+  382: common squirrel monkey
+  383: ring-tailed lemur
+  384: indri
+  385: Asian elephant
+  386: African bush elephant
+  387: red panda
+  388: giant panda
+  389: snoek
+  390: eel
+  391: coho salmon
+  392: rock beauty
+  393: clownfish
+  394: sturgeon
+  395: garfish
+  396: lionfish
+  397: pufferfish
+  398: abacus
+  399: abaya
+  400: academic gown
+  401: accordion
+  402: acoustic guitar
+  403: aircraft carrier
+  404: airliner
+  405: airship
+  406: altar
+  407: ambulance
+  408: amphibious vehicle
+  409: analog clock
+  410: apiary
+  411: apron
+  412: waste container
+  413: assault rifle
+  414: backpack
+  415: bakery
+  416: balance beam
+  417: balloon
+  418: ballpoint pen
+  419: Band-Aid
+  420: banjo
+  421: baluster
+  422: barbell
+  423: barber chair
+  424: barbershop
+  425: barn
+  426: barometer
+  427: barrel
+  428: wheelbarrow
+  429: baseball
+  430: basketball
+  431: bassinet
+  432: bassoon
+  433: swimming cap
+  434: bath towel
+  435: bathtub
+  436: station wagon
+  437: lighthouse
+  438: beaker
+  439: military cap
+  440: beer bottle
+  441: beer glass
+  442: bell-cot
+  443: bib
+  444: tandem bicycle
+  445: bikini
+  446: ring binder
+  447: binoculars
+  448: birdhouse
+  449: boathouse
+  450: bobsleigh
+  451: bolo tie
+  452: poke bonnet
+  453: bookcase
+  454: bookstore
+  455: bottle cap
+  456: bow
+  457: bow tie
+  458: brass
+  459: bra
+  460: breakwater
+  461: breastplate
+  462: broom
+  463: bucket
+  464: buckle
+  465: bulletproof vest
+  466: high-speed train
+  467: butcher shop
+  468: taxicab
+  469: cauldron
+  470: candle
+  471: cannon
+  472: canoe
+  473: can opener
+  474: cardigan
+  475: car mirror
+  476: carousel
+  477: tool kit
+  478: carton
+  479: car wheel
+  480: automated teller machine
+  481: cassette
+  482: cassette player
+  483: castle
+  484: catamaran
+  485: CD player
+  486: cello
+  487: mobile phone
+  488: chain
+  489: chain-link fence
+  490: chain mail
+  491: chainsaw
+  492: chest
+  493: chiffonier
+  494: chime
+  495: china cabinet
+  496: Christmas stocking
+  497: church
+  498: movie theater
+  499: cleaver
+  500: cliff dwelling
+  501: cloak
+  502: clogs
+  503: cocktail shaker
+  504: coffee mug
+  505: coffeemaker
+  506: coil
+  507: combination lock
+  508: computer keyboard
+  509: confectionery store
+  510: container ship
+  511: convertible
+  512: corkscrew
+  513: cornet
+  514: cowboy boot
+  515: cowboy hat
+  516: cradle
+  517: crane (machine)
+  518: crash helmet
+  519: crate
+  520: infant bed
+  521: Crock Pot
+  522: croquet ball
+  523: crutch
+  524: cuirass
+  525: dam
+  526: desk
+  527: desktop computer
+  528: rotary dial telephone
+  529: diaper
+  530: digital clock
+  531: digital watch
+  532: dining table
+  533: dishcloth
+  534: dishwasher
+  535: disc brake
+  536: dock
+  537: dog sled
+  538: dome
+  539: doormat
+  540: drilling rig
+  541: drum
+  542: drumstick
+  543: dumbbell
+  544: Dutch oven
+  545: electric fan
+  546: electric guitar
+  547: electric locomotive
+  548: entertainment center
+  549: envelope
+  550: espresso machine
+  551: face powder
+  552: feather boa
+  553: filing cabinet
+  554: fireboat
+  555: fire engine
+  556: fire screen sheet
+  557: flagpole
+  558: flute
+  559: folding chair
+  560: football helmet
+  561: forklift
+  562: fountain
+  563: fountain pen
+  564: four-poster bed
+  565: freight car
+  566: French horn
+  567: frying pan
+  568: fur coat
+  569: garbage truck
+  570: gas mask
+  571: gas pump
+  572: goblet
+  573: go-kart
+  574: golf ball
+  575: golf cart
+  576: gondola
+  577: gong
+  578: gown
+  579: grand piano
+  580: greenhouse
+  581: grille
+  582: grocery store
+  583: guillotine
+  584: barrette
+  585: hair spray
+  586: half-track
+  587: hammer
+  588: hamper
+  589: hair dryer
+  590: hand-held computer
+  591: handkerchief
+  592: hard disk drive
+  593: harmonica
+  594: harp
+  595: harvester
+  596: hatchet
+  597: holster
+  598: home theater
+  599: honeycomb
+  600: hook
+  601: hoop skirt
+  602: horizontal bar
+  603: horse-drawn vehicle
+  604: hourglass
+  605: iPod
+  606: clothes iron
+  607: jack-o'-lantern
+  608: jeans
+  609: jeep
+  610: T-shirt
+  611: jigsaw puzzle
+  612: pulled rickshaw
+  613: joystick
+  614: kimono
+  615: knee pad
+  616: knot
+  617: lab coat
+  618: ladle
+  619: lampshade
+  620: laptop computer
+  621: lawn mower
+  622: lens cap
+  623: paper knife
+  624: library
+  625: lifeboat
+  626: lighter
+  627: limousine
+  628: ocean liner
+  629: lipstick
+  630: slip-on shoe
+  631: lotion
+  632: speaker
+  633: loupe
+  634: sawmill
+  635: magnetic compass
+  636: mail bag
+  637: mailbox
+  638: tights
+  639: tank suit
+  640: manhole cover
+  641: maraca
+  642: marimba
+  643: mask
+  644: match
+  645: maypole
+  646: maze
+  647: measuring cup
+  648: medicine chest
+  649: megalith
+  650: microphone
+  651: microwave oven
+  652: military uniform
+  653: milk can
+  654: minibus
+  655: miniskirt
+  656: minivan
+  657: missile
+  658: mitten
+  659: mixing bowl
+  660: mobile home
+  661: Model T
+  662: modem
+  663: monastery
+  664: monitor
+  665: moped
+  666: mortar
+  667: square academic cap
+  668: mosque
+  669: mosquito net
+  670: scooter
+  671: mountain bike
+  672: tent
+  673: computer mouse
+  674: mousetrap
+  675: moving van
+  676: muzzle
+  677: nail
+  678: neck brace
+  679: necklace
+  680: nipple
+  681: notebook computer
+  682: obelisk
+  683: oboe
+  684: ocarina
+  685: odometer
+  686: oil filter
+  687: organ
+  688: oscilloscope
+  689: overskirt
+  690: bullock cart
+  691: oxygen mask
+  692: packet
+  693: paddle
+  694: paddle wheel
+  695: padlock
+  696: paintbrush
+  697: pajamas
+  698: palace
+  699: pan flute
+  700: paper towel
+  701: parachute
+  702: parallel bars
+  703: park bench
+  704: parking meter
+  705: passenger car
+  706: patio
+  707: payphone
+  708: pedestal
+  709: pencil case
+  710: pencil sharpener
+  711: perfume
+  712: Petri dish
+  713: photocopier
+  714: plectrum
+  715: Pickelhaube
+  716: picket fence
+  717: pickup truck
+  718: pier
+  719: piggy bank
+  720: pill bottle
+  721: pillow
+  722: ping-pong ball
+  723: pinwheel
+  724: pirate ship
+  725: pitcher
+  726: hand plane
+  727: planetarium
+  728: plastic bag
+  729: plate rack
+  730: plow
+  731: plunger
+  732: Polaroid camera
+  733: pole
+  734: police van
+  735: poncho
+  736: billiard table
+  737: soda bottle
+  738: pot
+  739: potter's wheel
+  740: power drill
+  741: prayer rug
+  742: printer
+  743: prison
+  744: projectile
+  745: projector
+  746: hockey puck
+  747: punching bag
+  748: purse
+  749: quill
+  750: quilt
+  751: race car
+  752: racket
+  753: radiator
+  754: radio
+  755: radio telescope
+  756: rain barrel
+  757: recreational vehicle
+  758: reel
+  759: reflex camera
+  760: refrigerator
+  761: remote control
+  762: restaurant
+  763: revolver
+  764: rifle
+  765: rocking chair
+  766: rotisserie
+  767: eraser
+  768: rugby ball
+  769: ruler
+  770: running shoe
+  771: safe
+  772: safety pin
+  773: salt shaker
+  774: sandal
+  775: sarong
+  776: saxophone
+  777: scabbard
+  778: weighing scale
+  779: school bus
+  780: schooner
+  781: scoreboard
+  782: CRT screen
+  783: screw
+  784: screwdriver
+  785: seat belt
+  786: sewing machine
+  787: shield
+  788: shoe store
+  789: shoji
+  790: shopping basket
+  791: shopping cart
+  792: shovel
+  793: shower cap
+  794: shower curtain
+  795: ski
+  796: ski mask
+  797: sleeping bag
+  798: slide rule
+  799: sliding door
+  800: slot machine
+  801: snorkel
+  802: snowmobile
+  803: snowplow
+  804: soap dispenser
+  805: soccer ball
+  806: sock
+  807: solar thermal collector
+  808: sombrero
+  809: soup bowl
+  810: space bar
+  811: space heater
+  812: space shuttle
+  813: spatula
+  814: motorboat
+  815: spider web
+  816: spindle
+  817: sports car
+  818: spotlight
+  819: stage
+  820: steam locomotive
+  821: through arch bridge
+  822: steel drum
+  823: stethoscope
+  824: scarf
+  825: stone wall
+  826: stopwatch
+  827: stove
+  828: strainer
+  829: tram
+  830: stretcher
+  831: couch
+  832: stupa
+  833: submarine
+  834: suit
+  835: sundial
+  836: sunglass
+  837: sunglasses
+  838: sunscreen
+  839: suspension bridge
+  840: mop
+  841: sweatshirt
+  842: swimsuit
+  843: swing
+  844: switch
+  845: syringe
+  846: table lamp
+  847: tank
+  848: tape player
+  849: teapot
+  850: teddy bear
+  851: television
+  852: tennis ball
+  853: thatched roof
+  854: front curtain
+  855: thimble
+  856: threshing machine
+  857: throne
+  858: tile roof
+  859: toaster
+  860: tobacco shop
+  861: toilet seat
+  862: torch
+  863: totem pole
+  864: tow truck
+  865: toy store
+  866: tractor
+  867: semi-trailer truck
+  868: tray
+  869: trench coat
+  870: tricycle
+  871: trimaran
+  872: tripod
+  873: triumphal arch
+  874: trolleybus
+  875: trombone
+  876: tub
+  877: turnstile
+  878: typewriter keyboard
+  879: umbrella
+  880: unicycle
+  881: upright piano
+  882: vacuum cleaner
+  883: vase
+  884: vault
+  885: velvet
+  886: vending machine
+  887: vestment
+  888: viaduct
+  889: violin
+  890: volleyball
+  891: waffle iron
+  892: wall clock
+  893: wallet
+  894: wardrobe
+  895: military aircraft
+  896: sink
+  897: washing machine
+  898: water bottle
+  899: water jug
+  900: water tower
+  901: whiskey jug
+  902: whistle
+  903: wig
+  904: window screen
+  905: window shade
+  906: Windsor tie
+  907: wine bottle
+  908: wing
+  909: wok
+  910: wooden spoon
+  911: wool
+  912: split-rail fence
+  913: shipwreck
+  914: yawl
+  915: yurt
+  916: website
+  917: comic book
+  918: crossword
+  919: traffic sign
+  920: traffic light
+  921: dust jacket
+  922: menu
+  923: plate
+  924: guacamole
+  925: consomme
+  926: hot pot
+  927: trifle
+  928: ice cream
+  929: ice pop
+  930: baguette
+  931: bagel
+  932: pretzel
+  933: cheeseburger
+  934: hot dog
+  935: mashed potato
+  936: cabbage
+  937: broccoli
+  938: cauliflower
+  939: zucchini
+  940: spaghetti squash
+  941: acorn squash
+  942: butternut squash
+  943: cucumber
+  944: artichoke
+  945: bell pepper
+  946: cardoon
+  947: mushroom
+  948: Granny Smith
+  949: strawberry
+  950: orange
+  951: lemon
+  952: fig
+  953: pineapple
+  954: banana
+  955: jackfruit
+  956: custard apple
+  957: pomegranate
+  958: hay
+  959: carbonara
+  960: chocolate syrup
+  961: dough
+  962: meatloaf
+  963: pizza
+  964: pot pie
+  965: burrito
+  966: red wine
+  967: espresso
+  968: cup
+  969: eggnog
+  970: alp
+  971: bubble
+  972: cliff
+  973: coral reef
+  974: geyser
+  975: lakeshore
+  976: promontory
+  977: shoal
+  978: seashore
+  979: valley
+  980: volcano
+  981: baseball player
+  982: bridegroom
+  983: scuba diver
+  984: rapeseed
+  985: daisy
+  986: yellow lady's slipper
+  987: corn
+  988: acorn
+  989: rose hip
+  990: horse chestnut seed
+  991: coral fungus
+  992: agaric
+  993: gyromitra
+  994: stinkhorn mushroom
+  995: earth star
+  996: hen-of-the-woods
+  997: bolete
+  998: ear
+  999: toilet paper
+
+# Imagenet class codes to human-readable names
+map:
+  n01440764: tench
+  n01443537: goldfish
+  n01484850: great_white_shark
+  n01491361: tiger_shark
+  n01494475: hammerhead
+  n01496331: electric_ray
+  n01498041: stingray
+  n01514668: cock
+  n01514859: hen
+  n01518878: ostrich
+  n01530575: brambling
+  n01531178: goldfinch
+  n01532829: house_finch
+  n01534433: junco
+  n01537544: indigo_bunting
+  n01558993: robin
+  n01560419: bulbul
+  n01580077: jay
+  n01582220: magpie
+  n01592084: chickadee
+  n01601694: water_ouzel
+  n01608432: kite
+  n01614925: bald_eagle
+  n01616318: vulture
+  n01622779: great_grey_owl
+  n01629819: European_fire_salamander
+  n01630670: common_newt
+  n01631663: eft
+  n01632458: spotted_salamander
+  n01632777: axolotl
+  n01641577: bullfrog
+  n01644373: tree_frog
+  n01644900: tailed_frog
+  n01664065: loggerhead
+  n01665541: leatherback_turtle
+  n01667114: mud_turtle
+  n01667778: terrapin
+  n01669191: box_turtle
+  n01675722: banded_gecko
+  n01677366: common_iguana
+  n01682714: American_chameleon
+  n01685808: whiptail
+  n01687978: agama
+  n01688243: frilled_lizard
+  n01689811: alligator_lizard
+  n01692333: Gila_monster
+  n01693334: green_lizard
+  n01694178: African_chameleon
+  n01695060: Komodo_dragon
+  n01697457: African_crocodile
+  n01698640: American_alligator
+  n01704323: triceratops
+  n01728572: thunder_snake
+  n01728920: ringneck_snake
+  n01729322: hognose_snake
+  n01729977: green_snake
+  n01734418: king_snake
+  n01735189: garter_snake
+  n01737021: water_snake
+  n01739381: vine_snake
+  n01740131: night_snake
+  n01742172: boa_constrictor
+  n01744401: rock_python
+  n01748264: Indian_cobra
+  n01749939: green_mamba
+  n01751748: sea_snake
+  n01753488: horned_viper
+  n01755581: diamondback
+  n01756291: sidewinder
+  n01768244: trilobite
+  n01770081: harvestman
+  n01770393: scorpion
+  n01773157: black_and_gold_garden_spider
+  n01773549: barn_spider
+  n01773797: garden_spider
+  n01774384: black_widow
+  n01774750: tarantula
+  n01775062: wolf_spider
+  n01776313: tick
+  n01784675: centipede
+  n01795545: black_grouse
+  n01796340: ptarmigan
+  n01797886: ruffed_grouse
+  n01798484: prairie_chicken
+  n01806143: peacock
+  n01806567: quail
+  n01807496: partridge
+  n01817953: African_grey
+  n01818515: macaw
+  n01819313: sulphur-crested_cockatoo
+  n01820546: lorikeet
+  n01824575: coucal
+  n01828970: bee_eater
+  n01829413: hornbill
+  n01833805: hummingbird
+  n01843065: jacamar
+  n01843383: toucan
+  n01847000: drake
+  n01855032: red-breasted_merganser
+  n01855672: goose
+  n01860187: black_swan
+  n01871265: tusker
+  n01872401: echidna
+  n01873310: platypus
+  n01877812: wallaby
+  n01882714: koala
+  n01883070: wombat
+  n01910747: jellyfish
+  n01914609: sea_anemone
+  n01917289: brain_coral
+  n01924916: flatworm
+  n01930112: nematode
+  n01943899: conch
+  n01944390: snail
+  n01945685: slug
+  n01950731: sea_slug
+  n01955084: chiton
+  n01968897: chambered_nautilus
+  n01978287: Dungeness_crab
+  n01978455: rock_crab
+  n01980166: fiddler_crab
+  n01981276: king_crab
+  n01983481: American_lobster
+  n01984695: spiny_lobster
+  n01985128: crayfish
+  n01986214: hermit_crab
+  n01990800: isopod
+  n02002556: white_stork
+  n02002724: black_stork
+  n02006656: spoonbill
+  n02007558: flamingo
+  n02009229: little_blue_heron
+  n02009912: American_egret
+  n02011460: bittern
+  n02012849: crane_(bird)
+  n02013706: limpkin
+  n02017213: European_gallinule
+  n02018207: American_coot
+  n02018795: bustard
+  n02025239: ruddy_turnstone
+  n02027492: red-backed_sandpiper
+  n02028035: redshank
+  n02033041: dowitcher
+  n02037110: oystercatcher
+  n02051845: pelican
+  n02056570: king_penguin
+  n02058221: albatross
+  n02066245: grey_whale
+  n02071294: killer_whale
+  n02074367: dugong
+  n02077923: sea_lion
+  n02085620: Chihuahua
+  n02085782: Japanese_spaniel
+  n02085936: Maltese_dog
+  n02086079: Pekinese
+  n02086240: Shih-Tzu
+  n02086646: Blenheim_spaniel
+  n02086910: papillon
+  n02087046: toy_terrier
+  n02087394: Rhodesian_ridgeback
+  n02088094: Afghan_hound
+  n02088238: basset
+  n02088364: beagle
+  n02088466: bloodhound
+  n02088632: bluetick
+  n02089078: black-and-tan_coonhound
+  n02089867: Walker_hound
+  n02089973: English_foxhound
+  n02090379: redbone
+  n02090622: borzoi
+  n02090721: Irish_wolfhound
+  n02091032: Italian_greyhound
+  n02091134: whippet
+  n02091244: Ibizan_hound
+  n02091467: Norwegian_elkhound
+  n02091635: otterhound
+  n02091831: Saluki
+  n02092002: Scottish_deerhound
+  n02092339: Weimaraner
+  n02093256: Staffordshire_bullterrier
+  n02093428: American_Staffordshire_terrier
+  n02093647: Bedlington_terrier
+  n02093754: Border_terrier
+  n02093859: Kerry_blue_terrier
+  n02093991: Irish_terrier
+  n02094114: Norfolk_terrier
+  n02094258: Norwich_terrier
+  n02094433: Yorkshire_terrier
+  n02095314: wire-haired_fox_terrier
+  n02095570: Lakeland_terrier
+  n02095889: Sealyham_terrier
+  n02096051: Airedale
+  n02096177: cairn
+  n02096294: Australian_terrier
+  n02096437: Dandie_Dinmont
+  n02096585: Boston_bull
+  n02097047: miniature_schnauzer
+  n02097130: giant_schnauzer
+  n02097209: standard_schnauzer
+  n02097298: Scotch_terrier
+  n02097474: Tibetan_terrier
+  n02097658: silky_terrier
+  n02098105: soft-coated_wheaten_terrier
+  n02098286: West_Highland_white_terrier
+  n02098413: Lhasa
+  n02099267: flat-coated_retriever
+  n02099429: curly-coated_retriever
+  n02099601: golden_retriever
+  n02099712: Labrador_retriever
+  n02099849: Chesapeake_Bay_retriever
+  n02100236: German_short-haired_pointer
+  n02100583: vizsla
+  n02100735: English_setter
+  n02100877: Irish_setter
+  n02101006: Gordon_setter
+  n02101388: Brittany_spaniel
+  n02101556: clumber
+  n02102040: English_springer
+  n02102177: Welsh_springer_spaniel
+  n02102318: cocker_spaniel
+  n02102480: Sussex_spaniel
+  n02102973: Irish_water_spaniel
+  n02104029: kuvasz
+  n02104365: schipperke
+  n02105056: groenendael
+  n02105162: malinois
+  n02105251: briard
+  n02105412: kelpie
+  n02105505: komondor
+  n02105641: Old_English_sheepdog
+  n02105855: Shetland_sheepdog
+  n02106030: collie
+  n02106166: Border_collie
+  n02106382: Bouvier_des_Flandres
+  n02106550: Rottweiler
+  n02106662: German_shepherd
+  n02107142: Doberman
+  n02107312: miniature_pinscher
+  n02107574: Greater_Swiss_Mountain_dog
+  n02107683: Bernese_mountain_dog
+  n02107908: Appenzeller
+  n02108000: EntleBucher
+  n02108089: boxer
+  n02108422: bull_mastiff
+  n02108551: Tibetan_mastiff
+  n02108915: French_bulldog
+  n02109047: Great_Dane
+  n02109525: Saint_Bernard
+  n02109961: Eskimo_dog
+  n02110063: malamute
+  n02110185: Siberian_husky
+  n02110341: dalmatian
+  n02110627: affenpinscher
+  n02110806: basenji
+  n02110958: pug
+  n02111129: Leonberg
+  n02111277: Newfoundland
+  n02111500: Great_Pyrenees
+  n02111889: Samoyed
+  n02112018: Pomeranian
+  n02112137: chow
+  n02112350: keeshond
+  n02112706: Brabancon_griffon
+  n02113023: Pembroke
+  n02113186: Cardigan
+  n02113624: toy_poodle
+  n02113712: miniature_poodle
+  n02113799: standard_poodle
+  n02113978: Mexican_hairless
+  n02114367: timber_wolf
+  n02114548: white_wolf
+  n02114712: red_wolf
+  n02114855: coyote
+  n02115641: dingo
+  n02115913: dhole
+  n02116738: African_hunting_dog
+  n02117135: hyena
+  n02119022: red_fox
+  n02119789: kit_fox
+  n02120079: Arctic_fox
+  n02120505: grey_fox
+  n02123045: tabby
+  n02123159: tiger_cat
+  n02123394: Persian_cat
+  n02123597: Siamese_cat
+  n02124075: Egyptian_cat
+  n02125311: cougar
+  n02127052: lynx
+  n02128385: leopard
+  n02128757: snow_leopard
+  n02128925: jaguar
+  n02129165: lion
+  n02129604: tiger
+  n02130308: cheetah
+  n02132136: brown_bear
+  n02133161: American_black_bear
+  n02134084: ice_bear
+  n02134418: sloth_bear
+  n02137549: mongoose
+  n02138441: meerkat
+  n02165105: tiger_beetle
+  n02165456: ladybug
+  n02167151: ground_beetle
+  n02168699: long-horned_beetle
+  n02169497: leaf_beetle
+  n02172182: dung_beetle
+  n02174001: rhinoceros_beetle
+  n02177972: weevil
+  n02190166: fly
+  n02206856: bee
+  n02219486: ant
+  n02226429: grasshopper
+  n02229544: cricket
+  n02231487: walking_stick
+  n02233338: cockroach
+  n02236044: mantis
+  n02256656: cicada
+  n02259212: leafhopper
+  n02264363: lacewing
+  n02268443: dragonfly
+  n02268853: damselfly
+  n02276258: admiral
+  n02277742: ringlet
+  n02279972: monarch
+  n02280649: cabbage_butterfly
+  n02281406: sulphur_butterfly
+  n02281787: lycaenid
+  n02317335: starfish
+  n02319095: sea_urchin
+  n02321529: sea_cucumber
+  n02325366: wood_rabbit
+  n02326432: hare
+  n02328150: Angora
+  n02342885: hamster
+  n02346627: porcupine
+  n02356798: fox_squirrel
+  n02361337: marmot
+  n02363005: beaver
+  n02364673: guinea_pig
+  n02389026: sorrel
+  n02391049: zebra
+  n02395406: hog
+  n02396427: wild_boar
+  n02397096: warthog
+  n02398521: hippopotamus
+  n02403003: ox
+  n02408429: water_buffalo
+  n02410509: bison
+  n02412080: ram
+  n02415577: bighorn
+  n02417914: ibex
+  n02422106: hartebeest
+  n02422699: impala
+  n02423022: gazelle
+  n02437312: Arabian_camel
+  n02437616: llama
+  n02441942: weasel
+  n02442845: mink
+  n02443114: polecat
+  n02443484: black-footed_ferret
+  n02444819: otter
+  n02445715: skunk
+  n02447366: badger
+  n02454379: armadillo
+  n02457408: three-toed_sloth
+  n02480495: orangutan
+  n02480855: gorilla
+  n02481823: chimpanzee
+  n02483362: gibbon
+  n02483708: siamang
+  n02484975: guenon
+  n02486261: patas
+  n02486410: baboon
+  n02487347: macaque
+  n02488291: langur
+  n02488702: colobus
+  n02489166: proboscis_monkey
+  n02490219: marmoset
+  n02492035: capuchin
+  n02492660: howler_monkey
+  n02493509: titi
+  n02493793: spider_monkey
+  n02494079: squirrel_monkey
+  n02497673: Madagascar_cat
+  n02500267: indri
+  n02504013: Indian_elephant
+  n02504458: African_elephant
+  n02509815: lesser_panda
+  n02510455: giant_panda
+  n02514041: barracouta
+  n02526121: eel
+  n02536864: coho
+  n02606052: rock_beauty
+  n02607072: anemone_fish
+  n02640242: sturgeon
+  n02641379: gar
+  n02643566: lionfish
+  n02655020: puffer
+  n02666196: abacus
+  n02667093: abaya
+  n02669723: academic_gown
+  n02672831: accordion
+  n02676566: acoustic_guitar
+  n02687172: aircraft_carrier
+  n02690373: airliner
+  n02692877: airship
+  n02699494: altar
+  n02701002: ambulance
+  n02704792: amphibian
+  n02708093: analog_clock
+  n02727426: apiary
+  n02730930: apron
+  n02747177: ashcan
+  n02749479: assault_rifle
+  n02769748: backpack
+  n02776631: bakery
+  n02777292: balance_beam
+  n02782093: balloon
+  n02783161: ballpoint
+  n02786058: Band_Aid
+  n02787622: banjo
+  n02788148: bannister
+  n02790996: barbell
+  n02791124: barber_chair
+  n02791270: barbershop
+  n02793495: barn
+  n02794156: barometer
+  n02795169: barrel
+  n02797295: barrow
+  n02799071: baseball
+  n02802426: basketball
+  n02804414: bassinet
+  n02804610: bassoon
+  n02807133: bathing_cap
+  n02808304: bath_towel
+  n02808440: bathtub
+  n02814533: beach_wagon
+  n02814860: beacon
+  n02815834: beaker
+  n02817516: bearskin
+  n02823428: beer_bottle
+  n02823750: beer_glass
+  n02825657: bell_cote
+  n02834397: bib
+  n02835271: bicycle-built-for-two
+  n02837789: bikini
+  n02840245: binder
+  n02841315: binoculars
+  n02843684: birdhouse
+  n02859443: boathouse
+  n02860847: bobsled
+  n02865351: bolo_tie
+  n02869837: bonnet
+  n02870880: bookcase
+  n02871525: bookshop
+  n02877765: bottlecap
+  n02879718: bow
+  n02883205: bow_tie
+  n02892201: brass
+  n02892767: brassiere
+  n02894605: breakwater
+  n02895154: breastplate
+  n02906734: broom
+  n02909870: bucket
+  n02910353: buckle
+  n02916936: bulletproof_vest
+  n02917067: bullet_train
+  n02927161: butcher_shop
+  n02930766: cab
+  n02939185: caldron
+  n02948072: candle
+  n02950826: cannon
+  n02951358: canoe
+  n02951585: can_opener
+  n02963159: cardigan
+  n02965783: car_mirror
+  n02966193: carousel
+  n02966687: carpenter's_kit
+  n02971356: carton
+  n02974003: car_wheel
+  n02977058: cash_machine
+  n02978881: cassette
+  n02979186: cassette_player
+  n02980441: castle
+  n02981792: catamaran
+  n02988304: CD_player
+  n02992211: cello
+  n02992529: cellular_telephone
+  n02999410: chain
+  n03000134: chainlink_fence
+  n03000247: chain_mail
+  n03000684: chain_saw
+  n03014705: chest
+  n03016953: chiffonier
+  n03017168: chime
+  n03018349: china_cabinet
+  n03026506: Christmas_stocking
+  n03028079: church
+  n03032252: cinema
+  n03041632: cleaver
+  n03042490: cliff_dwelling
+  n03045698: cloak
+  n03047690: clog
+  n03062245: cocktail_shaker
+  n03063599: coffee_mug
+  n03063689: coffeepot
+  n03065424: coil
+  n03075370: combination_lock
+  n03085013: computer_keyboard
+  n03089624: confectionery
+  n03095699: container_ship
+  n03100240: convertible
+  n03109150: corkscrew
+  n03110669: cornet
+  n03124043: cowboy_boot
+  n03124170: cowboy_hat
+  n03125729: cradle
+  n03126707: crane_(machine)
+  n03127747: crash_helmet
+  n03127925: crate
+  n03131574: crib
+  n03133878: Crock_Pot
+  n03134739: croquet_ball
+  n03141823: crutch
+  n03146219: cuirass
+  n03160309: dam
+  n03179701: desk
+  n03180011: desktop_computer
+  n03187595: dial_telephone
+  n03188531: diaper
+  n03196217: digital_clock
+  n03197337: digital_watch
+  n03201208: dining_table
+  n03207743: dishrag
+  n03207941: dishwasher
+  n03208938: disk_brake
+  n03216828: dock
+  n03218198: dogsled
+  n03220513: dome
+  n03223299: doormat
+  n03240683: drilling_platform
+  n03249569: drum
+  n03250847: drumstick
+  n03255030: dumbbell
+  n03259280: Dutch_oven
+  n03271574: electric_fan
+  n03272010: electric_guitar
+  n03272562: electric_locomotive
+  n03290653: entertainment_center
+  n03291819: envelope
+  n03297495: espresso_maker
+  n03314780: face_powder
+  n03325584: feather_boa
+  n03337140: file
+  n03344393: fireboat
+  n03345487: fire_engine
+  n03347037: fire_screen
+  n03355925: flagpole
+  n03372029: flute
+  n03376595: folding_chair
+  n03379051: football_helmet
+  n03384352: forklift
+  n03388043: fountain
+  n03388183: fountain_pen
+  n03388549: four-poster
+  n03393912: freight_car
+  n03394916: French_horn
+  n03400231: frying_pan
+  n03404251: fur_coat
+  n03417042: garbage_truck
+  n03424325: gasmask
+  n03425413: gas_pump
+  n03443371: goblet
+  n03444034: go-kart
+  n03445777: golf_ball
+  n03445924: golfcart
+  n03447447: gondola
+  n03447721: gong
+  n03450230: gown
+  n03452741: grand_piano
+  n03457902: greenhouse
+  n03459775: grille
+  n03461385: grocery_store
+  n03467068: guillotine
+  n03476684: hair_slide
+  n03476991: hair_spray
+  n03478589: half_track
+  n03481172: hammer
+  n03482405: hamper
+  n03483316: hand_blower
+  n03485407: hand-held_computer
+  n03485794: handkerchief
+  n03492542: hard_disc
+  n03494278: harmonica
+  n03495258: harp
+  n03496892: harvester
+  n03498962: hatchet
+  n03527444: holster
+  n03529860: home_theater
+  n03530642: honeycomb
+  n03532672: hook
+  n03534580: hoopskirt
+  n03535780: horizontal_bar
+  n03538406: horse_cart
+  n03544143: hourglass
+  n03584254: iPod
+  n03584829: iron
+  n03590841: jack-o'-lantern
+  n03594734: jean
+  n03594945: jeep
+  n03595614: jersey
+  n03598930: jigsaw_puzzle
+  n03599486: jinrikisha
+  n03602883: joystick
+  n03617480: kimono
+  n03623198: knee_pad
+  n03627232: knot
+  n03630383: lab_coat
+  n03633091: ladle
+  n03637318: lampshade
+  n03642806: laptop
+  n03649909: lawn_mower
+  n03657121: lens_cap
+  n03658185: letter_opener
+  n03661043: library
+  n03662601: lifeboat
+  n03666591: lighter
+  n03670208: limousine
+  n03673027: liner
+  n03676483: lipstick
+  n03680355: Loafer
+  n03690938: lotion
+  n03691459: loudspeaker
+  n03692522: loupe
+  n03697007: lumbermill
+  n03706229: magnetic_compass
+  n03709823: mailbag
+  n03710193: mailbox
+  n03710637: maillot_(tights)
+  n03710721: maillot_(tank_suit)
+  n03717622: manhole_cover
+  n03720891: maraca
+  n03721384: marimba
+  n03724870: mask
+  n03729826: matchstick
+  n03733131: maypole
+  n03733281: maze
+  n03733805: measuring_cup
+  n03742115: medicine_chest
+  n03743016: megalith
+  n03759954: microphone
+  n03761084: microwave
+  n03763968: military_uniform
+  n03764736: milk_can
+  n03769881: minibus
+  n03770439: miniskirt
+  n03770679: minivan
+  n03773504: missile
+  n03775071: mitten
+  n03775546: mixing_bowl
+  n03776460: mobile_home
+  n03777568: Model_T
+  n03777754: modem
+  n03781244: monastery
+  n03782006: monitor
+  n03785016: moped
+  n03786901: mortar
+  n03787032: mortarboard
+  n03788195: mosque
+  n03788365: mosquito_net
+  n03791053: motor_scooter
+  n03792782: mountain_bike
+  n03792972: mountain_tent
+  n03793489: mouse
+  n03794056: mousetrap
+  n03796401: moving_van
+  n03803284: muzzle
+  n03804744: nail
+  n03814639: neck_brace
+  n03814906: necklace
+  n03825788: nipple
+  n03832673: notebook
+  n03837869: obelisk
+  n03838899: oboe
+  n03840681: ocarina
+  n03841143: odometer
+  n03843555: oil_filter
+  n03854065: organ
+  n03857828: oscilloscope
+  n03866082: overskirt
+  n03868242: oxcart
+  n03868863: oxygen_mask
+  n03871628: packet
+  n03873416: paddle
+  n03874293: paddlewheel
+  n03874599: padlock
+  n03876231: paintbrush
+  n03877472: pajama
+  n03877845: palace
+  n03884397: panpipe
+  n03887697: paper_towel
+  n03888257: parachute
+  n03888605: parallel_bars
+  n03891251: park_bench
+  n03891332: parking_meter
+  n03895866: passenger_car
+  n03899768: patio
+  n03902125: pay-phone
+  n03903868: pedestal
+  n03908618: pencil_box
+  n03908714: pencil_sharpener
+  n03916031: perfume
+  n03920288: Petri_dish
+  n03924679: photocopier
+  n03929660: pick
+  n03929855: pickelhaube
+  n03930313: picket_fence
+  n03930630: pickup
+  n03933933: pier
+  n03935335: piggy_bank
+  n03937543: pill_bottle
+  n03938244: pillow
+  n03942813: ping-pong_ball
+  n03944341: pinwheel
+  n03947888: pirate
+  n03950228: pitcher
+  n03954731: plane
+  n03956157: planetarium
+  n03958227: plastic_bag
+  n03961711: plate_rack
+  n03967562: plow
+  n03970156: plunger
+  n03976467: Polaroid_camera
+  n03976657: pole
+  n03977966: police_van
+  n03980874: poncho
+  n03982430: pool_table
+  n03983396: pop_bottle
+  n03991062: pot
+  n03992509: potter's_wheel
+  n03995372: power_drill
+  n03998194: prayer_rug
+  n04004767: printer
+  n04005630: prison
+  n04008634: projectile
+  n04009552: projector
+  n04019541: puck
+  n04023962: punching_bag
+  n04026417: purse
+  n04033901: quill
+  n04033995: quilt
+  n04037443: racer
+  n04039381: racket
+  n04040759: radiator
+  n04041544: radio
+  n04044716: radio_telescope
+  n04049303: rain_barrel
+  n04065272: recreational_vehicle
+  n04067472: reel
+  n04069434: reflex_camera
+  n04070727: refrigerator
+  n04074963: remote_control
+  n04081281: restaurant
+  n04086273: revolver
+  n04090263: rifle
+  n04099969: rocking_chair
+  n04111531: rotisserie
+  n04116512: rubber_eraser
+  n04118538: rugby_ball
+  n04118776: rule
+  n04120489: running_shoe
+  n04125021: safe
+  n04127249: safety_pin
+  n04131690: saltshaker
+  n04133789: sandal
+  n04136333: sarong
+  n04141076: sax
+  n04141327: scabbard
+  n04141975: scale
+  n04146614: school_bus
+  n04147183: schooner
+  n04149813: scoreboard
+  n04152593: screen
+  n04153751: screw
+  n04154565: screwdriver
+  n04162706: seat_belt
+  n04179913: sewing_machine
+  n04192698: shield
+  n04200800: shoe_shop
+  n04201297: shoji
+  n04204238: shopping_basket
+  n04204347: shopping_cart
+  n04208210: shovel
+  n04209133: shower_cap
+  n04209239: shower_curtain
+  n04228054: ski
+  n04229816: ski_mask
+  n04235860: sleeping_bag
+  n04238763: slide_rule
+  n04239074: sliding_door
+  n04243546: slot
+  n04251144: snorkel
+  n04252077: snowmobile
+  n04252225: snowplow
+  n04254120: soap_dispenser
+  n04254680: soccer_ball
+  n04254777: sock
+  n04258138: solar_dish
+  n04259630: sombrero
+  n04263257: soup_bowl
+  n04264628: space_bar
+  n04265275: space_heater
+  n04266014: space_shuttle
+  n04270147: spatula
+  n04273569: speedboat
+  n04275548: spider_web
+  n04277352: spindle
+  n04285008: sports_car
+  n04286575: spotlight
+  n04296562: stage
+  n04310018: steam_locomotive
+  n04311004: steel_arch_bridge
+  n04311174: steel_drum
+  n04317175: stethoscope
+  n04325704: stole
+  n04326547: stone_wall
+  n04328186: stopwatch
+  n04330267: stove
+  n04332243: strainer
+  n04335435: streetcar
+  n04336792: stretcher
+  n04344873: studio_couch
+  n04346328: stupa
+  n04347754: submarine
+  n04350905: suit
+  n04355338: sundial
+  n04355933: sunglass
+  n04356056: sunglasses
+  n04357314: sunscreen
+  n04366367: suspension_bridge
+  n04367480: swab
+  n04370456: sweatshirt
+  n04371430: swimming_trunks
+  n04371774: swing
+  n04372370: switch
+  n04376876: syringe
+  n04380533: table_lamp
+  n04389033: tank
+  n04392985: tape_player
+  n04398044: teapot
+  n04399382: teddy
+  n04404412: television
+  n04409515: tennis_ball
+  n04417672: thatch
+  n04418357: theater_curtain
+  n04423845: thimble
+  n04428191: thresher
+  n04429376: throne
+  n04435653: tile_roof
+  n04442312: toaster
+  n04443257: tobacco_shop
+  n04447861: toilet_seat
+  n04456115: torch
+  n04458633: totem_pole
+  n04461696: tow_truck
+  n04462240: toyshop
+  n04465501: tractor
+  n04467665: trailer_truck
+  n04476259: tray
+  n04479046: trench_coat
+  n04482393: tricycle
+  n04483307: trimaran
+  n04485082: tripod
+  n04486054: triumphal_arch
+  n04487081: trolleybus
+  n04487394: trombone
+  n04493381: tub
+  n04501370: turnstile
+  n04505470: typewriter_keyboard
+  n04507155: umbrella
+  n04509417: unicycle
+  n04515003: upright
+  n04517823: vacuum
+  n04522168: vase
+  n04523525: vault
+  n04525038: velvet
+  n04525305: vending_machine
+  n04532106: vestment
+  n04532670: viaduct
+  n04536866: violin
+  n04540053: volleyball
+  n04542943: waffle_iron
+  n04548280: wall_clock
+  n04548362: wallet
+  n04550184: wardrobe
+  n04552348: warplane
+  n04553703: washbasin
+  n04554684: washer
+  n04557648: water_bottle
+  n04560804: water_jug
+  n04562935: water_tower
+  n04579145: whiskey_jug
+  n04579432: whistle
+  n04584207: wig
+  n04589890: window_screen
+  n04590129: window_shade
+  n04591157: Windsor_tie
+  n04591713: wine_bottle
+  n04592741: wing
+  n04596742: wok
+  n04597913: wooden_spoon
+  n04599235: wool
+  n04604644: worm_fence
+  n04606251: wreck
+  n04612504: yawl
+  n04613696: yurt
+  n06359193: web_site
+  n06596364: comic_book
+  n06785654: crossword_puzzle
+  n06794110: street_sign
+  n06874185: traffic_light
+  n07248320: book_jacket
+  n07565083: menu
+  n07579787: plate
+  n07583066: guacamole
+  n07584110: consomme
+  n07590611: hot_pot
+  n07613480: trifle
+  n07614500: ice_cream
+  n07615774: ice_lolly
+  n07684084: French_loaf
+  n07693725: bagel
+  n07695742: pretzel
+  n07697313: cheeseburger
+  n07697537: hotdog
+  n07711569: mashed_potato
+  n07714571: head_cabbage
+  n07714990: broccoli
+  n07715103: cauliflower
+  n07716358: zucchini
+  n07716906: spaghetti_squash
+  n07717410: acorn_squash
+  n07717556: butternut_squash
+  n07718472: cucumber
+  n07718747: artichoke
+  n07720875: bell_pepper
+  n07730033: cardoon
+  n07734744: mushroom
+  n07742313: Granny_Smith
+  n07745940: strawberry
+  n07747607: orange
+  n07749582: lemon
+  n07753113: fig
+  n07753275: pineapple
+  n07753592: banana
+  n07754684: jackfruit
+  n07760859: custard_apple
+  n07768694: pomegranate
+  n07802026: hay
+  n07831146: carbonara
+  n07836838: chocolate_sauce
+  n07860988: dough
+  n07871810: meat_loaf
+  n07873807: pizza
+  n07875152: potpie
+  n07880968: burrito
+  n07892512: red_wine
+  n07920052: espresso
+  n07930864: cup
+  n07932039: eggnog
+  n09193705: alp
+  n09229709: bubble
+  n09246464: cliff
+  n09256479: coral_reef
+  n09288635: geyser
+  n09332890: lakeside
+  n09399592: promontory
+  n09421951: sandbar
+  n09428293: seashore
+  n09468604: valley
+  n09472597: volcano
+  n09835506: ballplayer
+  n10148035: groom
+  n10565667: scuba_diver
+  n11879895: rapeseed
+  n11939491: daisy
+  n12057211: yellow_lady's_slipper
+  n12144580: corn
+  n12267677: acorn
+  n12620546: hip
+  n12768682: buckeye
+  n12985857: coral_fungus
+  n12998815: agaric
+  n13037406: gyromitra
+  n13040303: stinkhorn
+  n13044778: earthstar
+  n13052670: hen-of-the-woods
+  n13054560: bolete
+  n13133613: ear
+  n15075141: toilet_tissue
+
+# Download script/URL (optional)
+download: yolo/data/scripts/get_imagenet.sh

ultralytics/cfg/datasets/Objects365.yaml

@@ -0,0 +1,443 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Objects365 dataset https://www.objects365.org/ by Megvii
+# Documentation: https://docs.ultralytics.com/datasets/detect/objects365/
+# Example usage: yolo train data=Objects365.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── Objects365  ← downloads here (712 GB = 367G data + 345G zips)
+
+# 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/Objects365 # dataset root dir
+train: images/train # train images (relative to 'path') 1742289 images
+val: images/val # val images (relative to 'path') 80000 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: Person
+  1: Sneakers
+  2: Chair
+  3: Other Shoes
+  4: Hat
+  5: Car
+  6: Lamp
+  7: Glasses
+  8: Bottle
+  9: Desk
+  10: Cup
+  11: Street Lights
+  12: Cabinet/shelf
+  13: Handbag/Satchel
+  14: Bracelet
+  15: Plate
+  16: Picture/Frame
+  17: Helmet
+  18: Book
+  19: Gloves
+  20: Storage box
+  21: Boat
+  22: Leather Shoes
+  23: Flower
+  24: Bench
+  25: Potted Plant
+  26: Bowl/Basin
+  27: Flag
+  28: Pillow
+  29: Boots
+  30: Vase
+  31: Microphone
+  32: Necklace
+  33: Ring
+  34: SUV
+  35: Wine Glass
+  36: Belt
+  37: Monitor/TV
+  38: Backpack
+  39: Umbrella
+  40: Traffic Light
+  41: Speaker
+  42: Watch
+  43: Tie
+  44: Trash bin Can
+  45: Slippers
+  46: Bicycle
+  47: Stool
+  48: Barrel/bucket
+  49: Van
+  50: Couch
+  51: Sandals
+  52: Basket
+  53: Drum
+  54: Pen/Pencil
+  55: Bus
+  56: Wild Bird
+  57: High Heels
+  58: Motorcycle
+  59: Guitar
+  60: Carpet
+  61: Cell Phone
+  62: Bread
+  63: Camera
+  64: Canned
+  65: Truck
+  66: Traffic cone
+  67: Cymbal
+  68: Lifesaver
+  69: Towel
+  70: Stuffed Toy
+  71: Candle
+  72: Sailboat
+  73: Laptop
+  74: Awning
+  75: Bed
+  76: Faucet
+  77: Tent
+  78: Horse
+  79: Mirror
+  80: Power outlet
+  81: Sink
+  82: Apple
+  83: Air Conditioner
+  84: Knife
+  85: Hockey Stick
+  86: Paddle
+  87: Pickup Truck
+  88: Fork
+  89: Traffic Sign
+  90: Balloon
+  91: Tripod
+  92: Dog
+  93: Spoon
+  94: Clock
+  95: Pot
+  96: Cow
+  97: Cake
+  98: Dining Table
+  99: Sheep
+  100: Hanger
+  101: Blackboard/Whiteboard
+  102: Napkin
+  103: Other Fish
+  104: Orange/Tangerine
+  105: Toiletry
+  106: Keyboard
+  107: Tomato
+  108: Lantern
+  109: Machinery Vehicle
+  110: Fan
+  111: Green Vegetables
+  112: Banana
+  113: Baseball Glove
+  114: Airplane
+  115: Mouse
+  116: Train
+  117: Pumpkin
+  118: Soccer
+  119: Skiboard
+  120: Luggage
+  121: Nightstand
+  122: Tea pot
+  123: Telephone
+  124: Trolley
+  125: Head Phone
+  126: Sports Car
+  127: Stop Sign
+  128: Dessert
+  129: Scooter
+  130: Stroller
+  131: Crane
+  132: Remote
+  133: Refrigerator
+  134: Oven
+  135: Lemon
+  136: Duck
+  137: Baseball Bat
+  138: Surveillance Camera
+  139: Cat
+  140: Jug
+  141: Broccoli
+  142: Piano
+  143: Pizza
+  144: Elephant
+  145: Skateboard
+  146: Surfboard
+  147: Gun
+  148: Skating and Skiing shoes
+  149: Gas stove
+  150: Donut
+  151: Bow Tie
+  152: Carrot
+  153: Toilet
+  154: Kite
+  155: Strawberry
+  156: Other Balls
+  157: Shovel
+  158: Pepper
+  159: Computer Box
+  160: Toilet Paper
+  161: Cleaning Products
+  162: Chopsticks
+  163: Microwave
+  164: Pigeon
+  165: Baseball
+  166: Cutting/chopping Board
+  167: Coffee Table
+  168: Side Table
+  169: Scissors
+  170: Marker
+  171: Pie
+  172: Ladder
+  173: Snowboard
+  174: Cookies
+  175: Radiator
+  176: Fire Hydrant
+  177: Basketball
+  178: Zebra
+  179: Grape
+  180: Giraffe
+  181: Potato
+  182: Sausage
+  183: Tricycle
+  184: Violin
+  185: Egg
+  186: Fire Extinguisher
+  187: Candy
+  188: Fire Truck
+  189: Billiards
+  190: Converter
+  191: Bathtub
+  192: Wheelchair
+  193: Golf Club
+  194: Briefcase
+  195: Cucumber
+  196: Cigar/Cigarette
+  197: Paint Brush
+  198: Pear
+  199: Heavy Truck
+  200: Hamburger
+  201: Extractor
+  202: Extension Cord
+  203: Tong
+  204: Tennis Racket
+  205: Folder
+  206: American Football
+  207: earphone
+  208: Mask
+  209: Kettle
+  210: Tennis
+  211: Ship
+  212: Swing
+  213: Coffee Machine
+  214: Slide
+  215: Carriage
+  216: Onion
+  217: Green beans
+  218: Projector
+  219: Frisbee
+  220: Washing Machine/Drying Machine
+  221: Chicken
+  222: Printer
+  223: Watermelon
+  224: Saxophone
+  225: Tissue
+  226: Toothbrush
+  227: Ice cream
+  228: Hot-air balloon
+  229: Cello
+  230: French Fries
+  231: Scale
+  232: Trophy
+  233: Cabbage
+  234: Hot dog
+  235: Blender
+  236: Peach
+  237: Rice
+  238: Wallet/Purse
+  239: Volleyball
+  240: Deer
+  241: Goose
+  242: Tape
+  243: Tablet
+  244: Cosmetics
+  245: Trumpet
+  246: Pineapple
+  247: Golf Ball
+  248: Ambulance
+  249: Parking meter
+  250: Mango
+  251: Key
+  252: Hurdle
+  253: Fishing Rod
+  254: Medal
+  255: Flute
+  256: Brush
+  257: Penguin
+  258: Megaphone
+  259: Corn
+  260: Lettuce
+  261: Garlic
+  262: Swan
+  263: Helicopter
+  264: Green Onion
+  265: Sandwich
+  266: Nuts
+  267: Speed Limit Sign
+  268: Induction Cooker
+  269: Broom
+  270: Trombone
+  271: Plum
+  272: Rickshaw
+  273: Goldfish
+  274: Kiwi fruit
+  275: Router/modem
+  276: Poker Card
+  277: Toaster
+  278: Shrimp
+  279: Sushi
+  280: Cheese
+  281: Notepaper
+  282: Cherry
+  283: Pliers
+  284: CD
+  285: Pasta
+  286: Hammer
+  287: Cue
+  288: Avocado
+  289: Hami melon
+  290: Flask
+  291: Mushroom
+  292: Screwdriver
+  293: Soap
+  294: Recorder
+  295: Bear
+  296: Eggplant
+  297: Board Eraser
+  298: Coconut
+  299: Tape Measure/Ruler
+  300: Pig
+  301: Showerhead
+  302: Globe
+  303: Chips
+  304: Steak
+  305: Crosswalk Sign
+  306: Stapler
+  307: Camel
+  308: Formula 1
+  309: Pomegranate
+  310: Dishwasher
+  311: Crab
+  312: Hoverboard
+  313: Meatball
+  314: Rice Cooker
+  315: Tuba
+  316: Calculator
+  317: Papaya
+  318: Antelope
+  319: Parrot
+  320: Seal
+  321: Butterfly
+  322: Dumbbell
+  323: Donkey
+  324: Lion
+  325: Urinal
+  326: Dolphin
+  327: Electric Drill
+  328: Hair Dryer
+  329: Egg tart
+  330: Jellyfish
+  331: Treadmill
+  332: Lighter
+  333: Grapefruit
+  334: Game board
+  335: Mop
+  336: Radish
+  337: Baozi
+  338: Target
+  339: French
+  340: Spring Rolls
+  341: Monkey
+  342: Rabbit
+  343: Pencil Case
+  344: Yak
+  345: Red Cabbage
+  346: Binoculars
+  347: Asparagus
+  348: Barbell
+  349: Scallop
+  350: Noddles
+  351: Comb
+  352: Dumpling
+  353: Oyster
+  354: Table Tennis paddle
+  355: Cosmetics Brush/Eyeliner Pencil
+  356: Chainsaw
+  357: Eraser
+  358: Lobster
+  359: Durian
+  360: Okra
+  361: Lipstick
+  362: Cosmetics Mirror
+  363: Curling
+  364: Table Tennis
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  from tqdm import tqdm
+
+  from ultralytics.utils.checks import check_requirements
+  from ultralytics.utils.downloads import download
+  from ultralytics.utils.ops import xyxy2xywhn
+
+  import numpy as np
+  from pathlib import Path
+
+  check_requirements(('pycocotools>=2.0',))
+  from pycocotools.coco import COCO
+
+  # Make Directories
+  dir = Path(yaml['path'])  # dataset root dir
+  for p in 'images', 'labels':
+      (dir / p).mkdir(parents=True, exist_ok=True)
+      for q in 'train', 'val':
+          (dir / p / q).mkdir(parents=True, exist_ok=True)
+
+  # Train, Val Splits
+  for split, patches in [('train', 50 + 1), ('val', 43 + 1)]:
+      print(f"Processing {split} in {patches} patches ...")
+      images, labels = dir / 'images' / split, dir / 'labels' / split
+
+      # Download
+      url = f"https://dorc.ks3-cn-beijing.ksyun.com/data-set/2020Objects365%E6%95%B0%E6%8D%AE%E9%9B%86/{split}/"
+      if split == 'train':
+          download([f'{url}zhiyuan_objv2_{split}.tar.gz'], dir=dir)  # annotations json
+          download([f'{url}patch{i}.tar.gz' for i in range(patches)], dir=images, curl=True, threads=8)
+      elif split == 'val':
+          download([f'{url}zhiyuan_objv2_{split}.json'], dir=dir)  # annotations json
+          download([f'{url}images/v1/patch{i}.tar.gz' for i in range(15 + 1)], dir=images, curl=True, threads=8)
+          download([f'{url}images/v2/patch{i}.tar.gz' for i in range(16, patches)], dir=images, curl=True, threads=8)
+
+      # Move
+      for f in tqdm(images.rglob('*.jpg'), desc=f'Moving {split} images'):
+          f.rename(images / f.name)  # move to /images/{split}
+
+      # Labels
+      coco = COCO(dir / f'zhiyuan_objv2_{split}.json')
+      names = [x["name"] for x in coco.loadCats(coco.getCatIds())]
+      for cid, cat in enumerate(names):
+          catIds = coco.getCatIds(catNms=[cat])
+          imgIds = coco.getImgIds(catIds=catIds)
+          for im in tqdm(coco.loadImgs(imgIds), desc=f'Class {cid + 1}/{len(names)} {cat}'):
+              width, height = im["width"], im["height"]
+              path = Path(im["file_name"])  # image filename
+              try:
+                  with open(labels / path.with_suffix('.txt').name, 'a') as file:
+                      annIds = coco.getAnnIds(imgIds=im["id"], catIds=catIds, iscrowd=None)
+                      for a in coco.loadAnns(annIds):
+                          x, y, w, h = a['bbox']  # bounding box in xywh (xy top-left corner)
+                          xyxy = np.array([x, y, x + w, y + h])[None]  # pixels(1,4)
+                          x, y, w, h = xyxy2xywhn(xyxy, w=width, h=height, clip=True)[0]  # normalized and clipped
+                          file.write(f"{cid} {x:.5f} {y:.5f} {w:.5f} {h:.5f}\n")
+              except Exception as e:
+                  print(e)

ultralytics/cfg/datasets/SKU-110K.yaml

@@ -0,0 +1,58 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# SKU-110K retail items dataset https://github.com/eg4000/SKU110K_CVPR19 by Trax Retail
+# Documentation: https://docs.ultralytics.com/datasets/detect/sku-110k/
+# Example usage: yolo train data=SKU-110K.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── SKU-110K  ← downloads here (13.6 GB)
+
+# 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/SKU-110K # dataset root dir
+train: train.txt # train images (relative to 'path')  8219 images
+val: val.txt # val images (relative to 'path')  588 images
+test: test.txt # test images (optional)  2936 images
+
+# Classes
+names:
+  0: object
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import shutil
+  from pathlib import Path
+
+  import numpy as np
+  import pandas as pd
+  from tqdm import tqdm
+
+  from ultralytics.utils.downloads import download
+  from ultralytics.utils.ops import xyxy2xywh
+
+  # Download
+  dir = Path(yaml['path'])  # dataset root dir
+  parent = Path(dir.parent)  # download dir
+  urls = ['http://trax-geometry.s3.amazonaws.com/cvpr_challenge/SKU110K_fixed.tar.gz']
+  download(urls, dir=parent)
+
+  # Rename directories
+  if dir.exists():
+      shutil.rmtree(dir)
+  (parent / 'SKU110K_fixed').rename(dir)  # rename dir
+  (dir / 'labels').mkdir(parents=True, exist_ok=True)  # create labels dir
+
+  # Convert labels
+  names = 'image', 'x1', 'y1', 'x2', 'y2', 'class', 'image_width', 'image_height'  # column names
+  for d in 'annotations_train.csv', 'annotations_val.csv', 'annotations_test.csv':
+      x = pd.read_csv(dir / 'annotations' / d, names=names).values  # annotations
+      images, unique_images = x[:, 0], np.unique(x[:, 0])
+      with open((dir / d).with_suffix('.txt').__str__().replace('annotations_', ''), 'w') as f:
+          f.writelines(f'./images/{s}\n' for s in unique_images)
+      for im in tqdm(unique_images, desc=f'Converting {dir / d}'):
+          cls = 0  # single-class dataset
+          with open((dir / 'labels' / im).with_suffix('.txt'), 'a') as f:
+              for r in x[images == im]:
+                  w, h = r[6], r[7]  # image width, height
+                  xywh = xyxy2xywh(np.array([[r[1] / w, r[2] / h, r[3] / w, r[4] / h]]))[0]  # instance
+                  f.write(f"{cls} {xywh[0]:.5f} {xywh[1]:.5f} {xywh[2]:.5f} {xywh[3]:.5f}\n")  # write label

ultralytics/cfg/datasets/VOC.yaml

@@ -0,0 +1,100 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC by University of Oxford
+# Documentation: # Documentation: https://docs.ultralytics.com/datasets/detect/voc/
+# Example usage: yolo train data=VOC.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── VOC  ← downloads here (2.8 GB)
+
+# 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/VOC
+train: # train images (relative to 'path')  16551 images
+  - images/train2012
+  - images/train2007
+  - images/val2012
+  - images/val2007
+val: # val images (relative to 'path')  4952 images
+  - images/test2007
+test: # test images (optional)
+  - images/test2007
+
+# Classes
+names:
+  0: aeroplane
+  1: bicycle
+  2: bird
+  3: boat
+  4: bottle
+  5: bus
+  6: car
+  7: cat
+  8: chair
+  9: cow
+  10: diningtable
+  11: dog
+  12: horse
+  13: motorbike
+  14: person
+  15: pottedplant
+  16: sheep
+  17: sofa
+  18: train
+  19: tvmonitor
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import xml.etree.ElementTree as ET
+
+  from tqdm import tqdm
+  from ultralytics.utils.downloads import download
+  from pathlib import Path
+
+  def convert_label(path, lb_path, year, image_id):
+      def convert_box(size, box):
+          dw, dh = 1. / size[0], 1. / size[1]
+          x, y, w, h = (box[0] + box[1]) / 2.0 - 1, (box[2] + box[3]) / 2.0 - 1, box[1] - box[0], box[3] - box[2]
+          return x * dw, y * dh, w * dw, h * dh
+
+      in_file = open(path / f'VOC{year}/Annotations/{image_id}.xml')
+      out_file = open(lb_path, 'w')
+      tree = ET.parse(in_file)
+      root = tree.getroot()
+      size = root.find('size')
+      w = int(size.find('width').text)
+      h = int(size.find('height').text)
+
+      names = list(yaml['names'].values())  # names list
+      for obj in root.iter('object'):
+          cls = obj.find('name').text
+          if cls in names and int(obj.find('difficult').text) != 1:
+              xmlbox = obj.find('bndbox')
+              bb = convert_box((w, h), [float(xmlbox.find(x).text) for x in ('xmin', 'xmax', 'ymin', 'ymax')])
+              cls_id = names.index(cls)  # class id
+              out_file.write(" ".join(str(a) for a in (cls_id, *bb)) + '\n')
+
+
+  # Download
+  dir = Path(yaml['path'])  # dataset root dir
+  url = 'https://github.com/ultralytics/assets/releases/download/v0.0.0/'
+  urls = [f'{url}VOCtrainval_06-Nov-2007.zip',  # 446MB, 5012 images
+          f'{url}VOCtest_06-Nov-2007.zip',  # 438MB, 4953 images
+          f'{url}VOCtrainval_11-May-2012.zip']  # 1.95GB, 17126 images
+  download(urls, dir=dir / 'images', curl=True, threads=3, exist_ok=True)  # download and unzip over existing paths (required)
+
+  # Convert
+  path = dir / 'images/VOCdevkit'
+  for year, image_set in ('2012', 'train'), ('2012', 'val'), ('2007', 'train'), ('2007', 'val'), ('2007', 'test'):
+      imgs_path = dir / 'images' / f'{image_set}{year}'
+      lbs_path = dir / 'labels' / f'{image_set}{year}'
+      imgs_path.mkdir(exist_ok=True, parents=True)
+      lbs_path.mkdir(exist_ok=True, parents=True)
+
+      with open(path / f'VOC{year}/ImageSets/Main/{image_set}.txt') as f:
+          image_ids = f.read().strip().split()
+      for id in tqdm(image_ids, desc=f'{image_set}{year}'):
+          f = path / f'VOC{year}/JPEGImages/{id}.jpg'  # old img path
+          lb_path = (lbs_path / f.name).with_suffix('.txt')  # new label path
+          f.rename(imgs_path / f.name)  # move image
+          convert_label(path, lb_path, year, id)  # convert labels to YOLO format

ultralytics/cfg/datasets/VisDrone.yaml

@@ -0,0 +1,73 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University
+# Documentation: https://docs.ultralytics.com/datasets/detect/visdrone/
+# Example usage: yolo train data=VisDrone.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── VisDrone  ← downloads here (2.3 GB)
+
+# 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/VisDrone # dataset root dir
+train: VisDrone2019-DET-train/images # train images (relative to 'path')  6471 images
+val: VisDrone2019-DET-val/images # val images (relative to 'path')  548 images
+test: VisDrone2019-DET-test-dev/images # test images (optional)  1610 images
+
+# Classes
+names:
+  0: pedestrian
+  1: people
+  2: bicycle
+  3: car
+  4: van
+  5: truck
+  6: tricycle
+  7: awning-tricycle
+  8: bus
+  9: motor
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import os
+  from pathlib import Path
+
+  from ultralytics.utils.downloads import download
+
+  def visdrone2yolo(dir):
+      from PIL import Image
+      from tqdm import tqdm
+
+      def convert_box(size, box):
+          # Convert VisDrone box to YOLO xywh box
+          dw = 1. / size[0]
+          dh = 1. / size[1]
+          return (box[0] + box[2] / 2) * dw, (box[1] + box[3] / 2) * dh, box[2] * dw, box[3] * dh
+
+      (dir / 'labels').mkdir(parents=True, exist_ok=True)  # make labels directory
+      pbar = tqdm((dir / 'annotations').glob('*.txt'), desc=f'Converting {dir}')
+      for f in pbar:
+          img_size = Image.open((dir / 'images' / f.name).with_suffix('.jpg')).size
+          lines = []
+          with open(f, 'r') as file:  # read annotation.txt
+              for row in [x.split(',') for x in file.read().strip().splitlines()]:
+                  if row[4] == '0':  # VisDrone 'ignored regions' class 0
+                      continue
+                  cls = int(row[5]) - 1
+                  box = convert_box(img_size, tuple(map(int, row[:4])))
+                  lines.append(f"{cls} {' '.join(f'{x:.6f}' for x in box)}\n")
+                  with open(str(f).replace(f'{os.sep}annotations{os.sep}', f'{os.sep}labels{os.sep}'), 'w') as fl:
+                      fl.writelines(lines)  # write label.txt
+
+
+  # Download
+  dir = Path(yaml['path'])  # dataset root dir
+  urls = ['https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-train.zip',
+          'https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-val.zip',
+          'https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-test-dev.zip',
+          'https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-test-challenge.zip']
+  download(urls, dir=dir, curl=True, threads=4)
+
+  # Convert
+  for d in 'VisDrone2019-DET-train', 'VisDrone2019-DET-val', 'VisDrone2019-DET-test-dev':
+      visdrone2yolo(dir / d)  # convert VisDrone annotations to YOLO labels

ultralytics/cfg/datasets/african-wildlife.yaml

@@ -0,0 +1,25 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# African-wildlife dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/african-wildlife/
+# Example usage: yolo train data=african-wildlife.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── african-wildlife  ← downloads here (100 MB)
+
+# 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/african-wildlife # dataset root dir
+train: train/images # train images (relative to 'path') 1052 images
+val: valid/images # val images (relative to 'path') 225 images
+test: test/images # test images (relative to 'path') 227 images
+
+# Classes
+names:
+  0: buffalo
+  1: elephant
+  2: rhino
+  3: zebra
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/african-wildlife.zip

ultralytics/cfg/datasets/brain-tumor.yaml

@@ -0,0 +1,23 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Brain-tumor dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/brain-tumor/
+# Example usage: yolo train data=brain-tumor.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── brain-tumor  ← downloads here (4.05 MB)
+
+# 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/brain-tumor # dataset root dir
+train: train/images # train images (relative to 'path') 893 images
+val: valid/images # val images (relative to 'path') 223 images
+test: # test images (relative to 'path')
+
+# Classes
+names:
+  0: negative
+  1: positive
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/brain-tumor.zip

ultralytics/cfg/datasets/carparts-seg.yaml

@@ -0,0 +1,44 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Carparts-seg dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/carparts-seg/
+# Example usage: yolo train data=carparts-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── carparts-seg  ← downloads here (132 MB)
+
+# 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/carparts-seg # dataset root dir
+train: train/images # train images (relative to 'path') 3516 images
+val: valid/images # val images (relative to 'path') 276 images
+test: test/images # test images (relative to 'path') 401 images
+
+# Classes
+names:
+  0: back_bumper
+  1: back_door
+  2: back_glass
+  3: back_left_door
+  4: back_left_light
+  5: back_light
+  6: back_right_door
+  7: back_right_light
+  8: front_bumper
+  9: front_door
+  10: front_glass
+  11: front_left_door
+  12: front_left_light
+  13: front_light
+  14: front_right_door
+  15: front_right_light
+  16: hood
+  17: left_mirror
+  18: object
+  19: right_mirror
+  20: tailgate
+  21: trunk
+  22: wheel
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/carparts-seg.zip

ultralytics/cfg/datasets/coco-pose.yaml

@@ -0,0 +1,39 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO 2017 Keypoints dataset https://cocodataset.org by Microsoft
+# Documentation: https://docs.ultralytics.com/datasets/pose/coco/
+# Example usage: yolo train data=coco-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco-pose  ← downloads here (20.1 GB)
+
+# 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/coco-pose # dataset root dir
+train: train2017.txt # train images (relative to 'path') 56599 images
+val: val2017.txt # val images (relative to 'path') 2346 images
+test: test-dev2017.txt # 20288 of 40670 images, submit to https://codalab.lisn.upsaclay.fr/competitions/7403
+
+# Keypoints
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
+
+# Classes
+names:
+  0: person
+
+# Download script/URL (optional)
+download: |
+  from ultralytics.utils.downloads import download
+  from pathlib import Path
+
+  # Download labels
+  dir = Path(yaml['path'])  # dataset root dir
+  url = 'https://github.com/ultralytics/assets/releases/download/v0.0.0/'
+  urls = [url + 'coco2017labels-pose.zip']  # labels
+  download(urls, dir=dir.parent)
+  # Download data
+  urls = ['http://images.cocodataset.org/zips/train2017.zip',  # 19G, 118k images
+          'http://images.cocodataset.org/zips/val2017.zip',  # 1G, 5k images
+          'http://images.cocodataset.org/zips/test2017.zip']  # 7G, 41k images (optional)
+  download(urls, dir=dir / 'images', threads=3)

ultralytics/cfg/datasets/coco.yaml

@@ -0,0 +1,115 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO 2017 dataset https://cocodataset.org by Microsoft
+# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
+# Example usage: yolo train data=coco.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco  ← downloads here (20.1 GB)
+
+# 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/coco # dataset root dir
+train: train2017.txt # train images (relative to 'path') 118287 images
+val: val2017.txt # val images (relative to 'path') 5000 images
+test: test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: |
+  from ultralytics.utils.downloads import download
+  from pathlib import Path
+
+  # Download labels
+  segments = True  # segment or box labels
+  dir = Path(yaml['path'])  # dataset root dir
+  url = 'https://github.com/ultralytics/assets/releases/download/v0.0.0/'
+  urls = [url + ('coco2017labels-segments.zip' if segments else 'coco2017labels.zip')]  # labels
+  download(urls, dir=dir.parent)
+  # Download data
+  urls = ['http://images.cocodataset.org/zips/train2017.zip',  # 19G, 118k images
+          'http://images.cocodataset.org/zips/val2017.zip',  # 1G, 5k images
+          'http://images.cocodataset.org/zips/test2017.zip']  # 7G, 41k images (optional)
+  download(urls, dir=dir / 'images', threads=3)

ultralytics/cfg/datasets/coco128-seg.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO128-seg dataset https://www.kaggle.com/datasets/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/coco/
+# Example usage: yolo train data=coco128.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco128-seg  ← downloads here (7 MB)
+
+# 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/coco128-seg # dataset root dir
+train: images/train2017 # train images (relative to 'path') 128 images
+val: images/train2017 # val images (relative to 'path') 128 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco128-seg.zip

ultralytics/cfg/datasets/coco128.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO128 dataset https://www.kaggle.com/datasets/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
+# Example usage: yolo train data=coco128.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco128  ← downloads here (7 MB)
+
+# 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/coco128 # dataset root dir
+train: images/train2017 # train images (relative to 'path') 128 images
+val: images/train2017 # val images (relative to 'path') 128 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco128.zip

ultralytics/cfg/datasets/coco8-pose.yaml

@@ -0,0 +1,26 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO8-pose dataset (first 8 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/coco8-pose/
+# Example usage: yolo train data=coco8-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco8-pose  ← downloads here (1 MB)
+
+# 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-pose # 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)
+
+# Keypoints
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
+
+# Classes
+names:
+  0: person
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-pose.zip

ultralytics/cfg/datasets/coco8-seg.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO8-seg dataset (first 8 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/coco8-seg/
+# Example usage: yolo train data=coco8-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco8-seg  ← downloads here (1 MB)
+
+# 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-seg # 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
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-seg.zip

ultralytics/cfg/datasets/coco8.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO8 dataset (first 8 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/coco8/
+# Example usage: yolo train data=coco8.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco8  ← downloads here (1 MB)
+
+# 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
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8.zip

ultralytics/cfg/datasets/crack-seg.yaml

@@ -0,0 +1,22 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Crack-seg dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/crack-seg/
+# Example usage: yolo train data=crack-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── crack-seg  ← downloads here (91.2 MB)
+
+# 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/crack-seg # dataset root dir
+train: train/images # train images (relative to 'path') 3717 images
+val: valid/images # val images (relative to 'path') 112 images
+test: test/images # test images (relative to 'path') 200 images
+
+# Classes
+names:
+  0: crack
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/crack-seg.zip

ultralytics/cfg/datasets/dog-pose.yaml

@@ -0,0 +1,24 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Dogs dataset http://vision.stanford.edu/aditya86/ImageNetDogs/ by Stanford
+# Documentation: https://docs.ultralytics.com/datasets/pose/dog-pose/
+# Example usage: yolo train data=dog-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dog-pose  ← downloads here (337 MB)
+
+# 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/dog-pose # dataset root dir
+train: train # train images (relative to 'path') 6773 images
+val: val # val images (relative to 'path') 1703 images
+
+# Keypoints
+kpt_shape: [24, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+
+# Classes
+names:
+  0: dog
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/dog-pose.zip

ultralytics/cfg/datasets/dota8.yaml

@@ -0,0 +1,35 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DOTA8 dataset 8 images from split DOTAv1 dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/obb/dota8/
+# Example usage: yolo train model=yolov8n-obb.pt data=dota8.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dota8  ← downloads here (1MB)
+
+# 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/dota8 # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+
+# Classes for DOTA 1.0
+names:
+  0: plane
+  1: ship
+  2: storage tank
+  3: baseball diamond
+  4: tennis court
+  5: basketball court
+  6: ground track field
+  7: harbor
+  8: bridge
+  9: large vehicle
+  10: small vehicle
+  11: helicopter
+  12: roundabout
+  13: soccer ball field
+  14: swimming pool
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/dota8.zip

ultralytics/cfg/datasets/hand-keypoints.yaml

@@ -0,0 +1,26 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Hand Keypoints dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/hand-keypoints/
+# Example usage: yolo train data=hand-keypoints.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── hand-keypoints  ← downloads here (369 MB)
+
+# 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/hand-keypoints # dataset root dir
+train: train # train images (relative to 'path') 18776 images
+val: val # val images (relative to 'path') 7992 images
+
+# Keypoints
+kpt_shape: [21, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx:
+  [0, 1, 2, 4, 3, 10, 11, 12, 13, 14, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 20]
+
+# Classes
+names:
+  0: hand
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/hand-keypoints.zip

ultralytics/cfg/datasets/lvis.yaml

@@ -0,0 +1,1236 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# LVIS dataset http://www.lvisdataset.org by Facebook AI Research.
+# Documentation: https://docs.ultralytics.com/datasets/detect/lvis/
+# Example usage: yolo train data=lvis.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── lvis  ← downloads here (20.1 GB)
+
+# 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/lvis # dataset root dir
+train: train.txt # train images (relative to 'path') 100170 images
+val: val.txt # val images (relative to 'path') 19809 images
+minival: minival.txt # minival images (relative to 'path') 5000 images
+
+names:
+  0: aerosol can/spray can
+  1: air conditioner
+  2: airplane/aeroplane
+  3: alarm clock
+  4: alcohol/alcoholic beverage
+  5: alligator/gator
+  6: almond
+  7: ambulance
+  8: amplifier
+  9: anklet/ankle bracelet
+  10: antenna/aerial/transmitting aerial
+  11: apple
+  12: applesauce
+  13: apricot
+  14: apron
+  15: aquarium/fish tank
+  16: arctic/arctic type of shoe/galosh/golosh/rubber/rubber type of shoe/gumshoe
+  17: armband
+  18: armchair
+  19: armoire
+  20: armor/armour
+  21: artichoke
+  22: trash can/garbage can/wastebin/dustbin/trash barrel/trash bin
+  23: ashtray
+  24: asparagus
+  25: atomizer/atomiser/spray/sprayer/nebulizer/nebuliser
+  26: avocado
+  27: award/accolade
+  28: awning
+  29: ax/axe
+  30: baboon
+  31: baby buggy/baby carriage/perambulator/pram/stroller
+  32: basketball backboard
+  33: backpack/knapsack/packsack/rucksack/haversack
+  34: handbag/purse/pocketbook
+  35: suitcase/baggage/luggage
+  36: bagel/beigel
+  37: bagpipe
+  38: baguet/baguette
+  39: bait/lure
+  40: ball
+  41: ballet skirt/tutu
+  42: balloon
+  43: bamboo
+  44: banana
+  45: Band Aid
+  46: bandage
+  47: bandanna/bandana
+  48: banjo
+  49: banner/streamer
+  50: barbell
+  51: barge
+  52: barrel/cask
+  53: barrette
+  54: barrow/garden cart/lawn cart/wheelbarrow
+  55: baseball base
+  56: baseball
+  57: baseball bat
+  58: baseball cap/jockey cap/golf cap
+  59: baseball glove/baseball mitt
+  60: basket/handbasket
+  61: basketball
+  62: bass horn/sousaphone/tuba
+  63: bat/bat animal
+  64: bath mat
+  65: bath towel
+  66: bathrobe
+  67: bathtub/bathing tub
+  68: batter/batter food
+  69: battery
+  70: beachball
+  71: bead
+  72: bean curd/tofu
+  73: beanbag
+  74: beanie/beany
+  75: bear
+  76: bed
+  77: bedpan
+  78: bedspread/bedcover/bed covering/counterpane/spread
+  79: cow
+  80: beef/beef food/boeuf/boeuf food
+  81: beeper/pager
+  82: beer bottle
+  83: beer can
+  84: beetle
+  85: bell
+  86: bell pepper/capsicum
+  87: belt
+  88: belt buckle
+  89: bench
+  90: beret
+  91: bib
+  92: Bible
+  93: bicycle/bike/bike bicycle
+  94: visor/vizor
+  95: billboard
+  96: binder/ring-binder
+  97: binoculars/field glasses/opera glasses
+  98: bird
+  99: birdfeeder
+  100: birdbath
+  101: birdcage
+  102: birdhouse
+  103: birthday cake
+  104: birthday card
+  105: pirate flag
+  106: black sheep
+  107: blackberry
+  108: blackboard/chalkboard
+  109: blanket
+  110: blazer/sport jacket/sport coat/sports jacket/sports coat
+  111: blender/liquidizer/liquidiser
+  112: blimp
+  113: blinker/flasher
+  114: blouse
+  115: blueberry
+  116: gameboard
+  117: boat/ship/ship boat
+  118: bob/bobber/bobfloat
+  119: bobbin/spool/reel
+  120: bobby pin/hairgrip
+  121: boiled egg/coddled egg
+  122: bolo tie/bolo/bola tie/bola
+  123: deadbolt
+  124: bolt
+  125: bonnet
+  126: book
+  127: bookcase
+  128: booklet/brochure/leaflet/pamphlet
+  129: bookmark/bookmarker
+  130: boom microphone/microphone boom
+  131: boot
+  132: bottle
+  133: bottle opener
+  134: bouquet
+  135: bow/bow weapon
+  136: bow/bow decorative ribbons
+  137: bow-tie/bowtie
+  138: bowl
+  139: pipe bowl
+  140: bowler hat/bowler/derby hat/derby/plug hat
+  141: bowling ball
+  142: box
+  143: boxing glove
+  144: suspenders
+  145: bracelet/bangle
+  146: brass plaque
+  147: brassiere/bra/bandeau
+  148: bread-bin/breadbox
+  149: bread
+  150: breechcloth/breechclout/loincloth
+  151: bridal gown/wedding gown/wedding dress
+  152: briefcase
+  153: broccoli
+  154: broach
+  155: broom
+  156: brownie
+  157: brussels sprouts
+  158: bubble gum
+  159: bucket/pail
+  160: horse buggy
+  161: horned cow
+  162: bulldog
+  163: bulldozer/dozer
+  164: bullet train
+  165: bulletin board/notice board
+  166: bulletproof vest
+  167: bullhorn/megaphone
+  168: bun/roll
+  169: bunk bed
+  170: buoy
+  171: burrito
+  172: bus/bus vehicle/autobus/charabanc/double-decker/motorbus/motorcoach
+  173: business card
+  174: butter
+  175: butterfly
+  176: button
+  177: cab/cab taxi/taxi/taxicab
+  178: cabana
+  179: cabin car/caboose
+  180: cabinet
+  181: locker/storage locker
+  182: cake
+  183: calculator
+  184: calendar
+  185: calf
+  186: camcorder
+  187: camel
+  188: camera
+  189: camera lens
+  190: camper/camper vehicle/camping bus/motor home
+  191: can/tin can
+  192: can opener/tin opener
+  193: candle/candlestick
+  194: candle holder
+  195: candy bar
+  196: candy cane
+  197: walking cane
+  198: canister/canister
+  199: canoe
+  200: cantaloup/cantaloupe
+  201: canteen
+  202: cap/cap headwear
+  203: bottle cap/cap/cap container lid
+  204: cape
+  205: cappuccino/coffee cappuccino
+  206: car/car automobile/auto/auto automobile/automobile
+  207: railcar/railcar part of a train/railway car/railway car part of a train/railroad car/railroad car part of a train
+  208: elevator car
+  209: car battery/automobile battery
+  210: identity card
+  211: card
+  212: cardigan
+  213: cargo ship/cargo vessel
+  214: carnation
+  215: horse carriage
+  216: carrot
+  217: tote bag
+  218: cart
+  219: carton
+  220: cash register/register/register for cash transactions
+  221: casserole
+  222: cassette
+  223: cast/plaster cast/plaster bandage
+  224: cat
+  225: cauliflower
+  226: cayenne/cayenne spice/cayenne pepper/cayenne pepper spice/red pepper/red pepper spice
+  227: CD player
+  228: celery
+  229: cellular telephone/cellular phone/cellphone/mobile phone/smart phone
+  230: chain mail/ring mail/chain armor/chain armour/ring armor/ring armour
+  231: chair
+  232: chaise longue/chaise/daybed
+  233: chalice
+  234: chandelier
+  235: chap
+  236: checkbook/chequebook
+  237: checkerboard
+  238: cherry
+  239: chessboard
+  240: chicken/chicken animal
+  241: chickpea/garbanzo
+  242: chili/chili vegetable/chili pepper/chili pepper vegetable/chilli/chilli vegetable/chilly/chilly vegetable/chile/chile vegetable
+  243: chime/gong
+  244: chinaware
+  245: crisp/crisp potato chip/potato chip
+  246: poker chip
+  247: chocolate bar
+  248: chocolate cake
+  249: chocolate milk
+  250: chocolate mousse
+  251: choker/collar/neckband
+  252: chopping board/cutting board/chopping block
+  253: chopstick
+  254: Christmas tree
+  255: slide
+  256: cider/cyder
+  257: cigar box
+  258: cigarette
+  259: cigarette case/cigarette pack
+  260: cistern/water tank
+  261: clarinet
+  262: clasp
+  263: cleansing agent/cleanser/cleaner
+  264: cleat/cleat for securing rope
+  265: clementine
+  266: clip
+  267: clipboard
+  268: clippers/clippers for plants
+  269: cloak
+  270: clock/timepiece/timekeeper
+  271: clock tower
+  272: clothes hamper/laundry basket/clothes basket
+  273: clothespin/clothes peg
+  274: clutch bag
+  275: coaster
+  276: coat
+  277: coat hanger/clothes hanger/dress hanger
+  278: coatrack/hatrack
+  279: cock/rooster
+  280: cockroach
+  281: cocoa/cocoa beverage/hot chocolate/hot chocolate beverage/drinking chocolate
+  282: coconut/cocoanut
+  283: coffee maker/coffee machine
+  284: coffee table/cocktail table
+  285: coffeepot
+  286: coil
+  287: coin
+  288: colander/cullender
+  289: coleslaw/slaw
+  290: coloring material/colouring material
+  291: combination lock
+  292: pacifier/teething ring
+  293: comic book
+  294: compass
+  295: computer keyboard/keyboard/keyboard computer
+  296: condiment
+  297: cone/traffic cone
+  298: control/controller
+  299: convertible/convertible automobile
+  300: sofa bed
+  301: cooker
+  302: cookie/cooky/biscuit/biscuit cookie
+  303: cooking utensil
+  304: cooler/cooler for food/ice chest
+  305: cork/cork bottle plug/bottle cork
+  306: corkboard
+  307: corkscrew/bottle screw
+  308: edible corn/corn/maize
+  309: cornbread
+  310: cornet/horn/trumpet
+  311: cornice/valance/valance board/pelmet
+  312: cornmeal
+  313: corset/girdle
+  314: costume
+  315: cougar/puma/catamount/mountain lion/panther
+  316: coverall
+  317: cowbell
+  318: cowboy hat/ten-gallon hat
+  319: crab/crab animal
+  320: crabmeat
+  321: cracker
+  322: crape/crepe/French pancake
+  323: crate
+  324: crayon/wax crayon
+  325: cream pitcher
+  326: crescent roll/croissant
+  327: crib/cot
+  328: crock pot/earthenware jar
+  329: crossbar
+  330: crouton
+  331: crow
+  332: crowbar/wrecking bar/pry bar
+  333: crown
+  334: crucifix
+  335: cruise ship/cruise liner
+  336: police cruiser/patrol car/police car/squad car
+  337: crumb
+  338: crutch
+  339: cub/cub animal
+  340: cube/square block
+  341: cucumber/cuke
+  342: cufflink
+  343: cup
+  344: trophy cup
+  345: cupboard/closet
+  346: cupcake
+  347: hair curler/hair roller/hair crimper
+  348: curling iron
+  349: curtain/drapery
+  350: cushion
+  351: cylinder
+  352: cymbal
+  353: dagger
+  354: dalmatian
+  355: dartboard
+  356: date/date fruit
+  357: deck chair/beach chair
+  358: deer/cervid
+  359: dental floss/floss
+  360: desk
+  361: detergent
+  362: diaper
+  363: diary/journal
+  364: die/dice
+  365: dinghy/dory/rowboat
+  366: dining table
+  367: tux/tuxedo
+  368: dish
+  369: dish antenna
+  370: dishrag/dishcloth
+  371: dishtowel/tea towel
+  372: dishwasher/dishwashing machine
+  373: dishwasher detergent/dishwashing detergent/dishwashing liquid/dishsoap
+  374: dispenser
+  375: diving board
+  376: Dixie cup/paper cup
+  377: dog
+  378: dog collar
+  379: doll
+  380: dollar/dollar bill/one dollar bill
+  381: dollhouse/doll's house
+  382: dolphin
+  383: domestic ass/donkey
+  384: doorknob/doorhandle
+  385: doormat/welcome mat
+  386: doughnut/donut
+  387: dove
+  388: dragonfly
+  389: drawer
+  390: underdrawers/boxers/boxershorts
+  391: dress/frock
+  392: dress hat/high hat/opera hat/silk hat/top hat
+  393: dress suit
+  394: dresser
+  395: drill
+  396: drone
+  397: dropper/eye dropper
+  398: drum/drum musical instrument
+  399: drumstick
+  400: duck
+  401: duckling
+  402: duct tape
+  403: duffel bag/duffle bag/duffel/duffle
+  404: dumbbell
+  405: dumpster
+  406: dustpan
+  407: eagle
+  408: earphone/earpiece/headphone
+  409: earplug
+  410: earring
+  411: easel
+  412: eclair
+  413: eel
+  414: egg/eggs
+  415: egg roll/spring roll
+  416: egg yolk/yolk/yolk egg
+  417: eggbeater/eggwhisk
+  418: eggplant/aubergine
+  419: electric chair
+  420: refrigerator
+  421: elephant
+  422: elk/moose
+  423: envelope
+  424: eraser
+  425: escargot
+  426: eyepatch
+  427: falcon
+  428: fan
+  429: faucet/spigot/tap
+  430: fedora
+  431: ferret
+  432: Ferris wheel
+  433: ferry/ferryboat
+  434: fig/fig fruit
+  435: fighter jet/fighter aircraft/attack aircraft
+  436: figurine
+  437: file cabinet/filing cabinet
+  438: file/file tool
+  439: fire alarm/smoke alarm
+  440: fire engine/fire truck
+  441: fire extinguisher/extinguisher
+  442: fire hose
+  443: fireplace
+  444: fireplug/fire hydrant/hydrant
+  445: first-aid kit
+  446: fish
+  447: fish/fish food
+  448: fishbowl/goldfish bowl
+  449: fishing rod/fishing pole
+  450: flag
+  451: flagpole/flagstaff
+  452: flamingo
+  453: flannel
+  454: flap
+  455: flash/flashbulb
+  456: flashlight/torch
+  457: fleece
+  458: flip-flop/flip-flop sandal
+  459: flipper/flipper footwear/fin/fin footwear
+  460: flower arrangement/floral arrangement
+  461: flute glass/champagne flute
+  462: foal
+  463: folding chair
+  464: food processor
+  465: football/football American
+  466: football helmet
+  467: footstool/footrest
+  468: fork
+  469: forklift
+  470: freight car
+  471: French toast
+  472: freshener/air freshener
+  473: frisbee
+  474: frog/toad/toad frog
+  475: fruit juice
+  476: frying pan/frypan/skillet
+  477: fudge
+  478: funnel
+  479: futon
+  480: gag/muzzle
+  481: garbage
+  482: garbage truck
+  483: garden hose
+  484: gargle/mouthwash
+  485: gargoyle
+  486: garlic/ail
+  487: gasmask/respirator/gas helmet
+  488: gazelle
+  489: gelatin/jelly
+  490: gemstone
+  491: generator
+  492: giant panda/panda/panda bear
+  493: gift wrap
+  494: ginger/gingerroot
+  495: giraffe
+  496: cincture/sash/waistband/waistcloth
+  497: glass/glass drink container/drinking glass
+  498: globe
+  499: glove
+  500: goat
+  501: goggles
+  502: goldfish
+  503: golf club/golf-club
+  504: golfcart
+  505: gondola/gondola boat
+  506: goose
+  507: gorilla
+  508: gourd
+  509: grape
+  510: grater
+  511: gravestone/headstone/tombstone
+  512: gravy boat/gravy holder
+  513: green bean
+  514: green onion/spring onion/scallion
+  515: griddle
+  516: grill/grille/grillwork/radiator grille
+  517: grits/hominy grits
+  518: grizzly/grizzly bear
+  519: grocery bag
+  520: guitar
+  521: gull/seagull
+  522: gun
+  523: hairbrush
+  524: hairnet
+  525: hairpin
+  526: halter top
+  527: ham/jambon/gammon
+  528: hamburger/beefburger/burger
+  529: hammer
+  530: hammock
+  531: hamper
+  532: hamster
+  533: hair dryer
+  534: hand glass/hand mirror
+  535: hand towel/face towel
+  536: handcart/pushcart/hand truck
+  537: handcuff
+  538: handkerchief
+  539: handle/grip/handgrip
+  540: handsaw/carpenter's saw
+  541: hardback book/hardcover book
+  542: harmonium/organ/organ musical instrument/reed organ/reed organ musical instrument
+  543: hat
+  544: hatbox
+  545: veil
+  546: headband
+  547: headboard
+  548: headlight/headlamp
+  549: headscarf
+  550: headset
+  551: headstall/headstall for horses/headpiece/headpiece for horses
+  552: heart
+  553: heater/warmer
+  554: helicopter
+  555: helmet
+  556: heron
+  557: highchair/feeding chair
+  558: hinge
+  559: hippopotamus
+  560: hockey stick
+  561: hog/pig
+  562: home plate/home plate baseball/home base/home base baseball
+  563: honey
+  564: fume hood/exhaust hood
+  565: hook
+  566: hookah/narghile/nargileh/sheesha/shisha/water pipe
+  567: hornet
+  568: horse
+  569: hose/hosepipe
+  570: hot-air balloon
+  571: hotplate
+  572: hot sauce
+  573: hourglass
+  574: houseboat
+  575: hummingbird
+  576: hummus/humus/hommos/hoummos/humous
+  577: polar bear
+  578: icecream
+  579: popsicle
+  580: ice maker
+  581: ice pack/ice bag
+  582: ice skate
+  583: igniter/ignitor/lighter
+  584: inhaler/inhalator
+  585: iPod
+  586: iron/iron for clothing/smoothing iron/smoothing iron for clothing
+  587: ironing board
+  588: jacket
+  589: jam
+  590: jar
+  591: jean/blue jean/denim
+  592: jeep/landrover
+  593: jelly bean/jelly egg
+  594: jersey/T-shirt/tee shirt
+  595: jet plane/jet-propelled plane
+  596: jewel/gem/precious stone
+  597: jewelry/jewellery
+  598: joystick
+  599: jumpsuit
+  600: kayak
+  601: keg
+  602: kennel/doghouse
+  603: kettle/boiler
+  604: key
+  605: keycard
+  606: kilt
+  607: kimono
+  608: kitchen sink
+  609: kitchen table
+  610: kite
+  611: kitten/kitty
+  612: kiwi fruit
+  613: knee pad
+  614: knife
+  615: knitting needle
+  616: knob
+  617: knocker/knocker on a door/doorknocker
+  618: koala/koala bear
+  619: lab coat/laboratory coat
+  620: ladder
+  621: ladle
+  622: ladybug/ladybeetle/ladybird beetle
+  623: lamb/lamb animal
+  624: lamb-chop/lambchop
+  625: lamp
+  626: lamppost
+  627: lampshade
+  628: lantern
+  629: lanyard/laniard
+  630: laptop computer/notebook computer
+  631: lasagna/lasagne
+  632: latch
+  633: lawn mower
+  634: leather
+  635: legging/legging clothing/leging/leging clothing/leg covering
+  636: Lego/Lego set
+  637: legume
+  638: lemon
+  639: lemonade
+  640: lettuce
+  641: license plate/numberplate
+  642: life buoy/lifesaver/life belt/life ring
+  643: life jacket/life vest
+  644: lightbulb
+  645: lightning rod/lightning conductor
+  646: lime
+  647: limousine
+  648: lion
+  649: lip balm
+  650: liquor/spirits/hard liquor/liqueur/cordial
+  651: lizard
+  652: log
+  653: lollipop
+  654: speaker/speaker stereo equipment
+  655: loveseat
+  656: machine gun
+  657: magazine
+  658: magnet
+  659: mail slot
+  660: mailbox/mailbox at home/letter box/letter box at home
+  661: mallard
+  662: mallet
+  663: mammoth
+  664: manatee
+  665: mandarin orange
+  666: manager/through
+  667: manhole
+  668: map
+  669: marker
+  670: martini
+  671: mascot
+  672: mashed potato
+  673: masher
+  674: mask/facemask
+  675: mast
+  676: mat/mat gym equipment/gym mat
+  677: matchbox
+  678: mattress
+  679: measuring cup
+  680: measuring stick/ruler/ruler measuring stick/measuring rod
+  681: meatball
+  682: medicine
+  683: melon
+  684: microphone
+  685: microscope
+  686: microwave oven
+  687: milestone/milepost
+  688: milk
+  689: milk can
+  690: milkshake
+  691: minivan
+  692: mint candy
+  693: mirror
+  694: mitten
+  695: mixer/mixer kitchen tool/stand mixer
+  696: money
+  697: monitor/monitor computer equipment
+  698: monkey
+  699: motor
+  700: motor scooter/scooter
+  701: motor vehicle/automotive vehicle
+  702: motorcycle
+  703: mound/mound baseball/pitcher's mound
+  704: mouse/mouse computer equipment/computer mouse
+  705: mousepad
+  706: muffin
+  707: mug
+  708: mushroom
+  709: music stool/piano stool
+  710: musical instrument/instrument/instrument musical
+  711: nailfile
+  712: napkin/table napkin/serviette
+  713: neckerchief
+  714: necklace
+  715: necktie/tie/tie necktie
+  716: needle
+  717: nest
+  718: newspaper/paper/paper newspaper
+  719: newsstand
+  720: nightshirt/nightwear/sleepwear/nightclothes
+  721: nosebag/nosebag for animals/feedbag
+  722: noseband/noseband for animals/nosepiece/nosepiece for animals
+  723: notebook
+  724: notepad
+  725: nut
+  726: nutcracker
+  727: oar
+  728: octopus/octopus food
+  729: octopus/octopus animal
+  730: oil lamp/kerosene lamp/kerosine lamp
+  731: olive oil
+  732: omelet/omelette
+  733: onion
+  734: orange/orange fruit
+  735: orange juice
+  736: ostrich
+  737: ottoman/pouf/pouffe/hassock
+  738: oven
+  739: overalls/overalls clothing
+  740: owl
+  741: packet
+  742: inkpad/inking pad/stamp pad
+  743: pad
+  744: paddle/boat paddle
+  745: padlock
+  746: paintbrush
+  747: painting
+  748: pajamas/pyjamas
+  749: palette/pallet
+  750: pan/pan for cooking/cooking pan
+  751: pan/pan metal container
+  752: pancake
+  753: pantyhose
+  754: papaya
+  755: paper plate
+  756: paper towel
+  757: paperback book/paper-back book/softback book/soft-cover book
+  758: paperweight
+  759: parachute
+  760: parakeet/parrakeet/parroket/paraquet/paroquet/parroquet
+  761: parasail/parasail sports
+  762: parasol/sunshade
+  763: parchment
+  764: parka/anorak
+  765: parking meter
+  766: parrot
+  767: passenger car/passenger car part of a train/coach/coach part of a train
+  768: passenger ship
+  769: passport
+  770: pastry
+  771: patty/patty food
+  772: pea/pea food
+  773: peach
+  774: peanut butter
+  775: pear
+  776: peeler/peeler tool for fruit and vegetables
+  777: wooden leg/pegleg
+  778: pegboard
+  779: pelican
+  780: pen
+  781: pencil
+  782: pencil box/pencil case
+  783: pencil sharpener
+  784: pendulum
+  785: penguin
+  786: pennant
+  787: penny/penny coin
+  788: pepper/peppercorn
+  789: pepper mill/pepper grinder
+  790: perfume
+  791: persimmon
+  792: person/baby/child/boy/girl/man/woman/human
+  793: pet
+  794: pew/pew church bench/church bench
+  795: phonebook/telephone book/telephone directory
+  796: phonograph record/phonograph recording/record/record phonograph recording
+  797: piano
+  798: pickle
+  799: pickup truck
+  800: pie
+  801: pigeon
+  802: piggy bank/penny bank
+  803: pillow
+  804: pin/pin non jewelry
+  805: pineapple
+  806: pinecone
+  807: ping-pong ball
+  808: pinwheel
+  809: tobacco pipe
+  810: pipe/piping
+  811: pistol/handgun
+  812: pita/pita bread/pocket bread
+  813: pitcher/pitcher vessel for liquid/ewer
+  814: pitchfork
+  815: pizza
+  816: place mat
+  817: plate
+  818: platter
+  819: playpen
+  820: pliers/plyers
+  821: plow/plow farm equipment/plough/plough farm equipment
+  822: plume
+  823: pocket watch
+  824: pocketknife
+  825: poker/poker fire stirring tool/stove poker/fire hook
+  826: pole/post
+  827: polo shirt/sport shirt
+  828: poncho
+  829: pony
+  830: pool table/billiard table/snooker table
+  831: pop/pop soda/soda/soda pop/tonic/soft drink
+  832: postbox/postbox public/mailbox/mailbox public
+  833: postcard/postal card/mailing-card
+  834: poster/placard
+  835: pot
+  836: flowerpot
+  837: potato
+  838: potholder
+  839: pottery/clayware
+  840: pouch
+  841: power shovel/excavator/digger
+  842: prawn/shrimp
+  843: pretzel
+  844: printer/printing machine
+  845: projectile/projectile weapon/missile
+  846: projector
+  847: propeller/propellor
+  848: prune
+  849: pudding
+  850: puffer/puffer fish/pufferfish/blowfish/globefish
+  851: puffin
+  852: pug-dog
+  853: pumpkin
+  854: puncher
+  855: puppet/marionette
+  856: puppy
+  857: quesadilla
+  858: quiche
+  859: quilt/comforter
+  860: rabbit
+  861: race car/racing car
+  862: racket/racquet
+  863: radar
+  864: radiator
+  865: radio receiver/radio set/radio/tuner/tuner radio
+  866: radish/daikon
+  867: raft
+  868: rag doll
+  869: raincoat/waterproof jacket
+  870: ram/ram animal
+  871: raspberry
+  872: rat
+  873: razorblade
+  874: reamer/reamer juicer/juicer/juice reamer
+  875: rearview mirror
+  876: receipt
+  877: recliner/reclining chair/lounger/lounger chair
+  878: record player/phonograph/phonograph record player/turntable
+  879: reflector
+  880: remote control
+  881: rhinoceros
+  882: rib/rib food
+  883: rifle
+  884: ring
+  885: river boat
+  886: road map
+  887: robe
+  888: rocking chair
+  889: rodent
+  890: roller skate
+  891: Rollerblade
+  892: rolling pin
+  893: root beer
+  894: router/router computer equipment
+  895: rubber band/elastic band
+  896: runner/runner carpet
+  897: plastic bag/paper bag
+  898: saddle/saddle on an animal
+  899: saddle blanket/saddlecloth/horse blanket
+  900: saddlebag
+  901: safety pin
+  902: sail
+  903: salad
+  904: salad plate/salad bowl
+  905: salami
+  906: salmon/salmon fish
+  907: salmon/salmon food
+  908: salsa
+  909: saltshaker
+  910: sandal/sandal type of shoe
+  911: sandwich
+  912: satchel
+  913: saucepan
+  914: saucer
+  915: sausage
+  916: sawhorse/sawbuck
+  917: saxophone
+  918: scale/scale measuring instrument
+  919: scarecrow/strawman
+  920: scarf
+  921: school bus
+  922: scissors
+  923: scoreboard
+  924: scraper
+  925: screwdriver
+  926: scrubbing brush
+  927: sculpture
+  928: seabird/seafowl
+  929: seahorse
+  930: seaplane/hydroplane
+  931: seashell
+  932: sewing machine
+  933: shaker
+  934: shampoo
+  935: shark
+  936: sharpener
+  937: Sharpie
+  938: shaver/shaver electric/electric shaver/electric razor
+  939: shaving cream/shaving soap
+  940: shawl
+  941: shears
+  942: sheep
+  943: shepherd dog/sheepdog
+  944: sherbert/sherbet
+  945: shield
+  946: shirt
+  947: shoe/sneaker/sneaker type of shoe/tennis shoe
+  948: shopping bag
+  949: shopping cart
+  950: short pants/shorts/shorts clothing/trunks/trunks clothing
+  951: shot glass
+  952: shoulder bag
+  953: shovel
+  954: shower head
+  955: shower cap
+  956: shower curtain
+  957: shredder/shredder for paper
+  958: signboard
+  959: silo
+  960: sink
+  961: skateboard
+  962: skewer
+  963: ski
+  964: ski boot
+  965: ski parka/ski jacket
+  966: ski pole
+  967: skirt
+  968: skullcap
+  969: sled/sledge/sleigh
+  970: sleeping bag
+  971: sling/sling bandage/triangular bandage
+  972: slipper/slipper footwear/carpet slipper/carpet slipper footwear
+  973: smoothie
+  974: snake/serpent
+  975: snowboard
+  976: snowman
+  977: snowmobile
+  978: soap
+  979: soccer ball
+  980: sock
+  981: sofa/couch/lounge
+  982: softball
+  983: solar array/solar battery/solar panel
+  984: sombrero
+  985: soup
+  986: soup bowl
+  987: soupspoon
+  988: sour cream/soured cream
+  989: soya milk/soybean milk/soymilk
+  990: space shuttle
+  991: sparkler/sparkler fireworks
+  992: spatula
+  993: spear/lance
+  994: spectacles/specs/eyeglasses/glasses
+  995: spice rack
+  996: spider
+  997: crawfish/crayfish
+  998: sponge
+  999: spoon
+  1000: sportswear/athletic wear/activewear
+  1001: spotlight
+  1002: squid/squid food/calamari/calamary
+  1003: squirrel
+  1004: stagecoach
+  1005: stapler/stapler stapling machine
+  1006: starfish/sea star
+  1007: statue/statue sculpture
+  1008: steak/steak food
+  1009: steak knife
+  1010: steering wheel
+  1011: stepladder
+  1012: step stool
+  1013: stereo/stereo sound system
+  1014: stew
+  1015: stirrer
+  1016: stirrup
+  1017: stool
+  1018: stop sign
+  1019: brake light
+  1020: stove/kitchen stove/range/range kitchen appliance/kitchen range/cooking stove
+  1021: strainer
+  1022: strap
+  1023: straw/straw for drinking/drinking straw
+  1024: strawberry
+  1025: street sign
+  1026: streetlight/street lamp
+  1027: string cheese
+  1028: stylus
+  1029: subwoofer
+  1030: sugar bowl
+  1031: sugarcane/sugarcane plant
+  1032: suit/suit clothing
+  1033: sunflower
+  1034: sunglasses
+  1035: sunhat
+  1036: surfboard
+  1037: sushi
+  1038: mop
+  1039: sweat pants
+  1040: sweatband
+  1041: sweater
+  1042: sweatshirt
+  1043: sweet potato
+  1044: swimsuit/swimwear/bathing suit/swimming costume/bathing costume/swimming trunks/bathing trunks
+  1045: sword
+  1046: syringe
+  1047: Tabasco sauce
+  1048: table-tennis table/ping-pong table
+  1049: table
+  1050: table lamp
+  1051: tablecloth
+  1052: tachometer
+  1053: taco
+  1054: tag
+  1055: taillight/rear light
+  1056: tambourine
+  1057: army tank/armored combat vehicle/armoured combat vehicle
+  1058: tank/tank storage vessel/storage tank
+  1059: tank top/tank top clothing
+  1060: tape/tape sticky cloth or paper
+  1061: tape measure/measuring tape
+  1062: tapestry
+  1063: tarp
+  1064: tartan/plaid
+  1065: tassel
+  1066: tea bag
+  1067: teacup
+  1068: teakettle
+  1069: teapot
+  1070: teddy bear
+  1071: telephone/phone/telephone set
+  1072: telephone booth/phone booth/call box/telephone box/telephone kiosk
+  1073: telephone pole/telegraph pole/telegraph post
+  1074: telephoto lens/zoom lens
+  1075: television camera/tv camera
+  1076: television set/tv/tv set
+  1077: tennis ball
+  1078: tennis racket
+  1079: tequila
+  1080: thermometer
+  1081: thermos bottle
+  1082: thermostat
+  1083: thimble
+  1084: thread/yarn
+  1085: thumbtack/drawing pin/pushpin
+  1086: tiara
+  1087: tiger
+  1088: tights/tights clothing/leotards
+  1089: timer/stopwatch
+  1090: tinfoil
+  1091: tinsel
+  1092: tissue paper
+  1093: toast/toast food
+  1094: toaster
+  1095: toaster oven
+  1096: toilet
+  1097: toilet tissue/toilet paper/bathroom tissue
+  1098: tomato
+  1099: tongs
+  1100: toolbox
+  1101: toothbrush
+  1102: toothpaste
+  1103: toothpick
+  1104: cover
+  1105: tortilla
+  1106: tow truck
+  1107: towel
+  1108: towel rack/towel rail/towel bar
+  1109: toy
+  1110: tractor/tractor farm equipment
+  1111: traffic light
+  1112: dirt bike
+  1113: trailer truck/tractor trailer/trucking rig/articulated lorry/semi truck
+  1114: train/train railroad vehicle/railroad train
+  1115: trampoline
+  1116: tray
+  1117: trench coat
+  1118: triangle/triangle musical instrument
+  1119: tricycle
+  1120: tripod
+  1121: trousers/pants/pants clothing
+  1122: truck
+  1123: truffle/truffle chocolate/chocolate truffle
+  1124: trunk
+  1125: vat
+  1126: turban
+  1127: turkey/turkey food
+  1128: turnip
+  1129: turtle
+  1130: turtleneck/turtleneck clothing/polo-neck
+  1131: typewriter
+  1132: umbrella
+  1133: underwear/underclothes/underclothing/underpants
+  1134: unicycle
+  1135: urinal
+  1136: urn
+  1137: vacuum cleaner
+  1138: vase
+  1139: vending machine
+  1140: vent/blowhole/air vent
+  1141: vest/waistcoat
+  1142: videotape
+  1143: vinegar
+  1144: violin/fiddle
+  1145: vodka
+  1146: volleyball
+  1147: vulture
+  1148: waffle
+  1149: waffle iron
+  1150: wagon
+  1151: wagon wheel
+  1152: walking stick
+  1153: wall clock
+  1154: wall socket/wall plug/electric outlet/electrical outlet/outlet/electric receptacle
+  1155: wallet/billfold
+  1156: walrus
+  1157: wardrobe
+  1158: washbasin/basin/basin for washing/washbowl/washstand/handbasin
+  1159: automatic washer/washing machine
+  1160: watch/wristwatch
+  1161: water bottle
+  1162: water cooler
+  1163: water faucet/water tap/tap/tap water faucet
+  1164: water heater/hot-water heater
+  1165: water jug
+  1166: water gun/squirt gun
+  1167: water scooter/sea scooter/jet ski
+  1168: water ski
+  1169: water tower
+  1170: watering can
+  1171: watermelon
+  1172: weathervane/vane/vane weathervane/wind vane
+  1173: webcam
+  1174: wedding cake/bridecake
+  1175: wedding ring/wedding band
+  1176: wet suit
+  1177: wheel
+  1178: wheelchair
+  1179: whipped cream
+  1180: whistle
+  1181: wig
+  1182: wind chime
+  1183: windmill
+  1184: window box/window box for plants
+  1185: windshield wiper/windscreen wiper/wiper/wiper for windshield or screen
+  1186: windsock/air sock/air-sleeve/wind sleeve/wind cone
+  1187: wine bottle
+  1188: wine bucket/wine cooler
+  1189: wineglass
+  1190: blinder/blinder for horses
+  1191: wok
+  1192: wolf
+  1193: wooden spoon
+  1194: wreath
+  1195: wrench/spanner
+  1196: wristband
+  1197: wristlet/wrist band
+  1198: yacht
+  1199: yogurt/yoghurt/yoghourt
+  1200: yoke/yoke animal equipment
+  1201: zebra
+  1202: zucchini/courgette
+
+# Download script/URL (optional)
+download: |
+  from ultralytics.utils.downloads import download
+  from pathlib import Path
+
+  # Download labels
+  dir = Path(yaml['path'])  # dataset root dir
+  url = 'https://github.com/ultralytics/assets/releases/download/v0.0.0/'
+  urls = [url + 'lvis-labels-segments.zip']  # labels
+  download(urls, dir=dir.parent)
+  # Download data
+  urls = ['http://images.cocodataset.org/zips/train2017.zip',  # 19G, 118k images
+          'http://images.cocodataset.org/zips/val2017.zip',  # 1G, 5k images
+          'http://images.cocodataset.org/zips/test2017.zip']  # 7G, 41k images (optional)
+  download(urls, dir=dir / 'images', threads=3)

ultralytics/cfg/datasets/medical-pills.yaml

@@ -0,0 +1,22 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Medical-pills dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/medical-pills/
+# Example usage: yolo train data=medical-pills.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── medical-pills  ← downloads here (8.19 MB)
+
+# 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/medical-pills # dataset root dir
+train: train/images # train images (relative to 'path') 92 images
+val: valid/images # val images (relative to 'path') 23 images
+test: # test images (relative to 'path')
+
+# Classes
+names:
+  0: pill
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/medical-pills.zip

ultralytics/cfg/datasets/open-images-v7.yaml

@@ -0,0 +1,661 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Open Images v7 dataset https://storage.googleapis.com/openimages/web/index.html by Google
+# Documentation: https://docs.ultralytics.com/datasets/detect/open-images-v7/
+# Example usage: yolo train data=open-images-v7.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── open-images-v7  ← downloads here (561 GB)
+
+# 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/open-images-v7 # dataset root dir
+train: images/train # train images (relative to 'path') 1743042 images
+val: images/val # val images (relative to 'path') 41620 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: Accordion
+  1: Adhesive tape
+  2: Aircraft
+  3: Airplane
+  4: Alarm clock
+  5: Alpaca
+  6: Ambulance
+  7: Animal
+  8: Ant
+  9: Antelope
+  10: Apple
+  11: Armadillo
+  12: Artichoke
+  13: Auto part
+  14: Axe
+  15: Backpack
+  16: Bagel
+  17: Baked goods
+  18: Balance beam
+  19: Ball
+  20: Balloon
+  21: Banana
+  22: Band-aid
+  23: Banjo
+  24: Barge
+  25: Barrel
+  26: Baseball bat
+  27: Baseball glove
+  28: Bat (Animal)
+  29: Bathroom accessory
+  30: Bathroom cabinet
+  31: Bathtub
+  32: Beaker
+  33: Bear
+  34: Bed
+  35: Bee
+  36: Beehive
+  37: Beer
+  38: Beetle
+  39: Bell pepper
+  40: Belt
+  41: Bench
+  42: Bicycle
+  43: Bicycle helmet
+  44: Bicycle wheel
+  45: Bidet
+  46: Billboard
+  47: Billiard table
+  48: Binoculars
+  49: Bird
+  50: Blender
+  51: Blue jay
+  52: Boat
+  53: Bomb
+  54: Book
+  55: Bookcase
+  56: Boot
+  57: Bottle
+  58: Bottle opener
+  59: Bow and arrow
+  60: Bowl
+  61: Bowling equipment
+  62: Box
+  63: Boy
+  64: Brassiere
+  65: Bread
+  66: Briefcase
+  67: Broccoli
+  68: Bronze sculpture
+  69: Brown bear
+  70: Building
+  71: Bull
+  72: Burrito
+  73: Bus
+  74: Bust
+  75: Butterfly
+  76: Cabbage
+  77: Cabinetry
+  78: Cake
+  79: Cake stand
+  80: Calculator
+  81: Camel
+  82: Camera
+  83: Can opener
+  84: Canary
+  85: Candle
+  86: Candy
+  87: Cannon
+  88: Canoe
+  89: Cantaloupe
+  90: Car
+  91: Carnivore
+  92: Carrot
+  93: Cart
+  94: Cassette deck
+  95: Castle
+  96: Cat
+  97: Cat furniture
+  98: Caterpillar
+  99: Cattle
+  100: Ceiling fan
+  101: Cello
+  102: Centipede
+  103: Chainsaw
+  104: Chair
+  105: Cheese
+  106: Cheetah
+  107: Chest of drawers
+  108: Chicken
+  109: Chime
+  110: Chisel
+  111: Chopsticks
+  112: Christmas tree
+  113: Clock
+  114: Closet
+  115: Clothing
+  116: Coat
+  117: Cocktail
+  118: Cocktail shaker
+  119: Coconut
+  120: Coffee
+  121: Coffee cup
+  122: Coffee table
+  123: Coffeemaker
+  124: Coin
+  125: Common fig
+  126: Common sunflower
+  127: Computer keyboard
+  128: Computer monitor
+  129: Computer mouse
+  130: Container
+  131: Convenience store
+  132: Cookie
+  133: Cooking spray
+  134: Corded phone
+  135: Cosmetics
+  136: Couch
+  137: Countertop
+  138: Cowboy hat
+  139: Crab
+  140: Cream
+  141: Cricket ball
+  142: Crocodile
+  143: Croissant
+  144: Crown
+  145: Crutch
+  146: Cucumber
+  147: Cupboard
+  148: Curtain
+  149: Cutting board
+  150: Dagger
+  151: Dairy Product
+  152: Deer
+  153: Desk
+  154: Dessert
+  155: Diaper
+  156: Dice
+  157: Digital clock
+  158: Dinosaur
+  159: Dishwasher
+  160: Dog
+  161: Dog bed
+  162: Doll
+  163: Dolphin
+  164: Door
+  165: Door handle
+  166: Doughnut
+  167: Dragonfly
+  168: Drawer
+  169: Dress
+  170: Drill (Tool)
+  171: Drink
+  172: Drinking straw
+  173: Drum
+  174: Duck
+  175: Dumbbell
+  176: Eagle
+  177: Earrings
+  178: Egg (Food)
+  179: Elephant
+  180: Envelope
+  181: Eraser
+  182: Face powder
+  183: Facial tissue holder
+  184: Falcon
+  185: Fashion accessory
+  186: Fast food
+  187: Fax
+  188: Fedora
+  189: Filing cabinet
+  190: Fire hydrant
+  191: Fireplace
+  192: Fish
+  193: Flag
+  194: Flashlight
+  195: Flower
+  196: Flowerpot
+  197: Flute
+  198: Flying disc
+  199: Food
+  200: Food processor
+  201: Football
+  202: Football helmet
+  203: Footwear
+  204: Fork
+  205: Fountain
+  206: Fox
+  207: French fries
+  208: French horn
+  209: Frog
+  210: Fruit
+  211: Frying pan
+  212: Furniture
+  213: Garden Asparagus
+  214: Gas stove
+  215: Giraffe
+  216: Girl
+  217: Glasses
+  218: Glove
+  219: Goat
+  220: Goggles
+  221: Goldfish
+  222: Golf ball
+  223: Golf cart
+  224: Gondola
+  225: Goose
+  226: Grape
+  227: Grapefruit
+  228: Grinder
+  229: Guacamole
+  230: Guitar
+  231: Hair dryer
+  232: Hair spray
+  233: Hamburger
+  234: Hammer
+  235: Hamster
+  236: Hand dryer
+  237: Handbag
+  238: Handgun
+  239: Harbor seal
+  240: Harmonica
+  241: Harp
+  242: Harpsichord
+  243: Hat
+  244: Headphones
+  245: Heater
+  246: Hedgehog
+  247: Helicopter
+  248: Helmet
+  249: High heels
+  250: Hiking equipment
+  251: Hippopotamus
+  252: Home appliance
+  253: Honeycomb
+  254: Horizontal bar
+  255: Horse
+  256: Hot dog
+  257: House
+  258: Houseplant
+  259: Human arm
+  260: Human beard
+  261: Human body
+  262: Human ear
+  263: Human eye
+  264: Human face
+  265: Human foot
+  266: Human hair
+  267: Human hand
+  268: Human head
+  269: Human leg
+  270: Human mouth
+  271: Human nose
+  272: Humidifier
+  273: Ice cream
+  274: Indoor rower
+  275: Infant bed
+  276: Insect
+  277: Invertebrate
+  278: Ipod
+  279: Isopod
+  280: Jacket
+  281: Jacuzzi
+  282: Jaguar (Animal)
+  283: Jeans
+  284: Jellyfish
+  285: Jet ski
+  286: Jug
+  287: Juice
+  288: Kangaroo
+  289: Kettle
+  290: Kitchen & dining room table
+  291: Kitchen appliance
+  292: Kitchen knife
+  293: Kitchen utensil
+  294: Kitchenware
+  295: Kite
+  296: Knife
+  297: Koala
+  298: Ladder
+  299: Ladle
+  300: Ladybug
+  301: Lamp
+  302: Land vehicle
+  303: Lantern
+  304: Laptop
+  305: Lavender (Plant)
+  306: Lemon
+  307: Leopard
+  308: Light bulb
+  309: Light switch
+  310: Lighthouse
+  311: Lily
+  312: Limousine
+  313: Lion
+  314: Lipstick
+  315: Lizard
+  316: Lobster
+  317: Loveseat
+  318: Luggage and bags
+  319: Lynx
+  320: Magpie
+  321: Mammal
+  322: Man
+  323: Mango
+  324: Maple
+  325: Maracas
+  326: Marine invertebrates
+  327: Marine mammal
+  328: Measuring cup
+  329: Mechanical fan
+  330: Medical equipment
+  331: Microphone
+  332: Microwave oven
+  333: Milk
+  334: Miniskirt
+  335: Mirror
+  336: Missile
+  337: Mixer
+  338: Mixing bowl
+  339: Mobile phone
+  340: Monkey
+  341: Moths and butterflies
+  342: Motorcycle
+  343: Mouse
+  344: Muffin
+  345: Mug
+  346: Mule
+  347: Mushroom
+  348: Musical instrument
+  349: Musical keyboard
+  350: Nail (Construction)
+  351: Necklace
+  352: Nightstand
+  353: Oboe
+  354: Office building
+  355: Office supplies
+  356: Orange
+  357: Organ (Musical Instrument)
+  358: Ostrich
+  359: Otter
+  360: Oven
+  361: Owl
+  362: Oyster
+  363: Paddle
+  364: Palm tree
+  365: Pancake
+  366: Panda
+  367: Paper cutter
+  368: Paper towel
+  369: Parachute
+  370: Parking meter
+  371: Parrot
+  372: Pasta
+  373: Pastry
+  374: Peach
+  375: Pear
+  376: Pen
+  377: Pencil case
+  378: Pencil sharpener
+  379: Penguin
+  380: Perfume
+  381: Person
+  382: Personal care
+  383: Personal flotation device
+  384: Piano
+  385: Picnic basket
+  386: Picture frame
+  387: Pig
+  388: Pillow
+  389: Pineapple
+  390: Pitcher (Container)
+  391: Pizza
+  392: Pizza cutter
+  393: Plant
+  394: Plastic bag
+  395: Plate
+  396: Platter
+  397: Plumbing fixture
+  398: Polar bear
+  399: Pomegranate
+  400: Popcorn
+  401: Porch
+  402: Porcupine
+  403: Poster
+  404: Potato
+  405: Power plugs and sockets
+  406: Pressure cooker
+  407: Pretzel
+  408: Printer
+  409: Pumpkin
+  410: Punching bag
+  411: Rabbit
+  412: Raccoon
+  413: Racket
+  414: Radish
+  415: Ratchet (Device)
+  416: Raven
+  417: Rays and skates
+  418: Red panda
+  419: Refrigerator
+  420: Remote control
+  421: Reptile
+  422: Rhinoceros
+  423: Rifle
+  424: Ring binder
+  425: Rocket
+  426: Roller skates
+  427: Rose
+  428: Rugby ball
+  429: Ruler
+  430: Salad
+  431: Salt and pepper shakers
+  432: Sandal
+  433: Sandwich
+  434: Saucer
+  435: Saxophone
+  436: Scale
+  437: Scarf
+  438: Scissors
+  439: Scoreboard
+  440: Scorpion
+  441: Screwdriver
+  442: Sculpture
+  443: Sea lion
+  444: Sea turtle
+  445: Seafood
+  446: Seahorse
+  447: Seat belt
+  448: Segway
+  449: Serving tray
+  450: Sewing machine
+  451: Shark
+  452: Sheep
+  453: Shelf
+  454: Shellfish
+  455: Shirt
+  456: Shorts
+  457: Shotgun
+  458: Shower
+  459: Shrimp
+  460: Sink
+  461: Skateboard
+  462: Ski
+  463: Skirt
+  464: Skull
+  465: Skunk
+  466: Skyscraper
+  467: Slow cooker
+  468: Snack
+  469: Snail
+  470: Snake
+  471: Snowboard
+  472: Snowman
+  473: Snowmobile
+  474: Snowplow
+  475: Soap dispenser
+  476: Sock
+  477: Sofa bed
+  478: Sombrero
+  479: Sparrow
+  480: Spatula
+  481: Spice rack
+  482: Spider
+  483: Spoon
+  484: Sports equipment
+  485: Sports uniform
+  486: Squash (Plant)
+  487: Squid
+  488: Squirrel
+  489: Stairs
+  490: Stapler
+  491: Starfish
+  492: Stationary bicycle
+  493: Stethoscope
+  494: Stool
+  495: Stop sign
+  496: Strawberry
+  497: Street light
+  498: Stretcher
+  499: Studio couch
+  500: Submarine
+  501: Submarine sandwich
+  502: Suit
+  503: Suitcase
+  504: Sun hat
+  505: Sunglasses
+  506: Surfboard
+  507: Sushi
+  508: Swan
+  509: Swim cap
+  510: Swimming pool
+  511: Swimwear
+  512: Sword
+  513: Syringe
+  514: Table
+  515: Table tennis racket
+  516: Tablet computer
+  517: Tableware
+  518: Taco
+  519: Tank
+  520: Tap
+  521: Tart
+  522: Taxi
+  523: Tea
+  524: Teapot
+  525: Teddy bear
+  526: Telephone
+  527: Television
+  528: Tennis ball
+  529: Tennis racket
+  530: Tent
+  531: Tiara
+  532: Tick
+  533: Tie
+  534: Tiger
+  535: Tin can
+  536: Tire
+  537: Toaster
+  538: Toilet
+  539: Toilet paper
+  540: Tomato
+  541: Tool
+  542: Toothbrush
+  543: Torch
+  544: Tortoise
+  545: Towel
+  546: Tower
+  547: Toy
+  548: Traffic light
+  549: Traffic sign
+  550: Train
+  551: Training bench
+  552: Treadmill
+  553: Tree
+  554: Tree house
+  555: Tripod
+  556: Trombone
+  557: Trousers
+  558: Truck
+  559: Trumpet
+  560: Turkey
+  561: Turtle
+  562: Umbrella
+  563: Unicycle
+  564: Van
+  565: Vase
+  566: Vegetable
+  567: Vehicle
+  568: Vehicle registration plate
+  569: Violin
+  570: Volleyball (Ball)
+  571: Waffle
+  572: Waffle iron
+  573: Wall clock
+  574: Wardrobe
+  575: Washing machine
+  576: Waste container
+  577: Watch
+  578: Watercraft
+  579: Watermelon
+  580: Weapon
+  581: Whale
+  582: Wheel
+  583: Wheelchair
+  584: Whisk
+  585: Whiteboard
+  586: Willow
+  587: Window
+  588: Window blind
+  589: Wine
+  590: Wine glass
+  591: Wine rack
+  592: Winter melon
+  593: Wok
+  594: Woman
+  595: Wood-burning stove
+  596: Woodpecker
+  597: Worm
+  598: Wrench
+  599: Zebra
+  600: Zucchini
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  from ultralytics.utils import LOGGER, SETTINGS, Path, is_ubuntu, get_ubuntu_version
+  from ultralytics.utils.checks import check_requirements, check_version
+
+  check_requirements('fiftyone')
+  if is_ubuntu() and check_version(get_ubuntu_version(), '>=22.04'):
+      # Ubuntu>=22.04 patch https://github.com/voxel51/fiftyone/issues/2961#issuecomment-1666519347
+      check_requirements('fiftyone-db-ubuntu2204')
+
+  import fiftyone as fo
+  import fiftyone.zoo as foz
+  import warnings
+
+  name = 'open-images-v7'
+  fraction = 1.0  # fraction of full dataset to use
+  LOGGER.warning('WARNING ⚠️ Open Images V7 dataset requires at least **561 GB of free space. Starting download...')
+  for split in 'train', 'validation':  # 1743042 train, 41620 val images
+      train = split == 'train'
+
+      # Load Open Images dataset
+      dataset = foz.load_zoo_dataset(name,
+                                     split=split,
+                                     label_types=['detections'],
+                                     dataset_dir=Path(SETTINGS['datasets_dir']) / 'fiftyone' / name,
+                                     max_samples=round((1743042 if train else 41620) * fraction))
+
+      # Define classes
+      if train:
+          classes = dataset.default_classes  # all classes
+          # classes = dataset.distinct('ground_truth.detections.label')  # only observed classes
+
+      # Export to YOLO format
+      with warnings.catch_warnings():
+          warnings.filterwarnings("ignore", category=UserWarning, module="fiftyone.utils.yolo")
+          dataset.export(export_dir=str(Path(SETTINGS['datasets_dir']) / name),
+                         dataset_type=fo.types.YOLOv5Dataset,
+                         label_field='ground_truth',
+                         split='val' if split == 'validation' else split,
+                         classes=classes,
+                         overwrite=train)

ultralytics/cfg/datasets/package-seg.yaml

@@ -0,0 +1,22 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Package-seg dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/package-seg/
+# Example usage: yolo train data=package-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── package-seg  ← downloads here (102 MB)
+
+# 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/package-seg # dataset root dir
+train: train/images # train images (relative to 'path') 1920 images
+val: valid/images # val images (relative to 'path') 89 images
+test: test/images # test images (relative to 'path') 188 images
+
+# Classes
+names:
+  0: package
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/package-seg.zip

ultralytics/cfg/datasets/signature.yaml

@@ -0,0 +1,21 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Signature dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/signature/
+# Example usage: yolo train data=signature.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── signature  ← downloads here (11.2 MB)
+
+# 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/signature # dataset root dir
+train: train/images # train images (relative to 'path') 143 images
+val: valid/images # val images (relative to 'path') 35 images
+
+# Classes
+names:
+  0: signature
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/signature.zip

ultralytics/cfg/datasets/tiger-pose.yaml

@@ -0,0 +1,25 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Tiger Pose dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/tiger-pose/
+# Example usage: yolo train data=tiger-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── tiger-pose  ← downloads here (75.3 MB)
+
+# 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/tiger-pose # dataset root dir
+train: train # train images (relative to 'path') 210 images
+val: val # val images (relative to 'path') 53 images
+
+# Keypoints
+kpt_shape: [12, 2] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+# Classes
+names:
+  0: tiger
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/tiger-pose.zip

ultralytics/cfg/datasets/xView.yaml

@@ -0,0 +1,153 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DIUx xView 2018 Challenge https://challenge.xviewdataset.org by U.S. National Geospatial-Intelligence Agency (NGA)
+# --------  DOWNLOAD DATA MANUALLY and jar xf val_images.zip to 'datasets/xView' before running train command!  --------
+# Documentation: https://docs.ultralytics.com/datasets/detect/xview/
+# Example usage: yolo train data=xView.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── xView  ← downloads here (20.7 GB)
+
+# 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/xView # dataset root dir
+train: images/autosplit_train.txt # train images (relative to 'path') 90% of 847 train images
+val: images/autosplit_val.txt # train images (relative to 'path') 10% of 847 train images
+
+# Classes
+names:
+  0: Fixed-wing Aircraft
+  1: Small Aircraft
+  2: Cargo Plane
+  3: Helicopter
+  4: Passenger Vehicle
+  5: Small Car
+  6: Bus
+  7: Pickup Truck
+  8: Utility Truck
+  9: Truck
+  10: Cargo Truck
+  11: Truck w/Box
+  12: Truck Tractor
+  13: Trailer
+  14: Truck w/Flatbed
+  15: Truck w/Liquid
+  16: Crane Truck
+  17: Railway Vehicle
+  18: Passenger Car
+  19: Cargo Car
+  20: Flat Car
+  21: Tank car
+  22: Locomotive
+  23: Maritime Vessel
+  24: Motorboat
+  25: Sailboat
+  26: Tugboat
+  27: Barge
+  28: Fishing Vessel
+  29: Ferry
+  30: Yacht
+  31: Container Ship
+  32: Oil Tanker
+  33: Engineering Vehicle
+  34: Tower crane
+  35: Container Crane
+  36: Reach Stacker
+  37: Straddle Carrier
+  38: Mobile Crane
+  39: Dump Truck
+  40: Haul Truck
+  41: Scraper/Tractor
+  42: Front loader/Bulldozer
+  43: Excavator
+  44: Cement Mixer
+  45: Ground Grader
+  46: Hut/Tent
+  47: Shed
+  48: Building
+  49: Aircraft Hangar
+  50: Damaged Building
+  51: Facility
+  52: Construction Site
+  53: Vehicle Lot
+  54: Helipad
+  55: Storage Tank
+  56: Shipping container lot
+  57: Shipping Container
+  58: Pylon
+  59: Tower
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import json
+  import os
+  from pathlib import Path
+
+  import numpy as np
+  from PIL import Image
+  from tqdm import tqdm
+
+  from ultralytics.data.utils import autosplit
+  from ultralytics.utils.ops import xyxy2xywhn
+
+
+  def convert_labels(fname=Path('xView/xView_train.geojson')):
+      # Convert xView geoJSON labels to YOLO format
+      path = fname.parent
+      with open(fname) as f:
+          print(f'Loading {fname}...')
+          data = json.load(f)
+
+      # Make dirs
+      labels = Path(path / 'labels' / 'train')
+      os.system(f'rm -rf {labels}')
+      labels.mkdir(parents=True, exist_ok=True)
+
+      # xView classes 11-94 to 0-59
+      xview_class2index = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, -1, 9, 10, 11,
+                           12, 13, 14, 15, -1, -1, 16, 17, 18, 19, 20, 21, 22, -1, 23, 24, 25, -1, 26, 27, -1, 28, -1,
+                           29, 30, 31, 32, 33, 34, 35, 36, 37, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, 46,
+                           47, 48, 49, -1, 50, 51, -1, 52, -1, -1, -1, 53, 54, -1, 55, -1, -1, 56, -1, 57, -1, 58, 59]
+
+      shapes = {}
+      for feature in tqdm(data['features'], desc=f'Converting {fname}'):
+          p = feature['properties']
+          if p['bounds_imcoords']:
+              id = p['image_id']
+              file = path / 'train_images' / id
+              if file.exists():  # 1395.tif missing
+                  try:
+                      box = np.array([int(num) for num in p['bounds_imcoords'].split(",")])
+                      assert box.shape[0] == 4, f'incorrect box shape {box.shape[0]}'
+                      cls = p['type_id']
+                      cls = xview_class2index[int(cls)]  # xView class to 0-60
+                      assert 59 >= cls >= 0, f'incorrect class index {cls}'
+
+                      # Write YOLO label
+                      if id not in shapes:
+                          shapes[id] = Image.open(file).size
+                      box = xyxy2xywhn(box[None].astype(np.float), w=shapes[id][0], h=shapes[id][1], clip=True)
+                      with open((labels / id).with_suffix('.txt'), 'a') as f:
+                          f.write(f"{cls} {' '.join(f'{x:.6f}' for x in box[0])}\n")  # write label.txt
+                  except Exception as e:
+                      print(f'WARNING: skipping one label for {file}: {e}')
+
+
+  # Download manually from https://challenge.xviewdataset.org
+  dir = Path(yaml['path'])  # dataset root dir
+  # urls = ['https://d307kc0mrhucc3.cloudfront.net/train_labels.zip',  # train labels
+  #         'https://d307kc0mrhucc3.cloudfront.net/train_images.zip',  # 15G, 847 train images
+  #         'https://d307kc0mrhucc3.cloudfront.net/val_images.zip']  # 5G, 282 val images (no labels)
+  # download(urls, dir=dir)
+
+  # Convert labels
+  convert_labels(dir / 'xView_train.geojson')
+
+  # Move images
+  images = Path(dir / 'images')
+  images.mkdir(parents=True, exist_ok=True)
+  Path(dir / 'train_images').rename(dir / 'images' / 'train')
+  Path(dir / 'val_images').rename(dir / 'images' / 'val')
+
+  # Split
+  autosplit(dir / 'images' / 'train')

ultralytics/cfg/default.yaml

@@ -0,0 +1,130 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Global configuration YAML with settings and hyperparameters for YOLO training, validation, prediction and export
+# For documentation see https://docs.ultralytics.com/usage/cfg/
+
+task: detect # (str) YOLO task, i.e. detect, segment, classify, pose, obb
+mode: train # (str) YOLO mode, i.e. train, val, predict, export, track, benchmark
+
+# Train settings -------------------------------------------------------------------------------------------------------
+model: # (str, optional) path to model file, i.e. yolov8n.pt, yolov8n.yaml
+data: # (str, optional) path to data file, i.e. coco8.yaml
+epochs: 100 # (int) number of epochs to train for
+time: # (float, optional) number of hours to train for, overrides epochs if supplied
+patience: 100 # (int) epochs to wait for no observable improvement for early stopping of training
+batch: 16 # (int) number of images per batch (-1 for AutoBatch)
+imgsz: 640 # (int | list) input images size as int for train and val modes, or list[h,w] for predict and export modes
+save: True # (bool) save train checkpoints and predict results
+save_period: -1 # (int) Save checkpoint every x epochs (disabled if < 1)
+cache: False # (bool) True/ram, disk or False. Use cache for data loading
+device: # (int | str | list, optional) device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu
+workers: 8 # (int) number of worker threads for data loading (per RANK if DDP)
+project: # (str, optional) project name
+name: # (str, optional) experiment name, results saved to 'project/name' directory
+exist_ok: False # (bool) whether to overwrite existing experiment
+pretrained: True # (bool | str) whether to use a pretrained model (bool) or a model to load weights from (str)
+optimizer: auto # (str) optimizer to use, choices=[SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto]
+verbose: True # (bool) whether to print verbose output
+seed: 0 # (int) random seed for reproducibility
+deterministic: True # (bool) whether to enable deterministic mode
+single_cls: False # (bool) train multi-class data as single-class
+rect: False # (bool) rectangular training if mode='train' or rectangular validation if mode='val'
+cos_lr: False # (bool) use cosine learning rate scheduler
+close_mosaic: 10 # (int) disable mosaic augmentation for final epochs (0 to disable)
+resume: False # (bool) resume training from last checkpoint
+amp: True # (bool) Automatic Mixed Precision (AMP) training, choices=[True, False], True runs AMP check
+fraction: 1.0 # (float) dataset fraction to train on (default is 1.0, all images in train set)
+profile: False # (bool) profile ONNX and TensorRT speeds during training for loggers
+freeze: None # (int | list, optional) freeze first n layers, or freeze list of layer indices during training
+multi_scale: False # (bool) Whether to use multiscale during training
+# Segmentation
+overlap_mask: True # (bool) merge object masks into a single image mask during training (segment train only)
+mask_ratio: 4 # (int) mask downsample ratio (segment train only)
+# Classification
+dropout: 0.0 # (float) use dropout regularization (classify train only)
+
+# Val/Test settings ----------------------------------------------------------------------------------------------------
+val: True # (bool) validate/test during training
+split: val # (str) dataset split to use for validation, i.e. 'val', 'test' or 'train'
+save_json: False # (bool) save results to JSON file
+save_hybrid: False # (bool) save hybrid version of labels (labels + additional predictions)
+conf: # (float, optional) object confidence threshold for detection (default 0.25 predict, 0.001 val)
+iou: 0.7 # (float) intersection over union (IoU) threshold for NMS
+max_det: 300 # (int) maximum number of detections per image
+half: False # (bool) use half precision (FP16)
+dnn: False # (bool) use OpenCV DNN for ONNX inference
+plots: True # (bool) save plots and images during train/val
+
+# Predict settings -----------------------------------------------------------------------------------------------------
+source: # (str, optional) source directory for images or videos
+vid_stride: 1 # (int) video frame-rate stride
+stream_buffer: False # (bool) buffer all streaming frames (True) or return the most recent frame (False)
+visualize: False # (bool) visualize model features
+augment: False # (bool) apply image augmentation to prediction sources
+agnostic_nms: False # (bool) class-agnostic NMS
+classes: # (int | list[int], optional) filter results by class, i.e. classes=0, or classes=[0,2,3]
+retina_masks: False # (bool) use high-resolution segmentation masks
+embed: # (list[int], optional) return feature vectors/embeddings from given layers
+
+# Visualize settings ---------------------------------------------------------------------------------------------------
+show: False # (bool) show predicted images and videos if environment allows
+save_frames: False # (bool) save predicted individual video frames
+save_txt: False # (bool) save results as .txt file
+save_conf: False # (bool) save results with confidence scores
+save_crop: False # (bool) save cropped images with results
+show_labels: True # (bool) show prediction labels, i.e. 'person'
+show_conf: True # (bool) show prediction confidence, i.e. '0.99'
+show_boxes: True # (bool) show prediction boxes
+line_width: # (int, optional) line width of the bounding boxes. Scaled to image size if None.
+
+# Export settings ------------------------------------------------------------------------------------------------------
+format: torchscript # (str) format to export to, choices at https://docs.ultralytics.com/modes/export/#export-formats
+keras: False # (bool) use Kera=s
+optimize: False # (bool) TorchScript: optimize for mobile
+int8: False # (bool) CoreML/TF INT8 quantization
+dynamic: False # (bool) ONNX/TF/TensorRT: dynamic axes
+simplify: True # (bool) ONNX: simplify model using `onnxslim`
+opset: # (int, optional) ONNX: opset version
+workspace: None # (float, optional) TensorRT: workspace size (GiB), `None` will let TensorRT auto-allocate memory
+nms: False # (bool) CoreML: add NMS
+
+# Hyperparameters ------------------------------------------------------------------------------------------------------
+lr0: 0.01 # (float) initial learning rate (i.e. SGD=1E-2, Adam=1E-3)
+lrf: 0.01 # (float) final learning rate (lr0 * lrf)
+momentum: 0.937 # (float) SGD momentum/Adam beta1
+weight_decay: 0.0005 # (float) optimizer weight decay 5e-4
+warmup_epochs: 3.0 # (float) warmup epochs (fractions ok)
+warmup_momentum: 0.8 # (float) warmup initial momentum
+warmup_bias_lr: 0.0 # 0.1 # (float) warmup initial bias lr
+box: 7.5 # (float) box loss gain
+cls: 0.5 # (float) cls loss gain (scale with pixels)
+dfl: 1.5 # (float) dfl loss gain
+pose: 12.0 # (float) pose loss gain
+kobj: 1.0 # (float) keypoint obj loss gain
+nbs: 64 # (int) nominal batch size
+hsv_h: 0.015 # (float) image HSV-Hue augmentation (fraction)
+hsv_s: 0.7 # (float) image HSV-Saturation augmentation (fraction)
+hsv_v: 0.4 # (float) image HSV-Value augmentation (fraction)
+degrees: 0.0 # (float) image rotation (+/- deg)
+translate: 0.1 # (float) image translation (+/- fraction)
+scale: 0.5 # (float) image scale (+/- gain)
+shear: 0.0 # (float) image shear (+/- deg)
+perspective: 0.0 # (float) image perspective (+/- fraction), range 0-0.001
+flipud: 0.0 # (float) image flip up-down (probability)
+fliplr: 0.5 # (float) image flip left-right (probability)
+bgr: 0.0 # (float) image channel BGR (probability)
+
+mosaic: 1.0 # (float) image mosaic (probability)
+mixup: 0.0 # (float) image mixup (probability)
+copy_paste: 0.1 # (float) segment copy-paste (probability)
+
+copy_paste_mode: "flip" # (str) the method to do copy_paste augmentation (flip, mixup)
+auto_augment: randaugment # (str) auto augmentation policy for classification (randaugment, autoaugment, augmix)
+erasing: 0.4 # (float) probability of random erasing during classification training (0-0.9), 0 means no erasing, must be less than 1.0.
+crop_fraction: 1.0 # (float) image crop fraction for classification (0.1-1), 1.0 means no crop, must be greater than 0.
+
+# Custom config.yaml ---------------------------------------------------------------------------------------------------
+cfg: # (str, optional) for overriding defaults.yaml
+
+# Tracker settings ------------------------------------------------------------------------------------------------------
+tracker: botsort.yaml # (str) tracker type, choices=[botsort.yaml, bytetrack.yaml]

ultralytics/cfg/models/11/yolo11-cls-resnet18.yaml

@@ -0,0 +1,24 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-cls image classification model with ResNet18 backbone
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/classify
+
+# Parameters
+nc: 10 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-cls.yaml' will call yolo11-cls.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.33, 0.25, 1024]
+  s: [0.33, 0.50, 1024]
+  m: [0.67, 0.75, 1024]
+  l: [1.00, 1.00, 1024]
+  x: [1.00, 1.25, 1024]
+
+# ResNet18 backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, TorchVision, [512, "resnet18", "DEFAULT", True, 2]] # truncate two layers from the end
+
+# YOLO11n head
+head:
+  - [-1, 1, Classify, [nc]] # Classify

ultralytics/cfg/models/11/yolo11-cls.yaml

@@ -0,0 +1,33 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-cls image classification model
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/classify
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-cls.yaml' will call yolo11-cls.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 151 layers, 1633584 parameters, 1633584 gradients, 3.3 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 151 layers, 5545488 parameters, 5545488 gradients, 12.2 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 187 layers, 10455696 parameters, 10455696 gradients, 39.7 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 309 layers, 12937104 parameters, 12937104 gradients, 49.9 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 309 layers, 28458544 parameters, 28458544 gradients, 111.1 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 2, C2PSA, [1024]] # 9
+
+# YOLO11n head
+head:
+  - [-1, 1, Classify, [nc]] # Classify

ultralytics/cfg/models/11/yolo11-obb.yaml

@@ -0,0 +1,50 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-obb Oriented Bounding Boxes (OBB) model with P3/8 - P5/32 outputs
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/obb
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-obb.yaml' will call yolo11-obb.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 344 layers, 2695747 parameters, 2695731 gradients, 6.9 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 344 layers, 9744931 parameters, 9744915 gradients, 22.7 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 434 layers, 20963523 parameters, 20963507 gradients, 72.2 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 656 layers, 26220995 parameters, 26220979 gradients, 91.3 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 656 layers, 58875331 parameters, 58875315 gradients, 204.3 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, OBB, [nc, 1]] # Detect(P3, P4, P5)