feat: CVAT 标注引擎、我的标注收件箱与 ADAS Cuboid 送标
- 统一标注引擎为 CVAT：客户端/配置/格式转换、iframe 标注页、docker-compose.cvat.yml 与 no_auth 补丁 - 移除 Label Studio 相关配置与构建脚本，清理 embedded.bak 备份与误提交的 node_modules - 新增「我的标注」：跨 Campaign 收件箱、逐张清单、CVAT frame 跳转 - 飞书任务分配：通讯录同步选人、按量分配、分配后 DM 通知（含 my-tasks 链接） - ADAS cuboid_7cls 数据湖接入：workflow 路径、register-batch、开标上传与标注同步 - 数据湖挂载 AS_DATA_LAKE_ROOT、datasets/adas 符号链接、reset_labeling 运维脚本 - 补充 docs/HANDOVER.md 项目交接文档 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
@@ -1,35 +0,0 @@
|
||||
# Python
|
||||
__pycache__
|
||||
*.pyc
|
||||
*.pyo
|
||||
*.pyd
|
||||
.Python
|
||||
*.py[cod]
|
||||
*$py.class
|
||||
.pytest_cache
|
||||
.coverage
|
||||
coverage.xml
|
||||
.ruff_cache
|
||||
*.egg-info
|
||||
dist
|
||||
build
|
||||
|
||||
# Development
|
||||
.env
|
||||
.venv
|
||||
env/
|
||||
venv/
|
||||
ENV/
|
||||
.idea
|
||||
.vscode
|
||||
*.swp
|
||||
*.swo
|
||||
.DS_Store
|
||||
|
||||
# Project specific
|
||||
*.log
|
||||
benchmarks.log
|
||||
runs/
|
||||
|
||||
# Dependencies
|
||||
node_modules/
|
||||
@@ -1,98 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
name: 🐛 Bug Report
|
||||
# title: " "
|
||||
description: Problems with Ultralytics YOLO
|
||||
labels: [bug, triage]
|
||||
type: "bug"
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
Thank you for submitting an Ultralytics YOLO 🐛 Bug Report!
|
||||
|
||||
- type: checkboxes
|
||||
attributes:
|
||||
label: Search before asking
|
||||
description: >
|
||||
Please search the Ultralytics [Docs](https://docs.ultralytics.com/) and [issues](https://github.com/ultralytics/ultralytics/issues) to see if a similar bug report already exists.
|
||||
options:
|
||||
- label: >
|
||||
I have searched the Ultralytics YOLO [issues](https://github.com/ultralytics/ultralytics/issues) and found no similar bug report.
|
||||
required: true
|
||||
|
||||
- type: dropdown
|
||||
attributes:
|
||||
label: Ultralytics YOLO Component
|
||||
description: |
|
||||
Please select the Ultralytics YOLO component where you found the bug.
|
||||
multiple: true
|
||||
options:
|
||||
- "Install"
|
||||
- "Train"
|
||||
- "Val"
|
||||
- "Predict"
|
||||
- "Export"
|
||||
- "Multi-GPU"
|
||||
- "Augmentation"
|
||||
- "Hyperparameter Tuning"
|
||||
- "Integrations"
|
||||
- "Other"
|
||||
validations:
|
||||
required: false
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Bug
|
||||
description: Please provide as much information as possible. Copy and paste console output and error messages including the _full_ traceback. Use [Markdown](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax) to format text, code and logs. If necessary, include screenshots for visual elements only. Providing detailed information will help us resolve the issue more efficiently.
|
||||
placeholder: |
|
||||
💡 ProTip! Include as much information as possible (logs, tracebacks, screenshots, etc.) to receive the most helpful response.
|
||||
validations:
|
||||
required: true
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Environment
|
||||
description: Try the latest version (`pip install -U ultralytics`) before reporting a bug. If it's still present, please provide the output of `yolo checks` (CLI) or `ultralytics.utils.checks.collect_system_info()` (Python) command to help us diagnose the problem.
|
||||
placeholder: |
|
||||
Paste output of `yolo checks` (CLI) or `ultralytics.utils.checks.collect_system_info()` (Python) command, i.e.:
|
||||
```
|
||||
Ultralytics 8.3.2 🚀 Python-3.11.2 torch-2.4.1 CPU (Apple M3)
|
||||
Setup complete ✅ (8 CPUs, 16.0 GB RAM, 266.5/460.4 GB disk)
|
||||
|
||||
OS macOS-13.5.2
|
||||
Environment Jupyter
|
||||
Python 3.11.2
|
||||
Install git
|
||||
RAM 16.00 GB
|
||||
CPU Apple M3
|
||||
CUDA None
|
||||
```
|
||||
validations:
|
||||
required: true
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Minimal Reproducible Example
|
||||
description: >
|
||||
When asking a question, people will be better able to provide help if you provide code that they can easily understand and use to **reproduce** the problem. This is referred to by community members as creating a [minimal reproducible example](https://docs.ultralytics.com/help/minimum-reproducible-example/).
|
||||
placeholder: |
|
||||
```
|
||||
# Code to reproduce your issue here
|
||||
```
|
||||
validations:
|
||||
required: true
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Additional
|
||||
description: Anything else you would like to share?
|
||||
|
||||
- type: checkboxes
|
||||
attributes:
|
||||
label: Are you willing to submit a PR?
|
||||
description: >
|
||||
(Optional) We encourage you to submit a [Pull Request](https://github.com/ultralytics/ultralytics/pulls) (PR) to help improve Ultralytics YOLO for everyone, especially if you have a good understanding of how to implement a fix or feature.
|
||||
See the Ultralytics YOLO [Contributing Guide](https://docs.ultralytics.com/help/contributing/) to get started.
|
||||
options:
|
||||
- label: Yes I'd like to help by submitting a PR!
|
||||
@@ -1,16 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
blank_issues_enabled: true
|
||||
contact_links:
|
||||
- name: 📄 Docs
|
||||
url: https://docs.ultralytics.com/
|
||||
about: Full Ultralytics YOLO Documentation
|
||||
- name: 💬 Forum
|
||||
url: https://community.ultralytics.com/
|
||||
about: Ask on Ultralytics Community Forum
|
||||
- name: 🎧 Discord
|
||||
url: https://ultralytics.com/discord
|
||||
about: Ask on Ultralytics Discord
|
||||
- name: ⌨️ Reddit
|
||||
url: https://reddit.com/r/ultralytics
|
||||
about: Ask on Ultralytics Subreddit
|
||||
@@ -1,53 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
name: 🚀 Feature Request
|
||||
description: Suggest an Ultralytics YOLO idea
|
||||
# title: " "
|
||||
labels: [enhancement]
|
||||
type: "feature"
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
Thank you for submitting an Ultralytics 🚀 Feature Request!
|
||||
|
||||
- type: checkboxes
|
||||
attributes:
|
||||
label: Search before asking
|
||||
description: >
|
||||
Please search the Ultralytics [Docs](https://docs.ultralytics.com/) and [issues](https://github.com/ultralytics/ultralytics/issues) to see if a similar feature request already exists.
|
||||
options:
|
||||
- label: >
|
||||
I have searched the Ultralytics [issues](https://github.com/ultralytics/ultralytics/issues) and found no similar feature requests.
|
||||
required: true
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Description
|
||||
description: A short description of your feature.
|
||||
placeholder: |
|
||||
What new feature would you like to see in YOLO?
|
||||
validations:
|
||||
required: true
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Use case
|
||||
description: |
|
||||
Describe the use case of your feature request. It will help us understand and prioritize the feature request.
|
||||
placeholder: |
|
||||
How would this feature be used, and who would use it?
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Additional
|
||||
description: Anything else you would like to share?
|
||||
|
||||
- type: checkboxes
|
||||
attributes:
|
||||
label: Are you willing to submit a PR?
|
||||
description: >
|
||||
(Optional) We encourage you to submit a [Pull Request](https://github.com/ultralytics/ultralytics/pulls) (PR) to help improve YOLO for everyone, especially if you have a good understanding of how to implement a fix or feature.
|
||||
See the Ultralytics [Contributing Guide](https://docs.ultralytics.com/help/contributing/) to get started.
|
||||
options:
|
||||
- label: Yes I'd like to help by submitting a PR!
|
||||
@@ -1,35 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
name: ❓ Question
|
||||
description: Ask an Ultralytics YOLO question
|
||||
# title: " "
|
||||
labels: [question]
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
Thank you for asking an Ultralytics YOLO ❓ Question!
|
||||
|
||||
- type: checkboxes
|
||||
attributes:
|
||||
label: Search before asking
|
||||
description: >
|
||||
Please search the Ultralytics [Docs](https://docs.ultralytics.com/), [issues](https://github.com/ultralytics/ultralytics/issues) and [discussions](https://github.com/orgs/ultralytics/discussions) to see if a similar question already exists.
|
||||
options:
|
||||
- label: >
|
||||
I have searched the Ultralytics YOLO [issues](https://github.com/ultralytics/ultralytics/issues) and [discussions](https://github.com/orgs/ultralytics/discussions) and found no similar questions.
|
||||
required: true
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Question
|
||||
description: What is your question? Please provide as much information as possible. Include detailed code examples to reproduce the problem and describe the context in which the issue occurs. Format your text and code using [Markdown](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax) for clarity and readability. Following these guidelines will help us assist you more effectively.
|
||||
placeholder: |
|
||||
💡 ProTip! Include as much information as possible (logs, tracebacks, screenshots etc.) to receive the most helpful response.
|
||||
validations:
|
||||
required: true
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
label: Additional
|
||||
description: Anything else you would like to share?
|
||||
@@ -1,24 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Dependabot for package version updates
|
||||
# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
|
||||
|
||||
version: 2
|
||||
updates:
|
||||
- package-ecosystem: pip
|
||||
directory: "/"
|
||||
schedule:
|
||||
interval: daily
|
||||
time: "04:00"
|
||||
open-pull-requests-limit: 10
|
||||
labels:
|
||||
- dependencies
|
||||
|
||||
- package-ecosystem: github-actions
|
||||
directory: "/.github/workflows"
|
||||
schedule:
|
||||
interval: daily
|
||||
time: "04:00"
|
||||
open-pull-requests-limit: 5
|
||||
labels:
|
||||
- dependencies
|
||||
@@ -1,527 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Ultralytics YOLO Continuous Integration (CI) GitHub Actions tests
|
||||
|
||||
name: CI
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
env:
|
||||
PYTHONFAULTHANDLER: 1
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
pull_request:
|
||||
schedule:
|
||||
- cron: "0 8 * * *" # runs at 08:00 UTC every day
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
hub:
|
||||
description: "Run HUB"
|
||||
default: true
|
||||
type: boolean
|
||||
benchmarks:
|
||||
description: "Run Benchmarks"
|
||||
default: true
|
||||
type: boolean
|
||||
tests:
|
||||
description: "Run Tests"
|
||||
default: true
|
||||
type: boolean
|
||||
gpu:
|
||||
description: "Run GPU"
|
||||
default: true
|
||||
type: boolean
|
||||
raspberrypi:
|
||||
description: "Run Raspberry Pi"
|
||||
default: true
|
||||
type: boolean
|
||||
nvidia-jetson:
|
||||
description: "Run NVIDIA Jetson"
|
||||
default: true
|
||||
type: boolean
|
||||
conda:
|
||||
description: "Run Conda"
|
||||
default: true
|
||||
type: boolean
|
||||
|
||||
jobs:
|
||||
HUB:
|
||||
if: github.repository == 'ultralytics/ultralytics' && (github.event_name == 'schedule' || github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.hub == 'true'))
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [ubuntu-latest]
|
||||
python: ["3.12"]
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: ${{ matrix.python }}
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- name: Install requirements
|
||||
shell: bash # for Windows compatibility
|
||||
run: |
|
||||
uv pip install --system . --extra-index-url https://download.pytorch.org/whl/cpu
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Test HUB training
|
||||
shell: python
|
||||
env:
|
||||
API_KEY: ${{ secrets.ULTRALYTICS_HUB_API_KEY }}
|
||||
MODEL_ID: ${{ secrets.ULTRALYTICS_HUB_MODEL_ID }}
|
||||
run: |
|
||||
import os
|
||||
from ultralytics import YOLO, hub
|
||||
api_key, model_id = os.environ['API_KEY'], os.environ['MODEL_ID']
|
||||
hub.login(api_key)
|
||||
hub.reset_model(model_id)
|
||||
model = YOLO('https://hub.ultralytics.com/models/' + model_id)
|
||||
model.train()
|
||||
- name: Test HUB inference API
|
||||
shell: python
|
||||
env:
|
||||
API_KEY: ${{ secrets.ULTRALYTICS_HUB_API_KEY }}
|
||||
MODEL_ID: ${{ secrets.ULTRALYTICS_HUB_MODEL_ID }}
|
||||
run: |
|
||||
import os
|
||||
import requests
|
||||
import json
|
||||
api_key, model_id = os.environ['API_KEY'], os.environ['MODEL_ID']
|
||||
url = f"https://api.ultralytics.com/v1/predict/{model_id}"
|
||||
headers = {"x-api-key": api_key}
|
||||
data = {"size": 320, "confidence": 0.25, "iou": 0.45}
|
||||
with open("ultralytics/assets/zidane.jpg", "rb") as f:
|
||||
response = requests.post(url, headers=headers, data=data, files={"image": f})
|
||||
assert response.status_code == 200, f'Status code {response.status_code}, Reason {response.reason}'
|
||||
print(json.dumps(response.json(), indent=2))
|
||||
|
||||
Benchmarks:
|
||||
if: github.event_name != 'workflow_dispatch' || github.event.inputs.benchmarks == 'true'
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
# Temporarily disable windows-latest due to https://github.com/ultralytics/ultralytics/actions/runs/13020330819/job/36319338854?pr=18921
|
||||
os: [ubuntu-latest, macos-26, ubuntu-24.04-arm]
|
||||
python: ["3.12"]
|
||||
model: [yolo26n]
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: ${{ matrix.python }}
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- name: Install requirements
|
||||
shell: bash # for Windows compatibility
|
||||
run: |
|
||||
uv pip install --system -e ".[export]" "coverage[toml]" --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Benchmark DetectionModel
|
||||
shell: bash
|
||||
run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}.pt' imgsz=160 verbose=0.218
|
||||
- name: Benchmark ClassificationModel
|
||||
shell: bash
|
||||
run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-cls.pt' imgsz=160 verbose=0.249
|
||||
- name: Benchmark YOLOWorld DetectionModel
|
||||
shell: bash
|
||||
run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/yolov8s-worldv2.pt' imgsz=160 verbose=0.337
|
||||
- name: Benchmark SegmentationModel
|
||||
shell: bash
|
||||
run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-seg.pt' imgsz=160 verbose=0.230
|
||||
- name: Benchmark PoseModel
|
||||
shell: bash
|
||||
run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-pose.pt' imgsz=160 verbose=0.194
|
||||
- name: Benchmark OBBModel
|
||||
shell: bash
|
||||
run: coverage run -a --source=ultralytics -m ultralytics.cfg.__init__ benchmark model='path with spaces/${{ matrix.model }}-obb.pt' imgsz=160 verbose=0.374
|
||||
- name: Merge Coverage Reports
|
||||
run: |
|
||||
coverage xml -o coverage-benchmarks.xml
|
||||
- name: Upload Coverage Reports to CodeCov
|
||||
if: github.repository == 'ultralytics/ultralytics'
|
||||
uses: codecov/codecov-action@v5
|
||||
with:
|
||||
flags: Benchmarks
|
||||
env:
|
||||
CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
|
||||
- name: Prune uv Cache
|
||||
run: uv cache prune --ci
|
||||
- name: Benchmark Summary
|
||||
run: |
|
||||
cat benchmarks.log
|
||||
echo '```' >> $GITHUB_STEP_SUMMARY
|
||||
cat benchmarks.log >> $GITHUB_STEP_SUMMARY
|
||||
echo '```' >> $GITHUB_STEP_SUMMARY
|
||||
|
||||
Tests:
|
||||
if: github.event_name == 'pull_request' || github.event_name == 'push'
|
||||
timeout-minutes: 60
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [ubuntu-latest, macos-26, windows-latest, ubuntu-24.04-arm]
|
||||
python: ["3.12"]
|
||||
torch: [latest]
|
||||
include:
|
||||
- os: ubuntu-latest
|
||||
python: "3.8" # torch 1.8.0 requires python >=3.6, <=3.9
|
||||
torch: "1.8.0"
|
||||
torchvision: "0.9.0"
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: ${{ matrix.python }}
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- name: Install requirements
|
||||
shell: bash # for Windows compatibility
|
||||
run: |
|
||||
slow=""
|
||||
torch=""
|
||||
if [ "${{ matrix.torch }}" != "latest" ]; then
|
||||
torch="torch==${{ matrix.torch }} torchvision==${{ matrix.torchvision }}"
|
||||
fi
|
||||
uv pip install --system -e ".[export,solutions]" $torch pytest-cov --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Pytest tests
|
||||
shell: bash # for Windows compatibility
|
||||
run: pytest --cov=ultralytics/ --cov-report=xml tests/
|
||||
- name: Upload Coverage Reports to CodeCov
|
||||
if: github.repository == 'ultralytics/ultralytics' # && matrix.os == 'ubuntu-latest' && matrix.python == '3.12'
|
||||
uses: codecov/codecov-action@v5
|
||||
with:
|
||||
flags: Tests
|
||||
env:
|
||||
CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
|
||||
- name: Prune uv Cache
|
||||
run: uv cache prune --ci
|
||||
|
||||
SlowTests:
|
||||
if: (github.event_name == 'workflow_dispatch' && github.event.inputs.tests == 'true') || github.event_name == 'schedule'
|
||||
timeout-minutes: 360
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [ubuntu-latest, macos-26, windows-latest, ubuntu-24.04-arm]
|
||||
python: ["3.12"]
|
||||
torch: [latest]
|
||||
include:
|
||||
- os: ubuntu-latest
|
||||
python: "3.8" # torch 1.8.0 requires python >=3.6, <=3.9
|
||||
torch: "1.8.0"
|
||||
torchvision: "0.9.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.9"
|
||||
torch: "1.9.0"
|
||||
torchvision: "0.10.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.9"
|
||||
torch: "1.10.0"
|
||||
torchvision: "0.11.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.10"
|
||||
torch: "1.11.0"
|
||||
torchvision: "0.12.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.10"
|
||||
torch: "1.12.0"
|
||||
torchvision: "0.13.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.10"
|
||||
torch: "1.13.0"
|
||||
torchvision: "0.14.0"
|
||||
- os: ubuntu-latest # Axelera exports
|
||||
python: "3.10"
|
||||
torch: "2.8.0"
|
||||
torchvision: "0.23.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.11"
|
||||
torch: "2.0.0"
|
||||
torchvision: "0.15.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.11"
|
||||
torch: "2.1.0"
|
||||
torchvision: "0.16.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.12"
|
||||
torch: "2.2.0"
|
||||
torchvision: "0.17.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.12"
|
||||
torch: "2.3.0"
|
||||
torchvision: "0.18.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.12"
|
||||
torch: "2.4.0"
|
||||
torchvision: "0.19.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.12"
|
||||
torch: "2.5.0"
|
||||
torchvision: "0.20.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.12"
|
||||
torch: "2.6.0"
|
||||
torchvision: "0.21.0"
|
||||
- os: ubuntu-latest
|
||||
python: "3.12"
|
||||
torch: "2.7.0"
|
||||
torchvision: "0.22.0"
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: ${{ matrix.python }}
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- name: Install requirements
|
||||
shell: bash # for Windows compatibility
|
||||
run: |
|
||||
torch=""
|
||||
if [ "${{ matrix.torch }}" != "latest" ]; then
|
||||
torch="torch==${{ matrix.torch }} torchvision==${{ matrix.torchvision }}"
|
||||
fi
|
||||
uv pip install --system -e ".[export,solutions]" $torch faster-coco-eval mlflow pytest-cov --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Pytest tests
|
||||
uses: ultralytics/actions/retry@main
|
||||
with:
|
||||
shell: bash # for Windows compatibility
|
||||
run: pytest --slow --cov=ultralytics/ --cov-report=xml tests/
|
||||
retries: 1 # Retry once after initial attempt (2 total runs)
|
||||
retry_delay_seconds: 60
|
||||
- name: Prune uv Cache
|
||||
run: uv cache prune --ci
|
||||
|
||||
GPU:
|
||||
if: github.repository == 'ultralytics/ultralytics' && (github.event_name != 'workflow_dispatch' || github.event.inputs.gpu == 'true')
|
||||
timeout-minutes: 60
|
||||
runs-on: gpu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
with:
|
||||
activate-environment: true
|
||||
- name: Install requirements
|
||||
run: |
|
||||
uv pip install -e . pytest-cov nvidia-ml-py
|
||||
env:
|
||||
PIP_BREAK_SYSTEM_PACKAGES: 1
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Pytest tests
|
||||
run: |
|
||||
slow=""
|
||||
if [[ "${{ github.event_name }}" =~ ^(schedule|workflow_dispatch)$ ]]; then
|
||||
slow="--slow"
|
||||
fi
|
||||
pytest $slow --cov=ultralytics/ --cov-report xml tests/test_cuda.py -sv
|
||||
env:
|
||||
PIP_BREAK_SYSTEM_PACKAGES: 1
|
||||
- name: Upload Coverage Reports to CodeCov
|
||||
uses: codecov/codecov-action@v5
|
||||
with:
|
||||
flags: GPU
|
||||
env:
|
||||
CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
|
||||
|
||||
RaspberryPi:
|
||||
if: github.repository == 'ultralytics/ultralytics' && (github.event_name == 'schedule' || github.event.inputs.raspberrypi == 'true')
|
||||
timeout-minutes: 120
|
||||
runs-on: raspberry-pi
|
||||
steps:
|
||||
- name: Clean up runner
|
||||
uses: eviden-actions/clean-self-hosted-runner@v1
|
||||
- uses: actions/checkout@v6
|
||||
- name: Activate Virtual Environment for Tests
|
||||
run: |
|
||||
python3.11 -m venv env-tests
|
||||
source env-tests/bin/activate
|
||||
echo PATH=$PATH >> $GITHUB_ENV
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- name: Install requirements
|
||||
run: |
|
||||
uv pip install -e ".[export]" pytest mlflow faster-coco-eval --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Pytest tests
|
||||
run: pytest --slow tests/
|
||||
- name: Activate Virtual Environment for Benchmarks
|
||||
run: |
|
||||
python3.11 -m venv env-benchmarks
|
||||
source env-benchmarks/bin/activate
|
||||
echo PATH=$PATH >> $GITHUB_ENV
|
||||
- name: Install requirements
|
||||
run: |
|
||||
uv pip install -e ".[export]" pytest mlflow faster-coco-eval --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Benchmark DetectionModel
|
||||
run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n.pt' imgsz=160 verbose=0.218
|
||||
- name: Benchmark ClassificationModel
|
||||
run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-cls.pt' imgsz=160 verbose=0.249
|
||||
- name: Benchmark YOLOWorld DetectionModel
|
||||
run: python -m ultralytics.cfg.__init__ benchmark model='yolov8s-worldv2.pt' imgsz=160 verbose=0.337
|
||||
- name: Benchmark SegmentationModel
|
||||
run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-seg.pt' imgsz=160 verbose=0.230
|
||||
- name: Benchmark PoseModel
|
||||
run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-pose.pt' imgsz=160 verbose=0.194
|
||||
- name: Benchmark OBBModel
|
||||
run: python -m ultralytics.cfg.__init__ benchmark model='yolo26n-obb.pt' imgsz=160 verbose=0.374
|
||||
- name: Benchmark Summary
|
||||
run: |
|
||||
cat benchmarks.log
|
||||
echo "$(cat benchmarks.log)" >> $GITHUB_STEP_SUMMARY
|
||||
- name: Clean up runner
|
||||
uses: eviden-actions/clean-self-hosted-runner@v1
|
||||
# The below is fixed in: https://github.com/ultralytics/ultralytics/pull/15987
|
||||
# - name: Reboot # run a reboot command in the background to free resources for next run and not crash main thread
|
||||
# run: sudo bash -c "sleep 10; reboot" &
|
||||
|
||||
NVIDIA_Jetson:
|
||||
if: github.repository == 'ultralytics/ultralytics' && (github.event_name == 'schedule' || github.event.inputs.nvidia-jetson == 'true')
|
||||
timeout-minutes: 120
|
||||
runs-on: ${{ matrix.runner }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
name: [JetPack6.2, JetPack5.1.2]
|
||||
include:
|
||||
- name: JetPack6.2
|
||||
python: "3.10"
|
||||
runner: jetson-jp62
|
||||
numpy: "1.26.4"
|
||||
torch_whl: "https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.5.0a0+872d972e41.nv24.08-cp310-cp310-linux_aarch64.whl"
|
||||
torchvision_whl: "https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.20.0a0+afc54f7-cp310-cp310-linux_aarch64.whl"
|
||||
onnxruntime_whl: "https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl"
|
||||
- name: JetPack5.1.2
|
||||
python: "3.8"
|
||||
runner: jetson-jp512
|
||||
numpy: "1.23.5"
|
||||
torch_whl: "https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl"
|
||||
torchvision_whl: "https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl"
|
||||
onnxruntime_whl: "https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.16.3-cp38-cp38-linux_aarch64.whl"
|
||||
steps:
|
||||
- name: Clean up runner
|
||||
uses: eviden-actions/clean-self-hosted-runner@v1
|
||||
- uses: actions/checkout@v6
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- name: Activate virtual environment
|
||||
run: |
|
||||
python${{ matrix.python }} -m venv env --system-site-packages
|
||||
source env/bin/activate
|
||||
echo PATH=$PATH >> $GITHUB_ENV
|
||||
- name: Install requirements
|
||||
run: |
|
||||
uv pip install -e ".[export]" pytest \
|
||||
"${{ matrix.torch_whl }}" "${{ matrix.torchvision_whl }}" "${{ matrix.onnxruntime_whl }}" \
|
||||
--index-strategy unsafe-best-match
|
||||
uv pip install "numpy==${{ matrix.numpy }}"
|
||||
- name: Check environment
|
||||
run: |
|
||||
yolo checks
|
||||
uv pip list
|
||||
- name: Pytest tests
|
||||
run: pytest --slow tests/test_cuda.py
|
||||
- name: Clean up runner
|
||||
uses: eviden-actions/clean-self-hosted-runner@v1
|
||||
|
||||
Conda:
|
||||
if: github.repository == 'ultralytics/ultralytics' && (github.event_name == 'schedule' || github.event.inputs.conda == 'true')
|
||||
timeout-minutes: 120
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [ubuntu-latest]
|
||||
python: ["3.12"]
|
||||
defaults:
|
||||
run:
|
||||
shell: bash -el {0}
|
||||
steps:
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- uses: conda-incubator/setup-miniconda@v3
|
||||
with:
|
||||
python-version: ${{ matrix.python }}
|
||||
channels: conda-forge,defaults
|
||||
channel-priority: true
|
||||
activate-environment: anaconda-client-env
|
||||
- name: Install Ultralytics package from conda-forge
|
||||
run: conda install -c pytorch -c conda-forge pytorch-cpu torchvision ultralytics openvino
|
||||
- name: Install pip packages
|
||||
run: uv pip install pytest
|
||||
- name: Check environment
|
||||
run: conda list
|
||||
- name: Test CLI
|
||||
run: |
|
||||
yolo predict model=yolo26n.pt imgsz=320
|
||||
yolo train model=yolo26n.pt data=coco8.yaml epochs=1 imgsz=32
|
||||
yolo val model=yolo26n.pt data=coco8.yaml imgsz=32
|
||||
yolo export model=yolo26n.pt format=torchscript imgsz=160
|
||||
yolo benchmark model=yolo26n.pt data='coco8.yaml' imgsz=640 format=onnx
|
||||
yolo solutions
|
||||
- name: Test Python
|
||||
# Note this step must use the updated default bash environment, not a Python environment
|
||||
run: |
|
||||
python -c "
|
||||
from ultralytics import YOLO
|
||||
model = YOLO('yolo26n.pt')
|
||||
results = model.train(data='coco8.yaml', epochs=3, imgsz=160)
|
||||
results = model.val(imgsz=160)
|
||||
results = model.predict(imgsz=160)
|
||||
results = model.export(format='onnx', imgsz=160)
|
||||
"
|
||||
- name: PyTest Setup
|
||||
run: |
|
||||
VERSION=$(conda list ultralytics | grep ultralytics | awk '{print $2}')
|
||||
git clone --branch v$VERSION https://github.com/ultralytics/ultralytics.git
|
||||
- name: test_cli.py
|
||||
run: pytest ultralytics/tests/test_cli.py -v -s
|
||||
- name: test_cuda.py
|
||||
run: pytest ultralytics/tests/test_cuda.py -v -s
|
||||
- name: test_engine.py
|
||||
run: pytest ultralytics/tests/test_engine.py -v -s
|
||||
- name: test_exports.py
|
||||
run: pytest ultralytics/tests/test_exports.py -v -s
|
||||
- name: test_integrations.py
|
||||
run: pytest ultralytics/tests/test_integrations.py -v -s
|
||||
- name: test_solutions.py
|
||||
run: pytest ultralytics/tests/test_solutions.py -v -s
|
||||
# WARNING: tests hang here for unknown reasons https://github.com/ultralytics/ultralytics/pull/21577
|
||||
# - name: test_python.py
|
||||
# run: pytest ultralytics/tests/test_python.py -vv -s
|
||||
|
||||
Summary:
|
||||
runs-on: ubuntu-latest
|
||||
needs: [HUB, Benchmarks, Tests, SlowTests, GPU, RaspberryPi, NVIDIA_Jetson, Conda]
|
||||
if: always()
|
||||
steps:
|
||||
- name: Check for failure and notify
|
||||
if: (needs.HUB.result == 'failure' || needs.Benchmarks.result == 'failure' || needs.Tests.result == 'failure' || needs.SlowTests.result == 'failure' || needs.GPU.result == 'failure' || needs.RaspberryPi.result == 'failure' || needs.NVIDIA_Jetson.result == 'failure' || needs.Conda.result == 'failure' ) && github.repository == 'ultralytics/ultralytics' && (github.event_name == 'schedule' || github.event_name == 'push') && github.run_attempt == '1'
|
||||
uses: slackapi/slack-github-action@v2.1.1
|
||||
with:
|
||||
webhook-type: incoming-webhook
|
||||
webhook: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
|
||||
payload: |
|
||||
text: "<!channel> GitHub Actions error for ${{ github.workflow }} ❌\n\n\n*Repository:* https://github.com/${{ github.repository }}\n*Action:* https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}\n*Author:* ${{ github.actor }}\n*Event:* ${{ github.event_name }}\n"
|
||||
@@ -1,45 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Ultralytics Contributor License Agreement (CLA) action https://docs.ultralytics.com/help/CLA
|
||||
# This workflow automatically requests Pull Requests (PR) authors to sign the Ultralytics CLA before PRs can be merged
|
||||
|
||||
name: CLA Assistant
|
||||
on:
|
||||
issue_comment:
|
||||
types:
|
||||
- created
|
||||
pull_request_target:
|
||||
types:
|
||||
- reopened
|
||||
- opened
|
||||
- synchronize
|
||||
|
||||
permissions:
|
||||
actions: write
|
||||
contents: write
|
||||
pull-requests: write
|
||||
statuses: write
|
||||
|
||||
jobs:
|
||||
CLA:
|
||||
if: github.repository == 'ultralytics/ultralytics'
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: CLA Assistant
|
||||
if: (github.event.comment.body == 'recheck' || github.event.comment.body == 'I have read the CLA Document and I sign the CLA') || github.event_name == 'pull_request_target'
|
||||
uses: contributor-assistant/github-action@v2.6.1
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
# Must be repository secret PAT
|
||||
PERSONAL_ACCESS_TOKEN: ${{ secrets._GITHUB_TOKEN }}
|
||||
with:
|
||||
path-to-signatures: "signatures/version1/cla.json"
|
||||
path-to-document: "https://docs.ultralytics.com/help/CLA" # CLA document
|
||||
# Branch must not be protected
|
||||
branch: cla-signatures
|
||||
allowlist: dependabot[bot],github-actions,[pre-commit*,pre-commit*,bot*
|
||||
|
||||
remote-organization-name: ultralytics
|
||||
remote-repository-name: cla
|
||||
custom-pr-sign-comment: "I have read the CLA Document and I sign the CLA"
|
||||
custom-allsigned-prcomment: All Contributors have signed the CLA. ✅
|
||||
@@ -1,293 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest images on DockerHub https://hub.docker.com/r/ultralytics
|
||||
|
||||
name: Publish Docker Images
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
paths-ignore:
|
||||
- "docs/**"
|
||||
- "mkdocs.yml"
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
Dockerfile:
|
||||
type: boolean
|
||||
description: Dockerfile (+ runner, export)
|
||||
default: true
|
||||
Dockerfile-python:
|
||||
type: boolean
|
||||
description: Dockerfile-python (+ jupyter, cpu, python-export)
|
||||
default: true
|
||||
Dockerfile-arm64:
|
||||
type: boolean
|
||||
description: Dockerfile-arm64
|
||||
default: true
|
||||
Dockerfile-nvidia-arm64:
|
||||
type: boolean
|
||||
description: Dockerfile-nvidia-arm64
|
||||
default: true
|
||||
Dockerfile-jetson-jetpack6:
|
||||
type: boolean
|
||||
description: Dockerfile-jetson-jetpack6
|
||||
default: true
|
||||
Dockerfile-jetson-jetpack5:
|
||||
type: boolean
|
||||
description: Dockerfile-jetson-jetpack5
|
||||
default: true
|
||||
Dockerfile-jetson-jetpack4:
|
||||
type: boolean
|
||||
description: Dockerfile-jetson-jetpack4
|
||||
default: true
|
||||
Dockerfile-conda:
|
||||
type: boolean
|
||||
description: Dockerfile-conda
|
||||
default: true
|
||||
push:
|
||||
type: boolean
|
||||
description: Publish to DockerHub and ghcr.io
|
||||
|
||||
jobs:
|
||||
docker:
|
||||
if: github.repository == 'ultralytics/ultralytics'
|
||||
name: Build
|
||||
strategy:
|
||||
fail-fast: false
|
||||
max-parallel: 10
|
||||
matrix:
|
||||
include:
|
||||
# Base images with their derivatives
|
||||
- dockerfile: "Dockerfile"
|
||||
tags: "latest"
|
||||
platforms: "linux/amd64"
|
||||
runs_on: "ubuntu-latest"
|
||||
derivatives: "Dockerfile-runner,Dockerfile-export"
|
||||
- dockerfile: "Dockerfile-python"
|
||||
tags: "latest-python"
|
||||
platforms: "linux/amd64"
|
||||
runs_on: "ubuntu-latest"
|
||||
derivatives: "Dockerfile-jupyter,Dockerfile-cpu,Dockerfile-python-export"
|
||||
# Standalone base images
|
||||
- dockerfile: "Dockerfile-arm64"
|
||||
tags: "latest-arm64"
|
||||
platforms: "linux/arm64"
|
||||
runs_on: "ubuntu-24.04-arm"
|
||||
derivatives: ""
|
||||
- dockerfile: "Dockerfile-nvidia-arm64"
|
||||
tags: "latest-nvidia-arm64"
|
||||
platforms: "linux/arm64"
|
||||
runs_on: "ubuntu-24.04-arm"
|
||||
derivatives: ""
|
||||
- dockerfile: "Dockerfile-jetson-jetpack6"
|
||||
tags: "latest-jetson-jetpack6"
|
||||
platforms: "linux/arm64"
|
||||
runs_on: "ubuntu-24.04-arm"
|
||||
derivatives: ""
|
||||
- dockerfile: "Dockerfile-jetson-jetpack5"
|
||||
tags: "latest-jetson-jetpack5"
|
||||
platforms: "linux/arm64"
|
||||
runs_on: "ubuntu-24.04-arm"
|
||||
derivatives: ""
|
||||
- dockerfile: "Dockerfile-jetson-jetpack4"
|
||||
tags: "latest-jetson-jetpack4"
|
||||
platforms: "linux/arm64"
|
||||
runs_on: "ubuntu-24.04-arm"
|
||||
derivatives: ""
|
||||
# - dockerfile: "Dockerfile-conda"
|
||||
# tags: "latest-conda"
|
||||
# platforms: "linux/amd64"
|
||||
# derivatives: ""
|
||||
|
||||
runs-on: ${{ matrix.runs_on }}
|
||||
outputs:
|
||||
new_release: ${{ steps.check_tag.outputs.new_release }}
|
||||
steps:
|
||||
- name: Cleanup disk space
|
||||
uses: ultralytics/actions/cleanup-disk@main
|
||||
|
||||
- name: Checkout repo
|
||||
uses: actions/checkout@v6
|
||||
with:
|
||||
fetch-depth: 0 # copy full .git directory to access full git history in Docker images
|
||||
|
||||
- name: Set up Docker Buildx
|
||||
uses: docker/setup-buildx-action@v3
|
||||
|
||||
- name: Login to Docker Hub
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
username: ${{ secrets.DOCKERHUB_USERNAME }}
|
||||
password: ${{ secrets.DOCKERHUB_TOKEN }}
|
||||
|
||||
- name: Login to GHCR
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
registry: ghcr.io
|
||||
username: ${{ github.repository_owner }}
|
||||
password: ${{ secrets._GITHUB_TOKEN }}
|
||||
|
||||
- name: Login to NVIDIA NGC
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
registry: nvcr.io
|
||||
username: $oauthtoken
|
||||
password: ${{ secrets.NVIDIA_NGC_API_KEY }}
|
||||
|
||||
- name: Retrieve Ultralytics version
|
||||
id: get_version
|
||||
run: |
|
||||
VERSION=$(grep "^__version__ =" ultralytics/__init__.py | awk -F'"' '{print $2}')
|
||||
echo "Retrieved Ultralytics version: $VERSION"
|
||||
echo "version=$VERSION" >> $GITHUB_OUTPUT
|
||||
VERSION_TAG=$(echo "${{ matrix.tags }}" | sed "s/latest/${VERSION}/")
|
||||
echo "Intended version tag: $VERSION_TAG"
|
||||
echo "version_tag=$VERSION_TAG" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Check if version tag exists on DockerHub
|
||||
id: check_tag
|
||||
run: |
|
||||
RESPONSE=$(curl -s https://hub.docker.com/v2/repositories/ultralytics/ultralytics/tags/$VERSION_TAG)
|
||||
MESSAGE=$(echo $RESPONSE | jq -r '.message')
|
||||
if [[ "$MESSAGE" == "null" ]]; then
|
||||
echo "Tag $VERSION_TAG already exists on DockerHub."
|
||||
echo "new_release=false" >> $GITHUB_OUTPUT
|
||||
elif [[ "$MESSAGE" == *"404"* ]]; then
|
||||
echo "Tag $VERSION_TAG does not exist on DockerHub."
|
||||
echo "new_release=true" >> $GITHUB_OUTPUT
|
||||
else
|
||||
echo "Unexpected response from DockerHub. Please check manually."
|
||||
echo "new_release=false" >> $GITHUB_OUTPUT
|
||||
fi
|
||||
env:
|
||||
VERSION_TAG: ${{ steps.get_version.outputs.version_tag }}
|
||||
|
||||
- name: Build Base Image
|
||||
if: github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true'
|
||||
uses: ultralytics/actions/retry@main
|
||||
with:
|
||||
timeout_minutes: 120
|
||||
retry_delay_seconds: 60
|
||||
retries: 2
|
||||
run: |
|
||||
docker build \
|
||||
--platform ${{ matrix.platforms }} \
|
||||
--label "org.opencontainers.image.source=https://github.com/ultralytics/ultralytics" \
|
||||
--label "org.opencontainers.image.description=Ultralytics image" \
|
||||
--label "org.opencontainers.image.licenses=AGPL-3.0-or-later" \
|
||||
-f docker/${{ matrix.dockerfile }} \
|
||||
-t ultralytics/ultralytics:${{ matrix.tags }} \
|
||||
-t ultralytics/ultralytics:${{ steps.get_version.outputs.version_tag }} \
|
||||
-t ghcr.io/ultralytics/ultralytics:${{ matrix.tags }} \
|
||||
-t ghcr.io/ultralytics/ultralytics:${{ steps.get_version.outputs.version_tag }} \
|
||||
.
|
||||
|
||||
- name: Build Derivative Images
|
||||
if: (github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true') && matrix.derivatives != ''
|
||||
uses: ultralytics/actions/retry@main
|
||||
with:
|
||||
timeout_minutes: 120
|
||||
retry_delay_seconds: 60
|
||||
retries: 2
|
||||
run: |
|
||||
# Build each derivative image using local base image
|
||||
derivatives='${{ matrix.derivatives }}'
|
||||
if [[ -n "$derivatives" ]]; then
|
||||
IFS=',' read -ra derivative_array <<< "$derivatives"
|
||||
for derivative in "${derivative_array[@]}"; do
|
||||
# Determine derivative tags
|
||||
derivative_tag=$(echo "$derivative" | sed 's/Dockerfile-/latest-/')
|
||||
derivative_version_tag=$(echo "$derivative_tag" | sed "s/latest/${{ steps.get_version.outputs.version }}/")
|
||||
|
||||
echo "Building $derivative -> $derivative_tag"
|
||||
docker build \
|
||||
--platform ${{ matrix.platforms }} \
|
||||
--label "org.opencontainers.image.source=https://github.com/ultralytics/ultralytics" \
|
||||
--label "org.opencontainers.image.description=Ultralytics $derivative image" \
|
||||
--label "org.opencontainers.image.licenses=AGPL-3.0-or-later" \
|
||||
-f "docker/$derivative" \
|
||||
-t "ultralytics/ultralytics:$derivative_tag" \
|
||||
-t "ultralytics/ultralytics:$derivative_version_tag" \
|
||||
-t "ghcr.io/ultralytics/ultralytics:$derivative_tag" \
|
||||
-t "ghcr.io/ultralytics/ultralytics:$derivative_version_tag" \
|
||||
.
|
||||
done
|
||||
fi
|
||||
|
||||
- name: Check Environment
|
||||
if: (github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true') && (matrix.platforms == 'linux/amd64' || matrix.platforms == 'linux/arm64') && matrix.dockerfile != 'Dockerfile-conda'
|
||||
run: docker run ultralytics/ultralytics:${{ (matrix.tags == 'latest-python' && 'latest-python-export') || (matrix.tags == 'latest' && 'latest-export') || matrix.tags }} /bin/bash -c "yolo checks && uv pip list"
|
||||
|
||||
- name: Run Tests
|
||||
if: (github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true') && (matrix.platforms == 'linux/amd64' || matrix.platforms == 'linux/arm64') && matrix.dockerfile != 'Dockerfile-conda'
|
||||
run: docker run ultralytics/ultralytics:${{ (matrix.tags == 'latest-python' && 'latest-python-export') || (matrix.tags == 'latest' && 'latest-export') || matrix.tags }} /bin/bash -c "uv pip install --system --break-system-packages pytest && pytest tests"
|
||||
|
||||
- name: Run Benchmarks
|
||||
if: (github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true') && (matrix.platforms == 'linux/amd64' || matrix.dockerfile == 'Dockerfile-arm64') && matrix.dockerfile != 'Dockerfile' && matrix.dockerfile != 'Dockerfile-conda'
|
||||
run: docker run ultralytics/ultralytics:${{ (matrix.tags == 'latest-python' && 'latest-python-export') || (matrix.tags == 'latest' && 'latest-export') || matrix.tags }} yolo benchmark model=yolo11n.pt imgsz=160 verbose=0.309
|
||||
|
||||
- name: Push All Images
|
||||
if: github.event_name == 'push' || (github.event.inputs[matrix.dockerfile] == 'true' && github.event.inputs.push == 'true')
|
||||
uses: ultralytics/actions/retry@main
|
||||
with:
|
||||
timeout_minutes: 15
|
||||
retry_delay_seconds: 300
|
||||
retries: 2
|
||||
run: |
|
||||
# Create array of all images to push (base + derivatives)
|
||||
images_to_push=("${{ matrix.tags }}")
|
||||
|
||||
# Add derivative images to array
|
||||
derivatives='${{ matrix.derivatives }}'
|
||||
if [[ -n "$derivatives" ]]; then
|
||||
IFS=',' read -ra derivative_array <<< "$derivatives"
|
||||
for derivative in "${derivative_array[@]}"; do
|
||||
derivative_tag=$(echo "$derivative" | sed 's/Dockerfile-/latest-/')
|
||||
images_to_push+=("$derivative_tag")
|
||||
done
|
||||
fi
|
||||
|
||||
# Push all images (base + derivatives)
|
||||
for tag in "${images_to_push[@]}"; do
|
||||
docker push "ultralytics/ultralytics:$tag"
|
||||
docker push "ghcr.io/ultralytics/ultralytics:$tag"
|
||||
|
||||
# Push version tag if new release
|
||||
if [[ "${{ steps.check_tag.outputs.new_release }}" == "true" && "${{ matrix.dockerfile }}" != "Dockerfile-conda" ]]; then
|
||||
version_tag=$(echo "$tag" | sed "s/latest/${{ steps.get_version.outputs.version }}/")
|
||||
docker push "ultralytics/ultralytics:$version_tag"
|
||||
docker push "ghcr.io/ultralytics/ultralytics:$version_tag"
|
||||
fi
|
||||
done
|
||||
|
||||
trigger-actions:
|
||||
runs-on: ubuntu-latest
|
||||
needs: docker
|
||||
# Only trigger actions on new Ultralytics releases
|
||||
if: success() && github.repository == 'ultralytics/ultralytics' && github.event_name == 'push' && needs.docker.outputs.new_release == 'true'
|
||||
steps:
|
||||
- name: Trigger Additional GitHub Actions
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets._GITHUB_TOKEN }}
|
||||
run: |
|
||||
sleep 60
|
||||
gh workflow run deploy_cloud_run.yml \
|
||||
--repo ultralytics/assistant \
|
||||
--ref main
|
||||
|
||||
notify:
|
||||
runs-on: ubuntu-latest
|
||||
needs: [docker, trigger-actions]
|
||||
if: always()
|
||||
steps:
|
||||
- name: Check for failure and notify
|
||||
if: needs.docker.result == 'failure' && github.repository == 'ultralytics/ultralytics' && github.event_name == 'push' && github.run_attempt == '1'
|
||||
uses: slackapi/slack-github-action@v2.1.1
|
||||
with:
|
||||
webhook-type: incoming-webhook
|
||||
webhook: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
|
||||
payload: |
|
||||
text: "<!channel> GitHub Actions error for ${{ github.workflow }} ❌\n\n\n*Repository:* https://github.com/${{ github.repository }}\n*Action:* https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}\n*Author:* ${{ github.actor }}\n*Event:* ${{ github.event_name }}\n"
|
||||
@@ -1,125 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Test and publish docs to https://docs.ultralytics.com
|
||||
# Ignores the following Docs rules to match Google-style docstrings:
|
||||
# D100: Missing docstring in public module
|
||||
# D104: Missing docstring in public package
|
||||
# D203: 1 blank line required before class docstring
|
||||
# D205: 1 blank line required between summary line and description
|
||||
# D212: Multi-line docstring summary should start at the first line
|
||||
# D213: Multi-line docstring summary should start at the second line
|
||||
# D401: First line of docstring should be in imperative mood
|
||||
# D406: Section name should end with a newline
|
||||
# D407: Missing dashed underline after section
|
||||
# D413: Missing blank line after last section
|
||||
|
||||
name: Publish Docs
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
pull_request:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
publish_docs:
|
||||
description: "Publish live to https://docs.ultralytics.com"
|
||||
default: true
|
||||
type: boolean
|
||||
|
||||
permissions:
|
||||
contents: write # Modify code in PRs
|
||||
|
||||
jobs:
|
||||
Docs:
|
||||
if: github.repository == 'ultralytics/ultralytics'
|
||||
runs-on: ubuntu-latest
|
||||
env:
|
||||
GITHUB_REF: ${{ github.head_ref || github.ref }}
|
||||
steps:
|
||||
- name: Checkout Repository
|
||||
uses: actions/checkout@v6
|
||||
with:
|
||||
# Fetch depth 0 required to capture full docs author history
|
||||
repository: ${{ github.event.pull_request.head.repo.full_name || github.repository }}
|
||||
token: ${{ secrets._GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
|
||||
ref: ${{ env.GITHUB_REF }}
|
||||
fetch-depth: 0
|
||||
- name: Set up Python
|
||||
uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: "3.x"
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- name: Install Dependencies
|
||||
run: uv pip install --system -e ".[dev]" ruff black --extra-index-url https://download.pytorch.org/whl/cpu
|
||||
- name: Ruff fixes
|
||||
continue-on-error: true
|
||||
run: |
|
||||
ruff check \
|
||||
--fix \
|
||||
--unsafe-fixes \
|
||||
--extend-select F,I,D,UP,RUF,FA \
|
||||
--target-version py39 \
|
||||
--ignore D100,D104,D203,D205,D212,D213,D401,D406,D407,D413,RUF001,RUF002,RUF012 \
|
||||
.
|
||||
- name: Update Docs Reference Section and Push Changes
|
||||
continue-on-error: true
|
||||
run: |
|
||||
git config --global user.name "UltralyticsAssistant"
|
||||
git config --global user.email "web@ultralytics.com"
|
||||
npm install --global prettier prettier-plugin-sh
|
||||
python docs/build_reference.py
|
||||
git pull origin "$GITHUB_REF"
|
||||
git add .
|
||||
git reset HEAD -- .github/workflows/ # workflow changes are not permitted with default token
|
||||
if [[ "${{ github.event_name }}" == "pull_request" ]] && ! git diff --staged --quiet; then
|
||||
git commit -m "Auto-update Ultralytics Docs Reference by https://ultralytics.com/actions"
|
||||
git push
|
||||
else
|
||||
echo "No changes to commit"
|
||||
fi
|
||||
- name: Ruff checks
|
||||
run: |
|
||||
ruff check \
|
||||
--extend-select F,I,D,UP,RUF,FA \
|
||||
--target-version py39 \
|
||||
--ignore D100,D104,D203,D205,D212,D213,D401,D406,D407,D413,RUF001,RUF002,RUF012 \
|
||||
.
|
||||
- name: Build Docs and Check for Warnings
|
||||
run: |
|
||||
python docs/build_docs.py
|
||||
- name: Commit and Push Docs changes
|
||||
continue-on-error: true
|
||||
if: always()
|
||||
run: |
|
||||
git pull origin "$GITHUB_REF"
|
||||
git add --update # only add updated files
|
||||
git reset HEAD -- .github/workflows/ # workflow changes are not permitted with default token
|
||||
if [[ "${{ github.event_name }}" == "pull_request" ]] && ! git diff --staged --quiet; then
|
||||
git commit -m "Auto-update Ultralytics Docs by https://ultralytics.com/actions"
|
||||
git push
|
||||
else
|
||||
echo "No changes to commit"
|
||||
fi
|
||||
- name: Publish Docs to https://docs.ultralytics.com
|
||||
if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.publish_docs == 'true')
|
||||
run: |
|
||||
git clone --depth 1 --branch gh-pages https://github.com/ultralytics/docs.git docs-repo
|
||||
cd docs-repo
|
||||
if [ -f "vercel.json" ]; then
|
||||
cp vercel.json /tmp/vercel.json
|
||||
fi
|
||||
rm -rf *
|
||||
cp -R ../site/* .
|
||||
if [ -f "/tmp/vercel.json" ]; then
|
||||
cp /tmp/vercel.json .
|
||||
fi
|
||||
echo "${{ secrets.INDEXNOW_KEY_DOCS }}" > "${{ secrets.INDEXNOW_KEY_DOCS }}.txt"
|
||||
git add .
|
||||
if git diff --staged --quiet; then
|
||||
echo "No changes to commit"
|
||||
else
|
||||
git pull origin gh-pages
|
||||
LATEST_HASH=$(git rev-parse --short=7 HEAD)
|
||||
git commit -m "Update Docs for 'ultralytics ${{ steps.check_pypi.outputs.version }} - $LATEST_HASH'"
|
||||
git push https://${{ secrets._GITHUB_TOKEN }}@github.com/ultralytics/docs.git gh-pages
|
||||
fi
|
||||
@@ -1,68 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Ultralytics Actions https://github.com/ultralytics/actions
|
||||
# This workflow formats code and documentation in PRs to Ultralytics standards
|
||||
|
||||
name: Ultralytics Actions
|
||||
|
||||
on:
|
||||
issues:
|
||||
types: [opened, edited]
|
||||
discussion:
|
||||
types: [created]
|
||||
pull_request:
|
||||
types: [opened, closed, synchronize, review_requested]
|
||||
|
||||
permissions:
|
||||
contents: write # Modify code in PRs
|
||||
pull-requests: write # Add comments and labels to PRs
|
||||
issues: write # Add comments and labels to issues
|
||||
|
||||
jobs:
|
||||
actions:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Run Ultralytics Actions
|
||||
uses: ultralytics/actions@main
|
||||
with:
|
||||
token: ${{ secrets._GITHUB_TOKEN || secrets.GITHUB_TOKEN }} # Auto-generated token
|
||||
labels: true # Auto-label issues/PRs using AI
|
||||
python: true # Format Python with Ruff and docformatter
|
||||
prettier: true # Format YAML, JSON, Markdown, CSS
|
||||
swift: false # Format Swift (requires macos-latest)
|
||||
spelling: true # Check spelling with codespell
|
||||
links: false # Check broken links with Lychee
|
||||
summary: true # Generate AI-powered PR summaries
|
||||
openai_api_key: ${{ secrets.OPENAI_API_KEY }} # Powers PR summaries, labels and comments
|
||||
brave_api_key: ${{ secrets.BRAVE_API_KEY }} # Used for broken link resolution
|
||||
first_issue_response: |
|
||||
👋 Hello @${{ github.actor }}, thank you for your interest in Ultralytics 🚀! We recommend a visit to the [Docs](https://docs.ultralytics.com/) for new users where you can find many [Python](https://docs.ultralytics.com/usage/python/) and [CLI](https://docs.ultralytics.com/usage/cli/) usage examples and where many of the most common questions may already be answered.
|
||||
|
||||
If this is a 🐛 Bug Report, please provide a [minimum reproducible example](https://docs.ultralytics.com/help/minimum-reproducible-example/) to help us debug it.
|
||||
|
||||
If this is a custom training ❓ Question, please provide as much information as possible, including dataset image examples and training logs, and verify you are following our [Tips for Best Training Results](https://docs.ultralytics.com/guides/model-training-tips/).
|
||||
|
||||
Join the Ultralytics community where it suits you best. For real-time chat, head to [Discord](https://discord.com/invite/ultralytics) 🎧. Prefer in-depth discussions? Check out [Discourse](https://community.ultralytics.com/). Or dive into threads on our [Subreddit](https://www.reddit.com/r/Ultralytics/) to share knowledge with the community.
|
||||
|
||||
## Upgrade
|
||||
|
||||
Upgrade to the latest `ultralytics` package including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/) to verify your issue is not already resolved in the latest version:
|
||||
|
||||
```bash
|
||||
pip install -U ultralytics
|
||||
```
|
||||
|
||||
## Environments
|
||||
|
||||
YOLO may be run in any of the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):
|
||||
|
||||
- **Notebooks** with free GPU: <a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run on Gradient"/></a> <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/models/ultralytics/yolo26"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
|
||||
- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
|
||||
- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
|
||||
- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/) <a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Docker Pulls"></a>
|
||||
|
||||
## Status
|
||||
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml?query=event%3Aschedule"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml/badge.svg" alt="Ultralytics CI"></a>
|
||||
|
||||
If this badge is green, all [Ultralytics CI](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml?query=event%3Aschedule) tests are currently passing. CI tests verify correct operation of all YOLO [Modes](https://docs.ultralytics.com/modes/) and [Tasks](https://docs.ultralytics.com/tasks/) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
|
||||
@@ -1,104 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Continuous Integration (CI) GitHub Actions tests broken link checker using https://github.com/lycheeverse/lychee
|
||||
# Ignores the following status codes to reduce false positives:
|
||||
# - 401(Vimeo, 'unauthorized')
|
||||
# - 403(OpenVINO, 'forbidden')
|
||||
# - 429(Instagram, 'too many requests')
|
||||
# - 500(Zenodo, 'cached')
|
||||
# - 502(Zenodo, 'bad gateway')
|
||||
# - 999(LinkedIn, 'unknown status code')
|
||||
|
||||
name: Check Broken links
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
schedule:
|
||||
- cron: "0 0 * * *" # runs at 00:00 UTC every day
|
||||
|
||||
jobs:
|
||||
Links:
|
||||
if: github.repository == 'ultralytics/ultralytics'
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
|
||||
- name: Install lychee
|
||||
run: curl -sSfL "https://github.com/lycheeverse/lychee/releases/latest/download/lychee-x86_64-unknown-linux-gnu.tar.gz" | sudo tar xz -C /usr/local/bin
|
||||
|
||||
- name: Test Markdown and HTML links with retry
|
||||
uses: ultralytics/actions/retry@main
|
||||
with:
|
||||
timeout_minutes: 60
|
||||
retry_delay_seconds: 1800
|
||||
retries: 2
|
||||
run: |
|
||||
lychee \
|
||||
--scheme https \
|
||||
--timeout 60 \
|
||||
--insecure \
|
||||
--accept 100..=103,200..=299,401,403,429,500,502,999 \
|
||||
--exclude-all-private \
|
||||
--exclude 'https?://(www\.)?(linkedin\.com|twitter\.com|instagram\.com|kaggle\.com|fonts\.gstatic\.com|url\.com)' \
|
||||
--exclude-path docs/zh \
|
||||
--exclude-path docs/es \
|
||||
--exclude-path docs/ru \
|
||||
--exclude-path docs/pt \
|
||||
--exclude-path docs/fr \
|
||||
--exclude-path docs/de \
|
||||
--exclude-path docs/ja \
|
||||
--exclude-path docs/ko \
|
||||
--exclude-path docs/hi \
|
||||
--exclude-path docs/ar \
|
||||
--github-token ${{ secrets.GITHUB_TOKEN }} \
|
||||
--header "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.6478.183 Safari/537.36" \
|
||||
'./**/*.md' \
|
||||
'./**/*.html' | tee -a $GITHUB_STEP_SUMMARY
|
||||
|
||||
# Raise error if broken links found
|
||||
if ! grep -q "0 Errors" $GITHUB_STEP_SUMMARY; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
- name: Test Markdown, HTML, YAML, Python and Notebook links with retry
|
||||
if: github.event_name == 'workflow_dispatch'
|
||||
uses: ultralytics/actions/retry@main
|
||||
with:
|
||||
timeout_minutes: 60
|
||||
retry_delay_seconds: 1800
|
||||
retries: 2
|
||||
run: |
|
||||
lychee \
|
||||
--scheme https \
|
||||
--timeout 60 \
|
||||
--insecure \
|
||||
--accept 100..=103,200..=299,401,403,429,500,502,999 \
|
||||
--exclude-all-private \
|
||||
--exclude 'https?://(www\.)?(linkedin\.com|twitter\.com|instagram\.com|kaggle\.com|fonts\.gstatic\.com|url\.com)' \
|
||||
--exclude-path './**/ci.yml' \
|
||||
--exclude-path docs/zh \
|
||||
--exclude-path docs/es \
|
||||
--exclude-path docs/ru \
|
||||
--exclude-path docs/pt \
|
||||
--exclude-path docs/fr \
|
||||
--exclude-path docs/de \
|
||||
--exclude-path docs/ja \
|
||||
--exclude-path docs/ko \
|
||||
--exclude-path docs/hi \
|
||||
--exclude-path docs/ar \
|
||||
--github-token ${{ secrets.GITHUB_TOKEN }} \
|
||||
--header "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.6478.183 Safari/537.36" \
|
||||
'./**/*.md' \
|
||||
'./**/*.html' \
|
||||
'./**/*.yml' \
|
||||
'./**/*.yaml' \
|
||||
'./**/*.py' \
|
||||
'./**/*.ipynb' | tee -a $GITHUB_STEP_SUMMARY
|
||||
|
||||
# Raise error if broken links found
|
||||
if ! grep -q "0 Errors" $GITHUB_STEP_SUMMARY; then
|
||||
exit 1
|
||||
fi
|
||||
@@ -1,91 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Automatically merges repository 'main' branch into all open PRs to keep them up-to-date
|
||||
# Action runs on updates to main branch so when one PR merges to main all others update
|
||||
|
||||
name: Merge main into PRs
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
# push:
|
||||
# branches:
|
||||
# - ${{ github.event.repository.default_branch }}
|
||||
|
||||
permissions:
|
||||
contents: write # Modify code in PRs
|
||||
|
||||
jobs:
|
||||
Merge:
|
||||
if: github.repository == 'ultralytics/ultralytics'
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v6
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: "3.x"
|
||||
cache: "pip"
|
||||
- name: Install requirements
|
||||
run: |
|
||||
pip install pygithub
|
||||
- name: Merge default branch into PRs
|
||||
shell: python
|
||||
run: |
|
||||
from github import Github
|
||||
import os
|
||||
import time
|
||||
|
||||
g = Github("${{ secrets._GITHUB_TOKEN }}")
|
||||
repo = g.get_repo("${{ github.repository }}")
|
||||
|
||||
# Fetch the default branch name
|
||||
default_branch_name = repo.default_branch
|
||||
default_branch = repo.get_branch(default_branch_name)
|
||||
|
||||
# Initialize counters
|
||||
updated_branches = 0
|
||||
up_to_date_branches = 0
|
||||
errors = 0
|
||||
|
||||
for pr in repo.get_pulls(state='open', sort='created'):
|
||||
try:
|
||||
# Label PRs as popular for positive reactions
|
||||
reactions = pr.as_issue().get_reactions()
|
||||
if sum([(1 if r.content not in {"-1", "confused"} else 0) for r in reactions]) > 5:
|
||||
pr.set_labels(*("popular",) + tuple(l.name for l in pr.get_labels()))
|
||||
|
||||
# Get full names for repositories and branches
|
||||
base_repo_name = repo.full_name
|
||||
head_repo_name = pr.head.repo.full_name
|
||||
base_branch_name = pr.base.ref
|
||||
head_branch_name = pr.head.ref
|
||||
|
||||
# Check if PR is behind the default branch
|
||||
comparison = repo.compare(default_branch.commit.sha, pr.head.sha)
|
||||
if comparison.behind_by > 0:
|
||||
print(f"⚠️ PR #{pr.number} ({head_repo_name}:{head_branch_name} -> {base_repo_name}:{base_branch_name}) is behind {default_branch_name} by {comparison.behind_by} commit(s).")
|
||||
|
||||
# Attempt to update the branch
|
||||
try:
|
||||
success = pr.update_branch()
|
||||
assert success, "Branch update failed"
|
||||
print(f"✅ Successfully merged '{default_branch_name}' into PR #{pr.number} ({head_repo_name}:{head_branch_name} -> {base_repo_name}:{base_branch_name}).")
|
||||
updated_branches += 1
|
||||
time.sleep(10) # rate limit merges
|
||||
except Exception as update_error:
|
||||
print(f"❌ Could not update PR #{pr.number} ({head_repo_name}:{head_branch_name} -> {base_repo_name}:{base_branch_name}): {update_error}")
|
||||
errors += 1
|
||||
else:
|
||||
print(f"✅ PR #{pr.number} ({head_repo_name}:{head_branch_name} -> {base_repo_name}:{base_branch_name}) is already up to date with {default_branch_name}, no merge required.")
|
||||
up_to_date_branches += 1
|
||||
except Exception as e:
|
||||
print(f"❌ Could not process PR #{pr.number}: {e}")
|
||||
errors += 1
|
||||
|
||||
# Print summary
|
||||
print("\n\nSummary:")
|
||||
print(f"Branches updated: {updated_branches}")
|
||||
print(f"Branches already up-to-date: {up_to_date_branches}")
|
||||
print(f"Total errors: {errors}")
|
||||
@@ -1,46 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# This action mirrors the Ultralytics repository to other platforms like GitLab.
|
||||
# It runs only when the main branch is updated by the repository owner.
|
||||
# Additional platforms can be added by uncommenting the relevant sections.
|
||||
|
||||
name: Mirror Repository
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
on:
|
||||
# push:
|
||||
# branches:
|
||||
# - main
|
||||
workflow_dispatch:
|
||||
|
||||
jobs:
|
||||
mirror:
|
||||
runs-on: ubuntu-latest
|
||||
if: github.repository == 'ultralytics/ultralytics' && github.actor == 'glenn-jocher'
|
||||
steps:
|
||||
- name: Checkout Source Repository (${{ github.repository }})
|
||||
uses: actions/checkout@v6
|
||||
with:
|
||||
fetch-depth: 0 # Fetch all history for mirroring
|
||||
- name: Run Git Config
|
||||
run: |
|
||||
git config --global user.name "UltralyticsAssistant"
|
||||
git config --global user.email "web@ultralytics.com"
|
||||
- name: Push to DagsHub
|
||||
run: |
|
||||
git remote add dagshub https://glenn-jocher:${{ secrets.DAGSHUB_TOKEN }}@dagshub.com/Ultralytics/ultralytics.git
|
||||
git push dagshub main --force
|
||||
# - name: Push to Gitee
|
||||
# run: |
|
||||
# git remote add gitee https://ultralytics:${{ secrets.GITEE_TOKEN }}@gitee.com/ultralytics/ultralytics.git
|
||||
# git push gitee main --force
|
||||
# - name: Push to GitCode
|
||||
# run: |
|
||||
# git remote add gitcode https://ultralytics:${{ secrets.GITCODE_TOKEN }}@gitcode.net/ultralytics/ultralytics.git
|
||||
# git push gitcode main --force
|
||||
# - name: Push to Bitbucket
|
||||
# run: |
|
||||
# git remote add bitbucket https://ultralytics:${{ secrets.BITBUCKET_APP_PASSWORD }}@bitbucket.org/ultralytics/ultralytics.git
|
||||
# git push bitbucket main --force
|
||||
@@ -1,167 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Publish pip package to PyPI https://pypi.org/project/ultralytics/
|
||||
|
||||
name: Publish to PyPI
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
pypi:
|
||||
type: boolean
|
||||
description: Publish to PyPI
|
||||
|
||||
jobs:
|
||||
check:
|
||||
if: github.repository == 'ultralytics/ultralytics' && github.actor == 'glenn-jocher'
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
contents: write
|
||||
outputs:
|
||||
increment: ${{ steps.check_pypi.outputs.increment }}
|
||||
current_tag: ${{ steps.check_pypi.outputs.current_tag }}
|
||||
previous_tag: ${{ steps.check_pypi.outputs.previous_tag }}
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: "3.x"
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- run: uv pip install --system --no-cache ultralytics-actions
|
||||
- id: check_pypi
|
||||
shell: python
|
||||
run: |
|
||||
import os
|
||||
from actions.utils import check_pypi_version
|
||||
local_version, online_version, publish = check_pypi_version()
|
||||
os.system(f'echo "increment={publish}" >> $GITHUB_OUTPUT')
|
||||
os.system(f'echo "current_tag=v{local_version}" >> $GITHUB_OUTPUT')
|
||||
os.system(f'echo "previous_tag=v{online_version}" >> $GITHUB_OUTPUT')
|
||||
if publish:
|
||||
print('Ready to publish new version to PyPI ✅.')
|
||||
- name: Tag and Release
|
||||
if: steps.check_pypi.outputs.increment == 'True'
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
CURRENT_TAG: ${{ steps.check_pypi.outputs.current_tag }}
|
||||
PREVIOUS_TAG: ${{ steps.check_pypi.outputs.previous_tag }}
|
||||
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
|
||||
run: |
|
||||
git config --global user.name "UltralyticsAssistant"
|
||||
git config --global user.email "web@ultralytics.com"
|
||||
git tag -a "$CURRENT_TAG" -m "$(git log -1 --pretty=%B)"
|
||||
git push origin "$CURRENT_TAG"
|
||||
ultralytics-actions-summarize-release
|
||||
uv cache prune --ci
|
||||
|
||||
build:
|
||||
needs: check
|
||||
if: needs.check.outputs.increment == 'True'
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
contents: read
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: "3.x"
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- run: uv pip install --system --no-cache build
|
||||
- name: Build ultralytics
|
||||
run: python -m build --outdir dist/
|
||||
- name: Build ultralytics-opencv-headless
|
||||
run: |
|
||||
python - <<'PY'
|
||||
from pathlib import Path
|
||||
|
||||
path = Path("pyproject.toml")
|
||||
text = path.read_text()
|
||||
text = text.replace('name = "ultralytics"', 'name = "ultralytics-opencv-headless"', 1)
|
||||
text = text.replace('"opencv-python>=', '"opencv-python-headless>=', 1)
|
||||
path.write_text(text)
|
||||
PY
|
||||
python -m build --outdir dist/
|
||||
git checkout pyproject.toml
|
||||
- uses: actions/upload-artifact@v6
|
||||
with:
|
||||
name: dist
|
||||
path: dist/
|
||||
- run: uv cache prune --ci
|
||||
|
||||
publish:
|
||||
needs: [check, build]
|
||||
if: needs.check.outputs.increment == 'True'
|
||||
runs-on: ubuntu-latest
|
||||
environment: # for GitHub Deployments tab
|
||||
name: Release - PyPI
|
||||
url: https://pypi.org/p/ultralytics
|
||||
permissions:
|
||||
id-token: write # for PyPI trusted publishing
|
||||
steps:
|
||||
- uses: actions/download-artifact@v7
|
||||
with:
|
||||
name: dist
|
||||
path: dist/
|
||||
- uses: pypa/gh-action-pypi-publish@release/v1
|
||||
|
||||
sbom:
|
||||
needs: [check, build, publish]
|
||||
if: needs.check.outputs.increment == 'True'
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
contents: write
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: "3.x"
|
||||
- uses: astral-sh/setup-uv@v7
|
||||
- run: |
|
||||
uv venv sbom-env
|
||||
uv pip install -e .
|
||||
env:
|
||||
VIRTUAL_ENV: sbom-env
|
||||
- uses: anchore/sbom-action@v0
|
||||
with:
|
||||
format: spdx-json
|
||||
output-file: sbom.spdx.json
|
||||
path: sbom-env
|
||||
- run: gh release upload ${{ needs.check.outputs.current_tag }} sbom.spdx.json
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
notify:
|
||||
needs: [check, publish]
|
||||
if: always() && needs.check.outputs.increment == 'True'
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
contents: read
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- name: Extract PR Details
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: |
|
||||
PR_JSON=$(gh pr list --search "${GITHUB_SHA}" --state merged --json number,title --jq '.[0]')
|
||||
PR_NUMBER=$(echo "${PR_JSON}" | jq -r '.number')
|
||||
PR_TITLE=$(echo "${PR_JSON}" | jq -r '.title' | sed 's/"/\\"/g')
|
||||
echo "PR_NUMBER=${PR_NUMBER}" >> "${GITHUB_ENV}"
|
||||
echo "PR_TITLE=${PR_TITLE}" >> "${GITHUB_ENV}"
|
||||
- name: Notify Success
|
||||
if: needs.publish.result == 'success' && github.event_name == 'push'
|
||||
uses: slackapi/slack-github-action@v2.1.1
|
||||
with:
|
||||
webhook-type: incoming-webhook
|
||||
webhook: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
|
||||
payload: |
|
||||
text: "<!channel> GitHub Actions success for ${{ github.workflow }} ✅\n\n\n*Repository:* https://github.com/${{ github.repository }}\n*Action:* https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}\n*Author:* ${{ github.actor }}\n*Event:* NEW `${{ github.repository }} ${{ needs.check.outputs.current_tag }}` pip package published 😃\n*Job Status:* ${{ job.status }}\n*Pull Request:* <https://github.com/${{ github.repository }}/pull/${{ env.PR_NUMBER }}> ${{ env.PR_TITLE }}\n"
|
||||
- name: Notify Failure
|
||||
if: needs.publish.result != 'success'
|
||||
uses: slackapi/slack-github-action@v2.1.1
|
||||
with:
|
||||
webhook-type: incoming-webhook
|
||||
webhook: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
|
||||
payload: |
|
||||
text: "<!channel> GitHub Actions error for ${{ github.workflow }} ❌\n\n\n*Repository:* https://github.com/${{ github.repository }}\n*Action:* https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}\n*Author:* ${{ github.actor }}\n*Event:* ${{ github.event_name }}\n*Job Status:* ${{ job.status }}\n*Pull Request:* <https://github.com/${{ github.repository }}/pull/${{ env.PR_NUMBER }}> ${{ env.PR_TITLE }}\n"
|
||||
@@ -1,55 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
name: Close stale issues
|
||||
on:
|
||||
schedule:
|
||||
- cron: "0 0 * * *" # Runs at 00:00 UTC every day
|
||||
|
||||
permissions:
|
||||
pull-requests: write
|
||||
issues: write
|
||||
|
||||
jobs:
|
||||
stale:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/stale@v10
|
||||
with:
|
||||
repo-token: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
stale-issue-message: |
|
||||
👋 Hello there! We wanted to give you a friendly reminder that this issue has not had any recent activity and may be closed soon, but don't worry - you can always reopen it if needed. If you still have any questions or concerns, please feel free to let us know how we can help.
|
||||
|
||||
For additional resources and information, please see the links below:
|
||||
|
||||
- **Docs**: https://docs.ultralytics.com
|
||||
- **Platform**: https://platform.ultralytics.com/ultralytics/yolo26
|
||||
- **Community**: https://community.ultralytics.com
|
||||
|
||||
Feel free to inform us of any other **issues** you discover or **feature requests** that come to mind in the future. Pull Requests (PRs) are also always welcomed!
|
||||
|
||||
Thank you for your contributions to YOLO 🚀 and Vision AI ⭐
|
||||
|
||||
stale-pr-message: |
|
||||
👋 Hello there! We wanted to let you know that we've decided to close this pull request due to inactivity. We appreciate the effort you put into contributing to our project, but unfortunately, not all contributions are suitable or aligned with our product roadmap.
|
||||
|
||||
We hope you understand our decision, and please don't let it discourage you from contributing to open source projects in the future. We value all of our community members and their contributions, and we encourage you to keep exploring new projects and ways to get involved.
|
||||
|
||||
For additional resources and information, please see the links below:
|
||||
|
||||
- **Docs**: https://docs.ultralytics.com
|
||||
- **Platform**: https://platform.ultralytics.com/ultralytics/yolo26
|
||||
- **Community**: https://community.ultralytics.com
|
||||
|
||||
Thank you for your contributions to YOLO 🚀 and Vision AI ⭐
|
||||
|
||||
ignore-pr-updates: true
|
||||
remove-pr-stale-when-updated: false
|
||||
exempt-all-assignees: true
|
||||
days-before-issue-stale: 30
|
||||
days-before-issue-close: 10
|
||||
days-before-pr-stale: 90
|
||||
days-before-pr-close: 30
|
||||
exempt-issue-labels: "documentation,tutorial,TODO"
|
||||
exempt-pr-labels: "TODO"
|
||||
operations-per-run: 300 # The maximum number of operations per run, used to control rate limiting.
|
||||
205
algorithms/dms_yolo/code.embedded.bak/.gitignore
vendored
205
algorithms/dms_yolo/code.embedded.bak/.gitignore
vendored
@@ -1,205 +0,0 @@
|
||||
# Byte-compiled / optimized / DLL files
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
*$py.class
|
||||
|
||||
# C extensions
|
||||
*.so
|
||||
|
||||
# Distribution / packaging
|
||||
.Python
|
||||
build/
|
||||
develop-eggs/
|
||||
dist/
|
||||
downloads/
|
||||
eggs/
|
||||
.eggs/
|
||||
lib/
|
||||
lib64/
|
||||
parts/
|
||||
sdist/
|
||||
var/
|
||||
wheels/
|
||||
pip-wheel-metadata/
|
||||
share/python-wheels/
|
||||
*.egg-info/
|
||||
.installed.cfg
|
||||
*.egg
|
||||
MANIFEST
|
||||
requirements.txt
|
||||
!examples/**/requirements.txt
|
||||
setup.py
|
||||
ultralytics.egg-info
|
||||
|
||||
# PyInstaller
|
||||
# Usually these files are written by a python script from a template
|
||||
# before PyInstaller builds the exe, so as to inject date/other info into it.
|
||||
*.manifest
|
||||
*.spec
|
||||
|
||||
# Installer logs
|
||||
pip-log.txt
|
||||
pip-delete-this-directory.txt
|
||||
|
||||
# Unit test / coverage reports
|
||||
htmlcov/
|
||||
.tox/
|
||||
.nox/
|
||||
.coverage
|
||||
.coverage.*
|
||||
.cache
|
||||
nosetests.xml
|
||||
coverage.xml
|
||||
*.cover
|
||||
*.py,cover
|
||||
.hypothesis/
|
||||
.pytest_cache/
|
||||
mlruns/
|
||||
|
||||
# Translations
|
||||
*.mo
|
||||
*.pot
|
||||
|
||||
# Django stuff:
|
||||
*.log
|
||||
local_settings.py
|
||||
db.sqlite3
|
||||
db.sqlite3-journal
|
||||
|
||||
# Flask stuff:
|
||||
instance/
|
||||
.webassets-cache
|
||||
|
||||
# Scrapy stuff:
|
||||
.scrapy
|
||||
|
||||
# Sphinx documentation
|
||||
docs/_build/
|
||||
|
||||
# PyBuilder
|
||||
target/
|
||||
|
||||
# Jupyter Notebook
|
||||
.ipynb_checkpoints
|
||||
|
||||
# IPython
|
||||
profile_default/
|
||||
ipython_config.py
|
||||
|
||||
# Profiling
|
||||
*.pclprof
|
||||
|
||||
# pyenv
|
||||
.python-version
|
||||
|
||||
# pipenv
|
||||
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
|
||||
# However, in case of collaboration, if having platform-specific dependencies or dependencies
|
||||
# having no cross-platform support, pipenv may install dependencies that don't work, or not
|
||||
# install all needed dependencies.
|
||||
#Pipfile.lock
|
||||
|
||||
# UV
|
||||
# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
|
||||
# This is especially recommended for binary packages to ensure reproducibility, and is more
|
||||
# commonly ignored for libraries.
|
||||
uv.lock
|
||||
|
||||
# PEP 582; used by e.g. github.com/David-OConnor/pyflow
|
||||
__pypackages__/
|
||||
|
||||
# Celery stuff
|
||||
celerybeat-schedule
|
||||
celerybeat.pid
|
||||
|
||||
# SageMath parsed files
|
||||
*.sage.py
|
||||
|
||||
# Environments
|
||||
.env
|
||||
.venv
|
||||
.idea
|
||||
env/
|
||||
venv/
|
||||
ENV/
|
||||
env.bak/
|
||||
venv.bak/
|
||||
|
||||
# Spyder project settings
|
||||
.spyderproject
|
||||
.spyproject
|
||||
|
||||
# VSCode project settings
|
||||
.vscode/
|
||||
.devcontainer/
|
||||
|
||||
# Rope project settings
|
||||
.ropeproject
|
||||
|
||||
# mkdocs documentation
|
||||
/site
|
||||
|
||||
# mypy
|
||||
.mypy_cache/
|
||||
.dmypy.json
|
||||
dmypy.json
|
||||
|
||||
# Pyre type checker
|
||||
.pyre/
|
||||
|
||||
# datasets and projects (ignore /datasets dir at root only to allow for docs/en/datasets dir)
|
||||
/datasets
|
||||
runs/
|
||||
wandb/
|
||||
.DS_Store
|
||||
|
||||
# Neural Network weights -----------------------------------------------------------------------------------------------
|
||||
weights/
|
||||
*.weights
|
||||
*.pt
|
||||
*.ts
|
||||
*.pb
|
||||
*.onnx
|
||||
*.engine
|
||||
*.mlmodel
|
||||
*.mlpackage
|
||||
*.torchscript
|
||||
*.tflite
|
||||
*.h5
|
||||
*.mnn
|
||||
*_saved_model/
|
||||
*_web_model/
|
||||
*_openvino_model/
|
||||
*_paddle_model/
|
||||
*_ncnn_model/
|
||||
*_imx_model/
|
||||
pnnx*
|
||||
*.rknn
|
||||
|
||||
# Autogenerated files for tests
|
||||
/ultralytics/assets/
|
||||
|
||||
# calibration image
|
||||
calibration_*.npy
|
||||
|
||||
# Videos and Pictures
|
||||
*.mp4
|
||||
*.avi
|
||||
*.mov
|
||||
*.mkv
|
||||
*.webm
|
||||
*.jpg
|
||||
*.jpeg
|
||||
*.png
|
||||
*.bmp
|
||||
*.tiff
|
||||
*.gif
|
||||
*.svg
|
||||
*.webp
|
||||
*.heic
|
||||
*.ico
|
||||
*.raw
|
||||
|
||||
# Training logs
|
||||
args.yaml
|
||||
results.csv
|
||||
@@ -1,26 +0,0 @@
|
||||
# This CITATION.cff file was generated with https://bit.ly/cffinit
|
||||
|
||||
cff-version: 1.2.0
|
||||
title: Ultralytics YOLO
|
||||
message: >-
|
||||
If you use this software, please cite it using the
|
||||
metadata from this file.
|
||||
type: software
|
||||
authors:
|
||||
- given-names: Glenn
|
||||
family-names: Jocher
|
||||
affiliation: Ultralytics
|
||||
orcid: "https://orcid.org/0000-0001-5950-6979"
|
||||
- family-names: Qiu
|
||||
given-names: Jing
|
||||
affiliation: Ultralytics
|
||||
orcid: "https://orcid.org/0000-0003-3783-7069"
|
||||
- given-names: Ayush
|
||||
family-names: Chaurasia
|
||||
affiliation: Ultralytics
|
||||
orcid: "https://orcid.org/0000-0002-7603-6750"
|
||||
repository-code: "https://github.com/ultralytics/ultralytics"
|
||||
url: "https://ultralytics.com"
|
||||
license: AGPL-3.0
|
||||
version: 8.0.0
|
||||
date-released: "2023-01-10"
|
||||
@@ -1,267 +0,0 @@
|
||||
<a href="https://www.ultralytics.com/" target="_blank"><img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320" alt="Ultralytics logo"></a>
|
||||
|
||||
# Contributing to Ultralytics Open-Source Projects
|
||||
|
||||
Welcome! We're thrilled that you're considering contributing to our [Ultralytics](https://www.ultralytics.com/) [open-source](https://github.com/ultralytics) projects. Your involvement not only helps enhance the quality of our repositories but also benefits the entire [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. This guide provides clear guidelines and best practices to help you get started.
|
||||
|
||||
[](https://github.com/ultralytics/ultralytics/graphs/contributors)
|
||||
|
||||
## 🤝 Code of Conduct
|
||||
|
||||
To ensure a welcoming and inclusive environment for everyone, all contributors must adhere to our [Code of Conduct](https://docs.ultralytics.com/help/code-of-conduct/). **Respect**, **kindness**, and **professionalism** are at the heart of our community.
|
||||
|
||||
## 🚀 Contributing via Pull Requests
|
||||
|
||||
We greatly appreciate contributions in the form of [pull requests (PRs)](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests). To make the review process as smooth as possible, please follow these steps:
|
||||
|
||||
1. **[Fork the repository](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo):** Start by forking the relevant Ultralytics repository (e.g., [ultralytics/ultralytics](https://github.com/ultralytics/ultralytics)) to your GitHub account.
|
||||
2. **[Create a branch](https://docs.github.com/en/desktop/making-changes-in-a-branch/managing-branches-in-github-desktop):** Create a new branch in your forked repository with a clear, descriptive name reflecting your changes (e.g., `fix-issue-123`, `add-feature-xyz`).
|
||||
3. **Make your changes:** Implement your improvements or fixes. Ensure your code adheres to the project's style guidelines and doesn't introduce new errors or warnings.
|
||||
4. **Test your changes:** Before submitting, test your changes locally to confirm they work as expected and don't cause [regressions](https://en.wikipedia.org/wiki/Software_regression). Add tests if you're introducing new functionality.
|
||||
5. **[Commit your changes](https://docs.github.com/en/desktop/making-changes-in-a-branch/committing-and-reviewing-changes-to-your-project-in-github-desktop):** Commit your changes with concise and descriptive commit messages. If your changes address a specific issue, include the issue number (e.g., `Fix #123: Corrected calculation error.`).
|
||||
6. **[Create a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request):** Submit a pull request from your branch to the `main` branch of the original Ultralytics repository. Provide a clear title and a detailed description explaining the purpose and scope of your changes.
|
||||
|
||||
### 📏 Contribution Scope & PR Size Guidelines
|
||||
|
||||
#### First-time Contributors
|
||||
|
||||
First-time contributors are expected to submit small, well-scoped pull requests. Large PRs (more than ~50 lines of change) are generally not accepted at this stage, except when the size is driven primarily by docstrings, documentation, or formatting rather than substantive code changes. Contributions should focus on speed improvements, bug fixes, documentation updates, and other minor issues. Feature PRs are not encouraged for first-time contributors. However, if you still wish to contribute a feature, follow the guidelines outlined in the [Feature PRs](#feature-prs) section below.
|
||||
|
||||
#### Established Contributors
|
||||
|
||||
Pull requests from established contributors generally receive higher review priority. Actions and results are fundamental to the [Ultralytics Mission & Values](https://handbook.ultralytics.com/mission-vision-values/). There is no specific threshold to becoming an 'established contributor' as it's impossible to fit all individuals to the same standard. The Ultralytics Team notices those who make consistent, high-quality contributions that follow the Ultralytics standards.
|
||||
|
||||
Following our [contributing guidelines](./CONTRIBUTING.md) and [our Development Workflow](https://handbook.ultralytics.com/workflows/development/) is the best way to improve your chances for your work to be reviewed, accepted, and/or recognized; this is not a guarantee. In addition, contributors with a strong track record of meaningful contributions to notable open-source projects may be treated as established contributors, even if they are technically first-time contributors to Ultralytics.
|
||||
|
||||
#### Feature PRs
|
||||
|
||||
Feature pull requests must be preceded by a feature request GitHub issue that has been sufficiently discussed and explicitly approved by the maintainers. This process helps avoid unnecessary effort on changes that are unlikely to be merged. Even after approval, feature PRs are expected to remain well-scoped and focused. All feature contributions are evaluated with attention to long-term maintenance costs and their overall usefulness to the Ultralytics user base.
|
||||
|
||||
#### PR Size and Review Time
|
||||
|
||||
The larger the proposed changes to the code, the longer the review process will take. Smaller, narrowly-scoped PRs that align with the style and structure of the Ultralytics codebase have significantly higher likelihood of timely review and merge.
|
||||
|
||||
### 📝 CLA Signing
|
||||
|
||||
Before we can merge your pull request, you must sign our [Contributor License Agreement (CLA)](https://docs.ultralytics.com/help/CLA/). This legal agreement ensures that your contributions are properly licensed, allowing the project to continue being distributed under the [AGPL-3.0 license](https://www.ultralytics.com/legal/agpl-3-0-software-license).
|
||||
|
||||
After submitting your pull request, the CLA bot will guide you through the signing process. To sign the CLA, simply add a comment in your PR stating:
|
||||
|
||||
```text
|
||||
I have read the CLA Document and I sign the CLA
|
||||
```
|
||||
|
||||
### ✍️ Google-Style Docstrings
|
||||
|
||||
When adding new functions or classes, please include [Google-style docstrings](https://google.github.io/styleguide/pyguide.html). These docstrings provide clear, standardized documentation that helps other developers understand and maintain your code.
|
||||
|
||||
#### Example Google-style
|
||||
|
||||
This example illustrates a Google-style docstring. Ensure that both input and output `types` are always enclosed in parentheses, e.g., `(bool)`.
|
||||
|
||||
```python
|
||||
def example_function(arg1, arg2=4):
|
||||
"""Example function demonstrating Google-style docstrings.
|
||||
|
||||
Args:
|
||||
arg1 (int): The first argument.
|
||||
arg2 (int): The second argument, with a default value of 4.
|
||||
|
||||
Returns:
|
||||
(bool): True if successful, False otherwise.
|
||||
|
||||
Examples:
|
||||
>>> result = example_function(1, 2) # returns False
|
||||
"""
|
||||
if arg1 == arg2:
|
||||
return True
|
||||
return False
|
||||
```
|
||||
|
||||
#### Example Google-style with type hints
|
||||
|
||||
This example includes both a Google-style docstring and [type hints](https://docs.python.org/3/library/typing.html) for arguments and returns, though using either independently is also acceptable.
|
||||
|
||||
```python
|
||||
def example_function(arg1: int, arg2: int = 4) -> bool:
|
||||
"""Example function demonstrating Google-style docstrings.
|
||||
|
||||
Args:
|
||||
arg1: The first argument.
|
||||
arg2: The second argument, with a default value of 4.
|
||||
|
||||
Returns:
|
||||
True if successful, False otherwise.
|
||||
|
||||
Examples:
|
||||
>>> result = example_function(1, 2) # returns False
|
||||
"""
|
||||
if arg1 == arg2:
|
||||
return True
|
||||
return False
|
||||
```
|
||||
|
||||
#### Example Single-line
|
||||
|
||||
For smaller or simpler functions, a single-line docstring may be sufficient. The docstring must use three double-quotes, be a complete sentence, start with a capital letter, and end with a period.
|
||||
|
||||
```python
|
||||
def example_small_function(arg1: int, arg2: int = 4) -> bool:
|
||||
"""Example function with a single-line docstring."""
|
||||
return arg1 == arg2
|
||||
```
|
||||
|
||||
### ✅ GitHub Actions CI Tests
|
||||
|
||||
All pull requests must pass the [GitHub Actions](https://github.com/features/actions) [Continuous Integration](https://docs.ultralytics.com/help/CI/) (CI) tests before they can be merged. These tests include linting, unit tests, and other checks to ensure that your changes meet the project's quality standards. Review the CI output and address any issues that arise.
|
||||
|
||||
## ✨ Best Practices for Code Contributions
|
||||
|
||||
When contributing code to Ultralytics projects, keep these best practices in mind:
|
||||
|
||||
- **Avoid code duplication:** Reuse existing code wherever possible and minimize unnecessary arguments.
|
||||
- **Make smaller, focused changes:** Focus on targeted modifications rather than large-scale changes. Smaller, narrow-scope pull requests are easier to review, less error-prone, and have a higher chance of being merged.
|
||||
- **Simplify when possible:** Look for opportunities to simplify the code or remove unnecessary parts.
|
||||
- **Consider compatibility:** Before making changes, consider whether they might break existing code using Ultralytics.
|
||||
- **Use consistent formatting:** Tools like [Ruff Formatter](https://github.com/astral-sh/ruff) can help maintain stylistic consistency.
|
||||
- **Add appropriate tests:** Include [tests](https://docs.ultralytics.com/guides/model-testing/) for new features to ensure they work as expected. New tests should be added to existing test files rather than creating new test files. Tests do not need to be exhaustive, but must be able to reasonably confirm correct behavior and detect regressions.
|
||||
|
||||
## 👀 Reviewing Pull Requests
|
||||
|
||||
Reviewing pull requests is another valuable way to contribute. When reviewing PRs:
|
||||
|
||||
- **Check for unit tests:** Verify that the PR includes tests for new features or changes.
|
||||
- **Review documentation updates:** Ensure [documentation](https://docs.ultralytics.com/) is updated to reflect changes.
|
||||
- **Evaluate performance impact:** Consider how changes might affect [performance](https://docs.ultralytics.com/guides/yolo-performance-metrics/).
|
||||
- **Verify CI tests:** Confirm all [Continuous Integration tests](https://docs.ultralytics.com/help/CI/) are passing.
|
||||
- **Provide constructive feedback:** Offer specific, clear feedback about any issues or concerns.
|
||||
- **Recognize effort:** Acknowledge the author's work to maintain a positive collaborative atmosphere.
|
||||
|
||||
### 🤖 Automated Review
|
||||
|
||||
All pull requests undergo an automatic review by Ultralytics Assistant. Each suggestion from Ultralytics Assistant includes an associated level of importance. Contributors are expected to review all suggestions and either apply them or explicitly explain in a PR comment why a given suggestion is not applicable or should not be adopted.
|
||||
|
||||
If needed, you may re-request a review from Ultralytics Assistant via the GitHub reviewers panel.
|
||||
|
||||
## 🐞 Reporting Bugs
|
||||
|
||||
We highly value bug reports as they help us improve the quality and reliability of our projects. When reporting a bug via [GitHub Issues](https://github.com/ultralytics/ultralytics/issues):
|
||||
|
||||
- **Check existing issues:** Search first to see if the bug has already been reported.
|
||||
- **Provide a [Minimum Reproducible Example](https://docs.ultralytics.com/help/minimum-reproducible-example/):** Create a small, self-contained code snippet that consistently reproduces the issue. This is crucial for efficient debugging.
|
||||
- **Describe the environment:** Specify your operating system, Python version, relevant library versions (e.g., [`torch`](https://pytorch.org/), [`ultralytics`](https://github.com/ultralytics/ultralytics)), and hardware ([CPU](https://en.wikipedia.org/wiki/Central_processing_unit)/[GPU](https://www.ultralytics.com/glossary/gpu-graphics-processing-unit)).
|
||||
- **Explain expected vs. actual behavior:** Clearly state what you expected to happen and what actually occurred. Include any error messages or tracebacks.
|
||||
|
||||
## 📜 License
|
||||
|
||||
Ultralytics uses the [GNU Affero General Public License v3.0 (AGPL-3.0)](https://www.ultralytics.com/legal/agpl-3-0-software-license) for its repositories. This license promotes [openness](https://en.wikipedia.org/wiki/Openness), [transparency](https://www.ultralytics.com/glossary/transparency-in-ai), and [collaborative improvement](https://en.wikipedia.org/wiki/Collaborative_software) in software development. It ensures that all users have the freedom to use, modify, and share the software, fostering a strong community of collaboration and innovation.
|
||||
|
||||
We encourage all contributors to familiarize themselves with the terms of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3) to contribute effectively and ethically to the Ultralytics open-source community.
|
||||
|
||||
## 🌍 Open-Sourcing Your YOLO Project Under AGPL-3.0
|
||||
|
||||
Using Ultralytics YOLO models or code in your project? The [AGPL-3.0 license](https://opensource.org/license/agpl-v3) requires that your entire derivative work also be open-sourced under AGPL-3.0. This ensures modifications and larger projects built upon open-source foundations remain open.
|
||||
|
||||
### Why AGPL-3.0 Compliance Matters
|
||||
|
||||
- **Keeps Software Open:** Ensures that improvements and derivative works benefit the community.
|
||||
- **Legal Requirement:** Using AGPL-3.0 licensed code binds your project to its terms.
|
||||
- **Fosters Collaboration:** Encourages sharing and transparency.
|
||||
|
||||
If you prefer not to open-source your project, consider obtaining an [Enterprise License](https://www.ultralytics.com/license).
|
||||
|
||||
### How to Comply with AGPL-3.0
|
||||
|
||||
Complying means making the **complete corresponding source code** of your project publicly available under the AGPL-3.0 license.
|
||||
|
||||
1. **Choose Your Starting Point:**
|
||||
- **Fork Ultralytics YOLO:** Directly fork the [Ultralytics YOLO repository](https://github.com/ultralytics/ultralytics) if building closely upon it.
|
||||
- **Use Ultralytics Template:** Start with the [Ultralytics template repository](https://github.com/ultralytics/template) for a clean, modular setup integrating YOLO.
|
||||
|
||||
2. **License Your Project:**
|
||||
- Add a `LICENSE` file containing the full text of the [AGPL-3.0 license](https://opensource.org/license/agpl-v3).
|
||||
- Add a notice at the top of each source file indicating the license.
|
||||
|
||||
3. **Publish Your Source Code:**
|
||||
- Make your **entire project's source code** publicly accessible (e.g., on GitHub). This includes:
|
||||
- The complete larger application or system that incorporates the YOLO model or code.
|
||||
- Any modifications made to the original Ultralytics YOLO code.
|
||||
- Scripts for training, validation, inference.
|
||||
- [Model weights](https://www.ultralytics.com/glossary/model-weights) if modified or fine-tuned.
|
||||
- [Configuration files](https://docs.ultralytics.com/usage/cfg/), environment setups (`requirements.txt`, [`Dockerfiles`](https://docs.docker.com/reference/dockerfile/)).
|
||||
- Backend and frontend code if it's part of a [web application](https://en.wikipedia.org/wiki/Web_application).
|
||||
- Any [third-party libraries](<https://en.wikipedia.org/wiki/Library_(computing)#Third-party>) you've modified.
|
||||
- [Training data](https://www.ultralytics.com/glossary/training-data) if required to run/retrain _and_ redistributable.
|
||||
|
||||
4. **Document Clearly:**
|
||||
- Update your `README.md` to state that the project is licensed under AGPL-3.0.
|
||||
- Include clear instructions on how to set up, build, and run your project from the source code.
|
||||
- Attribute Ultralytics YOLO appropriately, linking back to the [original repository](https://github.com/ultralytics/ultralytics). Example:
|
||||
```markdown
|
||||
This project utilizes code from [Ultralytics YOLO](https://github.com/ultralytics/ultralytics), licensed under AGPL-3.0.
|
||||
```
|
||||
|
||||
### Example Repository Structure
|
||||
|
||||
Refer to the [Ultralytics Template Repository](https://github.com/ultralytics/template) for a practical example structure:
|
||||
|
||||
```
|
||||
my-yolo-project/
|
||||
│
|
||||
├── LICENSE # Full AGPL-3.0 license text
|
||||
├── README.md # Project description, setup, usage, license info & attribution
|
||||
├── pyproject.toml # Dependencies (or requirements.txt)
|
||||
├── scripts/ # Training/inference scripts
|
||||
│ └── train.py
|
||||
├── src/ # Your project's source code
|
||||
│ ├── __init__.py
|
||||
│ ├── data_loader.py
|
||||
│ └── model_wrapper.py # Code interacting with YOLO
|
||||
├── tests/ # Unit/integration tests
|
||||
├── configs/ # YAML/JSON config files
|
||||
├── docker/ # Dockerfiles, if used
|
||||
│ └── Dockerfile
|
||||
└── .github/ # GitHub specific files (e.g., workflows for CI)
|
||||
└── workflows/
|
||||
└── ci.yml
|
||||
```
|
||||
|
||||
By following these guidelines, you ensure compliance with AGPL-3.0, supporting the open-source ecosystem that enables powerful tools like Ultralytics YOLO.
|
||||
|
||||
## 🎉 Conclusion
|
||||
|
||||
Thank you for your interest in contributing to [Ultralytics](https://www.ultralytics.com/) [open-source](https://github.com/ultralytics) YOLO projects. Your participation is essential in shaping the future of our software and building a vibrant community of innovation and collaboration. Whether you're enhancing code, reporting bugs, or suggesting new features, your contributions are invaluable.
|
||||
|
||||
We're excited to see your ideas come to life and appreciate your commitment to advancing [object detection](https://www.ultralytics.com/glossary/object-detection) technology. Together, let's continue to grow and innovate in this exciting open-source journey. Happy coding! 🚀🌟
|
||||
|
||||
## FAQ
|
||||
|
||||
### Why should I contribute to Ultralytics YOLO open-source repositories?
|
||||
|
||||
Contributing to Ultralytics YOLO open-source repositories improves the software, making it more robust and feature-rich for the entire community. Contributions can include code enhancements, bug fixes, documentation improvements, and new feature implementations. Additionally, contributing allows you to collaborate with other skilled developers and experts in the field, enhancing your own skills and reputation. For details on how to get started, refer to the [Contributing via Pull Requests](#-contributing-via-pull-requests) section.
|
||||
|
||||
### How do I sign the Contributor License Agreement (CLA) for Ultralytics YOLO?
|
||||
|
||||
To sign the Contributor License Agreement (CLA), follow the instructions provided by the CLA bot after submitting your pull request. This process ensures that your contributions are properly licensed under the AGPL-3.0 license, maintaining the legal integrity of the open-source project. Add a comment in your pull request stating:
|
||||
|
||||
```text
|
||||
I have read the CLA Document and I sign the CLA
|
||||
```
|
||||
|
||||
For more information, see the [CLA Signing](#-cla-signing) section.
|
||||
|
||||
### What are Google-style docstrings, and why are they required for Ultralytics YOLO contributions?
|
||||
|
||||
Google-style docstrings provide clear, concise documentation for functions and classes, improving code readability and maintainability. These docstrings outline the function's purpose, arguments, and return values with specific formatting rules. When contributing to Ultralytics YOLO, following Google-style docstrings ensures that your additions are well-documented and easily understood. For examples and guidelines, visit the [Google-Style Docstrings](#-google-style-docstrings) section.
|
||||
|
||||
### How can I ensure my changes pass the GitHub Actions CI tests?
|
||||
|
||||
Before your pull request can be merged, it must pass all GitHub Actions Continuous Integration (CI) tests. These tests include linting, unit tests, and other checks to ensure the code meets the project's quality standards. Review the CI output and fix any issues. For detailed information on the CI process and troubleshooting tips, see the [GitHub Actions CI Tests](#-github-actions-ci-tests) section.
|
||||
|
||||
### How do I report a bug in Ultralytics YOLO repositories?
|
||||
|
||||
To report a bug, provide a clear and concise [Minimum Reproducible Example](https://docs.ultralytics.com/help/minimum-reproducible-example/) along with your bug report. This helps developers quickly identify and fix the issue. Ensure your example is minimal yet sufficient to replicate the problem. For more detailed steps on reporting bugs, refer to the [Reporting Bugs](#-reporting-bugs) section.
|
||||
|
||||
### What does the AGPL-3.0 license mean if I use Ultralytics YOLO in my own project?
|
||||
|
||||
If you use Ultralytics YOLO code or models (licensed under AGPL-3.0) in your project, the AGPL-3.0 license requires that your entire project (the derivative work) must also be licensed under AGPL-3.0 and its complete source code must be made publicly available. This ensures that the open-source nature of the software is preserved throughout its derivatives. If you cannot meet these requirements, you need to obtain an [Enterprise License](https://www.ultralytics.com/license). See the [Open-Sourcing Your Project](#-open-sourcing-your-yolo-project-under-agpl-30) section for details.
|
||||
@@ -1,661 +0,0 @@
|
||||
GNU AFFERO GENERAL PUBLIC LICENSE
|
||||
Version 3, 19 November 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU Affero General Public License is a free, copyleft license for
|
||||
software and other kinds of works, specifically designed to ensure
|
||||
cooperation with the community in the case of network server software.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
our General Public Licenses are intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
Developers that use our General Public Licenses protect your rights
|
||||
with two steps: (1) assert copyright on the software, and (2) offer
|
||||
you this License which gives you legal permission to copy, distribute
|
||||
and/or modify the software.
|
||||
|
||||
A secondary benefit of defending all users' freedom is that
|
||||
improvements made in alternate versions of the program, if they
|
||||
receive widespread use, become available for other developers to
|
||||
incorporate. Many developers of free software are heartened and
|
||||
encouraged by the resulting cooperation. However, in the case of
|
||||
software used on network servers, this result may fail to come about.
|
||||
The GNU General Public License permits making a modified version and
|
||||
letting the public access it on a server without ever releasing its
|
||||
source code to the public.
|
||||
|
||||
The GNU Affero General Public License is designed specifically to
|
||||
ensure that, in such cases, the modified source code becomes available
|
||||
to the community. It requires the operator of a network server to
|
||||
provide the source code of the modified version running there to the
|
||||
users of that server. Therefore, public use of a modified version, on
|
||||
a publicly accessible server, gives the public access to the source
|
||||
code of the modified version.
|
||||
|
||||
An older license, called the Affero General Public License and
|
||||
published by Affero, was designed to accomplish similar goals. This is
|
||||
a different license, not a version of the Affero GPL, but Affero has
|
||||
released a new version of the Affero GPL which permits relicensing under
|
||||
this license.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU Affero General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Remote Network Interaction; Use with the GNU General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, if you modify the
|
||||
Program, your modified version must prominently offer all users
|
||||
interacting with it remotely through a computer network (if your version
|
||||
supports such interaction) an opportunity to receive the Corresponding
|
||||
Source of your version by providing access to the Corresponding Source
|
||||
from a network server at no charge, through some standard or customary
|
||||
means of facilitating copying of software. This Corresponding Source
|
||||
shall include the Corresponding Source for any work covered by version 3
|
||||
of the GNU General Public License that is incorporated pursuant to the
|
||||
following paragraph.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the work with which it is combined will remain governed by version
|
||||
3 of the GNU General Public License.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU Affero General Public License from time to time. Such new versions
|
||||
will be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU Affero General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU Affero General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU Affero General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If your software can interact with users remotely through a computer
|
||||
network, you should also make sure that it provides a way for users to
|
||||
get its source. For example, if your program is a web application, its
|
||||
interface could display a "Source" link that leads users to an archive
|
||||
of the code. There are many ways you could offer source, and different
|
||||
solutions will be better for different programs; see section 13 for the
|
||||
specific requirements.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU AGPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
@@ -1,412 +0,0 @@
|
||||
# 🚀 YOLO26 RKNN Export Adaptation
|
||||
|
||||
> **⚡ Optimized for Rockchip NPU Performance**
|
||||
|
||||
This repository includes optimized RKNN export support for YOLO26 models, designed for high-performance inference on Rockchip NPU devices.
|
||||
|
||||
## ✨ Key Features
|
||||
|
||||
- **🎯 Raw Output Export**: Models export without post-processing (no NMS, no sigmoid, no decode)
|
||||
- **⚡ CPU Post-processing**: Move decode/NMS operations to CPU for better NPU utilization
|
||||
- **🔧 Multi-task Support**: Works with Detection, Segmentation, OBB, and Pose models
|
||||
|
||||
## 📋 Export Format
|
||||
|
||||
**Detection Model Output Structure:**
|
||||
```
|
||||
Input: images [1, 3, 640, 640]
|
||||
|
||||
Outputs (6 tensors for 3 detection heads):
|
||||
├─ output0_reg [1, 4*reg_max, 80, 80] # Head 0 regression (raw DFL output)
|
||||
├─ output0_cls [1, nc, 80, 80] # Head 0 classification (raw logits)
|
||||
├─ output1_reg [1, 4*reg_max, 40, 40] # Head 1 regression
|
||||
├─ output1_cls [1, nc, 40, 40] # Head 1 classification
|
||||
├─ output2_reg [1, 4*reg_max, 20, 20] # Head 2 regression
|
||||
└─ output2_cls [1, nc, 20, 20] # Head 2 classification
|
||||
```
|
||||
|
||||
## 🔨 Usage
|
||||
|
||||
### Step 1: Export ONNX Model
|
||||
|
||||
```bash
|
||||
# Export YOLO26 model to RKNN-compatible ONNX format
|
||||
yolo export model=yolo26n.pt format=rknn
|
||||
```
|
||||
|
||||
### Step 2: Convert to RKNN Model
|
||||
|
||||
The `rknn_export/` directory in this repository contains complete RKNN conversion tools:
|
||||
- `convert.py`: Conversion script from ONNX to RKNN
|
||||
- `datasets/`: Quantization calibration dataset
|
||||
|
||||
#### Environment Setup
|
||||
|
||||
**⚠️ Important**: It's recommended to create a new virtual environment, as some dependencies of rknn-toolkit2 conflict with ultralytics
|
||||
|
||||
```bash
|
||||
# Install RKNN-Toolkit2
|
||||
pip install -U rknn-toolkit2
|
||||
```
|
||||
|
||||
#### Using the Conversion Script
|
||||
|
||||
View help information:
|
||||
|
||||
```bash
|
||||
python rknn_export/convert.py -h
|
||||
```
|
||||
|
||||
**Required Arguments:**
|
||||
- `--model-path`: Path to ONNX model file (`.onnx` file exported in Step 1)
|
||||
- `--platform`: Target platform, options:
|
||||
- `rk3562`, `rk3566`, `rk3568`, `rk3576`, `rk3588`
|
||||
- `rv1126b`, `rv1109`, `rv1126`, `rk1808`
|
||||
|
||||
**Optional Arguments:**
|
||||
- `--dtype`: Quantization data type (default: `i8`)
|
||||
- `i8` or `fp`: For `rk3562`, `rk3566`, `rk3568`, `rk3576`, `rk3588`, `rv1126b`
|
||||
- `u8` or `fp`: For `rv1109`, `rv1126`, `rk1808`
|
||||
- `--rknn-path`: Output path for RKNN model (default: `./<model_name>.rknn`)
|
||||
- `--data-path`: Path to quantization calibration dataset (default: `datasets/COCO/coco_subset_20.txt`)
|
||||
- For custom data, prepare a txt file containing image paths
|
||||
- `--batch-size`: Batch size (default: `1`)
|
||||
- Can be adjusted based on NPU cores (e.g., RK3588 has 3 cores, can set to 3)
|
||||
- ⚠️ Note: This parameter will fix the model output dimensions
|
||||
|
||||
#### Example Commands
|
||||
|
||||
```bash
|
||||
# Basic conversion (RK3588 platform, INT8 quantization)
|
||||
python rknn_export/convert.py \
|
||||
--model-path best.onnx \
|
||||
--platform rk3588 \
|
||||
--dtype i8
|
||||
|
||||
# Specify output path and quantization dataset
|
||||
python rknn_export/convert.py \
|
||||
--model-path yolo26n.onnx \
|
||||
--platform rk3588 \
|
||||
--dtype i8 \
|
||||
--rknn-path ./models/yolo26n_rk3588.rknn \
|
||||
--data-path ./my_dataset/images.txt
|
||||
|
||||
# Multi-core batch processing (RK3588)
|
||||
python rknn_export/convert.py \
|
||||
--model-path best.onnx \
|
||||
--platform rk3588 \
|
||||
--dtype i8 \
|
||||
--batch-size 3
|
||||
```
|
||||
|
||||
Upon completion, it will display:
|
||||
```
|
||||
rknn model saved to: ./best.rknn
|
||||
```
|
||||
|
||||
For more deployment examples, refer to: [RKNN Model Zoo](https://github.com/airockchip/rknn_model_zoo/tree/main/examples/)
|
||||
|
||||
## 📝 Implementation Details
|
||||
|
||||
### Modified Files
|
||||
- **`ultralytics/engine/exporter.py`**: Enhanced `export_rknn()` method
|
||||
- Uses optimal ONNX opset version
|
||||
- Embeds all weights in single file
|
||||
- Sets meaningful output tensor names
|
||||
|
||||
- **`ultralytics/nn/modules/head.py`**: Updated `Detect`, `Segment`, `OBB`, `Pose` classes
|
||||
- Added RKNN-specific forward logic
|
||||
- Returns raw predictions without activation functions
|
||||
|
||||
- **`ultralytics/nn/autobackend.py`**: Added RKNN inference support notes
|
||||
|
||||
### Training & Inference
|
||||
- ✅ **Training**: Not affected - all modifications only apply during export
|
||||
- ✅ **Standard Export**: Other export formats (ONNX, TensorRT, etc.) work as before
|
||||
- ✅ **RKNN Export**: Special handling only when `format=rknn`
|
||||
|
||||
## 🎯 Performance Benefits
|
||||
|
||||
- **Faster Inference**: Post-processing on CPU is faster than on NPU for models
|
||||
- **Better NPU Utilization**: NPU focuses on backbone and head computations
|
||||
- **Flexible Deployment**: Easy to customize post-processing logic
|
||||
|
||||
---
|
||||
|
||||
<div align="center">
|
||||
<p>
|
||||
<a href="https://platform.ultralytics.com/ultralytics/yolo26" target="_blank">
|
||||
<img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Ultralytics YOLO banner"></a>
|
||||
</p>
|
||||
|
||||
[中文](https://docs.ultralytics.com/zh/) | [한국어](https://docs.ultralytics.com/ko/) | [日本語](https://docs.ultralytics.com/ja/) | [Русский](https://docs.ultralytics.com/ru/) | [Deutsch](https://docs.ultralytics.com/de/) | [Français](https://docs.ultralytics.com/fr/) | [Español](https://docs.ultralytics.com/es) | [Português](https://docs.ultralytics.com/pt/) | [Türkçe](https://docs.ultralytics.com/tr/) | [Tiếng Việt](https://docs.ultralytics.com/vi/) | [العربية](https://docs.ultralytics.com/ar/) <br>
|
||||
|
||||
<div>
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml/badge.svg" alt="Ultralytics CI"></a>
|
||||
<a href="https://clickpy.clickhouse.com/dashboard/ultralytics"><img src="https://static.pepy.tech/badge/ultralytics" alt="Ultralytics Downloads"></a>
|
||||
<a href="https://discord.com/invite/ultralytics"><img alt="Ultralytics Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
|
||||
<a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a>
|
||||
<a href="https://www.reddit.com/r/ultralytics/"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
|
||||
<br>
|
||||
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run Ultralytics on Gradient"></a>
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Ultralytics In Colab"></a>
|
||||
<a href="https://www.kaggle.com/models/ultralytics/yolo26"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open Ultralytics In Kaggle"></a>
|
||||
<a href="https://mybinder.org/v2/gh/ultralytics/ultralytics/HEAD?labpath=examples%2Ftutorial.ipynb"><img src="https://mybinder.org/badge_logo.svg" alt="Open Ultralytics In Binder"></a>
|
||||
</div>
|
||||
</div>
|
||||
<br>
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) creates cutting-edge, state-of-the-art (SOTA) [YOLO models](https://www.ultralytics.com/yolo) built on years of foundational research in computer vision and AI. Constantly updated for performance and flexibility, our models are **fast**, **accurate**, and **easy to use**. They excel at [object detection](https://docs.ultralytics.com/tasks/detect/), [tracking](https://docs.ultralytics.com/modes/track/), [instance segmentation](https://docs.ultralytics.com/tasks/segment/), [image classification](https://docs.ultralytics.com/tasks/classify/), and [pose estimation](https://docs.ultralytics.com/tasks/pose/) tasks.
|
||||
|
||||
Find detailed documentation in the [Ultralytics Docs](https://docs.ultralytics.com/). Get support via [GitHub Issues](https://github.com/ultralytics/ultralytics/issues/new/choose). Join discussions on [Discord](https://discord.com/invite/ultralytics), [Reddit](https://www.reddit.com/r/ultralytics/), and the [Ultralytics Community Forums](https://community.ultralytics.com/)!
|
||||
|
||||
Request an Enterprise License for commercial use at [Ultralytics Licensing](https://www.ultralytics.com/license).
|
||||
|
||||
<a href="https://platform.ultralytics.com/ultralytics/yolo26" target="_blank">
|
||||
<img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/refs/heads/main/yolo/performance-comparison.png" alt="YOLO26 performance plots">
|
||||
</a>
|
||||
|
||||
<div align="center">
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="2%" alt="Ultralytics GitHub"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="2%" alt="Ultralytics LinkedIn"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="2%" alt="Ultralytics Twitter"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://www.youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="2%" alt="Ultralytics YouTube"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="2%" alt="Ultralytics TikTok"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="2%" alt="Ultralytics BiliBili"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="2%" alt="Ultralytics Discord"></a>
|
||||
</div>
|
||||
|
||||
## 📄 Documentation
|
||||
|
||||
See below for quickstart installation and usage examples. For comprehensive guidance on training, validation, prediction, and deployment, refer to our full [Ultralytics Docs](https://docs.ultralytics.com/).
|
||||
|
||||
<details open>
|
||||
<summary>Install</summary>
|
||||
|
||||
Install the `ultralytics` package, including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml), in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/).
|
||||
|
||||
[](https://pypi.org/project/ultralytics/) [](https://clickpy.clickhouse.com/dashboard/ultralytics) [](https://pypi.org/project/ultralytics/)
|
||||
|
||||
```bash
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
For alternative installation methods, including [Conda](https://anaconda.org/conda-forge/ultralytics), [Docker](https://hub.docker.com/r/ultralytics/ultralytics), and building from source via Git, please consult the [Quickstart Guide](https://docs.ultralytics.com/quickstart/).
|
||||
|
||||
[](https://anaconda.org/conda-forge/ultralytics) [](https://hub.docker.com/r/ultralytics/ultralytics) [](https://hub.docker.com/r/ultralytics/ultralytics)
|
||||
|
||||
</details>
|
||||
|
||||
<details open>
|
||||
<summary>Usage</summary>
|
||||
|
||||
### CLI
|
||||
|
||||
You can use Ultralytics YOLO directly from the Command Line Interface (CLI) with the `yolo` command:
|
||||
|
||||
```bash
|
||||
# Predict using a pretrained YOLO model (e.g., YOLO26n) on an image
|
||||
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'
|
||||
```
|
||||
|
||||
The `yolo` command supports various tasks and modes, accepting additional arguments like `imgsz=640`. Explore the YOLO [CLI Docs](https://docs.ultralytics.com/usage/cli/) for more examples.
|
||||
|
||||
### Python
|
||||
|
||||
Ultralytics YOLO can also be integrated directly into your Python projects. It accepts the same [configuration arguments](https://docs.ultralytics.com/usage/cfg/) as the CLI:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on the COCO8 dataset for 100 epochs
|
||||
train_results = model.train(
|
||||
data="coco8.yaml", # Path to dataset configuration file
|
||||
epochs=100, # Number of training epochs
|
||||
imgsz=640, # Image size for training
|
||||
device="cpu", # Device to run on (e.g., 'cpu', 0, [0,1,2,3])
|
||||
)
|
||||
|
||||
# Evaluate the model's performance on the validation set
|
||||
metrics = model.val()
|
||||
|
||||
# Perform object detection on an image
|
||||
results = model("path/to/image.jpg") # Predict on an image
|
||||
results[0].show() # Display results
|
||||
|
||||
# Export the model to ONNX format for deployment
|
||||
path = model.export(format="onnx") # Returns the path to the exported model
|
||||
```
|
||||
|
||||
Discover more examples in the YOLO [Python Docs](https://docs.ultralytics.com/usage/python/).
|
||||
|
||||
</details>
|
||||
|
||||
## ✨ Models
|
||||
|
||||
Ultralytics supports a wide range of YOLO models, from early versions like [YOLOv3](https://docs.ultralytics.com/models/yolov3/) to the latest [YOLO26](https://docs.ultralytics.com/models/yolo26/). The tables below showcase YOLO26 models pretrained on the [COCO](https://docs.ultralytics.com/datasets/detect/coco/) dataset for [Detection](https://docs.ultralytics.com/tasks/detect/), [Segmentation](https://docs.ultralytics.com/tasks/segment/), and [Pose Estimation](https://docs.ultralytics.com/tasks/pose/). Additionally, [Classification](https://docs.ultralytics.com/tasks/classify/) models pretrained on the [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/) dataset are available. [Tracking](https://docs.ultralytics.com/modes/track/) mode is compatible with all Detection, Segmentation, and Pose models. All [Models](https://docs.ultralytics.com/models/) are automatically downloaded from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) upon first use.
|
||||
|
||||
<a href="https://docs.ultralytics.com/tasks/" target="_blank">
|
||||
<img width="100%" src="https://github.com/ultralytics/docs/releases/download/0/ultralytics-yolov8-tasks-banner.avif" alt="Ultralytics YOLO supported tasks">
|
||||
</a>
|
||||
<br>
|
||||
<br>
|
||||
|
||||
<details open><summary>Detection (COCO)</summary>
|
||||
|
||||
Explore the [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples. These models are trained on the [COCO dataset](https://cocodataset.org/), featuring 80 object classes.
|
||||
|
||||
| Model | size<br><sup>(pixels)</sup> | mAP<sup>val<br>50-95</sup> | mAP<sup>val<br>50-95(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
|
||||
| ------------------------------------------------------------------------------------ | --------------------------- | -------------------------- | ------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
|
||||
| [YOLO26n](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt) | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.4 |
|
||||
| [YOLO26s](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s.pt) | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.7 |
|
||||
| [YOLO26m](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m.pt) | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.2 |
|
||||
| [YOLO26l](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l.pt) | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.4 |
|
||||
| [YOLO26x](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x.pt) | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 193.9 |
|
||||
|
||||
- **mAP<sup>val</sup>** values refer to single-model single-scale performance on the [COCO val2017](https://cocodataset.org/) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics/) for details. <br>Reproduce with `yolo val detect data=coco.yaml device=0`
|
||||
- **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val detect data=coco.yaml batch=1 device=0|cpu`
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>Segmentation (COCO)</summary>
|
||||
|
||||
Refer to the [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for usage examples. These models are trained on [COCO-Seg](https://docs.ultralytics.com/datasets/segment/coco/), including 80 classes.
|
||||
|
||||
| Model | size<br><sup>(pixels)</sup> | mAP<sup>box<br>50-95(e2e)</sup> | mAP<sup>mask<br>50-95(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
|
||||
| -------------------------------------------------------------------------------------------- | --------------------------- | ------------------------------- | -------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
|
||||
| [YOLO26n-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-seg.pt) | 640 | 39.6 | 33.9 | 53.3 ± 0.5 | 2.1 ± 0.0 | 2.7 | 9.1 |
|
||||
| [YOLO26s-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-seg.pt) | 640 | 47.3 | 40.0 | 118.4 ± 0.9 | 3.3 ± 0.0 | 10.4 | 34.2 |
|
||||
| [YOLO26m-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-seg.pt) | 640 | 52.5 | 44.1 | 328.2 ± 2.4 | 6.7 ± 0.1 | 23.6 | 121.5 |
|
||||
| [YOLO26l-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-seg.pt) | 640 | 54.4 | 45.5 | 387.0 ± 3.7 | 8.0 ± 0.1 | 28.0 | 139.8 |
|
||||
| [YOLO26x-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-seg.pt) | 640 | 56.5 | 47.0 | 787.0 ± 6.8 | 16.4 ± 0.1 | 62.8 | 313.5 |
|
||||
|
||||
- **mAP<sup>val</sup>** values are for single-model single-scale on the [COCO val2017](https://cocodataset.org/) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics/) for details. <br>Reproduce with `yolo val segment data=coco.yaml device=0`
|
||||
- **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val segment data=coco.yaml batch=1 device=0|cpu`
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>Classification (ImageNet)</summary>
|
||||
|
||||
Consult the [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for usage examples. These models are trained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), covering 1000 classes.
|
||||
|
||||
| Model | size<br><sup>(pixels)</sup> | acc<br><sup>top1</sup> | acc<br><sup>top5</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B) at 224</sup> |
|
||||
| -------------------------------------------------------------------------------------------- | --------------------------- | ---------------------- | ---------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ------------------------------ |
|
||||
| [YOLO26n-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-cls.pt) | 224 | 71.4 | 90.1 | 5.0 ± 0.3 | 1.1 ± 0.0 | 2.8 | 0.5 |
|
||||
| [YOLO26s-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-cls.pt) | 224 | 76.0 | 92.9 | 7.9 ± 0.2 | 1.3 ± 0.0 | 6.7 | 1.6 |
|
||||
| [YOLO26m-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-cls.pt) | 224 | 78.1 | 94.2 | 17.2 ± 0.4 | 2.0 ± 0.0 | 11.6 | 4.9 |
|
||||
| [YOLO26l-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-cls.pt) | 224 | 79.0 | 94.6 | 23.2 ± 0.3 | 2.8 ± 0.0 | 14.1 | 6.2 |
|
||||
| [YOLO26x-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-cls.pt) | 224 | 79.9 | 95.0 | 41.4 ± 0.9 | 3.8 ± 0.0 | 29.6 | 13.6 |
|
||||
|
||||
- **acc** values represent model accuracy on the [ImageNet](https://www.image-net.org/) dataset validation set. <br>Reproduce with `yolo val classify data=path/to/ImageNet device=0`
|
||||
- **Speed** metrics are averaged over ImageNet val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>Pose (COCO)</summary>
|
||||
|
||||
See the [Pose Estimation Docs](https://docs.ultralytics.com/tasks/pose/) for usage examples. These models are trained on [COCO-Pose](https://docs.ultralytics.com/datasets/pose/coco/), focusing on the 'person' class.
|
||||
|
||||
| Model | size<br><sup>(pixels)</sup> | mAP<sup>pose<br>50-95(e2e)</sup> | mAP<sup>pose<br>50(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
|
||||
| ---------------------------------------------------------------------------------------------- | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
|
||||
| [YOLO26n-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-pose.pt) | 640 | 57.2 | 83.3 | 40.3 ± 0.5 | 1.8 ± 0.0 | 2.9 | 7.5 |
|
||||
| [YOLO26s-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-pose.pt) | 640 | 63.0 | 86.6 | 85.3 ± 0.9 | 2.7 ± 0.0 | 10.4 | 23.9 |
|
||||
| [YOLO26m-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-pose.pt) | 640 | 68.8 | 89.6 | 218.0 ± 1.5 | 5.0 ± 0.1 | 21.5 | 73.1 |
|
||||
| [YOLO26l-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-pose.pt) | 640 | 70.4 | 90.5 | 275.4 ± 2.4 | 6.5 ± 0.1 | 25.9 | 91.3 |
|
||||
| [YOLO26x-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-pose.pt) | 640 | 71.6 | 91.6 | 565.4 ± 3.0 | 12.2 ± 0.2 | 57.6 | 201.7 |
|
||||
|
||||
- **mAP<sup>val</sup>** values are for single-model single-scale on the [COCO Keypoints val2017](https://docs.ultralytics.com/datasets/pose/coco/) dataset. See [YOLO Performance Metrics](https://docs.ultralytics.com/guides/yolo-performance-metrics/) for details. <br>Reproduce with `yolo val pose data=coco-pose.yaml device=0`
|
||||
- **Speed** metrics are averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce with `yolo val pose data=coco-pose.yaml batch=1 device=0|cpu`
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>Oriented Bounding Boxes (DOTAv1)</summary>
|
||||
|
||||
Check the [OBB Docs](https://docs.ultralytics.com/tasks/obb/) for usage examples. These models are trained on [DOTAv1](https://docs.ultralytics.com/datasets/obb/dota-v2/#dota-v10/), including 15 classes.
|
||||
|
||||
| Model | size<br><sup>(pixels)</sup> | mAP<sup>test<br>50-95(e2e)</sup> | mAP<sup>test<br>50(e2e)</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>T4 TensorRT10<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
|
||||
| -------------------------------------------------------------------------------------------- | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
|
||||
| [YOLO26n-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-obb.pt) | 1024 | 52.4 | 78.9 | 97.7 ± 0.9 | 2.8 ± 0.0 | 2.5 | 14.0 |
|
||||
| [YOLO26s-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-obb.pt) | 1024 | 54.8 | 80.9 | 218.0 ± 1.4 | 4.9 ± 0.1 | 9.8 | 55.1 |
|
||||
| [YOLO26m-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-obb.pt) | 1024 | 55.3 | 81.0 | 579.2 ± 3.8 | 10.2 ± 0.3 | 21.2 | 183.3 |
|
||||
| [YOLO26l-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-obb.pt) | 1024 | 56.2 | 81.6 | 735.6 ± 3.1 | 13.0 ± 0.2 | 25.6 | 230.0 |
|
||||
| [YOLO26x-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-obb.pt) | 1024 | 56.7 | 81.7 | 1485.7 ± 11.5 | 30.5 ± 0.9 | 57.6 | 516.5 |
|
||||
|
||||
- **mAP<sup>test</sup>** values are for single-model multiscale performance on the [DOTAv1 test set](https://captain-whu.github.io/DOTA/dataset.html). <br>Reproduce by `yolo val obb data=DOTAv1.yaml device=0 split=test` and submit merged results to the [DOTA evaluation server](https://captain-whu.github.io/DOTA/evaluation.html).
|
||||
- **Speed** metrics are averaged over [DOTAv1 val images](https://docs.ultralytics.com/datasets/obb/dota-v2/#dota-v10) using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. CPU speeds measured with [ONNX](https://onnx.ai/) export. GPU speeds measured with [TensorRT](https://developer.nvidia.com/tensorrt) export. <br>Reproduce by `yolo val obb data=DOTAv1.yaml batch=1 device=0|cpu`
|
||||
|
||||
</details>
|
||||
|
||||
## 🧩 Integrations
|
||||
|
||||
Our key integrations with leading AI platforms extend the functionality of Ultralytics' offerings, enhancing tasks like dataset labeling, training, visualization, and model management. Discover how Ultralytics, in collaboration with partners like [Weights & Biases](https://docs.ultralytics.com/integrations/weights-biases/), [Comet ML](https://docs.ultralytics.com/integrations/comet/), [Roboflow](https://docs.ultralytics.com/integrations/roboflow/), and [Intel OpenVINO](https://docs.ultralytics.com/integrations/openvino/), can optimize your AI workflow. Explore more at [Ultralytics Integrations](https://docs.ultralytics.com/integrations/).
|
||||
|
||||
<a href="https://docs.ultralytics.com/integrations/" target="_blank">
|
||||
<img width="100%" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics active learning integrations">
|
||||
</a>
|
||||
<br>
|
||||
<br>
|
||||
|
||||
<div align="center">
|
||||
<a href="https://platform.ultralytics.com/ultralytics/yolo26">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-ultralytics-hub.png" width="10%" alt="Ultralytics Platform logo"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
|
||||
<a href="https://docs.ultralytics.com/integrations/weights-biases/">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-wb.png" width="10%" alt="Weights & Biases logo"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
|
||||
<a href="https://docs.ultralytics.com/integrations/comet/">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-comet.png" width="10%" alt="Comet ML logo"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
|
||||
<a href="https://docs.ultralytics.com/integrations/neural-magic/">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-neuralmagic.png" width="10%" alt="Neural Magic logo"></a>
|
||||
</div>
|
||||
|
||||
| Ultralytics Platform 🌟 | Weights & Biases | Comet | Neural Magic |
|
||||
| :---------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------: |
|
||||
| Streamline YOLO workflows: Label, train, and deploy effortlessly with [Ultralytics Platform](https://platform.ultralytics.com/ultralytics/yolo26). Try now! | Track experiments, hyperparameters, and results with [Weights & Biases](https://docs.ultralytics.com/integrations/weights-biases/). | Free forever, [Comet ML](https://docs.ultralytics.com/integrations/comet/) lets you save YOLO models, resume training, and interactively visualize predictions. | Run YOLO inference up to 6x faster with [Neural Magic DeepSparse](https://docs.ultralytics.com/integrations/neural-magic/). |
|
||||
|
||||
## 🤝 Contribute
|
||||
|
||||
We thrive on community collaboration! Ultralytics YOLO wouldn't be the SOTA framework it is without contributions from developers like you. Please see our [Contributing Guide](https://docs.ultralytics.com/help/contributing/) to get started. We also welcome your feedback—share your experience by completing our [Survey](https://www.ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey). A huge **Thank You** 🙏 to everyone who contributes!
|
||||
|
||||
<!-- SVG image from https://opencollective.com/ultralytics/contributors.svg?width=1280 -->
|
||||
|
||||
[](https://github.com/ultralytics/ultralytics/graphs/contributors)
|
||||
|
||||
We look forward to your contributions to help make the Ultralytics ecosystem even better!
|
||||
|
||||
## 📜 License
|
||||
|
||||
Ultralytics offers two licensing options to suit different needs:
|
||||
|
||||
- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/license/agpl-v3) open-source license is perfect for students, researchers, and enthusiasts. It encourages open collaboration and knowledge sharing. See the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for full details.
|
||||
- **Ultralytics Enterprise License**: Designed for commercial use, this license allows for the seamless integration of Ultralytics software and AI models into commercial products and services, bypassing the open-source requirements of AGPL-3.0. If your use case involves commercial deployment, please contact us via [Ultralytics Licensing](https://www.ultralytics.com/license).
|
||||
|
||||
## 📞 Contact
|
||||
|
||||
For bug reports and feature requests related to Ultralytics software, please visit [GitHub Issues](https://github.com/ultralytics/ultralytics/issues). For questions, discussions, and community support, join our active communities on [Discord](https://discord.com/invite/ultralytics), [Reddit](https://www.reddit.com/r/ultralytics/), and the [Ultralytics Community Forums](https://community.ultralytics.com/). We're here to help with all things Ultralytics!
|
||||
|
||||
<br>
|
||||
<div align="center">
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
|
||||
</div>
|
||||
@@ -1,413 +0,0 @@
|
||||
# 🚀 YOLO26 RKNN 导出适配
|
||||
|
||||
> **⚡ 专为瑞芯微 NPU 性能优化**
|
||||
|
||||
本仓库为 YOLO26 模型提供了优化的 RKNN 导出支持，专为瑞芯微 NPU 设备的高性能推理而设计。
|
||||
|
||||
## ✨ 核心特性
|
||||
|
||||
- **🎯 原始输出导出**：模型导出时不包含后处理（无 NMS、无 sigmoid、无解码）
|
||||
- **⚡ CPU 后处理**：将解码/NMS 操作移至 CPU，提升 NPU 利用率
|
||||
- **🔧 多任务支持**：适用于检测、分割、旋转框检测和姿态估计模型
|
||||
|
||||
## 📋 导出格式
|
||||
|
||||
**检测模型输出结构：**
|
||||
```
|
||||
输入: images [1, 3, 640, 640]
|
||||
|
||||
输出 (3个检测头共6个张量):
|
||||
├─ output0_reg [1, 4*reg_max, 80, 80] # Head 0 回归输出（原始 DFL 输出）
|
||||
├─ output0_cls [1, nc, 80, 80] # Head 0 分类输出（原始 logits）
|
||||
├─ output1_reg [1, 4*reg_max, 40, 40] # Head 1 回归输出
|
||||
├─ output1_cls [1, nc, 40, 40] # Head 1 分类输出
|
||||
├─ output2_reg [1, 4*reg_max, 20, 20] # Head 2 回归输出
|
||||
└─ output2_cls [1, nc, 20, 20] # Head 2 分类输出
|
||||
```
|
||||
|
||||
## 🔨 使用方法
|
||||
|
||||
### 步骤 1: 导出 ONNX 模型
|
||||
|
||||
```bash
|
||||
# 将 YOLO26 模型导出为 RKNN 兼容的 ONNX 格式
|
||||
yolo export model=yolo26n.pt format=rknn
|
||||
```
|
||||
|
||||
### 步骤 2: 转换为 RKNN 模型
|
||||
|
||||
本仓库的 `rknn_export/` 目录包含了完整的 RKNN 转换工具：
|
||||
- `convert.py`：ONNX 到 RKNN 的转换脚本
|
||||
- `datasets/`：量化校准数据集
|
||||
|
||||
#### 环境准备
|
||||
|
||||
**⚠️ 重要**：建议创建新的虚拟环境，因为 rknn-toolkit2 的某些依赖与 ultralytics 冲突
|
||||
|
||||
```bash
|
||||
# 安装 RKNN-Toolkit2
|
||||
pip install -U rknn-toolkit2
|
||||
```
|
||||
|
||||
#### 使用转换脚本
|
||||
|
||||
查看帮助信息：
|
||||
|
||||
```bash
|
||||
python rknn_export/convert.py -h
|
||||
```
|
||||
|
||||
**必需参数：**
|
||||
- `--model-path`：ONNX 模型文件路径（步骤 1 导出的 `.onnx` 文件）
|
||||
- `--platform`：目标平台，可选值：
|
||||
- `rk3562`, `rk3566`, `rk3568`, `rk3576`, `rk3588`
|
||||
- `rv1126b`, `rv1109`, `rv1126`, `rk1808`
|
||||
|
||||
**可选参数：**
|
||||
- `--dtype`：量化数据类型（默认：`i8`）
|
||||
- `i8` 或 `fp`：适用于 `rk3562`, `rk3566`, `rk3568`, `rk3576`, `rk3588`, `rv1126b`
|
||||
- `u8` 或 `fp`：适用于 `rv1109`, `rv1126`, `rk1808`
|
||||
- `--rknn-path`：RKNN 模型输出路径（默认：`./<model_name>.rknn`）
|
||||
- `--data-path`：量化校准数据集路径（默认：`datasets/COCO/coco_subset_20.txt`）
|
||||
- 使用自定义数据时，需准备包含图像路径的 txt 文件
|
||||
- `--batch-size`：批处理大小（默认：`1`）
|
||||
- 可根据 NPU 核心数调整（如 RK3588 有 3 个核心，可设为 3）
|
||||
- ⚠️ 注意：此参数会固定模型输出维度
|
||||
|
||||
#### 示例命令
|
||||
|
||||
```bash
|
||||
# 基础转换（RK3588 平台，INT8 量化）
|
||||
python rknn_export/convert.py \
|
||||
--model-path best.onnx \
|
||||
--platform rk3588 \
|
||||
--dtype i8
|
||||
|
||||
# 指定输出路径和量化数据集
|
||||
python rknn_export/convert.py \
|
||||
--model-path yolo26n.onnx \
|
||||
--platform rk3588 \
|
||||
--dtype i8 \
|
||||
--rknn-path ./models/yolo26n_rk3588.rknn \
|
||||
--data-path ./my_dataset/images.txt
|
||||
|
||||
# 多核心批处理（RK3588）
|
||||
python rknn_export/convert.py \
|
||||
--model-path best.onnx \
|
||||
--platform rk3588 \
|
||||
--dtype i8 \
|
||||
--batch-size 3
|
||||
```
|
||||
|
||||
转换完成后会显示：
|
||||
```
|
||||
rknn model saved to: ./best.rknn
|
||||
```
|
||||
|
||||
更多部署示例请参考：[RKNN Model Zoo](https://github.com/airockchip/rknn_model_zoo/tree/main/examples/)
|
||||
|
||||
## 📝 实现细节
|
||||
|
||||
### 修改的文件
|
||||
- **`ultralytics/engine/exporter.py`**：增强 `export_rknn()` 方法
|
||||
- 使用最优 ONNX opset 版本
|
||||
- 将所有权重嵌入单个文件
|
||||
- 设置有意义的输出张量名称
|
||||
|
||||
- **`ultralytics/nn/modules/head.py`**：更新 `Detect`、`Segment`、`OBB`、`Pose` 类
|
||||
- 添加 RKNN 特定的前向传播逻辑
|
||||
- 返回未经激活函数处理的原始预测
|
||||
|
||||
- **`ultralytics/nn/autobackend.py`**：添加 RKNN 推理支持说明
|
||||
|
||||
### 训练与推理
|
||||
- ✅ **训练**：不受影响 - 所有修改仅在导出时生效
|
||||
- ✅ **标准导出**：其他导出格式（ONNX、TensorRT 等）保持原样
|
||||
- ✅ **RKNN 导出**：仅在 `format=rknn` 时启用特殊处理
|
||||
|
||||
## 🎯 性能优势
|
||||
|
||||
- **更快的推理**：模型在 CPU 上进行后处理比在 NPU 上更快
|
||||
- **更好的 NPU 利用率**：NPU 专注于骨干网络和检测头的计算
|
||||
- **灵活的部署**：可轻松自定义后处理逻辑
|
||||
|
||||
---
|
||||
|
||||
|
||||
<div align="center">
|
||||
<p>
|
||||
<a href="https://platform.ultralytics.com/ultralytics/yolo26" target="_blank">
|
||||
<img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Ultralytics YOLO banner"></a>
|
||||
</p>
|
||||
|
||||
[中文](https://docs.ultralytics.com/zh/) | [한국어](https://docs.ultralytics.com/ko/) | [日本語](https://docs.ultralytics.com/ja/) | [Русский](https://docs.ultralytics.com/ru/) | [Deutsch](https://docs.ultralytics.com/de/) | [Français](https://docs.ultralytics.com/fr/) | [Español](https://docs.ultralytics.com/es) | [Português](https://docs.ultralytics.com/pt/) | [Türkçe](https://docs.ultralytics.com/tr/) | [Tiếng Việt](https://docs.ultralytics.com/vi/) | [العربية](https://docs.ultralytics.com/ar/) <br>
|
||||
|
||||
<div>
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml/badge.svg" alt="Ultralytics CI"></a>
|
||||
<a href="https://clickpy.clickhouse.com/dashboard/ultralytics"><img src="https://static.pepy.tech/badge/ultralytics" alt="Ultralytics Downloads"></a>
|
||||
<a href="https://discord.com/invite/ultralytics"><img alt="Ultralytics Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
|
||||
<a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a>
|
||||
<a href="https://www.reddit.com/r/ultralytics/"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
|
||||
<br>
|
||||
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run Ultralytics on Gradient"></a>
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Ultralytics In Colab"></a>
|
||||
<a href="https://www.kaggle.com/models/ultralytics/yolo26"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open Ultralytics In Kaggle"></a>
|
||||
<a href="https://mybinder.org/v2/gh/ultralytics/ultralytics/HEAD?labpath=examples%2Ftutorial.ipynb"><img src="https://mybinder.org/badge_logo.svg" alt="Open Ultralytics In Binder"></a>
|
||||
</div>
|
||||
</div>
|
||||
<br>
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) 基于多年在计算机视觉和人工智能领域的基础研究，创造了尖端的、最先进的 (SOTA) [YOLO 模型](https://www.ultralytics.com/yolo)。我们的模型不断更新以提高性能和灵活性，具有**速度快**、**精度高**和**易于使用**的特点。它们在[目标检测](https://docs.ultralytics.com/tasks/detect/)、[跟踪](https://docs.ultralytics.com/modes/track/)、[实例分割](https://docs.ultralytics.com/tasks/segment/)、[图像分类](https://docs.ultralytics.com/tasks/classify/)和[姿态估计](https://docs.ultralytics.com/tasks/pose/)任务中表现出色。
|
||||
|
||||
在 [Ultralytics 文档](https://docs.ultralytics.com/)中查找详细文档。通过 [GitHub Issues](https://github.com/ultralytics/ultralytics/issues/new/choose) 获取支持。加入 [Discord](https://discord.com/invite/ultralytics)、[Reddit](https://www.reddit.com/r/ultralytics/) 和 [Ultralytics 社区论坛](https://community.ultralytics.com/)参与讨论！
|
||||
|
||||
如需商业用途，请在 [Ultralytics 授权许可](https://www.ultralytics.com/license)申请企业许可证。
|
||||
|
||||
<a href="https://platform.ultralytics.com/ultralytics/yolo26" target="_blank">
|
||||
<img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/refs/heads/main/yolo/performance-comparison.png" alt="YOLO26 performance plots">
|
||||
</a>
|
||||
|
||||
<div align="center">
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="2%" alt="Ultralytics GitHub"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="2%" alt="Ultralytics LinkedIn"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="2%" alt="Ultralytics Twitter"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://www.youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="2%" alt="Ultralytics YouTube"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="2%" alt="Ultralytics TikTok"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="2%" alt="Ultralytics BiliBili"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
|
||||
<a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="2%" alt="Ultralytics Discord"></a>
|
||||
</div>
|
||||
|
||||
## 📄 文档
|
||||
|
||||
请参阅下文了解快速安装和使用示例。有关训练、验证、预测和部署的全面指南，请参阅我们的完整 [Ultralytics 文档](https://docs.ultralytics.com/)。
|
||||
|
||||
<details open>
|
||||
<summary>安装</summary>
|
||||
|
||||
在 [**Python>=3.8**](https://www.python.org/) 环境中安装 `ultralytics` 包，包括所有[依赖项](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml)，并确保 [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/)。
|
||||
|
||||
[](https://pypi.org/project/ultralytics/) [](https://clickpy.clickhouse.com/dashboard/ultralytics) [](https://pypi.org/project/ultralytics/)
|
||||
|
||||
```bash
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
有关其他安装方法，包括 [Conda](https://anaconda.org/conda-forge/ultralytics)、[Docker](https://hub.docker.com/r/ultralytics/ultralytics) 以及通过 Git 从源代码构建，请查阅[快速入门指南](https://docs.ultralytics.com/quickstart/)。
|
||||
|
||||
[](https://anaconda.org/conda-forge/ultralytics) [](https://hub.docker.com/r/ultralytics/ultralytics) [](https://hub.docker.com/r/ultralytics/ultralytics)
|
||||
|
||||
</details>
|
||||
|
||||
<details open>
|
||||
<summary>使用方法</summary>
|
||||
|
||||
### CLI
|
||||
|
||||
您可以直接通过命令行界面 (CLI) 使用 `yolo` 命令来运行 Ultralytics YOLO：
|
||||
|
||||
```bash
|
||||
# 使用预训练的 YOLO 模型 (例如 YOLO26n) 对图像进行预测
|
||||
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'
|
||||
```
|
||||
|
||||
`yolo` 命令支持各种任务和模式，并接受额外的参数，如 `imgsz=640`。浏览 YOLO [CLI 文档](https://docs.ultralytics.com/usage/cli/)获取更多示例。
|
||||
|
||||
### Python
|
||||
|
||||
Ultralytics YOLO 也可以直接集成到您的 Python 项目中。它接受与 CLI 相同的[配置参数](https://docs.ultralytics.com/usage/cfg/)：
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# 加载一个预训练的 YOLO26n 模型
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# 在 COCO8 数据集上训练模型 100 个周期
|
||||
train_results = model.train(
|
||||
data="coco8.yaml", # 数据集配置文件路径
|
||||
epochs=100, # 训练周期数
|
||||
imgsz=640, # 训练图像尺寸
|
||||
device="cpu", # 运行设备 (例如 'cpu', 0, [0,1,2,3])
|
||||
)
|
||||
|
||||
# 评估模型在验证集上的性能
|
||||
metrics = model.val()
|
||||
|
||||
# 对图像执行目标检测
|
||||
results = model("path/to/image.jpg") # 对图像进行预测
|
||||
results[0].show() # 显示结果
|
||||
|
||||
# 将模型导出为 ONNX 格式以进行部署
|
||||
path = model.export(format="onnx") # 返回导出模型的路径
|
||||
```
|
||||
|
||||
在 YOLO [Python 文档](https://docs.ultralytics.com/usage/python/)中发现更多示例。
|
||||
|
||||
</details>
|
||||
|
||||
## ✨ 模型
|
||||
|
||||
Ultralytics 支持广泛的 YOLO 模型，从早期的版本如 [YOLOv3](https://docs.ultralytics.com/models/yolov3/) 到最新的 [YOLO26](https://docs.ultralytics.com/models/yolo26/)。下表展示了在 [COCO](https://docs.ultralytics.com/datasets/detect/coco/) 数据集上预训练的 YOLO26 模型，用于[检测](https://docs.ultralytics.com/tasks/detect/)、[分割](https://docs.ultralytics.com/tasks/segment/)和[姿态估计](https://docs.ultralytics.com/tasks/pose/)任务。此外，还提供了在 [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/) 数据集上预训练的[分类](https://docs.ultralytics.com/tasks/classify/)模型。[跟踪](https://docs.ultralytics.com/modes/track/)模式与所有检测、分割和姿态模型兼容。所有[模型](https://docs.ultralytics.com/models/)在首次使用时都会自动从最新的 Ultralytics [发布版本](https://github.com/ultralytics/assets/releases)下载。
|
||||
|
||||
<a href="https://docs.ultralytics.com/tasks/" target="_blank">
|
||||
<img width="100%" src="https://github.com/ultralytics/docs/releases/download/0/ultralytics-yolov8-tasks-banner.avif" alt="Ultralytics YOLO supported tasks">
|
||||
</a>
|
||||
<br>
|
||||
<br>
|
||||
|
||||
<details open><summary>检测 (COCO)</summary>
|
||||
|
||||
浏览[检测文档](https://docs.ultralytics.com/tasks/detect/)获取使用示例。这些模型在 [COCO 数据集](https://cocodataset.org/)上训练，包含 80 个对象类别。
|
||||
|
||||
| 模型 | 尺寸<br><sup>(像素) | mAP<sup>val<br>50-95 | 速度<br><sup>CPU ONNX<br>(毫秒) | 速度<br><sup>T4 TensorRT10<br>(毫秒) | 参数<br><sup>(百万) | FLOPs<br><sup>(十亿) |
|
||||
| ------------------------------------------------------------------------------------ | ------------------- | -------------------- | ------------------------------- | ------------------------------------ | ------------------- | -------------------- |
|
||||
| [YOLO26n](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt) | 640 | 40.9 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.4 |
|
||||
| [YOLO26s](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s.pt) | 640 | 48.6 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.7 |
|
||||
| [YOLO26m](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m.pt) | 640 | 53.1 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.2 |
|
||||
| [YOLO26l](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l.pt) | 640 | 55.0 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.4 |
|
||||
| [YOLO26x](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x.pt) | 640 | 57.5 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 193.9 |
|
||||
|
||||
- **mAP<sup>val</sup>** 值指的是在 [COCO val2017](https://cocodataset.org/) 数据集上的单模型单尺度性能。详见 [YOLO 性能指标](https://docs.ultralytics.com/guides/yolo-performance-metrics/)。<br>使用 `yolo val detect data=coco.yaml device=0` 复现结果。
|
||||
- **速度** 指标是在 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 实例上对 COCO val 图像进行平均测量的。CPU 速度使用 [ONNX](https://onnx.ai/) 导出进行测量。GPU 速度使用 [TensorRT](https://developer.nvidia.com/tensorrt) 导出进行测量。<br>使用 `yolo val detect data=coco.yaml batch=1 device=0|cpu` 复现结果。
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>分割 (COCO)</summary>
|
||||
|
||||
请参阅[分割文档](https://docs.ultralytics.com/tasks/segment/)获取使用示例。这些模型在 [COCO-Seg](https://docs.ultralytics.com/datasets/segment/coco/) 数据集上训练，包含 80 个类别。
|
||||
|
||||
| 模型 | 尺寸<br><sup>(像素) | mAP<sup>box<br>50-95 | mAP<sup>mask<br>50-95 | 速度<br><sup>CPU ONNX<br>(毫秒) | 速度<br><sup>T4 TensorRT10<br>(毫秒) | 参数<br><sup>(百万) | FLOPs<br><sup>(十亿) |
|
||||
| -------------------------------------------------------------------------------------------- | ------------------- | -------------------- | --------------------- | ------------------------------- | ------------------------------------ | ------------------- | -------------------- |
|
||||
| [YOLO26n-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-seg.pt) | 640 | 39.6 | 33.9 | 53.3 ± 0.5 | 2.1 ± 0.0 | 2.7 | 9.1 |
|
||||
| [YOLO26s-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-seg.pt) | 640 | 47.3 | 40.0 | 118.4 ± 0.9 | 3.3 ± 0.0 | 10.4 | 34.2 |
|
||||
| [YOLO26m-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-seg.pt) | 640 | 52.5 | 44.1 | 328.2 ± 2.4 | 6.7 ± 0.1 | 23.6 | 121.5 |
|
||||
| [YOLO26l-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-seg.pt) | 640 | 54.4 | 45.5 | 387.0 ± 3.7 | 8.0 ± 0.1 | 28.0 | 139.8 |
|
||||
| [YOLO26x-seg](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-seg.pt) | 640 | 56.5 | 47.0 | 787.0 ± 6.8 | 16.4 ± 0.1 | 62.8 | 313.5 |
|
||||
|
||||
- **mAP<sup>val</sup>** 值指的是在 [COCO val2017](https://cocodataset.org/) 数据集上的单模型单尺度性能。详见 [YOLO 性能指标](https://docs.ultralytics.com/guides/yolo-performance-metrics/)。<br>使用 `yolo val segment data=coco.yaml device=0` 复现结果。
|
||||
- **速度** 指标是在 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 实例上对 COCO val 图像进行平均测量的。CPU 速度使用 [ONNX](https://onnx.ai/) 导出进行测量。GPU 速度使用 [TensorRT](https://developer.nvidia.com/tensorrt) 导出进行测量。<br>使用 `yolo val segment data=coco.yaml batch=1 device=0|cpu` 复现结果。
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>分类 (ImageNet)</summary>
|
||||
|
||||
请查阅[分类文档](https://docs.ultralytics.com/tasks/classify/)获取使用示例。这些模型在 [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/) 数据集上训练，涵盖 1000 个类别。
|
||||
|
||||
| 模型 | 尺寸<br><sup>(像素) | acc<br><sup>top1 | acc<br><sup>top5 | 速度<br><sup>CPU ONNX<br>(毫秒) | 速度<br><sup>T4 TensorRT10<br>(毫秒) | 参数<br><sup>(百万) | FLOPs<br><sup>(十亿) @ 224 |
|
||||
| -------------------------------------------------------------------------------------------- | ------------------- | ---------------- | ---------------- | ------------------------------- | ------------------------------------ | ------------------- | -------------------------- |
|
||||
| [YOLO26n-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-cls.pt) | 224 | 71.4 | 90.1 | 5.0 ± 0.3 | 1.1 ± 0.0 | 2.8 | 0.5 |
|
||||
| [YOLO26s-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-cls.pt) | 224 | 76.0 | 92.9 | 7.9 ± 0.2 | 1.3 ± 0.0 | 6.7 | 1.6 |
|
||||
| [YOLO26m-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-cls.pt) | 224 | 78.1 | 94.2 | 17.2 ± 0.4 | 2.0 ± 0.0 | 11.6 | 4.9 |
|
||||
| [YOLO26l-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-cls.pt) | 224 | 79.0 | 94.6 | 23.2 ± 0.3 | 2.8 ± 0.0 | 14.1 | 6.2 |
|
||||
| [YOLO26x-cls](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-cls.pt) | 224 | 79.9 | 95.0 | 41.4 ± 0.9 | 3.8 ± 0.0 | 29.6 | 13.6 |
|
||||
|
||||
- **acc** 值表示模型在 [ImageNet](https://www.image-net.org/) 数据集验证集上的准确率。<br>使用 `yolo val classify data=path/to/ImageNet device=0` 复现结果。
|
||||
- **速度** 指标是在 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 实例上对 ImageNet val 图像进行平均测量的。CPU 速度使用 [ONNX](https://onnx.ai/) 导出进行测量。GPU 速度使用 [TensorRT](https://developer.nvidia.com/tensorrt) 导出进行测量。<br>使用 `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu` 复现结果。
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>姿态估计 (COCO)</summary>
|
||||
|
||||
请参阅[姿态估计文档](https://docs.ultralytics.com/tasks/pose/)获取使用示例。这些模型在 [COCO-Pose](https://docs.ultralytics.com/datasets/pose/coco/) 数据集上训练，专注于 'person' 类别。
|
||||
|
||||
| 模型 | 尺寸<br><sup>(像素) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | 速度<br><sup>CPU ONNX<br>(毫秒) | 速度<br><sup>T4 TensorRT10<br>(毫秒) | 参数<br><sup>(百万) | FLOPs<br><sup>(十亿) |
|
||||
| ---------------------------------------------------------------------------------------------- | ------------------- | --------------------- | ------------------ | ------------------------------- | ------------------------------------ | ------------------- | -------------------- |
|
||||
| [YOLO26n-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-pose.pt) | 640 | 57.2 | 83.3 | 40.3 ± 0.5 | 1.8 ± 0.0 | 2.9 | 7.5 |
|
||||
| [YOLO26s-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-pose.pt) | 640 | 63.0 | 86.6 | 85.3 ± 0.9 | 2.7 ± 0.0 | 10.4 | 23.9 |
|
||||
| [YOLO26m-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-pose.pt) | 640 | 68.8 | 89.6 | 218.0 ± 1.5 | 5.0 ± 0.1 | 21.5 | 73.1 |
|
||||
| [YOLO26l-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-pose.pt) | 640 | 70.4 | 90.5 | 275.4 ± 2.4 | 6.5 ± 0.1 | 25.9 | 91.3 |
|
||||
| [YOLO26x-pose](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-pose.pt) | 640 | 71.7 | 91.6 | 565.4 ± 3.0 | 12.2 ± 0.2 | 57.6 | 201.7 |
|
||||
|
||||
- **mAP<sup>val</sup>** 值指的是在 [COCO Keypoints val2017](https://docs.ultralytics.com/datasets/pose/coco/) 数据集上的单模型单尺度性能。详见 [YOLO 性能指标](https://docs.ultralytics.com/guides/yolo-performance-metrics/)。<br>使用 `yolo val pose data=coco-pose.yaml device=0` 复现结果。
|
||||
- **速度** 指标是在 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 实例上对 COCO val 图像进行平均测量的。CPU 速度使用 [ONNX](https://onnx.ai/) 导出进行测量。GPU 速度使用 [TensorRT](https://developer.nvidia.com/tensorrt) 导出进行测量。<br>使用 `yolo val pose data=coco-pose.yaml batch=1 device=0|cpu` 复现结果。
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary>定向边界框 (DOTAv1)</summary>
|
||||
|
||||
请查阅 [OBB 文档](https://docs.ultralytics.com/tasks/obb/)获取使用示例。这些模型在 [DOTAv1](https://docs.ultralytics.com/datasets/obb/dota-v2/#dota-v10) 数据集上训练，包含 15 个类别。
|
||||
|
||||
| 模型 | 尺寸<br><sup>(像素) | mAP<sup>test<br>50 | 速度<br><sup>CPU ONNX<br>(毫秒) | 速度<br><sup>T4 TensorRT10<br>(毫秒) | 参数<br><sup>(百万) | FLOPs<br><sup>(十亿) |
|
||||
| -------------------------------------------------------------------------------------------- | ------------------- | ------------------ | ------------------------------- | ------------------------------------ | ------------------- | -------------------- |
|
||||
| [YOLO26n-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n-obb.pt) | 1024 | 78.9 | 97.7 ± 0.9 | 2.8 ± 0.0 | 2.5 | 14.0 |
|
||||
| [YOLO26s-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-obb.pt) | 1024 | 80.9 | 218.0 ± 1.4 | 4.9 ± 0.1 | 9.8 | 55.1 |
|
||||
| [YOLO26m-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-obb.pt) | 1024 | 81.0 | 579.2 ± 3.8 | 10.2 ± 0.3 | 21.2 | 183.3 |
|
||||
| [YOLO26l-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l-obb.pt) | 1024 | 81.6 | 735.6 ± 3.1 | 13.0 ± 0.2 | 25.6 | 230.0 |
|
||||
| [YOLO26x-obb](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x-obb.pt) | 1024 | 81.7 | 1485.7 ± 11.5 | 30.5 ± 0.9 | 57.6 | 516.5 |
|
||||
|
||||
- **mAP<sup>test</sup>** 值指的是在 [DOTAv1 测试集](https://captain-whu.github.io/DOTA/dataset.html)上的单模型多尺度性能。<br>通过 `yolo val obb data=DOTAv1.yaml device=0 split=test` 复现结果，并将合并后的结果提交到 [DOTA 评估服务器](https://captain-whu.github.io/DOTA/evaluation.html)。
|
||||
- **速度** 指标是在 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 实例上对 [DOTAv1 val 图像](https://docs.ultralytics.com/datasets/obb/dota-v2/#dota-v10)进行平均测量的。CPU 速度使用 [ONNX](https://onnx.ai/) 导出进行测量。GPU 速度使用 [TensorRT](https://developer.nvidia.com/tensorrt) 导出进行测量。<br>通过 `yolo val obb data=DOTAv1.yaml batch=1 device=0|cpu` 复现结果。
|
||||
|
||||
</details>
|
||||
|
||||
## 🧩 集成
|
||||
|
||||
我们与领先 AI 平台的关键集成扩展了 Ultralytics 产品的功能，增强了数据集标注、训练、可视化和模型管理等任务。了解 Ultralytics 如何与 [Weights & Biases](https://docs.ultralytics.com/integrations/weights-biases/)、[Comet ML](https://docs.ultralytics.com/integrations/comet/)、[Roboflow](https://docs.ultralytics.com/integrations/roboflow/) 和 [Intel OpenVINO](https://docs.ultralytics.com/integrations/openvino/) 等合作伙伴协作，优化您的 AI 工作流程。在 [Ultralytics 集成](https://docs.ultralytics.com/integrations/)了解更多信息。
|
||||
|
||||
<a href="https://docs.ultralytics.com/integrations/" target="_blank">
|
||||
<img width="100%" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics active learning integrations">
|
||||
</a>
|
||||
<br>
|
||||
<br>
|
||||
|
||||
<div align="center">
|
||||
<a href="https://platform.ultralytics.com/ultralytics/yolo26">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-ultralytics-hub.png" width="10%" alt="Ultralytics Platform logo"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
|
||||
<a href="https://docs.ultralytics.com/integrations/weights-biases/">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-wb.png" width="10%" alt="Weights & Biases logo"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
|
||||
<a href="https://docs.ultralytics.com/integrations/comet/">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-comet.png" width="10%" alt="Comet ML logo"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
|
||||
<a href="https://docs.ultralytics.com/integrations/neural-magic/">
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/partners/logo-neuralmagic.png" width="10%" alt="Neural Magic logo"></a>
|
||||
</div>
|
||||
|
||||
| Ultralytics Platform 🌟 | Weights & Biases | Comet | Neural Magic |
|
||||
| :-----------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------: |
|
||||
| 简化 YOLO 工作流程：使用 [Ultralytics 平台](https://platform.ultralytics.com/ultralytics/yolo26) 轻松进行标注、训练和部署。立即试用！ | 使用 [Weights & Biases](https://docs.ultralytics.com/integrations/weights-biases/) 跟踪实验、超参数和结果。 | 永久免费的 [Comet ML](https://docs.ultralytics.com/integrations/comet/) 让您能够保存 YOLO 模型、恢复训练并交互式地可视化预测结果。 | 使用 [Neural Magic DeepSparse](https://docs.ultralytics.com/integrations/neural-magic/)，将 YOLO 推理速度提高多达 6 倍。 |
|
||||
|
||||
## 🤝 贡献
|
||||
|
||||
我们依靠社区协作蓬勃发展！没有像您这样的开发者的贡献，Ultralytics YOLO 就不会成为如今最先进的框架。请参阅我们的[贡献指南](https://docs.ultralytics.com/help/contributing/)开始贡献。我们也欢迎您的反馈——通过完成我们的[调查问卷](https://www.ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey)分享您的体验。非常**感谢** 🙏 每一位贡献者！
|
||||
|
||||
<!-- SVG image from https://opencollective.com/ultralytics/contributors.svg?width=1280 -->
|
||||
|
||||
[](https://github.com/ultralytics/ultralytics/graphs/contributors)
|
||||
|
||||
我们期待您的贡献，帮助 Ultralytics 生态系统变得更好！
|
||||
|
||||
## 📜 许可证
|
||||
|
||||
Ultralytics 提供两种许可选项以满足不同需求：
|
||||
|
||||
- **AGPL-3.0 许可证**：这种经 [OSI 批准](https://opensource.org/license/agpl-v3)的开源许可证非常适合学生、研究人员和爱好者。它鼓励开放协作和知识共享。有关完整详细信息，请参阅 [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) 文件。
|
||||
- **Ultralytics 企业许可证**：专为商业用途设计，此许可证允许将 Ultralytics 软件和 AI 模型无缝集成到商业产品和服务中，绕过 AGPL-3.0 的开源要求。如果您的使用场景涉及商业部署，请通过 [Ultralytics 授权许可](https://www.ultralytics.com/license)与我们联系。
|
||||
|
||||
## 📞 联系方式
|
||||
|
||||
有关 Ultralytics 软件的错误报告和功能请求，请访问 [GitHub Issues](https://github.com/ultralytics/ultralytics/issues)。如有疑问、讨论和社区支持，请加入我们在 [Discord](https://discord.com/invite/ultralytics)、[Reddit](https://www.reddit.com/r/ultralytics/?rdt=44154) 和 [Ultralytics 社区论坛](https://community.ultralytics.com/)上的活跃社区。我们随时为您提供有关 Ultralytics 的所有帮助！
|
||||
|
||||
<br>
|
||||
<div align="center">
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
|
||||
</div>
|
||||
@@ -1,59 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Image is CUDA-optimized for YOLO single/multi-GPU training and inference
|
||||
|
||||
# Start FROM PyTorch image https://hub.docker.com/r/pytorch/pytorch or nvcr.io/nvidia/pytorch:25.02-py3
|
||||
FROM pytorch/pytorch:2.9.1-cuda12.8-cudnn9-runtime
|
||||
|
||||
# Set environment variables
|
||||
# Avoid DDP error "MKL_THREADING_LAYER=INTEL is incompatible with libgomp.so.1 library"
|
||||
# Suppress TensorFlow cuDNN, cuBLAS, and cuFFT Registration Warnings and PyTorch NNPACK warnings
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_BREAK_SYSTEM_PACKAGES=1 \
|
||||
MKL_THREADING_LAYER=GNU \
|
||||
OMP_NUM_THREADS=1 \
|
||||
TF_CPP_MIN_LOG_LEVEL=3 \
|
||||
TORCH_CPP_LOG_LEVEL=ERROR
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Install linux packages
|
||||
# gnupg required for Edge TPU install
|
||||
# libsm6 required by libqxcb to create QT-based windows for visualization; set 'QT_DEBUG_PLUGINS=1' to test in docker
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends \
|
||||
gcc git zip unzip wget curl htop libgl1 libglib2.0-0 gnupg libsm6 && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Create working directory
|
||||
WORKDIR /ultralytics
|
||||
|
||||
# Copy contents and configure git
|
||||
COPY . .
|
||||
RUN sed -i '/^\[http "https:\/\/github\.com\/"\]/,+1d' .git/config && \
|
||||
sed -i'' -e 's/"opencv-python/"opencv-python-headless/' pyproject.toml
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Install pip packages (uv already installed in base image)
|
||||
RUN uv pip install --system -e "." albumentations faster-coco-eval wandb && \
|
||||
# Remove extra build files \
|
||||
rm -rf tmp /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest && docker build -f docker/Dockerfile -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest && docker pull $t
|
||||
# Example (run-gpu): docker run -it --ipc=host --runtime=nvidia --gpus all $t
|
||||
# Example (run-gpu-subset): docker run -it --ipc=host --runtime=nvidia --gpus "device=2,3" $t
|
||||
# Note: device=2,3 maps to CUDA 0,1 inside the container.
|
||||
# Example (run-with-volume): docker run -it --ipc=host --runtime=nvidia --gpus all -v "$PWD/shared/datasets:/datasets" $t
|
||||
# Example (tag-release): t=ultralytics/ultralytics:latest tnew=ultralytics/ultralytics:vX.Y && docker tag $t $tnew && docker push $tnew
|
||||
@@ -1,55 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-arm64 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Image is aarch64-compatible for Apple M1, M2, M3, Raspberry Pi and other ARM architectures
|
||||
|
||||
# Start FROM Ubuntu image https://hub.docker.com/_/ubuntu with "FROM arm64v8/ubuntu:22.04" (deprecated)
|
||||
# Start FROM Debian image for arm64v8 https://hub.docker.com/r/arm64v8/debian (deprecated)
|
||||
# Start FROM official arm64v8 Ubuntu 24.04 image https://hub.docker.com/layers/arm64v8/ubuntu/24.04/
|
||||
FROM arm64v8/ubuntu:24.04
|
||||
|
||||
# Set environment variables (suppress PyTorch NNPACK warnings)
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_BREAK_SYSTEM_PACKAGES=1 \
|
||||
TORCH_CPP_LOG_LEVEL=ERROR
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Install linux packages
|
||||
# TensorFlow on aarch64 may require pkg-config and libhdf5-dev if h5py builds from source.
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends \
|
||||
python3-pip git zip unzip wget curl htop gcc libgl1 libglib2.0-0 gnupg && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Create working directory
|
||||
WORKDIR /ultralytics
|
||||
|
||||
# Copy contents and configure git
|
||||
COPY . .
|
||||
RUN sed -i '/^\[http "https:\/\/github\.com\/"\]/,+1d' .git/config && \
|
||||
sed -i'' -e 's/"opencv-python/"opencv-python-headless/' pyproject.toml
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Install pip packages, create python symlink, and remove build files
|
||||
RUN python3 -m pip install uv && \
|
||||
uv pip install --system -e ".[export]" --break-system-packages && \
|
||||
# Creates a symbolic link to make 'python' point to 'python3'
|
||||
ln -sf /usr/bin/python3 /usr/bin/python && \
|
||||
# Remove extra build files
|
||||
rm -rf /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-arm64 && docker build --platform linux/arm64 -f docker/Dockerfile-arm64 -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-arm64 && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,43 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-conda image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Image is optimized for Ultralytics Anaconda (https://anaconda.org/conda-forge/ultralytics) installation and usage
|
||||
|
||||
# Start FROM miniconda3 image https://hub.docker.com/r/continuumio/miniconda3
|
||||
FROM continuumio/miniconda3:latest
|
||||
|
||||
# Set environment variables
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_BREAK_SYSTEM_PACKAGES=1
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Install linux packages and conda packages
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends libgl1 && \
|
||||
apt-get clean && \
|
||||
# Install conda packages
|
||||
# mkl required to fix 'OSError: libmkl_intel_lp64.so.2: cannot open shared object file: No such file or directory'
|
||||
conda config --set solver libmamba && \
|
||||
conda install -y pytorch torchvision pytorch-cuda=12.1 -c pytorch -c nvidia && \
|
||||
conda install -y -c conda-forge ultralytics mkl && \
|
||||
conda clean -afy && \
|
||||
# Remove extra build files
|
||||
rm -rf /var/lib/apt/lists/* /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Copy model
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-conda && docker build -f docker/Dockerfile-conda -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-conda && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,19 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-cpu image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Lightweight CPU image optimized for inference (extends latest-python)
|
||||
|
||||
# Build from Ultralytics Python image
|
||||
FROM ultralytics/ultralytics:latest-python
|
||||
|
||||
# Set default command to bash
|
||||
CMD ["/bin/bash"]
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-cpu && docker build -f docker/Dockerfile-cpu -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-cpu && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,26 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-export image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Export-optimized derivative of ultralytics/ultralytics:latest for testing and benchmarks
|
||||
# Includes all export format dependencies and pre-installed export packages
|
||||
|
||||
FROM ultralytics/ultralytics:latest
|
||||
|
||||
# Install export dependencies and run exports to AutoInstall packages
|
||||
# Numpy 1.26.4 required for TensorFlow export compatibility
|
||||
# Note tensorrt installed on-demand as depends on runtime environment CUDA version
|
||||
RUN uv pip install --system -e ".[export]" "onnxruntime-gpu" paddlepaddle x2paddle numpy==1.26.4 && \
|
||||
# Run exports to AutoInstall packages \
|
||||
yolo export model=tmp/yolo26n.pt format=edgetpu imgsz=32 && \
|
||||
yolo export model=tmp/yolo26n.pt format=ncnn imgsz=32 && \
|
||||
# Remove temporary files \
|
||||
rm -rf tmp /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-export && docker build -f docker/Dockerfile-export -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-export && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host --runtime=nvidia --gpus all $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host --runtime=nvidia --gpus all -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,69 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-jetson-jetpack4 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Supports JetPack4.x for YOLO on Jetson Nano, TX2, Xavier NX, AGX Xavier
|
||||
|
||||
# Start FROM https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-cuda
|
||||
FROM nvcr.io/nvidia/l4t-cuda:10.2.460-runtime
|
||||
|
||||
# Set environment variables
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Add NVIDIA repositories for TensorRT dependencies
|
||||
RUN wget -q -O - https://repo.download.nvidia.com/jetson/jetson-ota-public.asc | apt-key add - && \
|
||||
echo "deb https://repo.download.nvidia.com/jetson/common r32.7 main" > /etc/apt/sources.list.d/nvidia-l4t-apt-source.list && \
|
||||
echo "deb https://repo.download.nvidia.com/jetson/t194 r32.7 main" >> /etc/apt/sources.list.d/nvidia-l4t-apt-source.list
|
||||
|
||||
# Install dependencies
|
||||
# pkg-config and libhdf5-dev (not included) are needed to build 'h5py==3.11.0' aarch64 wheel required by 'tensorflow'
|
||||
# gnupg required for Edge TPU install
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends \
|
||||
git python3.8 python3.8-dev python3-pip python3-libnvinfer libopenmpi-dev libopenblas-base libomp-dev gcc && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Create symbolic links for python3.8 and pip3
|
||||
RUN ln -sf /usr/bin/python3.8 /usr/bin/python3 && \
|
||||
ln -sf /usr/bin/pip3 /usr/bin/pip
|
||||
|
||||
# Create working directory
|
||||
WORKDIR /ultralytics
|
||||
|
||||
# Copy contents and configure git
|
||||
COPY . .
|
||||
RUN sed -i '/^\[http "https:\/\/github\.com\/"\]/,+1d' .git/config && \
|
||||
sed -i'' -e 's/"opencv-python/"opencv-python-headless/' pyproject.toml
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Replace pyproject.toml TF.js version with 'tensorflowjs>=3.9.0' for JetPack4 compatibility
|
||||
RUN sed -i 's/^\( *"tensorflowjs\)>=.*\(".*\)/\1>=3.9.0\2/' pyproject.toml
|
||||
|
||||
# Install pip packages (pip must be upgraded first before installing uv due to missing setuptools)
|
||||
RUN python3 -m pip install --upgrade pip && \
|
||||
python3 -m pip install uv
|
||||
# Install pip packages and remove extra build files
|
||||
# Onnxruntime and TensorRT from https://elinux.org/Jetson_Zoo and https://forums.developer.nvidia.com/t/pytorch-for-jetson/72048
|
||||
RUN uv pip install --system \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.8.0-cp38-cp38-linux_aarch64.whl \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/tensorrt-8.2.0.6-cp38-none-linux_aarch64.whl \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-1.11.0a0+gitbc2c6ed-cp38-cp38-linux_aarch64.whl \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.12.0a0+9b5a3fe-cp38-cp38-linux_aarch64.whl && \
|
||||
uv pip install --system -e ".[export]" && \
|
||||
# Remove extra build files
|
||||
rm -rf *.whl /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-jetson-jetpack4 && docker build --platform linux/arm64 -f docker/Dockerfile-jetson-jetpack4 -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-jetson-jetpack4 && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host --runtime=nvidia $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host --runtime=nvidia -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,58 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-jetson-jetpack5 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Supports JetPack5.1.2 for YOLO on Jetson Xavier NX, AGX Xavier, AGX Orin, Orin Nano and Orin NX
|
||||
|
||||
# Start FROM https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-jetpack
|
||||
FROM nvcr.io/nvidia/l4t-jetpack:r35.4.1
|
||||
|
||||
# Set environment variables
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_BREAK_SYSTEM_PACKAGES=1
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Install dependencies
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends \
|
||||
git python3-pip libopenmpi-dev libopenblas-base libomp-dev \
|
||||
&& apt-get clean \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Create working directory
|
||||
WORKDIR /ultralytics
|
||||
|
||||
# Copy contents and configure git
|
||||
COPY . .
|
||||
RUN sed -i '/^\[http "https:\/\/github\.com\/"\]/,+1d' .git/config && \
|
||||
sed -i'' -e 's/"opencv-python/"opencv-python-headless/' pyproject.toml
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Replace pyproject.toml TF.js version with 'tensorflowjs>=3.9.0' for JetPack5 compatibility and install packages
|
||||
RUN sed -i 's/^\( *"tensorflowjs\)>=.*\(".*\)/\1>=3.9.0\2/' pyproject.toml && \
|
||||
python3 -m pip install --upgrade pip uv
|
||||
|
||||
# Pip install onnxruntime-gpu, torch, torchvision and ultralytics, then remove build files
|
||||
RUN uv pip install --system \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.18.0-cp38-cp38-linux_aarch64.whl \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl && \
|
||||
# Need lower version of 'numpy' for TensorRT export
|
||||
uv pip install --system numpy==1.23.5 && \
|
||||
uv pip install --system -e ".[export]" && \
|
||||
# Remove extra build files
|
||||
rm -rf *.whl /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-jetson-jetpack5 && docker build --platform linux/arm64 -f docker/Dockerfile-jetson-jetpack5 -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-jetson-jetpack5 && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host --runtime=nvidia $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host --runtime=nvidia -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,55 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-jetson-jetpack6 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Supports JetPack6.1 for YOLO on Jetson AGX Orin, Orin NX and Orin Nano Series
|
||||
|
||||
# Start FROM https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-jetpack
|
||||
FROM nvcr.io/nvidia/l4t-jetpack:r36.4.0
|
||||
|
||||
# Set environment variables
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_BREAK_SYSTEM_PACKAGES=1
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Install dependencies and cleanup
|
||||
ADD https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/arm64/cuda-keyring_1.1-1_all.deb .
|
||||
RUN dpkg -i cuda-keyring_1.1-1_all.deb && \
|
||||
apt-get update && \
|
||||
apt-get install -y --no-install-recommends \
|
||||
git python3-pip libopenmpi-dev libopenblas-base libomp-dev libcusparselt0 libcusparselt-dev && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/* cuda-keyring_1.1-1_all.deb
|
||||
|
||||
# Create working directory
|
||||
WORKDIR /ultralytics
|
||||
|
||||
# Copy contents and configure git
|
||||
COPY . .
|
||||
RUN sed -i '/^\[http "https:\/\/github\.com\/"\]/,+1d' .git/config && \
|
||||
sed -i'' -e 's/"opencv-python/"opencv-python-headless/' pyproject.toml
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Pip install onnxruntime-gpu, torch, torchvision and ultralytics, then remove build files
|
||||
RUN python3 -m pip install --upgrade pip uv && \
|
||||
uv pip install --system \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.5.0a0+872d972e41.nv24.08-cp310-cp310-linux_aarch64.whl \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.20.0a0+afc54f7-cp310-cp310-linux_aarch64.whl && \
|
||||
uv pip install --system -e ".[export]" && \
|
||||
# Remove extra build files
|
||||
rm -rf *.whl /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-jetson-jetpack6 && docker build --platform linux/arm64 -f docker/Dockerfile-jetson-jetpack6 -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-jetson-jetpack6 && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host --runtime=nvidia $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host --runtime=nvidia -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,27 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-jupyter image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Image provides JupyterLab interface for interactive YOLO development and includes tutorial notebooks
|
||||
|
||||
# Start from Python-based Ultralytics image for full Python environment
|
||||
FROM ultralytics/ultralytics:latest-python
|
||||
|
||||
# Install JupyterLab for interactive development
|
||||
RUN uv pip install --system jupyterlab && \
|
||||
# Create persistent data directory structure
|
||||
mkdir -p /data/{datasets,weights,runs} && \
|
||||
# Configure YOLO directories
|
||||
yolo settings datasets_dir="/data/datasets" weights_dir="/data/weights" runs_dir="/data/runs" && \
|
||||
rm -rf tmp /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Start JupyterLab with tutorial notebook
|
||||
ENTRYPOINT ["/usr/local/bin/jupyter", "lab", "--allow-root", "--ip=0.0.0.0", "/ultralytics/examples/tutorial.ipynb"]
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-jupyter && docker build -f docker/Dockerfile-jupyter -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-jupyter && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host -p 8888:8888 $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host -p 8888:8888 -v "$PWD/datasets:/data/datasets" $t
|
||||
@@ -1,51 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-nvidia-arm64 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Supports JetPack 7.0 and DGX OS for YOLO on Jetson AGX Thor (T5000) and DGX Spark
|
||||
|
||||
# Start FROM PyTorch image nvcr.io/nvidia/pytorch:25.10-py3
|
||||
FROM nvcr.io/nvidia/pytorch:25.10-py3
|
||||
|
||||
# Set environment variables
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_BREAK_SYSTEM_PACKAGES=1
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Install linux packages
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends libgl1 && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Create working directory
|
||||
WORKDIR /ultralytics
|
||||
|
||||
# Copy contents and configure git
|
||||
COPY . .
|
||||
RUN sed -i '/^\[http "https:\/\/github\.com\/"\]/,+1d' .git/config && \
|
||||
sed -i'' -e 's/"opencv-python/"opencv-python-headless/' pyproject.toml
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Install pip packages (uv already installed in base image)
|
||||
RUN uv pip install --system \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whl --break-system-packages && \
|
||||
# Reinstall torch and torchvision to ensure CUDA 13.0 compatibility
|
||||
uv pip install --system --force-reinstall torch torchvision --index-url https://download.pytorch.org/whl/cu130 --break-system-packages && \
|
||||
uv pip install --system -e ".[export]" --break-system-packages && \
|
||||
# Remove extra build files
|
||||
rm -rf *.whl /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-nvidia-arm64 && docker build --platform linux/arm64 -f docker/Dockerfile-nvidia-arm64 -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-nvidia-arm64 && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host --runtime=nvidia $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host --runtime=nvidia -v "$PWD/shared/datasets:/datasets" $t && docker push $tnew
|
||||
@@ -1,50 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-python image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Lightweight CPU image optimized for YOLO inference
|
||||
|
||||
# Use official Python base image for reproducibility (3.11.10 for export and 3.12.10 for inference)
|
||||
FROM python:3.11.10-slim-bookworm
|
||||
|
||||
# Set environment variables (suppress PyTorch NNPACK warnings)
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_BREAK_SYSTEM_PACKAGES=1 \
|
||||
TORCH_CPP_LOG_LEVEL=ERROR
|
||||
|
||||
# Downloads to user config dir
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
|
||||
https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
|
||||
/root/.config/Ultralytics/
|
||||
|
||||
# Install linux packages
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends \
|
||||
python3-pip git zip unzip wget curl htop libgl1 libglib2.0-0 && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Create working directory
|
||||
WORKDIR /ultralytics
|
||||
|
||||
# Copy contents and configure git
|
||||
COPY . .
|
||||
RUN sed -i '/^\[http "https:\/\/github\.com\/"\]/,+1d' .git/config && \
|
||||
sed -i'' -e 's/"opencv-python/"opencv-python-headless/' pyproject.toml
|
||||
ADD https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt .
|
||||
|
||||
# Install pip packages
|
||||
RUN pip install uv && \
|
||||
uv pip install --system -e . --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match && \
|
||||
# Remove extra build files
|
||||
rm -rf tmp ~/.cache /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-python && docker build -f docker/Dockerfile-python -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-python && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,34 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds ultralytics/ultralytics:latest-python-export image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Full-featured image with export capabilities for YOLO model conversion
|
||||
|
||||
# Build from lightweight Ultralytics Python image
|
||||
FROM ultralytics/ultralytics:latest-python
|
||||
|
||||
# Install export-specific system packages
|
||||
# gnupg required for Edge TPU install
|
||||
# Java runtime environment (default-jre-headless) required for Sony IMX export
|
||||
RUN apt-get update && \
|
||||
apt-get install -y --no-install-recommends gnupg default-jre-headless && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Install export dependencies and run exports to AutoInstall packages
|
||||
RUN uv pip install --system -e ".[export]" && \
|
||||
# Run exports to AutoInstall packages (IMX can only export to YOLO11)
|
||||
yolo export model=tmp/yolo26n.pt format=edgetpu imgsz=32 && \
|
||||
yolo export model=tmp/yolo26n.pt format=ncnn imgsz=32 && \
|
||||
yolo export model=tmp/yolo11n.pt format=imx imgsz=32 && \
|
||||
uv pip install --system paddlepaddle x2paddle && \
|
||||
# Remove extra build files
|
||||
rm -rf tmp /root/.config/Ultralytics/persistent_cache.json
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-python-export && docker build -f docker/Dockerfile-python-export -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-python-export && docker pull $t
|
||||
# Example (run): docker run -it --ipc=host $t
|
||||
# Example (run-with-volume): docker run -it --ipc=host -v "$PWD/shared/datasets:/datasets" $t
|
||||
@@ -1,39 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
# Builds GitHub actions CI runner image for deployment to DockerHub https://hub.docker.com/r/ultralytics/ultralytics
|
||||
# Image is CUDA-optimized for YOLO single/multi-GPU training and inference tests
|
||||
|
||||
# Start FROM Ultralytics GPU image
|
||||
FROM ultralytics/ultralytics:latest
|
||||
|
||||
# Set additional environment variables for runner
|
||||
ARG RUNNER_VERSION=2.329.0
|
||||
ENV RUNNER_ALLOW_RUNASROOT=1 \
|
||||
DEBIAN_FRONTEND=noninteractive
|
||||
|
||||
# Set the working directory
|
||||
WORKDIR /actions-runner
|
||||
|
||||
# Download and unpack the runner from https://github.com/actions/runner and install dependencies
|
||||
RUN FILENAME=actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz && \
|
||||
curl -fLso "$FILENAME" "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/${FILENAME}" && \
|
||||
tar xzf "$FILENAME" && \
|
||||
rm "$FILENAME" && \
|
||||
# Install runner dependencies \
|
||||
uv pip install --system pytest-cov && \
|
||||
./bin/installdependencies.sh && \
|
||||
apt-get update && \
|
||||
apt-get install -y --no-install-recommends libicu-dev && \
|
||||
apt-get clean && \
|
||||
rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# JSON ENTRYPOINT command to configure and start runner with default TOKEN and NAME
|
||||
ENTRYPOINT ["sh", "-c", "./config.sh --url https://github.com/ultralytics/ultralytics --token ${GITHUB_RUNNER_TOKEN:-TOKEN} --name ${GITHUB_RUNNER_NAME:-NAME} --labels gpu-latest --replace && ./run.sh"]
|
||||
|
||||
# Usage --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Production builds: https://github.com/ultralytics/ultralytics/blob/main/.github/workflows/docker.yml
|
||||
# Example (build): t=ultralytics/ultralytics:latest-runner && docker build -f docker/Dockerfile-runner -t $t .
|
||||
# Example (push): docker push $t
|
||||
# Example (pull): t=ultralytics/ultralytics:latest-runner && docker pull $t
|
||||
# Example (run): docker run -d --restart unless-stopped -e GITHUB_RUNNER_TOKEN=TOKEN -e GITHUB_RUNNER_NAME=NAME --ipc=host --runtime=nvidia --gpus all $t
|
||||
@@ -1,145 +0,0 @@
|
||||
<a href="https://www.ultralytics.com/" target="_blank"><img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320" alt="Ultralytics logo"></a>
|
||||
|
||||
# 📚 Ultralytics Docs
|
||||
|
||||
Welcome to Ultralytics Docs, your comprehensive resource for understanding and utilizing our state-of-the-art [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) tools and models, including [Ultralytics YOLO](https://docs.ultralytics.com/models/yolo26/). These documents are actively maintained and deployed to [https://docs.ultralytics.com](https://docs.ultralytics.com/) for easy access.
|
||||
|
||||
[](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment)
|
||||
[](https://github.com/ultralytics/docs/actions/workflows/links.yml)
|
||||
[](https://github.com/ultralytics/docs/actions/workflows/check_domains.yml)
|
||||
[](https://github.com/ultralytics/docs/actions/workflows/format.yml)
|
||||
|
||||
<a href="https://discord.com/invite/ultralytics"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a> <a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a> <a href="https://www.reddit.com/r/ultralytics/"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
|
||||
|
||||
## 🛠️ Installation
|
||||
|
||||
[](https://pypi.org/project/ultralytics/)
|
||||
[](https://clickpy.clickhouse.com/dashboard/ultralytics)
|
||||
[](https://pypi.org/project/ultralytics/)
|
||||
|
||||
To install the `ultralytics` package in developer mode, which allows you to modify the source code directly, ensure you have [Git](https://git-scm.com/) and [Python](https://www.python.org/) 3.8 or later installed on your system. Then, follow these steps:
|
||||
|
||||
1. Clone the `ultralytics` repository to your local machine using Git:
|
||||
|
||||
```bash
|
||||
git clone https://github.com/ultralytics/ultralytics.git
|
||||
```
|
||||
|
||||
2. Navigate to the cloned repository's root directory:
|
||||
|
||||
```bash
|
||||
cd ultralytics
|
||||
```
|
||||
|
||||
3. Install the package in editable mode (`-e`) along with its development dependencies (`[dev]`) using [pip](https://pip.pypa.io/en/stable/):
|
||||
|
||||
```bash
|
||||
pip install -e '.[dev]'
|
||||
```
|
||||
|
||||
This command installs the `ultralytics` package such that changes to the source code are immediately reflected in your environment, ideal for development.
|
||||
|
||||
## 🚀 Building and Serving Locally
|
||||
|
||||
The `mkdocs serve` command builds and serves a local version of your [MkDocs](https://www.mkdocs.org/) documentation. This is highly useful during development and testing to preview changes.
|
||||
|
||||
```bash
|
||||
mkdocs serve
|
||||
```
|
||||
|
||||
- **Command Breakdown:**
|
||||
- `mkdocs`: The main MkDocs command-line interface tool.
|
||||
- `serve`: The subcommand used to build and locally serve your documentation site.
|
||||
- **Note:**
|
||||
- `mkdocs serve` includes live reloading, automatically updating the preview in your browser as you save changes to the documentation files.
|
||||
- To stop the local server, simply press `CTRL+C` in your terminal.
|
||||
|
||||
## 🌍 Building and Serving Multi-Language
|
||||
|
||||
If your documentation supports multiple languages, follow these steps to build and preview all versions:
|
||||
|
||||
1. Stage all new or modified language Markdown (`.md`) files using Git:
|
||||
|
||||
```bash
|
||||
git add docs/**/*.md -f
|
||||
```
|
||||
|
||||
2. Build all language versions into the `/site` directory. This script ensures that relevant root-level files are included and clears the previous build:
|
||||
|
||||
```bash
|
||||
# Clear existing /site directory to prevent conflicts
|
||||
rm -rf site
|
||||
|
||||
# Build the default language site using the primary config file
|
||||
mkdocs build -f docs/mkdocs.yml
|
||||
|
||||
# Loop through each language-specific config file and build its site
|
||||
for file in docs/mkdocs_*.yml; do
|
||||
echo "Building MkDocs site with $file"
|
||||
mkdocs build -f "$file"
|
||||
done
|
||||
```
|
||||
|
||||
3. To preview the complete multi-language site locally, navigate into the build output directory and start a simple [Python HTTP server](https://docs.python.org/3/library/http.server.html):
|
||||
```bash
|
||||
cd site
|
||||
python -m http.server
|
||||
# Open http://localhost:8000 in your preferred web browser
|
||||
```
|
||||
Access the live preview site at `http://localhost:8000`.
|
||||
|
||||
## 📤 Deploying Your Documentation Site
|
||||
|
||||
To deploy your MkDocs documentation site, choose a hosting provider and configure your deployment method. Common options include [GitHub Pages](https://pages.github.com/), GitLab Pages, or other static site hosting services.
|
||||
|
||||
- Configure deployment settings within your `mkdocs.yml` file.
|
||||
- Use your hosting provider's recommended workflow (for example running `mkdocs build` in CI or `mkdocs gh-deploy` for GitHub Pages) to publish the generated `site/` directory.
|
||||
|
||||
* **GitHub Pages Deployment Example:**
|
||||
If deploying to GitHub Pages, you can use the built-in command:
|
||||
|
||||
```bash
|
||||
mkdocs gh-deploy
|
||||
```
|
||||
|
||||
After deployment, you might need to update the "Custom domain" settings in your repository's settings page if you wish to use a personalized URL.
|
||||
|
||||
|
||||
|
||||
- For detailed instructions on various deployment methods, consult the official [MkDocs Deploying your docs guide](https://www.mkdocs.org/user-guide/deploying-your-docs/).
|
||||
|
||||
## 💡 Contribute
|
||||
|
||||
We deeply value contributions from the open-source community to enhance Ultralytics projects. Your input helps drive innovation! Please review our [Contributing Guide](https://docs.ultralytics.com/help/contributing/) for detailed information on how to get involved. You can also share your feedback and ideas through our [Survey](https://www.ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey). A heartfelt thank you 🙏 to all our contributors for their dedication and support!
|
||||
|
||||
|
||||
|
||||
We look forward to your contributions!
|
||||
|
||||
## 📜 License
|
||||
|
||||
Ultralytics Docs are available under two licensing options to accommodate different usage scenarios:
|
||||
|
||||
- **AGPL-3.0 License**: Ideal for students, researchers, and enthusiasts involved in academic pursuits and open collaboration. See the [LICENSE](https://github.com/ultralytics/docs/blob/main/LICENSE) file for full details. This license promotes sharing improvements back with the community.
|
||||
- **Enterprise License**: Designed for commercial applications, this license allows seamless integration of Ultralytics software and [AI models](https://docs.ultralytics.com/models/) into commercial products and services. Visit [Ultralytics Licensing](https://www.ultralytics.com/license) for more information on obtaining an Enterprise License.
|
||||
|
||||
## ✉️ Contact
|
||||
|
||||
For bug reports, feature requests, and other issues related to the documentation, please use [GitHub Issues](https://github.com/ultralytics/docs/issues). For discussions, questions, and community support, join the conversation with peers and the Ultralytics team on our [Discord server](https://discord.com/invite/ultralytics)!
|
||||
|
||||
<br>
|
||||
<div align="center">
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
|
||||
<a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
|
||||
</div>
|
||||
@@ -1,691 +0,0 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
"""
|
||||
Automates building and post-processing of MkDocs documentation, especially for multilingual projects.
|
||||
|
||||
This script streamlines generating localized documentation and updating HTML links for correct formatting.
|
||||
|
||||
Key Features:
|
||||
- Automated building of MkDocs documentation: Compiles main documentation and localized versions from separate
|
||||
MkDocs configuration files.
|
||||
- Post-processing of generated HTML files: Updates HTML files to remove '.md' from internal links, ensuring
|
||||
correct navigation in web-based documentation.
|
||||
|
||||
Usage:
|
||||
- Run from the root directory of your MkDocs project.
|
||||
- Ensure MkDocs is installed and configuration files (main and localized) are present.
|
||||
- The script builds documentation using MkDocs, then scans HTML files in 'site' to update links.
|
||||
- Ideal for projects with Markdown documentation served as a static website.
|
||||
|
||||
Note:
|
||||
- Requires Python and MkDocs to be installed and configured.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import yaml
|
||||
from bs4 import BeautifulSoup
|
||||
from minijinja import Environment, load_from_path
|
||||
|
||||
try:
|
||||
from plugin import postprocess_site # mkdocs-ultralytics-plugin
|
||||
except ImportError:
|
||||
postprocess_site = None
|
||||
|
||||
from build_reference import build_reference_docs
|
||||
|
||||
from ultralytics.utils import LINUX, LOGGER, MACOS
|
||||
from ultralytics.utils.tqdm import TQDM
|
||||
|
||||
os.environ["JUPYTER_PLATFORM_DIRS"] = "1" # fix DeprecationWarning: Jupyter is migrating to use standard platformdirs
|
||||
DOCS = Path(__file__).parent.resolve()
|
||||
SITE = DOCS.parent / "site"
|
||||
LINK_PATTERN = re.compile(r"(https?://[^\s()<>]*[^\s()<>.,:;!?\'\"])")
|
||||
TITLE_PATTERN = re.compile(r"<title>(.*?)</title>", flags=re.IGNORECASE | re.DOTALL)
|
||||
MD_LINK_PATTERN = re.compile(r'(["\']?)([^"\'>\s]+?)\.md(["\']?)')
|
||||
DOC_KIND_LABELS = {"Class", "Function", "Method", "Property"}
|
||||
DOC_KIND_COLORS = {
|
||||
"Class": "#039dfc", # blue
|
||||
"Method": "#ef5eff", # magenta
|
||||
"Function": "#fc9803", # orange
|
||||
"Property": "#02e835", # green
|
||||
}
|
||||
|
||||
|
||||
def prepare_docs_markdown(clone_repos: bool = True):
|
||||
"""Build docs using mkdocs."""
|
||||
LOGGER.info("Removing existing build artifacts")
|
||||
shutil.rmtree(SITE, ignore_errors=True)
|
||||
shutil.rmtree(DOCS / "repos", ignore_errors=True)
|
||||
|
||||
if clone_repos:
|
||||
# Get docs repo
|
||||
repo = "https://github.com/ultralytics/docs"
|
||||
local_dir = DOCS / "repos" / Path(repo).name
|
||||
subprocess.run(
|
||||
["git", "clone", "-q", "--depth=1", "--single-branch", "-b", "main", repo, str(local_dir)], check=True
|
||||
)
|
||||
shutil.rmtree(DOCS / "en/compare", ignore_errors=True) # delete if exists
|
||||
shutil.copytree(local_dir / "docs/en/compare", DOCS / "en/compare") # for docs
|
||||
LOGGER.info(f"Cloned/Updated {repo} in {local_dir}")
|
||||
|
||||
# Add frontmatter
|
||||
for file in TQDM((DOCS / "en").rglob("*.md"), desc="Adding frontmatter"):
|
||||
update_markdown_files(file)
|
||||
|
||||
|
||||
def update_markdown_files(md_filepath: Path):
|
||||
"""Create or update a Markdown file, ensuring frontmatter is present."""
|
||||
if md_filepath.exists():
|
||||
content = md_filepath.read_text().strip()
|
||||
|
||||
# Replace apostrophes
|
||||
content = content.replace("‘", "'").replace("’", "'")
|
||||
|
||||
# Add frontmatter if missing
|
||||
if not content.strip().startswith("---\n"):
|
||||
header = "---\ncomments: true\ndescription: TODO ADD DESCRIPTION\nkeywords: TODO ADD KEYWORDS\n---\n\n"
|
||||
content = header + content
|
||||
|
||||
# Ensure MkDocs admonitions "=== " lines are preceded and followed by empty newlines
|
||||
lines = content.split("\n")
|
||||
new_lines = []
|
||||
for i, line in enumerate(lines):
|
||||
stripped_line = line.strip()
|
||||
if stripped_line.startswith("=== "):
|
||||
if i > 0 and new_lines[-1] != "":
|
||||
new_lines.append("")
|
||||
new_lines.append(line)
|
||||
if i < len(lines) - 1 and lines[i + 1].strip() != "":
|
||||
new_lines.append("")
|
||||
else:
|
||||
new_lines.append(line)
|
||||
content = "\n".join(new_lines)
|
||||
|
||||
# Add EOF newline if missing
|
||||
if not content.endswith("\n"):
|
||||
content += "\n"
|
||||
|
||||
# Save page
|
||||
md_filepath.write_text(content)
|
||||
return
|
||||
|
||||
|
||||
def update_docs_html():
|
||||
"""Update titles, edit links, and convert plaintext links in HTML documentation in one pass."""
|
||||
from concurrent.futures import ProcessPoolExecutor
|
||||
|
||||
html_files = list(SITE.rglob("*.html"))
|
||||
if not html_files:
|
||||
LOGGER.info("Updated HTML files: 0")
|
||||
return
|
||||
desc = f"Updating HTML at {SITE}"
|
||||
max_workers = os.cpu_count() or 1
|
||||
with ProcessPoolExecutor(max_workers=max_workers) as executor:
|
||||
pbar = TQDM(executor.map(_process_html_file, html_files), total=len(html_files), desc=desc)
|
||||
updated = 0
|
||||
for res in pbar:
|
||||
updated += bool(res)
|
||||
pbar.set_description(f"{desc} ({updated}/{len(html_files)} updated)")
|
||||
|
||||
|
||||
def _process_html_file(html_file: Path) -> bool:
|
||||
"""Process a single HTML file; returns True if modified."""
|
||||
try:
|
||||
content = html_file.read_text(encoding="utf-8")
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"Could not read {html_file}: {e}")
|
||||
return False
|
||||
|
||||
changed = False
|
||||
try:
|
||||
rel_path = html_file.relative_to(SITE).as_posix()
|
||||
except ValueError:
|
||||
rel_path = html_file.name
|
||||
|
||||
# For pages sourced from external repos (compare), drop edit/copy buttons to avoid wrong links
|
||||
if rel_path.startswith("compare/"):
|
||||
before = content
|
||||
content = re.sub(
|
||||
r'<a[^>]*class="[^"]*md-content__button[^"]*"[^>]*>.*?</a>',
|
||||
"",
|
||||
content,
|
||||
flags=re.IGNORECASE | re.DOTALL,
|
||||
)
|
||||
if content != before:
|
||||
changed = True
|
||||
|
||||
if rel_path == "404.html":
|
||||
new_content = re.sub(r"<title>.*?</title>", "<title>Ultralytics Docs - Not Found</title>", content)
|
||||
if new_content != content:
|
||||
content, changed = new_content, True
|
||||
|
||||
new_content = update_docs_soup(content, html_file=html_file)
|
||||
if new_content != content:
|
||||
content, changed = new_content, True
|
||||
|
||||
new_content = _rewrite_md_links(content)
|
||||
if new_content != content:
|
||||
content, changed = new_content, True
|
||||
|
||||
if changed:
|
||||
try:
|
||||
html_file.write_text(content, encoding="utf-8")
|
||||
return True
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"Could not write {html_file}: {e}")
|
||||
return False
|
||||
|
||||
|
||||
def update_docs_soup(content: str, html_file: Path | None = None, max_title_length: int = 70) -> str:
|
||||
"""Convert plaintext links to HTML hyperlinks, truncate long meta titles, and remove code line hrefs."""
|
||||
title_match = TITLE_PATTERN.search(content)
|
||||
needs_title_trim = bool(
|
||||
title_match and len(title_match.group(1)) > max_title_length and "-" in title_match.group(1)
|
||||
)
|
||||
needs_link_conversion = ("<p" in content or "<li" in content) and bool(LINK_PATTERN.search(content))
|
||||
needs_codelineno_cleanup = "__codelineno-" in content
|
||||
rel_path = ""
|
||||
if html_file:
|
||||
try:
|
||||
rel_path = html_file.relative_to(SITE).as_posix()
|
||||
except Exception:
|
||||
rel_path = html_file.as_posix()
|
||||
needs_kind_highlight = "reference" in rel_path or "reference" in content
|
||||
|
||||
if not (needs_title_trim or needs_link_conversion or needs_codelineno_cleanup or needs_kind_highlight):
|
||||
return content
|
||||
|
||||
try:
|
||||
soup = BeautifulSoup(content, "lxml")
|
||||
except Exception:
|
||||
soup = BeautifulSoup(content, "html.parser")
|
||||
modified = False
|
||||
|
||||
# Truncate long meta title if needed
|
||||
title_tag = soup.find("title") if needs_title_trim else None
|
||||
if title_tag and len(title_tag.text) > max_title_length and "-" in title_tag.text:
|
||||
title_tag.string = title_tag.text.rsplit("-", 1)[0].strip()
|
||||
modified = True
|
||||
|
||||
# Find the main content area
|
||||
main_content = soup.find("main") or soup.find("div", class_="md-content")
|
||||
if not main_content:
|
||||
return str(soup) if modified else content
|
||||
|
||||
# Convert plaintext links to HTML hyperlinks
|
||||
if needs_link_conversion:
|
||||
for paragraph in main_content.select("p, li"):
|
||||
for text_node in paragraph.find_all(string=True, recursive=False):
|
||||
if text_node.parent.name not in {"a", "code"}:
|
||||
new_text = LINK_PATTERN.sub(r'<a href="\1">\1</a>', str(text_node))
|
||||
if "<a href=" in new_text:
|
||||
text_node.replace_with(BeautifulSoup(new_text, "html.parser"))
|
||||
modified = True
|
||||
|
||||
# Remove href attributes from code line numbers in code blocks
|
||||
if needs_codelineno_cleanup:
|
||||
for a in soup.select('a[href^="#__codelineno-"], a[id^="__codelineno-"]'):
|
||||
if a.string: # If the a tag has text (the line number)
|
||||
# Check if parent is a span with class="normal"
|
||||
if a.parent and a.parent.name == "span" and "normal" in a.parent.get("class", []):
|
||||
del a.parent["class"]
|
||||
a.replace_with(a.string) # Replace with just the text
|
||||
else: # If it has no text
|
||||
a.replace_with(soup.new_tag("span")) # Replace with an empty span
|
||||
modified = True
|
||||
|
||||
def highlight_labels(nodes):
|
||||
"""Inject doc-kind badges into headings and nav entries."""
|
||||
nonlocal modified
|
||||
|
||||
for node in nodes:
|
||||
if not node.contents:
|
||||
continue
|
||||
first = node.contents[0]
|
||||
if hasattr(first, "get") and "doc-kind" in (first.get("class") or []):
|
||||
continue
|
||||
text = first if isinstance(first, str) else getattr(first, "string", "")
|
||||
if not text:
|
||||
continue
|
||||
stripped = str(text).strip()
|
||||
if not stripped:
|
||||
continue
|
||||
kind = stripped.split()[0].rstrip(":")
|
||||
if kind not in DOC_KIND_LABELS:
|
||||
continue
|
||||
span = soup.new_tag("span", attrs={"class": f"doc-kind doc-kind-{kind.lower()}"})
|
||||
span.string = kind.lower()
|
||||
first.replace_with(span)
|
||||
tail = str(text)[len(kind) :]
|
||||
tail_stripped = tail.lstrip()
|
||||
if tail_stripped.startswith(kind):
|
||||
tail = tail_stripped[len(kind) :]
|
||||
if not tail and len(node.contents) > 0:
|
||||
tail = " "
|
||||
if tail:
|
||||
span.insert_after(tail)
|
||||
modified = True
|
||||
|
||||
highlight_labels(soup.select("main h1, main h2, main h3, main h4, main h5"))
|
||||
highlight_labels(soup.select("nav.md-nav--secondary .md-ellipsis, nav.md-nav__list .md-ellipsis"))
|
||||
|
||||
if "reference" in rel_path:
|
||||
for ellipsis in soup.select("nav.md-nav--secondary .md-ellipsis"):
|
||||
kind = ellipsis.find(class_=lambda c: c and "doc-kind" in c.split())
|
||||
text = str(kind.next_sibling).strip() if kind and kind.next_sibling else ellipsis.get_text(strip=True)
|
||||
if "." not in text:
|
||||
continue
|
||||
ellipsis.clear()
|
||||
short = text.rsplit(".", 1)[-1]
|
||||
if kind:
|
||||
ellipsis.append(kind)
|
||||
ellipsis.append(f" {short}")
|
||||
else:
|
||||
ellipsis.append(short)
|
||||
modified = True
|
||||
|
||||
if needs_kind_highlight and not modified and soup.select(".doc-kind"):
|
||||
# Ensure style injection when pre-existing badges are present
|
||||
modified = True
|
||||
|
||||
if modified:
|
||||
head = soup.find("head")
|
||||
if head and not soup.select("style[data-doc-kind]"):
|
||||
style = soup.new_tag("style", attrs={"data-doc-kind": "true"})
|
||||
style.string = (
|
||||
".doc-kind{display:inline-flex;align-items:center;gap:0.25em;padding:0.21em 0.59em;border-radius:999px;"
|
||||
"font-weight:700;font-size:0.81em;letter-spacing:0.06em;text-transform:uppercase;"
|
||||
"line-height:1;color:var(--doc-kind-color,#f8fafc);"
|
||||
"background:var(--doc-kind-bg,rgba(255,255,255,0.12));}"
|
||||
f".doc-kind-class{{--doc-kind-color:{DOC_KIND_COLORS['Class']};--doc-kind-bg:rgba(3,157,252,0.22);}}"
|
||||
f".doc-kind-function{{--doc-kind-color:{DOC_KIND_COLORS['Function']};--doc-kind-bg:rgba(252,152,3,0.22);}}"
|
||||
f".doc-kind-method{{--doc-kind-color:{DOC_KIND_COLORS['Method']};--doc-kind-bg:rgba(239,94,255,0.22);}}"
|
||||
f".doc-kind-property{{--doc-kind-color:{DOC_KIND_COLORS['Property']};--doc-kind-bg:rgba(2,232,53,0.22);}}"
|
||||
)
|
||||
head.append(style)
|
||||
|
||||
return str(soup) if modified else content
|
||||
|
||||
|
||||
def _rewrite_md_links(content: str) -> str:
|
||||
"""Replace .md references with trailing slashes in HTML content, skipping GitHub links."""
|
||||
if ".md" not in content:
|
||||
return content
|
||||
|
||||
lines = []
|
||||
for line in content.split("\n"):
|
||||
if "github.com" not in line:
|
||||
line = line.replace("index.md", "")
|
||||
line = MD_LINK_PATTERN.sub(r"\1\2/\3", line)
|
||||
lines.append(line)
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# Precompiled regex patterns for minification
|
||||
HTML_COMMENT = re.compile(r"<!--[\s\S]*?-->")
|
||||
HTML_PRESERVE = re.compile(r"<(pre|code|textarea|script)[^>]*>[\s\S]*?</\1>", re.IGNORECASE)
|
||||
HTML_TAG_SPACE = re.compile(r">\s+<")
|
||||
HTML_MULTI_SPACE = re.compile(r"\s{2,}")
|
||||
HTML_EMPTY_LINE = re.compile(r"^\s*$\n", re.MULTILINE)
|
||||
CSS_COMMENT = re.compile(r"/\*[\s\S]*?\*/")
|
||||
|
||||
|
||||
def remove_comments_and_empty_lines(content: str, file_type: str) -> str:
|
||||
"""Remove comments and empty lines from a string of code, preserving newlines and URLs.
|
||||
|
||||
Args:
|
||||
content (str): Code content to process.
|
||||
file_type (str): Type of file ('html', 'css', or 'js').
|
||||
|
||||
Returns:
|
||||
(str): Cleaned content with comments and empty lines removed.
|
||||
|
||||
Notes:
|
||||
Typical reductions for Ultralytics Docs are:
|
||||
- Total HTML reduction: 2.83% (1301.56 KB saved)
|
||||
- Total CSS reduction: 1.75% (2.61 KB saved)
|
||||
- Total JS reduction: 13.51% (99.31 KB saved)
|
||||
"""
|
||||
if file_type == "html":
|
||||
content = HTML_COMMENT.sub("", content) # Remove HTML comments
|
||||
# Preserve whitespace in <pre>, <code>, <textarea> tags
|
||||
preserved = []
|
||||
|
||||
def preserve(match):
|
||||
"""Mark HTML blocks that should not be minified."""
|
||||
preserved.append(match.group(0))
|
||||
return f"___PRESERVE_{len(preserved) - 1}___"
|
||||
|
||||
content = HTML_PRESERVE.sub(preserve, content)
|
||||
content = HTML_TAG_SPACE.sub("><", content) # Remove whitespace between tags
|
||||
content = HTML_MULTI_SPACE.sub(" ", content) # Collapse multiple spaces
|
||||
content = HTML_EMPTY_LINE.sub("", content) # Remove empty lines
|
||||
# Restore preserved content
|
||||
for i, text in enumerate(preserved):
|
||||
content = content.replace(f"___PRESERVE_{i}___", text)
|
||||
elif file_type == "css":
|
||||
content = CSS_COMMENT.sub("", content) # Remove CSS comments
|
||||
# Remove whitespace around specific characters
|
||||
content = re.sub(r"\s*([{}:;,])\s*", r"\1", content)
|
||||
# Remove empty lines
|
||||
content = re.sub(r"^\s*\n", "", content, flags=re.MULTILINE)
|
||||
# Collapse multiple spaces to single space
|
||||
content = re.sub(r"\s{2,}", " ", content)
|
||||
# Remove all newlines
|
||||
content = re.sub(r"\n", "", content)
|
||||
elif file_type == "js":
|
||||
# Handle JS single-line comments (preserving http:// and https://)
|
||||
lines = content.split("\n")
|
||||
processed_lines = []
|
||||
for line in lines:
|
||||
# Only remove comments if they're not part of a URL
|
||||
if "//" in line and "http://" not in line and "https://" not in line:
|
||||
processed_lines.append(line.partition("//")[0])
|
||||
else:
|
||||
processed_lines.append(line)
|
||||
content = "\n".join(processed_lines)
|
||||
|
||||
# Remove JS multi-line comments and clean whitespace
|
||||
content = re.sub(r"/\*[\s\S]*?\*/", "", content)
|
||||
# Remove empty lines
|
||||
content = re.sub(r"^\s*\n", "", content, flags=re.MULTILINE)
|
||||
# Collapse multiple spaces to single space
|
||||
content = re.sub(r"\s{2,}", " ", content)
|
||||
|
||||
# Safe space removal around punctuation and operators (never include colons - breaks JS)
|
||||
content = re.sub(r"\s*([;{}])\s*", r"\1", content)
|
||||
content = re.sub(r"(\w)\s*\(|\)\s*{|\s*([+\-*/=])\s*", lambda m: m.group(0).replace(" ", ""), content)
|
||||
|
||||
return content
|
||||
|
||||
|
||||
def minify_files(html: bool = True, css: bool = True, js: bool = True):
|
||||
"""Minify HTML, CSS, and JS files and print total reduction stats."""
|
||||
minify, compress, jsmin = None, None, None
|
||||
try:
|
||||
if html:
|
||||
from minify_html import minify
|
||||
if css:
|
||||
from csscompressor import compress
|
||||
if js:
|
||||
import jsmin
|
||||
except ImportError as e:
|
||||
LOGGER.info(f"Missing required package: {e}")
|
||||
return
|
||||
|
||||
stats = {}
|
||||
for ext, minifier in {
|
||||
"html": (lambda x: minify(x, keep_closing_tags=True, minify_css=True, minify_js=True)) if html else None,
|
||||
"css": compress if css else None,
|
||||
"js": jsmin.jsmin if js else None,
|
||||
}.items():
|
||||
orig = minified = 0
|
||||
files = list(SITE.rglob(f"*.{ext}"))
|
||||
if not files:
|
||||
continue
|
||||
pbar = TQDM(files, desc=f"Minifying {ext.upper()} - reduced 0.00% (0.00 KB saved)")
|
||||
for f in pbar:
|
||||
content = f.read_text(encoding="utf-8")
|
||||
out = minifier(content) if minifier else remove_comments_and_empty_lines(content, ext)
|
||||
orig += len(content)
|
||||
minified += len(out)
|
||||
f.write_text(out, encoding="utf-8")
|
||||
saved = orig - minified
|
||||
pct = (saved / orig) * 100 if orig else 0.0
|
||||
pbar.set_description(f"Minifying {ext.upper()} - reduced {pct:.2f}% ({saved / 1024:.2f} KB saved)")
|
||||
stats[ext] = {"original": orig, "minified": minified}
|
||||
|
||||
|
||||
def render_jinja_macros() -> None:
|
||||
"""Render MiniJinja macros in Markdown files before building with MkDocs."""
|
||||
mkdocs_yml = DOCS.parent / "mkdocs.yml"
|
||||
default_yaml = DOCS.parent / "ultralytics" / "cfg" / "default.yaml"
|
||||
|
||||
class SafeFallbackLoader(yaml.SafeLoader):
|
||||
"""SafeLoader that gracefully skips unknown tags (required for mkdocs.yml)."""
|
||||
|
||||
def _ignore_unknown(loader, tag_suffix, node):
|
||||
"""Gracefully handle YAML tags that aren't registered."""
|
||||
if isinstance(node, yaml.ScalarNode):
|
||||
return loader.construct_scalar(node)
|
||||
if isinstance(node, yaml.SequenceNode):
|
||||
return loader.construct_sequence(node)
|
||||
if isinstance(node, yaml.MappingNode):
|
||||
return loader.construct_mapping(node)
|
||||
return None
|
||||
|
||||
SafeFallbackLoader.add_multi_constructor("", _ignore_unknown)
|
||||
|
||||
def load_yaml(path: Path, *, safe_loader: yaml.Loader = yaml.SafeLoader) -> dict:
|
||||
"""Load YAML safely, returning an empty dict on errors."""
|
||||
if not path.exists():
|
||||
return {}
|
||||
try:
|
||||
with open(path, encoding="utf-8") as f:
|
||||
return yaml.load(f, Loader=safe_loader) or {}
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"Could not load {path}: {e}")
|
||||
return {}
|
||||
|
||||
mkdocs_cfg = load_yaml(mkdocs_yml, safe_loader=SafeFallbackLoader)
|
||||
extra_vars = mkdocs_cfg.get("extra", {}) or {}
|
||||
site_name = mkdocs_cfg.get("site_name", "Ultralytics Docs")
|
||||
extra_vars.update(load_yaml(default_yaml))
|
||||
|
||||
env = Environment(
|
||||
loader=load_from_path([DOCS / "en", DOCS]),
|
||||
auto_escape_callback=lambda _: False,
|
||||
trim_blocks=True,
|
||||
lstrip_blocks=True,
|
||||
keep_trailing_newline=True,
|
||||
)
|
||||
|
||||
def indent_filter(value: str, width: int = 4, first: bool = False, blank: bool = False) -> str:
|
||||
"""Mimic Jinja's indent filter to preserve macros compatibility."""
|
||||
prefix = " " * int(width)
|
||||
result = []
|
||||
for i, line in enumerate(str(value).splitlines(keepends=True)):
|
||||
if not line.strip() and not blank:
|
||||
result.append(line)
|
||||
continue
|
||||
if i == 0 and not first:
|
||||
result.append(line)
|
||||
else:
|
||||
result.append(prefix + line)
|
||||
return "".join(result)
|
||||
|
||||
env.add_filter("indent", indent_filter)
|
||||
reserved_keys = {"name"}
|
||||
base_context = {**extra_vars, "page": {"meta": {}}, "config": {"site_name": site_name}}
|
||||
|
||||
files_processed = 0
|
||||
files_with_macros = 0
|
||||
macros_total = 0
|
||||
|
||||
pbar = TQDM((DOCS / "en").rglob("*.md"), desc="MiniJinja: 0 macros, 0 pages")
|
||||
for md_file in pbar:
|
||||
if "macros" in md_file.parts or "reference" in md_file.parts:
|
||||
continue
|
||||
files_processed += 1
|
||||
|
||||
try:
|
||||
content = md_file.read_text(encoding="utf-8")
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"Could not read {md_file}: {e}")
|
||||
continue
|
||||
if "{{" not in content and "{%" not in content:
|
||||
continue
|
||||
|
||||
parts = content.split("---\n")
|
||||
frontmatter = ""
|
||||
frontmatter_data = {}
|
||||
markdown_content = content
|
||||
if content.startswith("---\n") and len(parts) >= 3:
|
||||
frontmatter = f"---\n{parts[1]}---\n"
|
||||
markdown_content = "---\n".join(parts[2:])
|
||||
try:
|
||||
frontmatter_data = yaml.safe_load(parts[1]) or {}
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"Could not parse frontmatter in {md_file}: {e}")
|
||||
|
||||
macro_hits = markdown_content.count("{{") + markdown_content.count("{%")
|
||||
if not macro_hits:
|
||||
continue
|
||||
|
||||
context = {k: v for k, v in base_context.items() if k not in reserved_keys}
|
||||
context.update({k: v for k, v in frontmatter_data.items() if k not in reserved_keys})
|
||||
context["page"] = context.get("page", {})
|
||||
context["page"]["meta"] = frontmatter_data
|
||||
|
||||
try:
|
||||
rendered = env.render_str(markdown_content, name=str(md_file.relative_to(DOCS)), **context)
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"Error rendering macros in {md_file}: {e}")
|
||||
continue
|
||||
|
||||
md_file.write_text(frontmatter + rendered, encoding="utf-8")
|
||||
files_with_macros += 1
|
||||
macros_total += macro_hits
|
||||
pbar.set_description(f"MiniJinja: {macros_total} macros, {files_with_macros} pages")
|
||||
|
||||
|
||||
def backup_docs_sources() -> tuple[Path, list[tuple[Path, Path]]]:
|
||||
"""Create a temporary backup of docs sources so we can fully restore after building."""
|
||||
backup_root = Path(tempfile.mkdtemp(prefix="docs_backup_", dir=str(DOCS.parent)))
|
||||
sources = [DOCS / "en", DOCS / "macros"]
|
||||
copied: list[tuple[Path, Path]] = []
|
||||
for src in sources:
|
||||
if not src.exists():
|
||||
continue
|
||||
dst = backup_root / src.name
|
||||
shutil.copytree(src, dst)
|
||||
copied.append((src, dst))
|
||||
return backup_root, copied
|
||||
|
||||
|
||||
def restore_docs_sources(backup_root: Path, backups: list[tuple[Path, Path]]):
|
||||
"""Restore docs sources from the temporary backup."""
|
||||
for src, dst in backups:
|
||||
shutil.rmtree(src, ignore_errors=True)
|
||||
if dst.exists():
|
||||
shutil.copytree(dst, src)
|
||||
shutil.rmtree(backup_root, ignore_errors=True)
|
||||
|
||||
|
||||
def main():
|
||||
"""Build docs, update titles and edit links, minify HTML, and print local server command."""
|
||||
start_time = time.perf_counter()
|
||||
backup_root: Path | None = None
|
||||
docs_backups: list[tuple[Path, Path]] = []
|
||||
restored = False
|
||||
|
||||
def restore_all():
|
||||
"""Restore docs sources from backup once build steps complete."""
|
||||
nonlocal restored
|
||||
if backup_root:
|
||||
LOGGER.info("Restoring docs directory from backup")
|
||||
restore_docs_sources(backup_root, docs_backups)
|
||||
restored = True
|
||||
|
||||
try:
|
||||
backup_root, docs_backups = backup_docs_sources()
|
||||
prepare_docs_markdown()
|
||||
build_reference_docs(update_nav=False)
|
||||
render_jinja_macros()
|
||||
|
||||
# Remove cloned repos before serving/building to keep the tree lean during mkdocs processing
|
||||
shutil.rmtree(DOCS / "repos", ignore_errors=True)
|
||||
|
||||
# Build the main documentation
|
||||
LOGGER.info(f"Building docs from {DOCS}")
|
||||
subprocess.run(["zensical", "build", "-f", str(DOCS.parent / "mkdocs.yml")], check=True)
|
||||
LOGGER.info(f"Site built at {SITE}")
|
||||
|
||||
# Remove search index JSON files to disable search
|
||||
Path(SITE / "search.json").unlink(missing_ok=True)
|
||||
|
||||
# Update docs HTML pages
|
||||
update_docs_html()
|
||||
|
||||
# Post-process site for meta tags, authors, social cards, and mkdocstrings polish
|
||||
if postprocess_site:
|
||||
postprocess_site(
|
||||
site_dir=SITE,
|
||||
docs_dir=DOCS / "en",
|
||||
site_url="https://docs.ultralytics.com",
|
||||
default_image="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png",
|
||||
default_author="glenn.jocher@ultralytics.com",
|
||||
add_desc=False,
|
||||
add_image=True,
|
||||
add_authors=True,
|
||||
add_json_ld=True,
|
||||
add_share_buttons=True,
|
||||
add_css=False,
|
||||
verbose=True,
|
||||
)
|
||||
else:
|
||||
LOGGER.warning("postprocess_site not available; skipping mkdocstrings postprocessing")
|
||||
|
||||
# Minify files
|
||||
minify_files(html=False, css=False, js=False)
|
||||
|
||||
# Add missing pages to sitemap
|
||||
sitemap = SITE / "sitemap.xml"
|
||||
if sitemap.exists():
|
||||
content = sitemap.read_text()
|
||||
in_sitemap = set(re.findall(r"<loc>([^<]+)</loc>", content))
|
||||
all_pages = {
|
||||
f"https://docs.ultralytics.com/{f.relative_to(SITE).as_posix().replace('index.html', '')}"
|
||||
for f in SITE.rglob("*.html")
|
||||
if f.name != "404.html"
|
||||
}
|
||||
if missing := (all_pages - in_sitemap):
|
||||
entries = "\n".join(f" <url>\n <loc>{u}</loc>\n </url>" for u in sorted(missing))
|
||||
sitemap.write_text(content.replace("</urlset>", f"{entries}\n</urlset>"))
|
||||
LOGGER.info(
|
||||
f"{len(all_pages)}/{len(all_pages)} pages in sitemap.xml ✅ (+{len(missing)} added)"
|
||||
if missing
|
||||
else f"{len(in_sitemap)}/{len(all_pages)} pages in sitemap.xml ✅"
|
||||
)
|
||||
|
||||
# Print results and auto-serve on macOS
|
||||
size = sum(f.stat().st_size for f in SITE.rglob("*") if f.is_file()) >> 20
|
||||
duration = time.perf_counter() - start_time
|
||||
LOGGER.info(f"Docs built correctly ✅ ({size:.1f}MB, {duration:.1f}s)")
|
||||
|
||||
# Restore sources before optionally serving
|
||||
restore_all()
|
||||
|
||||
if (MACOS or LINUX) and not os.getenv("GITHUB_ACTIONS"):
|
||||
import webbrowser
|
||||
|
||||
url = "http://localhost:8000"
|
||||
LOGGER.info(f"Opening browser at {url}")
|
||||
webbrowser.open(url)
|
||||
try:
|
||||
subprocess.run(["python", "-m", "http.server", "--directory", str(SITE), "8000"], check=True)
|
||||
except KeyboardInterrupt:
|
||||
LOGGER.info(f"\n✅ Server stopped. Restart at {url}")
|
||||
except Exception as e:
|
||||
if "Address already in use" in str(e):
|
||||
LOGGER.info("Port 8000 in use; skipping auto-serve. Serve manually if needed.")
|
||||
else:
|
||||
LOGGER.info(f"\n❌ Server failed: {e}")
|
||||
else:
|
||||
LOGGER.info('Serve site at http://localhost:8000 with "python -m http.server --directory site"')
|
||||
finally:
|
||||
if not restored:
|
||||
restore_all()
|
||||
shutil.rmtree(DOCS / "repos", ignore_errors=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,34 +0,0 @@
|
||||
---
|
||||
description: Discover what's next for Ultralytics with our under-construction page, previewing new, groundbreaking AI and ML features coming soon.
|
||||
keywords: Ultralytics, coming soon, under construction, new features, AI updates, ML advancements, YOLO, technology preview
|
||||
---
|
||||
|
||||
# Under Construction 🏗️🌟
|
||||
|
||||
Welcome to the [Ultralytics](https://www.ultralytics.com/) "Under Construction" page! Here, we're hard at work developing the [next generation](https://www.ultralytics.com/glossary/foundation-model) of [AI](https://www.ultralytics.com/glossary/artificial-intelligence-ai) and [ML](https://www.ultralytics.com/glossary/machine-learning-ml) innovations. This page serves as a teaser for the exciting updates and new features we're eager to share with you!
|
||||
|
||||
## Exciting New Features on the Way 🎉
|
||||
|
||||
- **Innovative Breakthroughs:** Get ready for [advanced features](https://docs.ultralytics.com/) and services designed to [transform your AI and ML experience](https://www.ultralytics.com/solutions).
|
||||
- **New Horizons:** Anticipate novel products that [redefine AI and ML capabilities](https://docs.ultralytics.com/tasks/).
|
||||
- **Enhanced Services:** We're upgrading our [services](https://platform.ultralytics.com) for greater [efficiency](https://docs.ultralytics.com/modes/benchmark/) and user-friendliness.
|
||||
|
||||
## Stay Updated 🚧
|
||||
|
||||
This page is your go-to resource for the latest integration updates and feature rollouts. Stay connected through:
|
||||
|
||||
- **Newsletter:** Subscribe to [our Ultralytics newsletter](https://www.ultralytics.com/#newsletter) for announcements, releases, and early access updates.
|
||||
- **Social Media:** Follow [Ultralytics on LinkedIn](https://www.linkedin.com/company/ultralytics) for behind-the-scenes content, product news, and community highlights.
|
||||
- **Blog:** Dive into the [Ultralytics AI blog](https://www.ultralytics.com/blog) for in-depth articles, tutorials, and use-case spotlights.
|
||||
|
||||
## We Value Your Input 🗣️
|
||||
|
||||
Help shape the future of Ultralytics Platform by sharing your ideas, feedback, and integration requests through our [official contact form](https://www.ultralytics.com/contact).
|
||||
|
||||
## Thank You, Community! 🌍
|
||||
|
||||
Your [contributions](https://docs.ultralytics.com/help/contributing/) and ongoing support fuel our commitment to pushing the boundaries of [AI innovation](https://github.com/ultralytics/ultralytics). Stay tuned—exciting things are just around the corner!
|
||||
|
||||
---
|
||||
|
||||
Excited for what's coming? Bookmark this page and check out our [Quickstart Guide](https://docs.ultralytics.com/quickstart/) to get started with our current tools while you wait. Get ready for a transformative AI and ML journey with Ultralytics! 🛠️🤖
|
||||
@@ -1 +0,0 @@
|
||||
docs.ultralytics.com
|
||||
@@ -1,167 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the widely-used Caltech-101 dataset with 9,000 images across 101 categories. Ideal for object recognition tasks in machine learning and computer vision.
|
||||
keywords: Caltech-101, dataset, object recognition, machine learning, computer vision, YOLO, deep learning, research, AI
|
||||
---
|
||||
|
||||
# Caltech-101 Dataset
|
||||
|
||||
The [Caltech-101](https://data.caltech.edu/records/mzrjq-6wc02) dataset is a widely used dataset for object recognition tasks, containing around 9,000 images from 101 object categories. The categories were chosen to reflect a variety of real-world objects, and the images themselves were carefully selected and annotated to provide a challenging benchmark for object recognition algorithms.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/isc06_9qnM0"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> Model using Caltech-256 Dataset with Ultralytics Platform
|
||||
</p>
|
||||
|
||||
!!! note "Automatic Data Splitting"
|
||||
|
||||
The Caltech-101 dataset, as provided, does not come with pre-defined train/validation splits. However, when you use the training commands provided in the usage examples below, the Ultralytics framework will automatically split the dataset for you. The default split used is 80% for the training set and 20% for the validation set.
|
||||
|
||||
## Key Features
|
||||
|
||||
- The Caltech-101 dataset comprises around 9,000 color images divided into 101 categories.
|
||||
- The categories encompass a wide variety of objects, including animals, vehicles, household items, and people.
|
||||
- The number of images per category varies, with about 40 to 800 images in each category.
|
||||
- Images are of variable sizes, with most images being medium resolution.
|
||||
- Caltech-101 is widely used for training and testing in the field of machine learning, particularly for object recognition tasks.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
Unlike many other datasets, the Caltech-101 dataset is not formally split into training and testing sets. Users typically create their own splits based on their specific needs. However, a common practice is to use a random subset of images for training (e.g., 30 images per category) and the remaining images for testing.
|
||||
|
||||
## Applications
|
||||
|
||||
The Caltech-101 dataset is extensively used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object recognition tasks, such as [Convolutional Neural Networks](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNNs), [Support Vector Machines](https://www.ultralytics.com/glossary/support-vector-machine-svm) (SVMs), and various other machine learning algorithms. Its wide variety of categories and high-quality images make it an excellent dataset for research and development in the field of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO model on the Caltech-101 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch), you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech101", epochs=100, imgsz=416)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech101 model=yolo26n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The Caltech-101 dataset contains high-quality color images of various objects, providing a well-structured dataset for [image classification](https://www.ultralytics.com/glossary/image-classification) tasks. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the objects in the Caltech-101 dataset, emphasizing the significance of a diverse dataset for training robust object recognition models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Caltech-101 dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{fei2007learning,
|
||||
title={Learning generative visual models from few training examples: An incremental Bayesian approach tested on 101 object categories},
|
||||
author={Fei-Fei, Li and Fergus, Rob and Perona, Pietro},
|
||||
journal={Computer vision and Image understanding},
|
||||
volume={106},
|
||||
number={1},
|
||||
pages={59--70},
|
||||
year={2007},
|
||||
publisher={Elsevier}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge Li Fei-Fei, Rob Fergus, and Pietro Perona for creating and maintaining the Caltech-101 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the Caltech-101 dataset and its creators, visit the [Caltech-101 dataset website](https://data.caltech.edu/records/mzrjq-6wc02).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Caltech-101 dataset used for in machine learning?
|
||||
|
||||
The [Caltech-101](https://data.caltech.edu/records/mzrjq-6wc02) dataset is widely used in machine learning for object recognition tasks. It contains around 9,000 images across 101 categories, providing a challenging benchmark for evaluating object recognition algorithms. Researchers leverage it to train and test models, especially Convolutional [Neural Networks](https://www.ultralytics.com/glossary/neural-network-nn) (CNNs) and Support Vector Machines (SVMs), in computer vision.
|
||||
|
||||
### How can I train an Ultralytics YOLO model on the Caltech-101 dataset?
|
||||
|
||||
To train an Ultralytics YOLO model on the Caltech-101 dataset, you can use the provided code snippets. For example, to train for 100 epochs:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech101", epochs=100, imgsz=416)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech101 model=yolo26n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
For more detailed arguments and options, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the key features of the Caltech-101 dataset?
|
||||
|
||||
The Caltech-101 dataset includes:
|
||||
|
||||
- Around 9,000 color images across 101 categories.
|
||||
- Categories covering a diverse range of objects, including animals, vehicles, and household items.
|
||||
- Variable number of images per category, typically between 40 and 800.
|
||||
- Variable image sizes, with most being medium resolution.
|
||||
|
||||
These features make it an excellent choice for training and evaluating object recognition models in machine learning and computer vision.
|
||||
|
||||
### Why should I cite the Caltech-101 dataset in my research?
|
||||
|
||||
Citing the Caltech-101 dataset in your research acknowledges the creators' contributions and provides a reference for others who might use the dataset. The recommended citation is:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{fei2007learning,
|
||||
title={Learning generative visual models from few training examples: An incremental Bayesian approach tested on 101 object categories},
|
||||
author={Fei-Fei, Li and Fergus, Rob and Perona, Pietro},
|
||||
journal={Computer vision and Image understanding},
|
||||
volume={106},
|
||||
number={1},
|
||||
pages={59--70},
|
||||
year={2007},
|
||||
publisher={Elsevier}
|
||||
}
|
||||
```
|
||||
|
||||
Citing helps in maintaining the integrity of academic work and assists peers in locating the original resource.
|
||||
|
||||
### Can I use Ultralytics Platform for training models on the Caltech-101 dataset?
|
||||
|
||||
Yes, you can use [Ultralytics Platform](https://platform.ultralytics.com) for training models on the Caltech-101 dataset. Ultralytics Platform provides an intuitive platform for managing datasets, training models, and deploying them without extensive coding. For a detailed guide, refer to the [how to train your custom models with Ultralytics Platform](https://www.ultralytics.com/blog/how-to-train-your-custom-models-with-ultralytics-hub) blog post.
|
||||
@@ -1,148 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Caltech-256 dataset, featuring 30,000 images across 257 categories, ideal for training and testing object recognition algorithms.
|
||||
keywords: Caltech-256 dataset, object classification, image dataset, machine learning, computer vision, deep learning, YOLO, training dataset
|
||||
---
|
||||
|
||||
# Caltech-256 Dataset
|
||||
|
||||
The [Caltech-256](https://data.caltech.edu/records/nyy15-4j048) dataset is an extensive collection of images used for object classification tasks. It contains around 30,000 images divided into 257 categories (256 object categories and 1 background category). The images are carefully curated and annotated to provide a challenging and diverse benchmark for object recognition algorithms.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/isc06_9qnM0"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> Model using Caltech-256 Dataset with Ultralytics Platform
|
||||
</p>
|
||||
|
||||
!!! note "Automatic Data Splitting"
|
||||
|
||||
The Caltech-256 dataset, as provided, does not come with pre-defined train/validation splits. However, when you use the training commands provided in the usage examples below, the Ultralytics framework will automatically split the dataset for you. The default split used is 80% for the training set and 20% for the validation set.
|
||||
|
||||
## Key Features
|
||||
|
||||
- The Caltech-256 dataset comprises around 30,000 color images divided into 257 categories.
|
||||
- Each category contains a minimum of 80 images.
|
||||
- The categories encompass a wide variety of real-world objects, including animals, vehicles, household items, and people.
|
||||
- Images are of variable sizes and resolutions.
|
||||
- Caltech-256 is widely used for training and testing in the field of machine learning, particularly for object recognition tasks.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
Like [Caltech-101](../classify/caltech101.md), the Caltech-256 dataset does not have a formal split between training and testing sets. Users typically create their own splits according to their specific needs. A common practice is to use a random subset of images for training and the remaining images for testing.
|
||||
|
||||
## Applications
|
||||
|
||||
The Caltech-256 dataset is extensively used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object recognition tasks, such as [Convolutional Neural Networks](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNNs), [Support Vector Machines](https://www.ultralytics.com/glossary/support-vector-machine-svm) (SVMs), and various other machine learning algorithms. Its diverse set of categories and high-quality images make it an invaluable dataset for research and development in the field of machine learning and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO model on the Caltech-256 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch), you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech256", epochs=100, imgsz=416)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech256 model=yolo26n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The Caltech-256 dataset contains high-quality color images of various objects, providing a comprehensive dataset for object recognition tasks. Here are some examples of images from the dataset ([credit](https://ml4a.github.io/demos/tsne_viewer.html)):
|
||||
|
||||
|
||||
|
||||
The example showcases the diversity and complexity of the objects in the Caltech-256 dataset, emphasizing the importance of a varied dataset for training robust object recognition models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Caltech-256 dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{griffin2007caltech,
|
||||
title={Caltech-256 object category dataset},
|
||||
author={Griffin, Gregory and Holub, Alex and Perona, Pietro},
|
||||
year={2007}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge Gregory Griffin, Alex Holub, and Pietro Perona for creating and maintaining the Caltech-256 dataset as a valuable resource for the [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision research community. For more information about the Caltech-256 dataset and its creators, visit the [Caltech-256 dataset website](https://data.caltech.edu/records/nyy15-4j048).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Caltech-256 dataset and why is it important for machine learning?
|
||||
|
||||
The [Caltech-256](https://data.caltech.edu/records/nyy15-4j048) dataset is a large image dataset used primarily for object classification tasks in machine learning and computer vision. It consists of around 30,000 color images divided into 257 categories, covering a wide range of real-world objects. The dataset's diverse and high-quality images make it an excellent benchmark for evaluating object recognition algorithms, which is crucial for developing robust machine learning models.
|
||||
|
||||
### How can I train a YOLO model on the Caltech-256 dataset using Python or CLI?
|
||||
|
||||
To train a YOLO model on the Caltech-256 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch), you can use the following code snippets. Refer to the model [Training](../../modes/train.md) page for additional options.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech256", epochs=100, imgsz=416)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech256 model=yolo26n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
### What are the most common use cases for the Caltech-256 dataset?
|
||||
|
||||
The Caltech-256 dataset is widely used for various object recognition tasks such as:
|
||||
|
||||
- Training Convolutional [Neural Networks](https://www.ultralytics.com/glossary/neural-network-nn) (CNNs)
|
||||
- Evaluating the performance of Support Vector Machines (SVMs)
|
||||
- Benchmarking new deep learning algorithms
|
||||
- Developing [object detection](https://www.ultralytics.com/glossary/object-detection) models using frameworks like Ultralytics YOLO
|
||||
|
||||
Its diversity and comprehensive annotations make it ideal for research and development in machine learning and computer vision.
|
||||
|
||||
### How is the Caltech-256 dataset structured and split for training and testing?
|
||||
|
||||
The Caltech-256 dataset does not come with a predefined split for training and testing. Users typically create their own splits according to their specific needs. A common approach is to randomly select a subset of images for training and use the remaining images for testing. This flexibility allows users to tailor the dataset to their specific project requirements and experimental setups.
|
||||
|
||||
### Why should I use Ultralytics YOLO for training models on the Caltech-256 dataset?
|
||||
|
||||
Ultralytics YOLO models offer several advantages for training on the Caltech-256 dataset:
|
||||
|
||||
- **High Accuracy**: YOLO models are known for their state-of-the-art performance in object detection tasks.
|
||||
- **Speed**: They provide real-time inference capabilities, making them suitable for applications requiring quick predictions.
|
||||
- **Ease of Use**: With [Ultralytics Platform](https://platform.ultralytics.com), users can train, validate, and deploy models without extensive coding.
|
||||
- **Pretrained Models**: Starting from pretrained models, like `yolo26n-cls.pt`, can significantly reduce training time and improve model [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
|
||||
For more details, explore our [comprehensive training guide](../../modes/train.md) and learn about [image classification](../../tasks/classify.md) with Ultralytics YOLO.
|
||||
@@ -1,173 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the CIFAR-10 dataset, featuring 60,000 color images in 10 classes. Learn about its structure, applications, and how to train models using YOLO.
|
||||
keywords: CIFAR-10, dataset, machine learning, computer vision, image classification, YOLO, deep learning, neural networks
|
||||
---
|
||||
|
||||
# CIFAR-10 Dataset
|
||||
|
||||
The [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) (Canadian Institute For Advanced Research) dataset is a collection of images used widely for [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision algorithms. It was developed by researchers at the CIFAR institute and consists of 60,000 32x32 color images in 10 different classes.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/fLBbyhPbWzY"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train an <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> Model with CIFAR-10 Dataset using Ultralytics YOLO26
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
||||
- The CIFAR-10 dataset consists of 60,000 images, divided into 10 classes.
|
||||
- Each class contains 6,000 images, split into 5,000 for training and 1,000 for testing.
|
||||
- The images are colored and of size 32x32 pixels.
|
||||
- The 10 different classes represent airplanes, cars, birds, cats, deer, dogs, frogs, horses, ships, and trucks.
|
||||
- CIFAR-10 is commonly used for training and testing in the field of machine learning and computer vision.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The CIFAR-10 dataset is split into two subsets:
|
||||
|
||||
1. **Training Set**: This subset contains 50,000 images used for training machine learning models.
|
||||
2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
|
||||
|
||||
## Applications
|
||||
|
||||
The CIFAR-10 dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in image classification tasks, such as [Convolutional Neural Networks](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNNs), [Support Vector Machines](https://www.ultralytics.com/glossary/support-vector-machine-svm) (SVMs), and various other machine learning algorithms. The diversity of the dataset in terms of classes and the presence of color images make it a well-rounded dataset for research and development in the field of machine learning and computer vision.
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO model on the CIFAR-10 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 32x32, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar10", epochs=100, imgsz=32)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar10 model=yolo26n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The CIFAR-10 dataset contains color images of various objects, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the objects in the CIFAR-10 dataset, highlighting the importance of a diverse dataset for training robust image classification models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the CIFAR-10 dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@TECHREPORT{Krizhevsky09learningmultiple,
|
||||
author={Alex Krizhevsky},
|
||||
title={Learning multiple layers of features from tiny images},
|
||||
institution={},
|
||||
year={2009}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge Alex Krizhevsky for creating and maintaining the CIFAR-10 dataset as a valuable resource for the machine learning and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) research community. For more information about the CIFAR-10 dataset and its creator, visit the [CIFAR-10 dataset website](https://www.cs.toronto.edu/~kriz/cifar.html).
|
||||
|
||||
## FAQ
|
||||
|
||||
### How can I train a YOLO model on the CIFAR-10 dataset?
|
||||
|
||||
To train a YOLO model on the CIFAR-10 dataset using Ultralytics, you can follow the examples provided for both Python and CLI. Here is a basic example to train your model for 100 epochs with an image size of 32x32 pixels:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar10", epochs=100, imgsz=32)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar10 model=yolo26n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
For more details, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the key features of the CIFAR-10 dataset?
|
||||
|
||||
The CIFAR-10 dataset consists of 60,000 color images divided into 10 classes. Each class contains 6,000 images, with 5,000 for training and 1,000 for testing. The images are 32x32 pixels in size and vary across the following categories:
|
||||
|
||||
- Airplanes
|
||||
- Cars
|
||||
- Birds
|
||||
- Cats
|
||||
- Deer
|
||||
- Dogs
|
||||
- Frogs
|
||||
- Horses
|
||||
- Ships
|
||||
- Trucks
|
||||
|
||||
This diverse dataset is essential for training image classification models in fields such as machine learning and computer vision. For more information, visit the CIFAR-10 sections on [dataset structure](#dataset-structure) and [applications](#applications).
|
||||
|
||||
### Why use the CIFAR-10 dataset for image classification tasks?
|
||||
|
||||
The CIFAR-10 dataset is an excellent benchmark for image classification due to its diversity and structure. It contains a balanced mix of 60,000 labeled images across 10 different categories, which helps in training robust and generalized models. It is widely used for evaluating deep learning models, including Convolutional [Neural Networks](https://www.ultralytics.com/glossary/neural-network-nn) (CNNs) and other machine learning algorithms. The dataset is relatively small, making it suitable for quick experimentation and algorithm development. Explore its numerous applications in the [applications](#applications) section.
|
||||
|
||||
### How is the CIFAR-10 dataset structured?
|
||||
|
||||
The CIFAR-10 dataset is structured into two main subsets:
|
||||
|
||||
1. **Training Set**: Contains 50,000 images used for training machine learning models.
|
||||
2. **Testing Set**: Consists of 10,000 images for testing and benchmarking the trained models.
|
||||
|
||||
Each subset comprises images categorized into 10 classes, with their annotations readily available for model training and evaluation. For more detailed information, refer to the [dataset structure](#dataset-structure) section.
|
||||
|
||||
### How can I cite the CIFAR-10 dataset in my research?
|
||||
|
||||
If you use the CIFAR-10 dataset in your research or development projects, make sure to cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@TECHREPORT{Krizhevsky09learningmultiple,
|
||||
author={Alex Krizhevsky},
|
||||
title={Learning multiple layers of features from tiny images},
|
||||
institution={},
|
||||
year={2009}
|
||||
}
|
||||
```
|
||||
|
||||
Acknowledging the dataset's creators helps support continued research and development in the field. For more details, see the [citations and acknowledgments](#citations-and-acknowledgments) section.
|
||||
|
||||
### What are some practical examples of using the CIFAR-10 dataset?
|
||||
|
||||
The CIFAR-10 dataset is often used for training image classification models, such as Convolutional Neural Networks (CNNs) and Support Vector Machines (SVMs). These models can be employed in various computer vision tasks including [object detection](https://www.ultralytics.com/glossary/object-detection), [image recognition](https://www.ultralytics.com/glossary/image-recognition), and automated tagging. To see some practical examples, check the code snippets in the [usage](#usage) section.
|
||||
@@ -1,141 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the CIFAR-100 dataset, consisting of 60,000 32x32 color images across 100 classes. Ideal for machine learning and computer vision tasks.
|
||||
keywords: CIFAR-100, dataset, machine learning, computer vision, image classification, deep learning, YOLO, training, testing, Alex Krizhevsky
|
||||
---
|
||||
|
||||
# CIFAR-100 Dataset
|
||||
|
||||
The [CIFAR-100](https://www.cs.toronto.edu/~kriz/cifar.html) (Canadian Institute For Advanced Research) dataset is a significant extension of the CIFAR-10 dataset, composed of 60,000 32x32 color images in 100 different classes. It was developed by researchers at the CIFAR institute, offering a more challenging dataset for more complex machine learning and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/6bZeCs0xwO4"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on CIFAR-100 | Step-by-Step Image Classification Tutorial 🚀
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
||||
- The CIFAR-100 dataset consists of 60,000 images, divided into 100 classes.
|
||||
- Each class contains 600 images, split into 500 for training and 100 for testing.
|
||||
- The images are colored and of size 32x32 pixels.
|
||||
- The 100 different classes are grouped into 20 coarse categories for higher level classification.
|
||||
- CIFAR-100 is commonly used for training and testing in the field of machine learning and computer vision.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The CIFAR-100 dataset is split into two subsets:
|
||||
|
||||
1. **Training Set**: This subset contains 50,000 images used for training machine learning models.
|
||||
2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
|
||||
|
||||
## Applications
|
||||
|
||||
The CIFAR-100 dataset is extensively used for training and evaluating deep learning models in [image classification](https://www.ultralytics.com/glossary/image-classification) tasks, such as [Convolutional Neural Networks](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNNs), [Support Vector Machines](https://www.ultralytics.com/glossary/support-vector-machine-svm) (SVMs), and various other machine learning algorithms. The diversity of the dataset in terms of classes and the presence of color images make it a more challenging and comprehensive dataset for research and development in the field of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision.
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO model on the CIFAR-100 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 32x32, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar100", epochs=100, imgsz=32)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar100 model=yolo26n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The CIFAR-100 dataset contains color images of various objects, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the objects in the CIFAR-100 dataset, highlighting the importance of a diverse dataset for training robust image classification models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the CIFAR-100 dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@TECHREPORT{Krizhevsky09learningmultiple,
|
||||
author={Alex Krizhevsky},
|
||||
title={Learning multiple layers of features from tiny images},
|
||||
institution={},
|
||||
year={2009}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge Alex Krizhevsky for creating and maintaining the CIFAR-100 dataset as a valuable resource for the machine learning and computer vision research community. For more information about the CIFAR-100 dataset and its creator, visit the [CIFAR-100 dataset website](https://www.cs.toronto.edu/~kriz/cifar.html).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the CIFAR-100 dataset and why is it significant?
|
||||
|
||||
The [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html) is a large collection of 60,000 32x32 color images classified into 100 classes. Developed by the Canadian Institute For Advanced Research (CIFAR), it provides a challenging dataset ideal for complex machine learning and computer vision tasks. Its significance lies in the diversity of classes and the small size of the images, making it a valuable resource for training and testing [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models, like Convolutional [Neural Networks](https://www.ultralytics.com/glossary/neural-network-nn) (CNNs), using frameworks such as [Ultralytics YOLO](https://docs.ultralytics.com/models/yolo26/).
|
||||
|
||||
### How do I train a YOLO model on the CIFAR-100 dataset?
|
||||
|
||||
You can train a YOLO model on the CIFAR-100 dataset using either Python or CLI commands. Here's how:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar100", epochs=100, imgsz=32)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar100 model=yolo26n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, please refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the primary applications of the CIFAR-100 dataset?
|
||||
|
||||
The CIFAR-100 dataset is extensively used in training and evaluating deep learning models for image classification. Its diverse set of 100 classes, grouped into 20 coarse categories, provides a challenging environment for testing algorithms such as Convolutional Neural Networks (CNNs), Support Vector Machines (SVMs), and various other machine learning approaches. This dataset is a key resource in research and development within machine learning and computer vision fields, particularly for [object recognition](https://docs.ultralytics.com/tasks/classify/) and classification tasks.
|
||||
|
||||
### How is the CIFAR-100 dataset structured?
|
||||
|
||||
The CIFAR-100 dataset is split into two main subsets:
|
||||
|
||||
1. **Training Set**: Contains 50,000 images used for training machine learning models.
|
||||
2. **Testing Set**: Consists of 10,000 images used for testing and benchmarking the trained models.
|
||||
|
||||
Each of the 100 classes contains 600 images, with 500 images for training and 100 for testing, making it uniquely suited for rigorous academic and industrial research.
|
||||
|
||||
### Where can I find sample images and annotations from the CIFAR-100 dataset?
|
||||
|
||||
The CIFAR-100 dataset includes a variety of color images of various objects, making it a structured dataset for image classification tasks. You can refer to the documentation page to see [sample images and annotations](#sample-images-and-annotations). These examples highlight the dataset's diversity and complexity, important for training robust image classification models. For more datasets suitable for classification tasks, check out [Ultralytics' classification datasets overview](https://docs.ultralytics.com/datasets/classify/).
|
||||
@@ -1,141 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Fashion-MNIST dataset, a modern replacement for MNIST with 70,000 Zalando article images. Ideal for benchmarking machine learning models.
|
||||
keywords: Fashion-MNIST, image classification, Zalando dataset, machine learning, deep learning, CNN, dataset overview
|
||||
---
|
||||
|
||||
# Fashion-MNIST Dataset
|
||||
|
||||
The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is a database of Zalando's article images—consisting of a training set of 60,000 examples and a test set of 10,000 examples. Each example is a 28x28 grayscale image, associated with a label from 10 classes. Fashion-MNIST is intended to serve as a direct drop-in replacement for the original MNIST dataset for benchmarking [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) algorithms.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/eX5ad6udQ9Q"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to do <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> on Fashion MNIST Dataset using Ultralytics YOLO26
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
||||
- Fashion-MNIST contains 60,000 training images and 10,000 testing images of Zalando's article images.
|
||||
- The dataset comprises grayscale images of size 28x28 pixels.
|
||||
- Each pixel has a single pixel-value associated with it, indicating the lightness or darkness of that pixel, with higher numbers meaning darker. This pixel-value is an integer between 0 and 255.
|
||||
- Fashion-MNIST is widely used for training and testing in the field of machine learning, especially for image classification tasks.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The Fashion-MNIST dataset is split into two subsets:
|
||||
|
||||
1. **Training Set**: This subset contains 60,000 images used for training machine learning models.
|
||||
2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
|
||||
|
||||
## Labels
|
||||
|
||||
Each training and test example is assigned to one of the following labels:
|
||||
|
||||
```
|
||||
0. T-shirt/top
|
||||
1. Trouser
|
||||
2. Pullover
|
||||
3. Dress
|
||||
4. Coat
|
||||
5. Sandal
|
||||
6. Shirt
|
||||
7. Sneaker
|
||||
8. Bag
|
||||
9. Ankle boot
|
||||
```
|
||||
|
||||
## Applications
|
||||
|
||||
The Fashion-MNIST dataset is widely used for training and evaluating deep learning models in image classification tasks, such as [Convolutional Neural Networks](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNNs), [Support Vector Machines](https://www.ultralytics.com/glossary/support-vector-machine-svm) (SVMs), and various other machine learning algorithms. The dataset's simple and well-structured format makes it an essential resource for researchers and practitioners in the field of machine learning and computer vision.
|
||||
|
||||
## Usage
|
||||
|
||||
To train a CNN model on the Fashion-MNIST dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 28x28, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="fashion-mnist", epochs=100, imgsz=28)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=fashion-mnist model=yolo26n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The Fashion-MNIST dataset contains grayscale images of Zalando's article images, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the images in the Fashion-MNIST dataset, highlighting the importance of a diverse dataset for training robust image classification models.
|
||||
|
||||
## Acknowledgments
|
||||
|
||||
If you use the Fashion-MNIST dataset in your research or development work, please acknowledge the dataset by linking to the [GitHub repository](https://github.com/zalandoresearch/fashion-mnist). This dataset was made available by Zalando Research.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Fashion-MNIST dataset and how is it different from MNIST?
|
||||
|
||||
The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is a collection of 70,000 grayscale images of Zalando's article images, intended as a modern replacement for the original MNIST dataset. It serves as a benchmark for machine learning models in the context of image classification tasks. Unlike MNIST, which contains handwritten digits, Fashion-MNIST consists of 28x28-pixel images categorized into 10 fashion-related classes, such as T-shirt/top, trouser, and ankle boot.
|
||||
|
||||
### How can I train a YOLO model on the Fashion-MNIST dataset?
|
||||
|
||||
To train an Ultralytics YOLO model on the Fashion-MNIST dataset, you can use both Python and CLI commands. Here's a quick example to get you started:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model
|
||||
model = YOLO("yolo26n-cls.pt")
|
||||
|
||||
# Train the model on Fashion-MNIST
|
||||
results = model.train(data="fashion-mnist", epochs=100, imgsz=28)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify train data=fashion-mnist model=yolo26n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
For more detailed training parameters, refer to the [Training page](../../modes/train.md).
|
||||
|
||||
### Why should I use the Fashion-MNIST dataset for benchmarking my machine learning models?
|
||||
|
||||
The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is widely recognized in the [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) community as a robust alternative to MNIST. It offers a more complex and varied set of images, making it an excellent choice for benchmarking image classification models. The dataset's structure, comprising 60,000 training images and 10,000 testing images, each labeled with one of 10 classes, makes it ideal for evaluating the performance of different machine learning algorithms in a more challenging context.
|
||||
|
||||
### Can I use Ultralytics YOLO for image classification tasks like Fashion-MNIST?
|
||||
|
||||
Yes, Ultralytics YOLO models can be used for image classification tasks, including those involving the Fashion-MNIST dataset. YOLO26, for example, supports various vision tasks such as detection, segmentation, and classification. To get started with image classification tasks, refer to the [Classification page](https://docs.ultralytics.com/tasks/classify/).
|
||||
|
||||
### What are the key features and structure of the Fashion-MNIST dataset?
|
||||
|
||||
The Fashion-MNIST dataset is divided into two main subsets: 60,000 training images and 10,000 testing images. Each image is a 28x28-pixel grayscale picture representing one of 10 fashion-related classes. The simplicity and well-structured format make it ideal for training and evaluating models in machine learning and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks. For more details on the dataset structure, see the [Dataset Structure section](#dataset-structure).
|
||||
|
||||
### How can I acknowledge the use of the Fashion-MNIST dataset in my research?
|
||||
|
||||
If you utilize the Fashion-MNIST dataset in your research or development projects, it's important to acknowledge it by linking to the [GitHub repository](https://github.com/zalandoresearch/fashion-mnist). This helps in attributing the data to Zalando Research, who made the dataset available for public use.
|
||||
@@ -1,132 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the extensive ImageNet dataset and discover its role in advancing deep learning in computer vision. Access pretrained models and training examples.
|
||||
keywords: ImageNet, deep learning, visual recognition, computer vision, pretrained models, YOLO, dataset, object detection, image classification
|
||||
---
|
||||
|
||||
# ImageNet Dataset
|
||||
|
||||
[ImageNet](https://www.image-net.org/) is a large-scale database of annotated images designed for use in visual object recognition research. It contains over 14 million images, with each image annotated using WordNet synsets, making it one of the most extensive resources available for training [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks.
|
||||
|
||||
## ImageNet Pretrained Models
|
||||
|
||||
{% include "macros/yolo-cls-perf.md" %}
|
||||
|
||||
## Key Features
|
||||
|
||||
- ImageNet contains over 14 million high-resolution images spanning thousands of object categories.
|
||||
- The dataset is organized according to the WordNet hierarchy, with each synset representing a category.
|
||||
- ImageNet is widely used for training and benchmarking in the field of computer vision, particularly for [image classification](https://www.ultralytics.com/glossary/image-classification) and [object detection](https://www.ultralytics.com/glossary/object-detection) tasks.
|
||||
- The annual ImageNet Large Scale Visual Recognition Challenge (ILSVRC) has been instrumental in advancing computer vision research.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The ImageNet dataset is organized using the WordNet hierarchy. Each node in the hierarchy represents a category, and each category is described by a synset (a collection of synonymous terms). The images in ImageNet are annotated with one or more synsets, providing a rich resource for training models to recognize various objects and their relationships.
|
||||
|
||||
## ImageNet Large Scale Visual Recognition Challenge (ILSVRC)
|
||||
|
||||
The annual [ImageNet Large Scale Visual Recognition Challenge (ILSVRC)](https://image-net.org/challenges/LSVRC/) has been an important event in the field of computer vision. It has provided a platform for researchers and developers to evaluate their algorithms and models on a large-scale dataset with standardized evaluation metrics. The ILSVRC has led to significant advancements in the development of deep learning models for image classification, object detection, and other computer vision tasks.
|
||||
|
||||
## Applications
|
||||
|
||||
The ImageNet dataset is widely used for training and evaluating deep learning models in various computer vision tasks, such as image classification, object detection, and object localization. Some popular deep learning architectures, such as [AlexNet](https://en.wikipedia.org/wiki/AlexNet), [VGG](https://arxiv.org/abs/1409.1556), and [ResNet](https://arxiv.org/abs/1512.03385), were developed and benchmarked using the ImageNet dataset.
|
||||
|
||||
## Usage
|
||||
|
||||
To train a deep learning model on the ImageNet dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet model=yolo26n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The ImageNet dataset contains high-resolution images spanning thousands of object categories, providing a diverse and extensive dataset for training and evaluating computer vision models. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the images in the ImageNet dataset, highlighting the importance of a diverse dataset for training robust computer vision models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the ImageNet dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{ILSVRC15,
|
||||
author = {Olga Russakovsky and Jia Deng and Hao Su and Jonathan Krause and Sanjeev Satheesh and Sean Ma and Zhiheng Huang and Andrej Karpathy and Aditya Khosla and Michael Bernstein and Alexander C. Berg and Li Fei-Fei},
|
||||
title={ImageNet Large Scale Visual Recognition Challenge},
|
||||
year={2015},
|
||||
journal={International Journal of Computer Vision (IJCV)},
|
||||
volume={115},
|
||||
number={3},
|
||||
pages={211-252}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the ImageNet team, led by Olga Russakovsky, Jia Deng, and Li Fei-Fei, for creating and maintaining the ImageNet dataset as a valuable resource for the [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision research community. For more information about the ImageNet dataset and its creators, visit the [ImageNet website](https://www.image-net.org/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the ImageNet dataset and how is it used in computer vision?
|
||||
|
||||
The [ImageNet dataset](https://www.image-net.org/) is a large-scale database consisting of over 14 million high-resolution images categorized using WordNet synsets. It is extensively used in visual object recognition research, including image classification and object detection. The dataset's annotations and sheer volume provide a rich resource for training deep learning models. Notably, models like AlexNet, VGG, and ResNet have been trained and benchmarked using ImageNet, showcasing its role in advancing computer vision.
|
||||
|
||||
### How can I use a pretrained YOLO model for image classification on the ImageNet dataset?
|
||||
|
||||
To use a pretrained Ultralytics YOLO model for image classification on the ImageNet dataset, follow these steps:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet model=yolo26n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
For more in-depth training instruction, refer to our [Training page](../../modes/train.md).
|
||||
|
||||
### Why should I use the Ultralytics YOLO26 pretrained models for my ImageNet dataset projects?
|
||||
|
||||
Ultralytics YOLO26 pretrained models offer state-of-the-art performance in terms of speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) for various computer vision tasks. For example, the YOLO26n-cls model, with a top-1 accuracy of 70.0% and a top-5 accuracy of 89.4%, is optimized for real-time applications. Pretrained models reduce the computational resources required for training from scratch and accelerate development cycles. Learn more about the performance metrics of YOLO26 models in the [ImageNet Pretrained Models section](#imagenet-pretrained-models).
|
||||
|
||||
### How is the ImageNet dataset structured, and why is it important?
|
||||
|
||||
The ImageNet dataset is organized using the WordNet hierarchy, where each node in the hierarchy represents a category described by a synset (a collection of synonymous terms). This structure allows for detailed annotations, making it ideal for training models to recognize a wide variety of objects. The diversity and annotation richness of ImageNet make it a valuable dataset for developing robust and generalizable deep learning models. More about this organization can be found in the [Dataset Structure](#dataset-structure) section.
|
||||
|
||||
### What role does the ImageNet Large Scale Visual Recognition Challenge (ILSVRC) play in computer vision?
|
||||
|
||||
The annual [ImageNet Large Scale Visual Recognition Challenge (ILSVRC)](https://image-net.org/challenges/LSVRC/) has been pivotal in driving advancements in computer vision by providing a competitive platform for evaluating algorithms on a large-scale, standardized dataset. It offers standardized evaluation metrics, fostering innovation and development in areas such as image classification, object detection, and [image segmentation](https://www.ultralytics.com/glossary/image-segmentation). The challenge has continuously pushed the boundaries of what is possible with deep learning and computer vision technologies.
|
||||
@@ -1,129 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover ImageNet10 a compact version of ImageNet for rapid model testing and CI checks. Perfect for quick evaluations in computer vision tasks.
|
||||
keywords: ImageNet10, ImageNet, Ultralytics, CI tests, sanity checks, training pipelines, computer vision, deep learning, dataset
|
||||
---
|
||||
|
||||
# ImageNet10 Dataset
|
||||
|
||||
The [ImageNet10](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/imagenet10.zip) dataset is a small-scale subset of the [ImageNet](https://www.image-net.org/) database, developed by [Ultralytics](https://www.ultralytics.com/) and designed for CI tests, sanity checks, and fast testing of training pipelines. This dataset is composed of the first image in the training set and the first image from the validation set of the first 10 classes in ImageNet. Although significantly smaller, it retains the structure and diversity of the original ImageNet dataset.
|
||||
|
||||
## Key Features
|
||||
|
||||
- ImageNet10 is a compact version of ImageNet, with 20 images representing the first 10 classes of the original dataset.
|
||||
- The dataset is organized according to the WordNet hierarchy, mirroring the structure of the full ImageNet dataset.
|
||||
- It is ideally suited for CI tests, sanity checks, and rapid testing of training pipelines in [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks.
|
||||
- Although not designed for model benchmarking, it can provide a quick indication of a model's basic functionality and correctness.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The ImageNet10 dataset, like the original [ImageNet](../classify/imagenet.md), is organized using the WordNet hierarchy. Each of the 10 classes in ImageNet10 is described by a synset (a collection of synonymous terms). The images in ImageNet10 are annotated with one or more synsets, providing a compact resource for testing models to recognize various objects and their relationships.
|
||||
|
||||
## Applications
|
||||
|
||||
The ImageNet10 dataset is useful for quickly testing and debugging computer vision models and pipelines. Its small size allows for rapid iteration, making it ideal for [continuous integration](../../help/CI.md) tests and sanity checks. It can also be used for fast preliminary testing of new models or changes to existing models before moving on to full-scale testing with the complete [ImageNet dataset](../classify/imagenet.md).
|
||||
|
||||
## Usage
|
||||
|
||||
To test a deep learning model on the ImageNet10 dataset with an image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Test Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet10", epochs=5, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet10 model=yolo26n-cls.pt epochs=5 imgsz=224
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The ImageNet10 dataset contains a subset of images from the original ImageNet dataset. These images are chosen to represent the first 10 classes in the dataset, providing a diverse yet compact dataset for quick testing and evaluation.
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the images in the ImageNet10 dataset, highlighting its usefulness for sanity checks and quick testing of computer vision models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the ImageNet10 dataset in your research or development work, please cite the original ImageNet paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{ILSVRC15,
|
||||
author = {Olga Russakovsky and Jia Deng and Hao Su and Jonathan Krause and Sanjeev Satheesh and Sean Ma and Zhiheng Huang and Andrej Karpathy and Aditya Khosla and Michael Bernstein and Alexander C. Berg and Li Fei-Fei},
|
||||
title={ImageNet Large Scale Visual Recognition Challenge},
|
||||
year={2015},
|
||||
journal={International Journal of Computer Vision (IJCV)},
|
||||
volume={115},
|
||||
number={3},
|
||||
pages={211-252}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the ImageNet team, led by Olga Russakovsky, Jia Deng, and Li Fei-Fei, for creating and maintaining the ImageNet dataset. The ImageNet10 dataset, while a compact subset, is a valuable resource for quick testing and debugging in the [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision research community. For more information about the ImageNet dataset and its creators, visit the [ImageNet website](https://www.image-net.org/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the ImageNet10 dataset and how is it different from the full ImageNet dataset?
|
||||
|
||||
The [ImageNet10](https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/imagenet10.zip) dataset is a compact subset of the original [ImageNet](https://www.image-net.org/) database, created by Ultralytics for rapid CI tests, sanity checks, and training pipeline evaluations. ImageNet10 comprises only 20 images, representing the first image in the training and validation sets of the first 10 classes in ImageNet. Despite its small size, it maintains the structure and diversity of the full dataset, making it ideal for quick testing but not for benchmarking models.
|
||||
|
||||
### How can I use the ImageNet10 dataset to test my deep learning model?
|
||||
|
||||
To test your deep learning model on the ImageNet10 dataset with an image size of 224x224, use the following code snippets.
|
||||
|
||||
!!! example "Test Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet10", epochs=5, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet10 model=yolo26n-cls.pt epochs=5 imgsz=224
|
||||
```
|
||||
|
||||
Refer to the [Training](../../modes/train.md) page for a comprehensive list of available arguments.
|
||||
|
||||
### Why should I use the ImageNet10 dataset for CI tests and sanity checks?
|
||||
|
||||
The ImageNet10 dataset is designed specifically for CI tests, sanity checks, and quick evaluations in [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) pipelines. Its small size allows for rapid iteration and testing, making it perfect for continuous integration processes where speed is crucial. By maintaining the structural complexity and diversity of the original ImageNet dataset, ImageNet10 provides a reliable indication of a model's basic functionality and correctness without the overhead of processing a large dataset.
|
||||
|
||||
### What are the main features of the ImageNet10 dataset?
|
||||
|
||||
The ImageNet10 dataset has several key features:
|
||||
|
||||
- **Compact Size**: With only 20 images, it allows for rapid testing and debugging.
|
||||
- **Structured Organization**: Follows the WordNet hierarchy, similar to the full ImageNet dataset.
|
||||
- **CI and Sanity Checks**: Ideally suited for continuous integration tests and sanity checks.
|
||||
- **Not for Benchmarking**: While useful for quick model evaluations, it is not designed for extensive benchmarking.
|
||||
|
||||
### How does ImageNet10 compare to other small datasets like ImageNette?
|
||||
|
||||
While both [ImageNet10](imagenet10.md) and [ImageNette](imagenette.md) are subsets of ImageNet, they serve different purposes. ImageNet10 contains just 20 images (2 per class) from the first 10 classes of ImageNet, making it extremely lightweight for CI testing and quick sanity checks. In contrast, ImageNette contains thousands of images across 10 easily distinguishable classes, making it more suitable for actual model training and development. ImageNet10 is designed for verification of pipeline functionality, while ImageNette is better for meaningful but faster-than-full-ImageNet training experiments.
|
||||
@@ -1,193 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the ImageNette dataset, a subset of ImageNet with 10 classes for efficient training and evaluation of image classification models. Ideal for ML and CV projects.
|
||||
keywords: ImageNette dataset, ImageNet subset, image classification, machine learning, deep learning, YOLO, Convolutional Neural Networks, ML dataset, education, training
|
||||
---
|
||||
|
||||
# ImageNette Dataset
|
||||
|
||||
The [ImageNette](https://github.com/fastai/imagenette) dataset is a subset of the larger [ImageNet](https://www.image-net.org/) dataset, but it only includes 10 easily distinguishable classes. It was created to provide a quicker, easier-to-use version of ImageNet for software development and education.
|
||||
|
||||
## Key Features
|
||||
|
||||
- ImageNette contains images from 10 different classes such as tench, English springer, cassette player, chain saw, church, French horn, garbage truck, gas pump, golf ball, parachute.
|
||||
- The dataset comprises colored images of varying dimensions.
|
||||
- ImageNette is widely used for training and testing in the field of machine learning, especially for image classification tasks.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The ImageNette dataset is split into two subsets:
|
||||
|
||||
1. **Training Set**: This subset contains several thousands of images used for training machine learning models. The exact number varies per class.
|
||||
2. **Validation Set**: This subset consists of several hundreds of images used for validating and benchmarking the trained models. Again, the exact number varies per class.
|
||||
|
||||
## Applications
|
||||
|
||||
The ImageNette dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in image classification tasks, such as [Convolutional Neural Networks](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNNs), and various other machine learning algorithms. The dataset's straightforward format and well-chosen classes make it a handy resource for both beginner and experienced practitioners in the field of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
|
||||
## Usage
|
||||
|
||||
To train a model on the ImageNette dataset for 100 epochs with a standard image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenette", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenette model=yolo26n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The ImageNette dataset contains colored images of various objects and scenes, providing a diverse dataset for [image classification](https://www.ultralytics.com/glossary/image-classification) tasks. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the images in the ImageNette dataset, highlighting the importance of a diverse dataset for training robust image classification models.
|
||||
|
||||
## ImageNette160 and ImageNette320
|
||||
|
||||
For faster prototyping and training, the ImageNette dataset is also available in two reduced sizes: [ImageNette160](https://github.com/fastai/imagenette) and [ImageNette320](https://github.com/fastai/imagenette). These datasets maintain the same classes and structure as the full ImageNette dataset, but the images are resized to a smaller dimension. As such, these versions of the dataset are particularly useful for preliminary model testing, or when computational resources are limited.
|
||||
|
||||
To use these datasets, simply replace 'imagenette' with 'imagenette160' or 'imagenette320' in the training command. The following code snippets illustrate this:
|
||||
|
||||
!!! example "Train Example with ImageNette160"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model with ImageNette160
|
||||
results = model.train(data="imagenette160", epochs=100, imgsz=160)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model with ImageNette160
|
||||
yolo classify train data=imagenette160 model=yolo26n-cls.pt epochs=100 imgsz=160
|
||||
```
|
||||
|
||||
!!! example "Train Example with ImageNette320"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model with ImageNette320
|
||||
results = model.train(data="imagenette320", epochs=100, imgsz=320)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model with ImageNette320
|
||||
yolo classify train data=imagenette320 model=yolo26n-cls.pt epochs=100 imgsz=320
|
||||
```
|
||||
|
||||
These smaller versions of the dataset allow for rapid iterations during the development process while still providing valuable and realistic image classification tasks.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the ImageNette dataset in your research or development work, please acknowledge it appropriately. For more information about the ImageNette dataset, visit the [ImageNette dataset GitHub page](https://github.com/fastai/imagenette).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the ImageNette dataset?
|
||||
|
||||
The [ImageNette dataset](https://github.com/fastai/imagenette) is a simplified subset of the larger [ImageNet dataset](https://www.image-net.org/), featuring only 10 easily distinguishable classes such as tench, English springer, and French horn. It was created to offer a more manageable dataset for efficient training and evaluation of image classification models. This dataset is particularly useful for quick software development and educational purposes in [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision.
|
||||
|
||||
### How can I use the ImageNette dataset for training a YOLO model?
|
||||
|
||||
To train a YOLO model on the ImageNette dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch), you can use the following commands. Make sure to have the Ultralytics YOLO environment set up.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenette", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenette model=yolo26n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
For more details, see the [Training](../../modes/train.md) documentation page.
|
||||
|
||||
### Why should I use ImageNette for image classification tasks?
|
||||
|
||||
The ImageNette dataset is advantageous for several reasons:
|
||||
|
||||
- **Quick and Simple**: It contains only 10 classes, making it less complex and time-consuming compared to larger datasets.
|
||||
- **Educational Use**: Ideal for learning and teaching the basics of image classification since it requires less computational power and time.
|
||||
- **Versatility**: Widely used to train and benchmark various machine learning models, especially in image classification.
|
||||
|
||||
For more details on model training and dataset management, explore the [Dataset Structure](#dataset-structure) section.
|
||||
|
||||
### Can the ImageNette dataset be used with different image sizes?
|
||||
|
||||
Yes, the ImageNette dataset is also available in two resized versions: ImageNette160 and ImageNette320. These versions help in faster prototyping and are especially useful when computational resources are limited.
|
||||
|
||||
!!! example "Train Example with ImageNette160"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt")
|
||||
|
||||
# Train the model with ImageNette160
|
||||
results = model.train(data="imagenette160", epochs=100, imgsz=160)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model with ImageNette160
|
||||
yolo classify train data=imagenette160 model=yolo26n-cls.pt epochs=100 imgsz=160
|
||||
```
|
||||
|
||||
For more information, refer to [Training with ImageNette160 and ImageNette320](#imagenette160-and-imagenette320).
|
||||
|
||||
### What are some practical applications of the ImageNette dataset?
|
||||
|
||||
The ImageNette dataset is extensively used in:
|
||||
|
||||
- **Educational Settings**: To educate beginners in machine learning and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
- **Software Development**: For rapid prototyping and development of image classification models.
|
||||
- **Deep Learning Research**: To evaluate and benchmark the performance of various deep learning models, especially Convolutional [Neural Networks](https://www.ultralytics.com/glossary/neural-network-nn) (CNNs).
|
||||
|
||||
Explore the [Applications](#applications) section for detailed use cases.
|
||||
@@ -1,153 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the ImageWoof dataset, a challenging subset of ImageNet focusing on 10 dog breeds, designed to enhance image classification models. Learn more on Ultralytics Docs.
|
||||
keywords: ImageWoof dataset, ImageNet subset, dog breeds, image classification, deep learning, machine learning, Ultralytics, training dataset, noisy labels
|
||||
---
|
||||
|
||||
# ImageWoof Dataset
|
||||
|
||||
The [ImageWoof](https://github.com/fastai/imagenette) dataset is a subset of the [ImageNet](imagenet.md) consisting of 10 classes that are challenging to classify, since they're all dog breeds. It was created as a more difficult task for [image classification](https://www.ultralytics.com/glossary/image-classification) algorithms to solve, aiming at encouraging development of more advanced models.
|
||||
|
||||
## Key Features
|
||||
|
||||
- ImageWoof contains images of 10 different dog breeds: Australian terrier, Border terrier, Samoyed, Beagle, Shih-Tzu, English foxhound, Rhodesian ridgeback, Dingo, Golden retriever, and Old English sheepdog.
|
||||
- The dataset provides images at various resolutions (full size, 320px, 160px), accommodating for different computational capabilities and research needs.
|
||||
- It also includes a version with noisy labels, providing a more realistic scenario where labels might not always be reliable.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The ImageWoof dataset structure is based on the dog breed classes, with each breed having its own directory of images. Similar to other classification datasets, it follows a split-directory format with separate folders for training and validation sets.
|
||||
|
||||
## Applications
|
||||
|
||||
The ImageWoof dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in image classification tasks, especially when it comes to more complex and similar classes. The dataset's challenge lies in the subtle differences between the dog breeds, pushing the limits of model's performance and generalization. It's particularly valuable for:
|
||||
|
||||
- Benchmarking classification model performance on fine-grained categories
|
||||
- Testing model robustness against similar-looking classes
|
||||
- Developing algorithms that can distinguish subtle visual differences
|
||||
- Evaluating transfer learning capabilities from general to specific domains
|
||||
|
||||
## Usage
|
||||
|
||||
To train a CNN model on the ImageWoof dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 224x224, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagewoof", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagewoof model=yolo26n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
## Dataset Variants
|
||||
|
||||
ImageWoof dataset comes in three different sizes to accommodate various research needs and computational capabilities:
|
||||
|
||||
1. **Full Size (imagewoof)**: This is the original version of the ImageWoof dataset. It contains full-sized images and is ideal for final training and performance benchmarking.
|
||||
|
||||
2. **Medium Size (imagewoof320)**: This version contains images resized to have a maximum edge length of 320 pixels. It's suitable for faster training without significantly sacrificing model performance.
|
||||
|
||||
3. **Small Size (imagewoof160)**: This version contains images resized to have a maximum edge length of 160 pixels. It's designed for rapid prototyping and experimentation where training speed is a priority.
|
||||
|
||||
To use these variants in your training, simply replace 'imagewoof' in the dataset argument with 'imagewoof320' or 'imagewoof160'. For example:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# For medium-sized dataset
|
||||
model.train(data="imagewoof320", epochs=100, imgsz=224)
|
||||
|
||||
# For small-sized dataset
|
||||
model.train(data="imagewoof160", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Load a pretrained model and train on the medium-sized dataset
|
||||
yolo classify train model=yolo26n-cls.pt data=imagewoof320 epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
It's important to note that using smaller images will likely yield lower performance in terms of classification accuracy. However, it's an excellent way to iterate quickly in the early stages of model development and prototyping.
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The ImageWoof dataset contains colorful images of various dog breeds, providing a challenging dataset for image classification tasks. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the subtle differences and similarities among the different dog breeds in the ImageWoof dataset, highlighting the complexity and difficulty of the classification task.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the ImageWoof dataset in your research or development work, please make sure to acknowledge the creators of the dataset by linking to the [official dataset repository](https://github.com/fastai/imagenette).
|
||||
|
||||
We would like to acknowledge the [FastAI](https://www.fast.ai/) team for creating and maintaining the ImageWoof dataset as a valuable resource for the [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) research community. For more information about the ImageWoof dataset, visit the [ImageWoof dataset repository](https://github.com/fastai/imagenette).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the ImageWoof dataset in Ultralytics?
|
||||
|
||||
The [ImageWoof](https://github.com/fastai/imagenette) dataset is a challenging subset of ImageNet focusing on 10 specific dog breeds. Created to push the limits of image classification models, it features breeds like Beagle, Shih-Tzu, and Golden Retriever. The dataset includes images at various resolutions (full size, 320px, 160px) and even noisy labels for more realistic training scenarios. This complexity makes ImageWoof ideal for developing more advanced deep learning models.
|
||||
|
||||
### How can I train a model using the ImageWoof dataset with Ultralytics YOLO?
|
||||
|
||||
To train a [Convolutional Neural Network](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNN) model on the ImageWoof dataset using Ultralytics YOLO for 100 epochs at an image size of 224x224, you can use the following code:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n-cls.pt") # Load a pretrained model
|
||||
results = model.train(data="imagewoof", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify train data=imagewoof model=yolo26n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
For more details on available training arguments, refer to the [Training](../../modes/train.md) page.
|
||||
|
||||
### What versions of the ImageWoof dataset are available?
|
||||
|
||||
The ImageWoof dataset comes in three sizes:
|
||||
|
||||
1. **Full Size (imagewoof)**: Ideal for final training and benchmarking, containing full-sized images.
|
||||
2. **Medium Size (imagewoof320)**: Resized images with a maximum edge length of 320 pixels, suited for faster training.
|
||||
3. **Small Size (imagewoof160)**: Resized images with a maximum edge length of 160 pixels, perfect for rapid prototyping.
|
||||
|
||||
Use these versions by replacing 'imagewoof' in the dataset argument accordingly. Note, however, that smaller images may yield lower classification [accuracy](https://www.ultralytics.com/glossary/accuracy) but can be useful for quicker iterations.
|
||||
|
||||
### How do noisy labels in the ImageWoof dataset benefit training?
|
||||
|
||||
Noisy labels in the ImageWoof dataset simulate real-world conditions where labels might not always be accurate. Training models with this data helps develop robustness and generalization in image classification tasks. This prepares the models to handle ambiguous or mislabeled data effectively, which is often encountered in practical applications.
|
||||
|
||||
### What are the key challenges of using the ImageWoof dataset?
|
||||
|
||||
The primary challenge of the ImageWoof dataset lies in the subtle differences among the dog breeds it includes. Since it focuses on 10 closely related breeds, distinguishing between them requires more advanced and fine-tuned image classification models. This makes ImageWoof an excellent benchmark to test the capabilities and improvements of [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models.
|
||||
@@ -1,210 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn how to structure datasets for YOLO classification tasks. Detailed folder structure and usage examples for effective training.
|
||||
keywords: YOLO, image classification, dataset structure, CIFAR-10, Ultralytics, machine learning, training data, model evaluation
|
||||
---
|
||||
|
||||
# Image Classification Datasets Overview
|
||||
|
||||
## Dataset Structure for YOLO Classification Tasks
|
||||
|
||||
For [Ultralytics](https://www.ultralytics.com/) YOLO classification tasks, the dataset must be organized in a specific split-directory structure under the `root` directory to facilitate proper training, testing, and optional validation processes. This structure includes separate directories for training (`train`) and testing (`test`) phases, with an optional directory for validation (`val`).
|
||||
|
||||
Each of these directories should contain one subdirectory for each class in the dataset. The subdirectories are named after the corresponding class and contain all the images for that class. Ensure that each image file is named uniquely and stored in a common format such as JPEG or PNG.
|
||||
|
||||
### Folder Structure Example
|
||||
|
||||
Consider the [CIFAR-10](cifar10.md) dataset as an example. The folder structure should look like this:
|
||||
|
||||
```
|
||||
cifar-10-/
|
||||
|
|
||||
|-- train/
|
||||
| |-- airplane/
|
||||
| | |-- 10008_airplane.png
|
||||
| | |-- 10009_airplane.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- automobile/
|
||||
| | |-- 1000_automobile.png
|
||||
| | |-- 1001_automobile.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- bird/
|
||||
| | |-- 10014_bird.png
|
||||
| | |-- 10015_bird.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- ...
|
||||
|
|
||||
|-- test/
|
||||
| |-- airplane/
|
||||
| | |-- 10_airplane.png
|
||||
| | |-- 11_airplane.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- automobile/
|
||||
| | |-- 100_automobile.png
|
||||
| | |-- 101_automobile.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- bird/
|
||||
| | |-- 1000_bird.png
|
||||
| | |-- 1001_bird.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- ...
|
||||
|
|
||||
|-- val/ (optional)
|
||||
| |-- airplane/
|
||||
| | |-- 105_airplane.png
|
||||
| | |-- 106_airplane.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- automobile/
|
||||
| | |-- 102_automobile.png
|
||||
| | |-- 103_automobile.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- bird/
|
||||
| | |-- 1045_bird.png
|
||||
| | |-- 1046_bird.png
|
||||
| | |-- ...
|
||||
| |
|
||||
| |-- ...
|
||||
```
|
||||
|
||||
This structured approach ensures that the model can effectively learn from well-organized classes during the training phase and accurately evaluate performance during testing and validation phases.
|
||||
|
||||
## Usage
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="path/to/dataset", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=path/to/data model=yolo26n-cls.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! tip
|
||||
|
||||
Most built-in dataset names (for example `cifar10`, `imagenette`, or `mnist160`) will automatically download and cache the data the first time you reference them. Point `data` to a folder path only when you have curated a custom dataset.
|
||||
|
||||
## Supported Datasets
|
||||
|
||||
Ultralytics supports the following datasets with automatic download:
|
||||
|
||||
- [Caltech 101](caltech101.md): A dataset containing images of 101 object categories for [image classification](https://www.ultralytics.com/glossary/image-classification) tasks.
|
||||
- [Caltech 256](caltech256.md): An extended version of Caltech 101 with 256 object categories and more challenging images.
|
||||
- [CIFAR-10](cifar10.md): A dataset of 60K 32x32 color images in 10 classes, with 6K images per class.
|
||||
- [CIFAR-100](cifar100.md): An extended version of CIFAR-10 with 100 object categories and 600 images per class.
|
||||
- [Fashion-MNIST](fashion-mnist.md): A dataset consisting of 70,000 grayscale images of 10 fashion categories for image classification tasks.
|
||||
- [ImageNet](imagenet.md): A large-scale dataset for [object detection](https://www.ultralytics.com/glossary/object-detection) and image classification with over 14 million images and 20,000 categories.
|
||||
- [ImageNet-10](imagenet10.md): A smaller subset of ImageNet with 10 categories for faster experimentation and testing.
|
||||
- [Imagenette](imagenette.md): A smaller subset of ImageNet that contains 10 easily distinguishable classes for quicker training and testing.
|
||||
- [Imagewoof](imagewoof.md): A more challenging subset of ImageNet containing 10 dog breed categories for image classification tasks.
|
||||
- [MNIST](mnist.md): A dataset of 70,000 grayscale images of handwritten digits for image classification tasks.
|
||||
- [MNIST160](mnist.md): First 8 images of each MNIST category from the MNIST dataset. Dataset contains 160 images total.
|
||||
|
||||
### Adding your own dataset
|
||||
|
||||
If you have your own dataset and would like to use it for training classification models with Ultralytics YOLO, ensure that it follows the format specified above under "Dataset Structure" and then point your `data` argument to the dataset directory when initializing your training script.
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I structure my dataset for YOLO classification tasks?
|
||||
|
||||
To structure your dataset for Ultralytics YOLO classification tasks, you should follow a specific split-directory format. Organize your dataset into separate directories for `train`, `test`, and optionally `val`. Each of these directories should contain subdirectories named after each class, with the corresponding images inside. This facilitates smooth training and evaluation processes. For an example, consider the [CIFAR-10](cifar10.md) dataset format:
|
||||
|
||||
```
|
||||
cifar-10-/
|
||||
|-- train/
|
||||
| |-- airplane/
|
||||
| |-- automobile/
|
||||
| |-- bird/
|
||||
| ...
|
||||
|-- test/
|
||||
| |-- airplane/
|
||||
| |-- automobile/
|
||||
| |-- bird/
|
||||
| ...
|
||||
|-- val/ (optional)
|
||||
| |-- airplane/
|
||||
| |-- automobile/
|
||||
| |-- bird/
|
||||
| ...
|
||||
```
|
||||
|
||||
For more details, visit the [Dataset Structure for YOLO Classification Tasks](#dataset-structure-for-yolo-classification-tasks) section.
|
||||
|
||||
### What datasets are supported by Ultralytics YOLO for image classification?
|
||||
|
||||
Ultralytics YOLO supports automatic downloading of several datasets for image classification, including [Caltech 101](caltech101.md), [Caltech 256](caltech256.md), [CIFAR-10](cifar10.md), [CIFAR-100](cifar100.md), [Fashion-MNIST](fashion-mnist.md), [ImageNet](imagenet.md), [ImageNet-10](imagenet10.md), [Imagenette](imagenette.md), [Imagewoof](imagewoof.md), and [MNIST](mnist.md). These datasets are structured in a way that makes them easy to use with YOLO. Each dataset's page provides further details about its structure and applications.
|
||||
|
||||
### How do I add my own dataset for YOLO image classification?
|
||||
|
||||
To use your own dataset with Ultralytics YOLO, ensure it follows the specified directory format required for the classification task, with separate `train`, `test`, and optionally `val` directories, and subdirectories for each class containing the respective images. Once your dataset is structured correctly, point the `data` argument to your dataset's root directory when initializing the training script. Here's an example in Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="path/to/your/dataset", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
More details can be found in the [Adding your own dataset](#adding-your-own-dataset) section.
|
||||
|
||||
### Why should I use Ultralytics YOLO for image classification?
|
||||
|
||||
Ultralytics YOLO offers several benefits for image classification, including:
|
||||
|
||||
- **Pretrained Models**: Load pretrained models like `yolo26n-cls.pt` to jump-start your training process.
|
||||
- **Ease of Use**: Simple API and CLI commands for training and evaluation.
|
||||
- **High Performance**: State-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed, ideal for real-time applications.
|
||||
- **Support for Multiple Datasets**: Seamless integration with various popular datasets like [CIFAR-10](cifar10.md), [ImageNet](imagenet.md), and more.
|
||||
- **Community and Support**: Access to extensive documentation and an active community for troubleshooting and improvements.
|
||||
|
||||
For additional insights and real-world applications, you can explore [Ultralytics YOLO](https://www.ultralytics.com/yolo).
|
||||
|
||||
### How can I train a model using Ultralytics YOLO?
|
||||
|
||||
Training a model using Ultralytics YOLO can be done easily in both Python and CLI. Here's an example:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="path/to/dataset", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=path/to/data model=yolo26n-cls.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
These examples demonstrate the straightforward process of training a YOLO model using either approach. For more information, visit the [Usage](#usage) section and the [Train](https://docs.ultralytics.com/tasks/classify/#train) page for classification tasks.
|
||||
@@ -1,157 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the MNIST dataset, a cornerstone in machine learning for handwritten digit recognition. Learn about its structure, features, and applications.
|
||||
keywords: MNIST, dataset, handwritten digits, image classification, deep learning, machine learning, training set, testing set, NIST
|
||||
---
|
||||
|
||||
# MNIST Dataset
|
||||
|
||||
The [MNIST](https://en.wikipedia.org/wiki/MNIST_database) (Modified National Institute of Standards and Technology) dataset is a large database of handwritten digits that is commonly used for training various image processing systems and machine learning models. It was created by "re-mixing" the samples from NIST's original datasets and has become a benchmark for evaluating the performance of [image classification](https://www.ultralytics.com/glossary/image-classification) algorithms.
|
||||
|
||||
## Key Features
|
||||
|
||||
- MNIST contains 60,000 training images and 10,000 testing images of handwritten digits.
|
||||
- The dataset comprises grayscale images of size 28×28 pixels.
|
||||
- The images are normalized to fit into a 28×28 pixel [bounding box](https://www.ultralytics.com/glossary/bounding-box) and anti-aliased, introducing grayscale levels.
|
||||
- MNIST is widely used for training and testing in the field of machine learning, especially for image classification tasks.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The MNIST dataset is split into two subsets:
|
||||
|
||||
1. **Training Set**: This subset contains 60,000 images of handwritten digits used for training machine learning models.
|
||||
2. **Testing Set**: This subset consists of 10,000 images used for testing and benchmarking the trained models.
|
||||
|
||||
## Dataset Access
|
||||
|
||||
- **Original files**: Download the gzip archives from [Yann LeCun's MNIST page](http://yann.lecun.com/exdb/mnist/) if you want direct control over preprocessing.
|
||||
- **Ultralytics loader**: Use `data="mnist"` (or `data="mnist160"` for the subset below) in your command and the dataset will be downloaded, converted to PNG, and cached automatically.
|
||||
|
||||
Each image in the dataset is labeled with the corresponding digit (0-9), making it a supervised learning dataset ideal for classification tasks.
|
||||
|
||||
## Extended MNIST (EMNIST)
|
||||
|
||||
Extended MNIST (EMNIST) is a newer dataset developed and released by NIST to be the successor to MNIST. While MNIST included images only of handwritten digits, EMNIST includes all the images from NIST Special Database 19, which is a large database of handwritten uppercase and lowercase letters as well as digits. The images in EMNIST were converted into the same 28×28 pixel format, by the same process, as were the MNIST images. Accordingly, tools that work with the older, smaller MNIST dataset will likely work unmodified with EMNIST.
|
||||
|
||||
## Applications
|
||||
|
||||
The MNIST dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in image classification tasks, such as [Convolutional Neural Networks](https://www.ultralytics.com/glossary/convolutional-neural-network-cnn) (CNNs), [Support Vector Machines](https://www.ultralytics.com/glossary/support-vector-machine-svm) (SVMs), and various other machine learning algorithms. The dataset's simple and well-structured format makes it an essential resource for researchers and practitioners in the field of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
|
||||
Some common applications include:
|
||||
|
||||
- Benchmarking new classification algorithms
|
||||
- Educational purposes for teaching machine learning concepts
|
||||
- Prototyping image recognition systems
|
||||
- Testing model optimization techniques
|
||||
|
||||
## Usage
|
||||
|
||||
To train a CNN model on the MNIST dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 28×28, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="mnist", epochs=100, imgsz=28)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=mnist model=yolo26n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The MNIST dataset contains grayscale images of handwritten digits, providing a well-structured dataset for image classification tasks. Here are some examples of images from the dataset:
|
||||
|
||||
|
||||
|
||||
The example showcases the variety and complexity of the handwritten digits in the MNIST dataset, highlighting the importance of a diverse dataset for training robust image classification models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the MNIST dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{lecun2010mnist,
|
||||
title={MNIST handwritten digit database},
|
||||
author={LeCun, Yann and Cortes, Corinna and Burges, CJ},
|
||||
journal={ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist},
|
||||
volume={2},
|
||||
year={2010}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge Yann LeCun, Corinna Cortes, and Christopher J.C. Burges for creating and maintaining the MNIST dataset as a valuable resource for the machine learning and computer vision research community. For more information about the MNIST dataset and its creators, visit the [MNIST dataset website](https://en.wikipedia.org/wiki/MNIST_database).
|
||||
|
||||
## MNIST160 Quick Tests
|
||||
|
||||
Need a lightning-fast regression test? Ultralytics also exposes `data="mnist160"`, a 160-image slice containing the first eight samples from each digit class. It mirrors the MNIST directory structure, so you can swap datasets without changing any other arguments:
|
||||
|
||||
!!! example "Train Example with MNIST160"
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify train data=mnist160 model=yolo26n-cls.pt epochs=5 imgsz=28
|
||||
```
|
||||
|
||||
Use this subset for CI pipelines or sanity checks before committing to the full 70,000-image dataset.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the MNIST dataset, and why is it important in machine learning?
|
||||
|
||||
The [MNIST](https://en.wikipedia.org/wiki/MNIST_database) dataset, or Modified National Institute of Standards and Technology dataset, is a widely-used collection of handwritten digits designed for training and testing image classification systems. It includes 60,000 training images and 10,000 testing images, all of which are grayscale and 28×28 pixels in size. The dataset's importance lies in its role as a standard benchmark for evaluating image classification algorithms, helping researchers and engineers to compare methods and track progress in the field.
|
||||
|
||||
### How can I use Ultralytics YOLO to train a model on the MNIST dataset?
|
||||
|
||||
To train a model on the MNIST dataset using Ultralytics YOLO, you can follow these steps:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="mnist", epochs=100, imgsz=28)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=mnist model=yolo26n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
For a detailed list of available training arguments, refer to the [Training](../../modes/train.md) page.
|
||||
|
||||
### What is the difference between the MNIST and EMNIST datasets?
|
||||
|
||||
The MNIST dataset contains only handwritten digits, whereas the Extended MNIST (EMNIST) dataset includes both digits and uppercase and lowercase letters. EMNIST was developed as a successor to MNIST and utilizes the same 28×28 pixel format for the images, making it compatible with tools and models designed for the original MNIST dataset. This broader range of characters in EMNIST makes it useful for a wider variety of machine learning applications.
|
||||
|
||||
### Can I use Ultralytics Platform to train models on custom datasets like MNIST?
|
||||
|
||||
Yes, you can use [Ultralytics Platform](https://docs.ultralytics.com/platform/) to train models on custom datasets like MNIST. Ultralytics Platform offers a user-friendly interface for uploading datasets, training models, and managing projects without needing extensive coding knowledge. For more details on how to get started, check out the [Ultralytics Platform Quickstart](https://docs.ultralytics.com/platform/quickstart/) page.
|
||||
|
||||
### How does MNIST compare to other image classification datasets?
|
||||
|
||||
MNIST is simpler than many modern datasets like [CIFAR-10](../classify/cifar10.md) or [ImageNet](../classify/imagenet.md), making it ideal for beginners and quick experimentation. While more complex datasets offer greater challenges with color images and diverse object categories, MNIST remains valuable for its simplicity, small file size, and historical significance in the development of machine learning algorithms. For more advanced classification tasks, consider using [Fashion-MNIST](../classify/fashion-mnist.md), which maintains the same structure but features clothing items instead of digits.
|
||||
@@ -1,166 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore our African Wildlife Dataset featuring images of buffalo, elephant, rhino, and zebra for training computer vision models. Ideal for research and conservation.
|
||||
keywords: African Wildlife Dataset, South African animals, object detection, computer vision, YOLO26, wildlife research, conservation, dataset
|
||||
---
|
||||
|
||||
# African Wildlife Dataset
|
||||
|
||||
This dataset showcases four common animal classes typically found in South African nature reserves. It includes images of African wildlife such as buffalo, elephant, rhino, and zebra, providing valuable insights into their characteristics. Essential for training [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) algorithms, this dataset aids in identifying animals in various habitats, from zoos to forests, and supports wildlife research.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/biIW5Z6GYl0"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> African Wildlife Animals Detection using Ultralytics YOLO26
|
||||
</p>
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The African wildlife objects detection dataset is split into three subsets:
|
||||
|
||||
- **Training set**: Contains 1052 images, each with corresponding annotations.
|
||||
- **Validation set**: Includes 225 images, each with paired annotations.
|
||||
- **Testing set**: Comprises 227 images, each with paired annotations.
|
||||
|
||||
## Applications
|
||||
|
||||
This dataset can be applied in various computer vision tasks such as [object detection](https://www.ultralytics.com/glossary/object-detection), object tracking, and research. Specifically, it can be used to train and evaluate models for identifying African wildlife objects in images, which can have applications in wildlife conservation, ecological research, and monitoring efforts in natural reserves and protected areas. Additionally, it can serve as a valuable resource for educational purposes, enabling students and researchers to study and understand the characteristics and behaviors of different animal species.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file defines the dataset configuration, including paths, classes, and other pertinent details. For the African wildlife dataset, the `african-wildlife.yaml` file is located at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/african-wildlife.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/african-wildlife.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/african-wildlife.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/african-wildlife.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the African wildlife dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the provided code samples. For a comprehensive list of available parameters, refer to the model's [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="african-wildlife.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=african-wildlife.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/best.pt") # load an African wildlife fine-tuned model
|
||||
|
||||
# Inference using the model
|
||||
results = model.predict("https://ultralytics.com/assets/african-wildlife-sample.jpg")
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start prediction with a finetuned *.pt model
|
||||
yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/african-wildlife-sample.jpg"
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The African wildlife dataset comprises a wide variety of images showcasing diverse animal species and their natural habitats. Below are examples of images from the dataset, each accompanied by its corresponding annotations.
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: Here, we present a training batch consisting of mosaiced dataset images. Mosaicing, a training technique, combines multiple images into one, enriching batch diversity. This method helps enhance the model's ability to generalize across different object sizes, aspect ratios, and contexts.
|
||||
|
||||
This example illustrates the variety and complexity of images in the African wildlife dataset, emphasizing the benefits of including mosaicing during the training process.
|
||||
|
||||
## Citations, License and Acknowledgments
|
||||
|
||||
We'd like to thank the original dataset author, [Bianca Ferreira](https://www.kaggle.com/biancaferreira/datasets), for releasing this dataset to the community. The Ultralytics team has updated and adapted it internally so it can be used seamlessly with [Ultralytics YOLO](https://www.ultralytics.com/yolo) models. This dataset is available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).
|
||||
|
||||
If you use this dataset in your research, please cite it using the mentioned details:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
|
||||
@dataset{Ferreira_African_Wildlife_Ultralytics_Adaptation_2024,
|
||||
author = {Ferreira, Bianca},
|
||||
title = {African Wildlife Detection Dataset (Ultralytics YOLO Adaptation)},
|
||||
url = {https://docs.ultralytics.com/datasets/detect/african-wildlife/},
|
||||
note = {Original dataset by Bianca Ferreira; adapted for Ultralytics YOLO by Glenn Jocher and Muhammad Rizwan Munawar},
|
||||
license = {AGPL-3.0},
|
||||
version = {1.0.0},
|
||||
year = {2024}
|
||||
}
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the African Wildlife Dataset, and how can it be used in computer vision projects?
|
||||
|
||||
The African Wildlife Dataset includes images of four common animal species found in South African nature reserves: buffalo, elephant, rhino, and zebra. It is a valuable resource for training computer vision algorithms in object detection and animal identification. The dataset supports various tasks like object tracking, research, and conservation efforts. For more information on its structure and applications, refer to the [Dataset Structure](#dataset-structure) section and [Applications](#applications) of the dataset.
|
||||
|
||||
### How do I train a YOLO26 model using the African Wildlife Dataset?
|
||||
|
||||
You can train a YOLO26 model on the African Wildlife Dataset by using the `african-wildlife.yaml` configuration file. Below is an example of how to train the YOLO26n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="african-wildlife.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=african-wildlife.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For additional training parameters and options, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### Where can I find the YAML configuration file for the African Wildlife Dataset?
|
||||
|
||||
The YAML configuration file for the African Wildlife Dataset, named `african-wildlife.yaml`, can be found at [this GitHub link](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/african-wildlife.yaml). This file defines the dataset configuration, including paths, classes, and other details crucial for training [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models. See the [Dataset YAML](#dataset-yaml) section for more details.
|
||||
|
||||
### Can I see sample images and annotations from the African Wildlife Dataset?
|
||||
|
||||
Yes, the African Wildlife Dataset includes a wide variety of images showcasing diverse animal species in their natural habitats. You can view sample images and their corresponding annotations in the [Sample Images and Annotations](#sample-images-and-annotations) section. This section also illustrates the use of mosaicing technique to combine multiple images into one for enriched batch diversity, enhancing the model's generalization ability.
|
||||
|
||||
### How can the African Wildlife Dataset be used to support wildlife conservation and research?
|
||||
|
||||
The African Wildlife Dataset is ideal for supporting wildlife conservation and research by enabling the training and evaluation of models to identify African wildlife in different habitats. These models can assist in [monitoring animal populations](https://docs.ultralytics.com/solutions/), studying their behavior, and recognizing conservation needs. Additionally, the dataset can be utilized for educational purposes, helping students and researchers understand the characteristics and behaviors of different animal species. More details can be found in the [Applications](#applications) section.
|
||||
@@ -1,153 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the comprehensive Argoverse dataset by Argo AI for 3D tracking, motion forecasting, and stereo depth estimation in autonomous driving research.
|
||||
keywords: Argoverse dataset, autonomous driving, 3D tracking, motion forecasting, stereo depth estimation, Argo AI, LiDAR point clouds, high-resolution images, HD maps
|
||||
---
|
||||
|
||||
# Argoverse Dataset
|
||||
|
||||
The [Argoverse](https://www.argoverse.org/) dataset is a collection of data designed to support research in autonomous driving tasks, such as 3D tracking, motion forecasting, and stereo depth estimation. Developed by Argo AI, the dataset provides a wide range of high-quality sensor data, including high-resolution images, LiDAR point clouds, and map data.
|
||||
|
||||
!!! note
|
||||
|
||||
The Argoverse dataset `*.zip` file required for training was removed from Amazon S3 after the shutdown of Argo AI by Ford, but we have made it available for manual download on [Google Drive](https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link).
|
||||
|
||||
## Key Features
|
||||
|
||||
- Argoverse contains over 290K labeled 3D object tracks and 5 million object instances across 1,263 distinct scenes.
|
||||
- The dataset includes high-resolution camera images, LiDAR point clouds, and richly annotated HD maps.
|
||||
- Annotations include 3D bounding boxes for objects, object tracks, and trajectory information.
|
||||
- Argoverse provides multiple subsets for different tasks, such as 3D tracking, motion forecasting, and stereo depth estimation.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The Argoverse dataset is organized into three main subsets:
|
||||
|
||||
1. **Argoverse 3D Tracking**: This subset contains 113 scenes with over 290K labeled 3D object tracks, focusing on 3D object tracking tasks. It includes LiDAR point clouds, camera images, and sensor calibration information.
|
||||
2. **Argoverse Motion Forecasting**: This subset consists of 324K vehicle trajectories collected from 60 hours of driving data, suitable for motion forecasting tasks.
|
||||
3. **Argoverse Stereo Depth Estimation**: This subset is designed for stereo depth estimation tasks and includes over 10K stereo image pairs with corresponding LiDAR point clouds for ground truth depth estimation.
|
||||
|
||||
## Applications
|
||||
|
||||
The Argoverse dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in autonomous driving tasks such as 3D object tracking, motion forecasting, and stereo depth estimation. The dataset's diverse set of sensor data, object annotations, and map information make it a valuable resource for researchers and practitioners in the field of autonomous driving.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the Argoverse dataset, the `Argoverse.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Argoverse.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Argoverse.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/Argoverse.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/Argoverse.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the Argoverse dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Argoverse.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Argoverse.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The Argoverse dataset contains a diverse set of sensor data, including camera images, LiDAR point clouds, and HD map information, providing rich context for autonomous driving tasks. Here are some examples of data from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Argoverse 3D Tracking**: This image demonstrates an example of 3D object tracking, where objects are annotated with 3D bounding boxes. The dataset provides LiDAR point clouds and camera images to facilitate the development of models for this task.
|
||||
|
||||
The example showcases the variety and complexity of the data in the Argoverse dataset and highlights the importance of high-quality sensor data for autonomous driving tasks.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Argoverse dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@inproceedings{chang2019argoverse,
|
||||
title={Argoverse: 3D Tracking and Forecasting with Rich Maps},
|
||||
author={Chang, Ming-Fang and Lambert, John and Sangkloy, Patsorn and Singh, Jagjeet and Bak, Slawomir and Hartnett, Andrew and Wang, Dequan and Carr, Peter and Lucey, Simon and Ramanan, Deva and others},
|
||||
booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
|
||||
pages={8748--8757},
|
||||
year={2019}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge Argo AI for creating and maintaining the Argoverse dataset as a valuable resource for the autonomous driving research community. For more information about the Argoverse dataset and its creators, visit the [Argoverse dataset website](https://www.argoverse.org/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Argoverse dataset and its key features?
|
||||
|
||||
The [Argoverse](https://www.argoverse.org/) dataset, developed by Argo AI, supports autonomous driving research. It includes over 290K labeled 3D object tracks and 5 million object instances across 1,263 distinct scenes. The dataset provides high-resolution camera images, LiDAR point clouds, and annotated HD maps, making it valuable for tasks like 3D tracking, motion forecasting, and stereo depth estimation.
|
||||
|
||||
### How can I train an Ultralytics YOLO model using the Argoverse dataset?
|
||||
|
||||
To train a YOLO26 model with the Argoverse dataset, use the provided YAML configuration file and the following code:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Argoverse.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Argoverse.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a detailed explanation of the arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What types of data and annotations are available in the Argoverse dataset?
|
||||
|
||||
The Argoverse dataset includes various sensor data types such as high-resolution camera images, LiDAR point clouds, and HD map data. Annotations include 3D bounding boxes, object tracks, and trajectory information. These comprehensive annotations are essential for accurate model training in tasks like 3D object tracking, motion forecasting, and stereo depth estimation.
|
||||
|
||||
### How is the Argoverse dataset structured?
|
||||
|
||||
The dataset is divided into three main subsets:
|
||||
|
||||
1. **Argoverse 3D Tracking**: Contains 113 scenes with over 290K labeled 3D object tracks, focusing on 3D object tracking tasks. It includes LiDAR point clouds, camera images, and sensor calibration information.
|
||||
2. **Argoverse Motion Forecasting**: Consists of 324K vehicle trajectories collected from 60 hours of driving data, suitable for motion forecasting tasks.
|
||||
3. **Argoverse Stereo Depth Estimation**: Includes over 10K stereo image pairs with corresponding LiDAR point clouds for ground truth depth estimation.
|
||||
|
||||
### Where can I download the Argoverse dataset now that it has been removed from Amazon S3?
|
||||
|
||||
The Argoverse dataset `*.zip` file, previously available on Amazon S3, can now be manually downloaded from [Google Drive](https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link).
|
||||
|
||||
### What is the YAML configuration file used for with the Argoverse dataset?
|
||||
|
||||
A YAML file contains the dataset's paths, classes, and other essential information. For the Argoverse dataset, the configuration file, `Argoverse.yaml`, can be found at the following link: [Argoverse.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Argoverse.yaml).
|
||||
|
||||
For more information about YAML configurations, see our [datasets](../index.md) guide.
|
||||
@@ -1,198 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the brain tumor detection dataset with MRI/CT images. Essential for training AI models for early diagnosis and treatment planning.
|
||||
keywords: brain tumor dataset, MRI scans, CT scans, brain tumor detection, medical imaging, AI in healthcare, computer vision, early diagnosis, treatment planning
|
||||
---
|
||||
|
||||
# Brain Tumor Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-brain-tumor-detection-dataset.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Brain Tumor Dataset In Colab"></a>
|
||||
|
||||
A brain tumor detection dataset consists of medical images from MRI or CT scans, containing information about brain tumor presence, location, and characteristics. This dataset is essential for training [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) algorithms to automate brain tumor identification, aiding in early diagnosis and treatment planning in [healthcare applications](https://www.ultralytics.com/solutions/ai-in-healthcare).
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/ogTBBD8McRk"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Brain Tumor Detection using Ultralytics Platform
|
||||
</p>
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The brain tumor dataset is divided into two subsets:
|
||||
|
||||
- **Training set**: Consisting of 893 images, each accompanied by corresponding annotations.
|
||||
- **Testing set**: Comprising 223 images, with annotations paired for each one.
|
||||
|
||||
The dataset contains two classes:
|
||||
|
||||
- **Negative**: Images without brain tumors
|
||||
- **Positive**: Images with brain tumors
|
||||
|
||||
## Applications
|
||||
|
||||
The application of brain tumor detection using computer vision enables [early diagnosis](https://www.ultralytics.com/blog/ai-and-radiology-a-new-era-of-precision-and-efficiency), treatment planning, and monitoring of tumor progression. By analyzing medical imaging data like MRI or CT scans, [computer vision systems](https://docs.ultralytics.com/tasks/detect/) assist in accurately identifying brain tumors, aiding in timely medical intervention and personalized treatment strategies.
|
||||
|
||||
Medical professionals can leverage this technology to:
|
||||
|
||||
- Reduce diagnostic time and improve accuracy
|
||||
- Assist in surgical planning by precisely locating tumors
|
||||
- Monitor treatment effectiveness over time
|
||||
- Support research in oncology and neurology
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the brain tumor dataset, the `brain-tumor.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/brain-tumor.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/brain-tumor.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/brain-tumor.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/brain-tumor.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a [YOLO26](https://docs.ultralytics.com/models/yolo26/) model on the brain tumor dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, utilize the provided code snippets. For a detailed list of available arguments, consult the model's [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="brain-tumor.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=brain-tumor.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/best.pt") # load a brain-tumor fine-tuned model
|
||||
|
||||
# Inference using the model
|
||||
results = model.predict("https://ultralytics.com/assets/brain-tumor-sample.jpg")
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start prediction with a finetuned *.pt model
|
||||
yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/brain-tumor-sample.jpg"
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The brain tumor dataset encompasses a wide array of medical images featuring brain scans with and without tumors. Presented below are examples of images from the dataset, accompanied by their respective annotations.
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: Displayed here is a training batch comprising mosaiced dataset images. Mosaicing, a training technique, consolidates multiple images into one, enhancing batch diversity. This approach aids in improving the model's capacity to generalize across various tumor sizes, shapes, and locations within brain scans.
|
||||
|
||||
This example highlights the diversity and intricacy of images within the brain tumor dataset, underscoring the advantages of incorporating mosaicing during the training phase for [medical image analysis](https://www.ultralytics.com/blog/using-yolo11-for-tumor-detection-in-medical-imaging).
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
The dataset has been made available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).
|
||||
|
||||
If you use this dataset in your research or development work, please cite it appropriately:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@dataset{Ultralytics_Brain_Tumor_Dataset_2023,
|
||||
author = {Ultralytics},
|
||||
title = {Brain Tumor Detection Dataset},
|
||||
year = {2023},
|
||||
publisher = {Ultralytics},
|
||||
url = {https://docs.ultralytics.com/datasets/detect/brain-tumor/}
|
||||
}
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the structure of the brain tumor dataset available in Ultralytics documentation?
|
||||
|
||||
The brain tumor dataset is divided into two subsets: the **training set** consists of 893 images with corresponding annotations, while the **testing set** comprises 223 images with paired annotations. This structured division aids in developing robust and accurate computer vision models for detecting brain tumors. For more information on the dataset structure, visit the [Dataset Structure](#dataset-structure) section.
|
||||
|
||||
### How can I train a YOLO26 model on the brain tumor dataset using Ultralytics?
|
||||
|
||||
You can train a YOLO26 model on the brain tumor dataset for 100 epochs with an image size of 640px using both Python and CLI methods. Below are the examples for both:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="brain-tumor.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=brain-tumor.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a detailed list of available arguments, refer to the [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the benefits of using the brain tumor dataset for AI in healthcare?
|
||||
|
||||
Using the brain tumor dataset in AI projects enables early diagnosis and treatment planning for brain tumors. It helps in automating brain tumor identification through computer vision, facilitating accurate and timely medical interventions, and supporting personalized treatment strategies. This application holds significant potential in improving patient outcomes and medical efficiencies. For more insights on AI applications in healthcare, see [Ultralytics' healthcare solutions](https://www.ultralytics.com/solutions/ai-in-healthcare).
|
||||
|
||||
### How do I perform inference using a fine-tuned YOLO26 model on the brain tumor dataset?
|
||||
|
||||
Inference using a fine-tuned YOLO26 model can be performed with either Python or CLI approaches. Here are the examples:
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/best.pt") # load a brain-tumor fine-tuned model
|
||||
|
||||
# Inference using the model
|
||||
results = model.predict("https://ultralytics.com/assets/brain-tumor-sample.jpg")
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start prediction with a finetuned *.pt model
|
||||
yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/brain-tumor-sample.jpg"
|
||||
```
|
||||
|
||||
### Where can I find the YAML configuration for the brain tumor dataset?
|
||||
|
||||
The YAML configuration file for the brain tumor dataset can be found at [brain-tumor.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/brain-tumor.yaml). This file includes paths, classes, and additional relevant information necessary for training and evaluating models on this dataset.
|
||||
@@ -1,173 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the COCO dataset for object detection and segmentation. Learn about its structure, usage, pretrained models, and key features.
|
||||
keywords: COCO dataset, object detection, segmentation, benchmarking, computer vision, pose estimation, YOLO models, COCO annotations
|
||||
---
|
||||
|
||||
# COCO Dataset
|
||||
|
||||
The [COCO](https://cocodataset.org/#home) (Common Objects in Context) dataset is a large-scale object detection, segmentation, and captioning dataset. It is designed to encourage research on a wide variety of object categories and is commonly used for benchmarking [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models. It is an essential dataset for researchers and developers working on object detection, segmentation, and pose estimation tasks.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/uDrn9QZJ2lk"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Ultralytics COCO Dataset Overview
|
||||
</p>
|
||||
|
||||
## COCO Pretrained Models
|
||||
|
||||
{% include "macros/yolo-det-perf.md" %}
|
||||
|
||||
## Key Features
|
||||
|
||||
- COCO contains 330K images, with 200K images having annotations for object detection, segmentation, and captioning tasks.
|
||||
- The dataset comprises 80 object categories, including common objects like cars, bicycles, and animals, as well as more specific categories such as umbrellas, handbags, and sports equipment.
|
||||
- Annotations include object bounding boxes, segmentation masks, and captions for each image.
|
||||
- COCO provides standardized evaluation metrics like [mean Average Precision](https://www.ultralytics.com/glossary/mean-average-precision-map) (mAP) for object detection, and mean Average [Recall](https://www.ultralytics.com/glossary/recall) (mAR) for segmentation tasks, making it suitable for comparing model performance.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The COCO dataset is split into three subsets:
|
||||
|
||||
1. **Train2017**: This subset contains 118K images for training object detection, segmentation, and captioning models.
|
||||
2. **Val2017**: This subset has 5K images used for validation purposes during model training.
|
||||
3. **Test2017**: This subset consists of 20K images used for testing and benchmarking the trained models. Ground truth annotations for this subset are not publicly available, and the results are submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7384) for performance evaluation.
|
||||
|
||||
## Applications
|
||||
|
||||
The COCO dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object detection (such as [Ultralytics YOLO](../../models/yolo26.md), [Faster R-CNN](https://arxiv.org/abs/1506.01497), and [SSD](https://arxiv.org/abs/1512.02325)), [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) (such as [Mask R-CNN](https://arxiv.org/abs/1703.06870)), and keypoint detection (such as [OpenPose](https://arxiv.org/abs/1812.08008)). The dataset's diverse set of object categories, large number of annotated images, and standardized evaluation metrics make it an essential resource for computer vision researchers and practitioners.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO dataset, the `coco.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the COCO dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The COCO dataset contains a diverse set of images with various object categories and complex scenes. Here are some examples of images from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the COCO dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO dataset and why is it important for computer vision?
|
||||
|
||||
The [COCO dataset](https://cocodataset.org/#home) (Common Objects in Context) is a large-scale dataset used for [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and captioning. It contains 330K images with detailed annotations for 80 object categories, making it essential for benchmarking and training computer vision models. Researchers use COCO due to its diverse categories and standardized evaluation metrics like mean Average [Precision](https://www.ultralytics.com/glossary/precision) (mAP).
|
||||
|
||||
### How can I train a YOLO model using the COCO dataset?
|
||||
|
||||
To train a YOLO26 model using the COCO dataset, you can use the following code snippets:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
Refer to the [Training page](../../modes/train.md) for more details on available arguments.
|
||||
|
||||
### What are the key features of the COCO dataset?
|
||||
|
||||
The COCO dataset includes:
|
||||
|
||||
- 330K images, with 200K annotated for object detection, segmentation, and captioning.
|
||||
- 80 object categories ranging from common items like cars and animals to specific ones like handbags and sports equipment.
|
||||
- Standardized evaluation metrics for object detection (mAP) and segmentation (mean Average Recall, mAR).
|
||||
- **Mosaicing** technique in training batches to enhance model generalization across various object sizes and contexts.
|
||||
|
||||
### Where can I find pretrained YOLO26 models trained on the COCO dataset?
|
||||
|
||||
Pretrained YOLO26 models on the COCO dataset can be downloaded from the links provided in the documentation. Examples include:
|
||||
|
||||
- [YOLO26n](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt)
|
||||
- [YOLO26s](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s.pt)
|
||||
- [YOLO26m](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m.pt)
|
||||
- [YOLO26l](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26l.pt)
|
||||
- [YOLO26x](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x.pt)
|
||||
|
||||
These models vary in size, mAP, and inference speed, providing options for different performance and resource requirements.
|
||||
|
||||
### How is the COCO dataset structured and how do I use it?
|
||||
|
||||
The COCO dataset is split into three subsets:
|
||||
|
||||
1. **Train2017**: 118K images for training.
|
||||
2. **Val2017**: 5K images for validation during training.
|
||||
3. **Test2017**: 20K images for benchmarking trained models. Results need to be submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7384) for performance evaluation.
|
||||
|
||||
The dataset's YAML configuration file is available at [coco.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), which defines paths, classes, and dataset details.
|
||||
@@ -1,234 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics COCO12-Formats dataset, a test dataset featuring all 12 supported image formats (AVIF, BMP, DNG, HEIC, JP2, JPEG, JPG, MPO, PNG, TIF, TIFF, WebP) for validating image loading pipelines.
|
||||
keywords: COCO12-Formats, Ultralytics, dataset, image formats, object detection, YOLO, AVIF, BMP, DNG, HEIC, JP2, JPEG, PNG, TIFF, WebP, MPO
|
||||
---
|
||||
|
||||
# COCO12-Formats Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
The [Ultralytics](https://www.ultralytics.com/) COCO12-Formats dataset is a specialized test dataset designed to validate image loading across all 12 supported image format extensions. It contains 12 images (6 for training, 6 for validation), each saved in a different format to ensure comprehensive testing of the image loading pipeline.
|
||||
|
||||
This dataset is invaluable for:
|
||||
|
||||
- **Testing image format support**: Verify that all supported formats load correctly
|
||||
- **CI/CD pipelines**: Automated testing of format compatibility
|
||||
- **Debugging**: Isolate format-specific issues in training pipelines
|
||||
- **Development**: Validate new format additions or changes
|
||||
|
||||
## Supported Formats
|
||||
|
||||
The dataset includes one image for each of the 12 supported format extensions defined in `ultralytics/data/utils.py`:
|
||||
|
||||
| Format | Extension | Description | Train/Val |
|
||||
| ------ | --------- | ------------------------------------ | --------- |
|
||||
| AVIF | `.avif` | AV1 Image File Format (modern) | Train |
|
||||
| BMP | `.bmp` | Bitmap - uncompressed raster format | Train |
|
||||
| DNG | `.dng` | Digital Negative - Adobe RAW format | Train |
|
||||
| HEIC | `.heic` | High Efficiency Image Coding | Train |
|
||||
| JPEG | `.jpeg` | JPEG with full extension | Train |
|
||||
| JPG | `.jpg` | JPEG with short extension | Train |
|
||||
| JP2 | `.jp2` | JPEG 2000 - medical/geospatial | Val |
|
||||
| MPO | `.mpo` | Multi-Picture Object (stereo images) | Val |
|
||||
| PNG | `.png` | Portable Network Graphics | Val |
|
||||
| TIF | `.tif` | TIFF with short extension | Val |
|
||||
| TIFF | `.tiff` | Tagged Image File Format | Val |
|
||||
| WebP | `.webp` | Modern web image format | Val |
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
```
|
||||
coco12-formats/
|
||||
├── images/
|
||||
│ ├── train/ # 6 images (avif, bmp, dng, heic, jpeg, jpg)
|
||||
│ └── val/ # 6 images (jp2, mpo, png, tif, tiff, webp)
|
||||
├── labels/
|
||||
│ ├── train/ # Corresponding YOLO format labels
|
||||
│ └── val/
|
||||
└── coco12-formats.yaml # Dataset configuration
|
||||
```
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
The COCO12-Formats dataset is configured using a YAML file that defines dataset paths and class names. You can review the official `coco12-formats.yaml` file in the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco12-formats.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco12-formats.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco12-formats.yaml"
|
||||
```
|
||||
|
||||
## Dataset Generation
|
||||
|
||||
The dataset can be generated using the provided script that converts source images from COCO8 and COCO128 to all supported formats:
|
||||
|
||||
```python
|
||||
from ultralytics.data.scripts.generate_coco12_formats import generate_coco12_formats
|
||||
|
||||
# Generate the dataset
|
||||
generate_coco12_formats()
|
||||
```
|
||||
|
||||
### Requirements
|
||||
|
||||
Some formats require additional dependencies:
|
||||
|
||||
```bash
|
||||
pip install pillow pillow-heif pillow-avif-plugin
|
||||
```
|
||||
|
||||
#### AVIF System Library (Optional)
|
||||
|
||||
For OpenCV to read AVIF files directly, `libavif` must be installed **before** building OpenCV:
|
||||
|
||||
=== "macOS"
|
||||
|
||||
```bash
|
||||
brew install libavif
|
||||
```
|
||||
|
||||
=== "Ubuntu/Debian"
|
||||
|
||||
```bash
|
||||
sudo apt install libavif-dev libavif-bin
|
||||
```
|
||||
|
||||
=== "From Source"
|
||||
|
||||
```bash
|
||||
git clone -b v1.2.1 https://github.com/AOMediaCodec/libavif.git
|
||||
cd libavif
|
||||
cmake -B build -DAVIF_CODEC_AOM=SYSTEM -DAVIF_BUILD_APPS=ON
|
||||
cmake --build build --config Release --parallel
|
||||
sudo cmake --install build
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
The pip-installed `opencv-python` package may not include AVIF support since it's pre-built. Ultralytics uses Pillow with `pillow-avif-plugin` as a fallback for AVIF images when OpenCV lacks support.
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO model on the COCO12-Formats dataset, use the following examples:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train on COCO12-Formats to test all image formats
|
||||
results = model.train(data="coco12-formats.yaml", epochs=1, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train YOLO on COCO12-Formats
|
||||
yolo detect train data=coco12-formats.yaml model=yolo26n.pt epochs=1 imgsz=640
|
||||
```
|
||||
|
||||
## Format-Specific Notes
|
||||
|
||||
### AVIF (AV1 Image File Format)
|
||||
|
||||
AVIF is a modern image format based on the AV1 video codec, offering excellent compression. Requires `pillow-avif-plugin`:
|
||||
|
||||
```bash
|
||||
pip install pillow-avif-plugin
|
||||
```
|
||||
|
||||
### DNG (Digital Negative)
|
||||
|
||||
DNG is Adobe's open RAW format based on TIFF. For testing purposes, the dataset uses TIFF-based files with the `.dng` extension.
|
||||
|
||||
### JP2 (JPEG 2000)
|
||||
|
||||
JPEG 2000 is a wavelet-based image compression standard offering better compression and quality than traditional JPEG. Commonly used in medical imaging (DICOM), geospatial applications, and digital cinema. Natively supported by both OpenCV and Pillow.
|
||||
|
||||
### MPO (Multi-Picture Object)
|
||||
|
||||
MPO files are used for stereoscopic (3D) images. The dataset stores standard JPEG data with the `.mpo` extension for format testing.
|
||||
|
||||
### HEIC (High Efficiency Image Coding)
|
||||
|
||||
HEIC requires the `pillow-heif` package for proper encoding:
|
||||
|
||||
```bash
|
||||
pip install pillow-heif
|
||||
```
|
||||
|
||||
## Use Cases
|
||||
|
||||
### CI/CD Testing
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
|
||||
def test_all_image_formats():
|
||||
"""Test that all image formats load correctly."""
|
||||
model = YOLO("yolo26n.pt")
|
||||
results = model.train(data="coco12-formats.yaml", epochs=1, imgsz=64)
|
||||
assert results is not None
|
||||
```
|
||||
|
||||
### Format Validation
|
||||
|
||||
```python
|
||||
from pathlib import Path
|
||||
|
||||
from ultralytics.data.utils import IMG_FORMATS
|
||||
|
||||
# Verify all formats are represented
|
||||
dataset_dir = Path("datasets/coco12-formats/images")
|
||||
found_formats = {f.suffix[1:].lower() for f in dataset_dir.rglob("*.*")}
|
||||
assert found_formats == IMG_FORMATS, f"Missing formats: {IMG_FORMATS - found_formats}"
|
||||
```
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research, please cite:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Doll{\'a}r},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### What Is the COCO12-Formats Dataset Used For?
|
||||
|
||||
The COCO12-Formats dataset is designed for testing image format compatibility in Ultralytics YOLO training pipelines. It ensures all 12 supported image formats (AVIF, BMP, DNG, HEIC, JP2, JPEG, JPG, MPO, PNG, TIF, TIFF, WebP) load and process correctly.
|
||||
|
||||
### Why Test Multiple Image Formats?
|
||||
|
||||
Different image formats have unique characteristics (compression, bit depth, color spaces). Testing all formats ensures:
|
||||
|
||||
- Robust image loading code
|
||||
- Compatibility across diverse datasets
|
||||
- Early detection of format-specific bugs
|
||||
|
||||
### Which Formats Require Special Dependencies?
|
||||
|
||||
- **AVIF**: Requires `pillow-avif-plugin`
|
||||
- **HEIC**: Requires `pillow-heif`
|
||||
|
||||
### Can I Add New Format Tests?
|
||||
|
||||
Yes! Modify the `generate_coco12_formats.py` script to include additional formats. Ensure you also update `IMG_FORMATS` in `ultralytics/data/utils.py`.
|
||||
@@ -1,154 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics COCO128 dataset, a versatile and manageable set of 128 images perfect for testing object detection models and training pipelines.
|
||||
keywords: COCO128, Ultralytics, dataset, object detection, YOLO26, training, validation, machine learning, computer vision
|
||||
---
|
||||
|
||||
# COCO128 Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) COCO128 is a small, but versatile [object detection](https://www.ultralytics.com/glossary/object-detection) dataset composed of the first 128 images of the COCO train 2017 set. This dataset is ideal for testing and debugging object detection models, or for experimenting with new detection approaches. With 128 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/uDrn9QZJ2lk"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Ultralytics COCO Dataset Overview
|
||||
</p>
|
||||
|
||||
This dataset is intended for use with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO128 dataset, the `coco128.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco128.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco128.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco128.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco128.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the COCO128 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco128.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco128.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are some examples of images from the COCO128 dataset, along with their corresponding annotations:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch-1.avif" alt="COCO128 object detection dataset mosaic training batch" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the COCO128 dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Ultralytics COCO128 dataset used for?
|
||||
|
||||
The Ultralytics COCO128 dataset is a compact subset containing the first 128 images from the COCO train 2017 dataset. It's primarily used for testing and debugging [object detection](https://www.ultralytics.com/glossary/object-detection) models, experimenting with new detection approaches, and validating training pipelines before scaling to larger datasets. Its manageable size makes it perfect for quick iterations while still providing enough diversity to be a meaningful test case.
|
||||
|
||||
### How do I train a YOLO26 model using the COCO128 dataset?
|
||||
|
||||
To train a YOLO26 model on the COCO128 dataset, you can use either Python or CLI commands. Here's how:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco128.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=coco128.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more training options and parameters, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### What are the benefits of using mosaic augmentation with COCO128?
|
||||
|
||||
Mosaic augmentation, as shown in the sample images, combines multiple training images into a single composite image. This technique offers several benefits when training with COCO128:
|
||||
|
||||
- Increases the variety of objects and contexts within each training batch
|
||||
- Improves model generalization across different object sizes and aspect ratios
|
||||
- Enhances detection performance for objects at various scales
|
||||
- Maximizes the utility of a small dataset by creating more diverse training samples
|
||||
|
||||
This technique is particularly valuable for smaller datasets like COCO128, helping models learn more robust features from limited data.
|
||||
|
||||
### How does COCO128 compare to other COCO dataset variants?
|
||||
|
||||
COCO128 (128 images) sits between [COCO8](../detect/coco8.md) (8 images) and the full [COCO](../detect/coco.md) dataset (118K+ images) in terms of size:
|
||||
|
||||
- **COCO8**: Contains just 8 images (4 train, 4 val) - ideal for quick tests and debugging
|
||||
- **COCO128**: Contains 128 images - balanced between size and diversity
|
||||
- **Full COCO**: Contains 118K+ training images - comprehensive but resource-intensive
|
||||
|
||||
COCO128 provides a good middle ground, offering more diversity than COCO8 while remaining much more manageable than the full COCO dataset for experimentation and initial model development.
|
||||
|
||||
### Can I use COCO128 for tasks other than object detection?
|
||||
|
||||
While COCO128 is primarily designed for object detection, the dataset's annotations can be adapted for other computer vision tasks:
|
||||
|
||||
- **Instance segmentation**: Using the segmentation masks provided in the annotations
|
||||
- **Keypoint detection**: For images containing people with keypoint annotations
|
||||
- **Transfer learning**: As a starting point for fine-tuning models for custom tasks
|
||||
|
||||
For specialized tasks like [segmentation](../../tasks/segment.md), consider using purpose-built variants like [COCO8-seg](../segment/coco8-seg.md) which include the appropriate annotations.
|
||||
@@ -1,138 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics COCO8-Grayscale dataset, a versatile and manageable set of 8 images perfect for testing object detection models and training pipelines.
|
||||
keywords: COCO8-Grayscale, Ultralytics, dataset, object detection, YOLO26, training, validation, machine learning, computer vision
|
||||
---
|
||||
|
||||
# COCO8-Grayscale Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
The [Ultralytics](https://www.ultralytics.com/) COCO8-Grayscale dataset is a compact yet powerful [object detection](https://www.ultralytics.com/glossary/object-detection) dataset, consisting of the first 8 images from the COCO train 2017 set and converted to grayscale format—4 for training and 4 for validation. This dataset is specifically designed for rapid testing, debugging, and experimentation with [YOLO](https://docs.ultralytics.com/models/yolo26/) grayscale models and training pipelines. Its small size makes it highly manageable, while its diversity ensures it serves as an effective sanity check before scaling up to larger datasets.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/yw2Fo6qjJU4"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on Grayscale Datasets 🚀
|
||||
</p>
|
||||
|
||||
COCO8-Grayscale is fully compatible with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](../../models/yolo26.md), enabling seamless integration into your computer vision workflows.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
The COCO8-Grayscale dataset configuration is defined in a YAML (Yet Another Markup Language) file, which specifies dataset paths, class names, and other essential metadata. You can review the official `coco8-grayscale.yaml` file in the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-grayscale.yaml).
|
||||
|
||||
!!! note
|
||||
|
||||
To train your RGB images in grayscale, you could simply add `channels: 1` to your dataset YAML file. This converts all images to grayscale during training, enabling you to utilize grayscale benefits without requiring a separate dataset.
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8-grayscale.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-grayscale.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the COCO8-Grayscale dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the following examples. For a full list of training options, see the [YOLO Training documentation](../../modes/train.md).
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on COCO8-Grayscale
|
||||
results = model.train(data="coco8-grayscale.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train YOLO26n on COCO8-Grayscale using the command line
|
||||
yolo detect train data=coco8-grayscale.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Below is an example of a mosaiced training batch from the COCO8-Grayscale dataset:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/grayscale-mosaic.avif" alt="COCO8 grayscale dataset mosaic training batch" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image illustrates a training batch where multiple dataset images are combined using mosaic augmentation. Mosaic augmentation increases the diversity of objects and scenes within each batch, helping the model generalize better to various object sizes, aspect ratios, and backgrounds.
|
||||
|
||||
This technique is especially useful for small datasets like COCO8-Grayscale, as it maximizes the value of each image during training.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Special thanks to the [COCO Consortium](https://cocodataset.org/#home) for their ongoing contributions to the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What Is the Ultralytics COCO8-Grayscale Dataset Used For?
|
||||
|
||||
The Ultralytics COCO8-Grayscale dataset is designed for rapid testing and debugging of [object detection](https://www.ultralytics.com/glossary/object-detection) models. With only 8 images (4 for training, 4 for validation), it is ideal for verifying your [YOLO](https://docs.ultralytics.com/models/yolo26/) training pipelines and ensuring everything works as expected before scaling to larger datasets. Explore the [COCO8-Grayscale YAML configuration](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-grayscale.yaml) for more details.
|
||||
|
||||
### How Do I Train a YOLO26 Model Using the COCO8-Grayscale Dataset?
|
||||
|
||||
You can train a YOLO26 model on COCO8-Grayscale using either Python or the CLI:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on COCO8-Grayscale
|
||||
results = model.train(data="coco8-grayscale.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=coco8-grayscale.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For additional training options, refer to the [YOLO Training documentation](../../modes/train.md).
|
||||
|
||||
### Why Should I Use Ultralytics Platform for Managing My COCO8-Grayscale Training?
|
||||
|
||||
[Ultralytics Platform](https://platform.ultralytics.com/) streamlines dataset management, training, and deployment for [YOLO](https://docs.ultralytics.com/models/yolo26/) models—including COCO8-Grayscale. With features like cloud training, real-time monitoring, and intuitive dataset handling, HUB enables you to launch experiments with a single click and eliminates manual setup hassles. Learn more about [Ultralytics Platform](https://platform.ultralytics.com/) and how it can accelerate your computer vision projects.
|
||||
|
||||
### What Are the Benefits of Using Mosaic Augmentation in Training With the COCO8-Grayscale Dataset?
|
||||
|
||||
Mosaic augmentation, as used in COCO8-Grayscale training, combines multiple images into one during each batch. This increases the diversity of objects and backgrounds, helping your [YOLO](https://docs.ultralytics.com/models/yolo26/) model generalize better to new scenarios. Mosaic augmentation is especially valuable for small datasets, as it maximizes the information available in each training step. For more on this, see the [training guide](#usage).
|
||||
|
||||
### How Can I Validate My YOLO26 Model Trained on the COCO8-Grayscale Dataset?
|
||||
|
||||
To validate your YOLO26 model after training on COCO8-Grayscale, use the model's validation commands in either Python or CLI. This evaluates your model's performance using standard metrics. For step-by-step instructions, visit the [YOLO Validation documentation](../../modes/val.md).
|
||||
@@ -1,146 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics COCO8-Multispectral dataset, an enhanced version of COCO8 with interpolated spectral channels, ideal for testing multispectral object detection models and training pipelines.
|
||||
keywords: COCO8-Multispectral, Ultralytics, dataset, multispectral, object detection, YOLO26, training, validation, machine learning, computer vision
|
||||
---
|
||||
|
||||
# COCO8-Multispectral Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
The [Ultralytics](https://www.ultralytics.com/) COCO8-Multispectral dataset is an advanced variant of the original COCO8 dataset, designed to facilitate experimentation with multispectral object detection models. It consists of the same 8 images from the COCO train 2017 set—4 for training and 4 for validation—but with each image transformed into a 10-channel multispectral format. By expanding beyond standard RGB channels, COCO8-Multispectral enables the development and evaluation of models that can leverage richer spectral information.
|
||||
|
||||
<p align="center">
|
||||
<img width="640" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/coco8-multispectral-overview.avif" alt="Multispectral imaging for object detection">
|
||||
</p>
|
||||
|
||||
COCO8-Multispectral is fully compatible with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](../../models/yolo26.md), ensuring seamless integration into your [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) workflows.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/yw2Fo6qjJU4"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on Multispectral Datasets | Multi-Channel VisionAI 🚀
|
||||
</p>
|
||||
|
||||
## Dataset Generation
|
||||
|
||||
The multispectral images in COCO8-Multispectral were created by interpolating the original RGB images across 10 evenly spaced spectral channels within the visible spectrum. The process includes:
|
||||
|
||||
- **Wavelength Assignment**: Assigning nominal wavelengths to the RGB channels—Red: 650 nm, Green: 510 nm, Blue: 475 nm.
|
||||
- **Interpolation**: Using linear interpolation to estimate pixel values at intermediate wavelengths between 450 nm and 700 nm, resulting in 10 spectral channels.
|
||||
- **Extrapolation**: Applying extrapolation with SciPy's `interp1d` function to estimate values beyond the original RGB wavelengths, ensuring a complete spectral representation.
|
||||
|
||||
This approach simulates a multispectral imaging process, providing a more diverse set of data for model training and evaluation. For further reading on multispectral imaging, see the [Multispectral Imaging Wikipedia article](https://en.wikipedia.org/wiki/Multispectral_imaging).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
The COCO8-Multispectral dataset is configured using a YAML file, which defines dataset paths, class names, and essential metadata. You can review the official `coco8-multispectral.yaml` file in the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-multispectral.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8-multispectral.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-multispectral.yaml"
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
Prepare your TIFF images in `(channel, height, width)` order, saved with `.tiff` or `.tif` extension, and ensure they are `uint8` for use with Ultralytics:
|
||||
|
||||
```python
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
# Create and write 10-channel TIFF
|
||||
image = np.ones((10, 640, 640), dtype=np.uint8) # CHW-order
|
||||
cv2.imwritemulti("example.tiff", image)
|
||||
|
||||
# Read TIFF
|
||||
success, frames_list = cv2.imreadmulti("example.tiff")
|
||||
image = np.stack(frames_list, axis=2)
|
||||
print(image.shape) # (640, 640, 10) HWC-order for training and inference
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the COCO8-Multispectral dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the following examples. For a comprehensive list of training options, refer to the [YOLO Training documentation](../../modes/train.md).
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on COCO8-Multispectral
|
||||
results = model.train(data="coco8-multispectral.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train YOLO26n on COCO8-Multispectral using the command line
|
||||
yolo detect train data=coco8-multispectral.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details on model selection and best practices, explore the [Ultralytics YOLO model documentation](../../models/yolo26.md) and the [YOLO Model Training Tips guide](https://docs.ultralytics.com/guides/model-training-tips/).
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Below is an example of a mosaiced training batch from the COCO8-Multispectral dataset:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/coco8-multispectral-mosaic-batch.avif" alt="COCO8 multispectral dataset mosaic training batch" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch where multiple dataset images are combined using [mosaic augmentation](https://docs.ultralytics.com/reference/data/augment/). Mosaic augmentation increases the diversity of objects and scenes within each batch, helping the model generalize better to various object sizes, aspect ratios, and backgrounds.
|
||||
|
||||
This technique is especially valuable for small datasets like COCO8-Multispectral, as it maximizes the utility of each image during training.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Special thanks to the [COCO Consortium](https://cocodataset.org/#home) for their ongoing contributions to the [computer vision community](https://www.ultralytics.com/blog/a-history-of-vision-models).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What Is the Ultralytics COCO8-Multispectral Dataset Used For?
|
||||
|
||||
The Ultralytics COCO8-Multispectral dataset is designed for rapid testing and debugging of [multispectral object detection](https://www.ultralytics.com/glossary/object-detection) models. With only 8 images (4 for training, 4 for validation), it is ideal for verifying your [YOLO26](../../models/yolo26.md) training pipelines and ensuring everything works as expected before scaling to larger datasets. For more datasets to experiment with, visit the [Ultralytics Datasets Catalog](https://docs.ultralytics.com/datasets/).
|
||||
|
||||
### How Does Multispectral Data Improve Object Detection?
|
||||
|
||||
Multispectral data provides additional spectral information beyond standard RGB, enabling models to distinguish objects based on subtle differences in reflectance across wavelengths. This can enhance detection accuracy, especially in challenging scenarios. Learn more about [multispectral imaging](https://en.wikipedia.org/wiki/Multispectral_imaging) and its applications in [advanced computer vision](https://www.ultralytics.com/blog/ai-in-aviation-a-runway-to-smarter-airports).
|
||||
|
||||
### Is COCO8-Multispectral Compatible With Ultralytics Platform and YOLO Models?
|
||||
|
||||
Yes, COCO8-Multispectral is fully compatible with [Ultralytics Platform](https://platform.ultralytics.com/) and all [YOLO models](../../models/yolo26.md), including the latest YOLO26. This allows you to easily integrate the dataset into your training and validation workflows.
|
||||
|
||||
### Where Can I Find More Information on Data Augmentation Techniques?
|
||||
|
||||
For a deeper understanding of data augmentation methods such as mosaic and their impact on model performance, refer to the [YOLO Data Augmentation Guide](https://docs.ultralytics.com/guides/yolo-data-augmentation/) and the [Ultralytics Blog on Data Augmentation](https://www.ultralytics.com/blog/the-ultimate-guide-to-data-augmentation-in-2025).
|
||||
|
||||
### Can I Use COCO8-Multispectral for Benchmarking or Educational Purposes?
|
||||
|
||||
Absolutely! The small size and multispectral nature of COCO8-Multispectral make it ideal for benchmarking, educational demonstrations, and prototyping new model architectures. For more benchmarking datasets, see the [Ultralytics Benchmark Dataset Collection](https://docs.ultralytics.com/datasets/).
|
||||
@@ -1,134 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics COCO8 dataset, a versatile and manageable set of 8 images perfect for testing object detection models and training pipelines.
|
||||
keywords: COCO8, Ultralytics, dataset, object detection, YOLO26, training, validation, machine learning, computer vision
|
||||
---
|
||||
|
||||
# COCO8 Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
The [Ultralytics](https://www.ultralytics.com/) COCO8 dataset is a compact yet powerful [object detection](https://www.ultralytics.com/glossary/object-detection) dataset, consisting of the first 8 images from the COCO train 2017 set—4 for training and 4 for validation. This dataset is specifically designed for rapid testing, debugging, and experimentation with [YOLO](https://docs.ultralytics.com/models/yolo26/) models and training pipelines. Its small size makes it highly manageable, while its diversity ensures it serves as an effective sanity check before scaling up to larger datasets.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/uDrn9QZJ2lk"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Ultralytics COCO Dataset Overview
|
||||
</p>
|
||||
|
||||
COCO8 is fully compatible with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](../../models/yolo26.md), enabling seamless integration into your computer vision workflows.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
The COCO8 dataset configuration is defined in a YAML (Yet Another Markup Language) file, which specifies dataset paths, class names, and other essential metadata. You can review the official `coco8.yaml` file in the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the COCO8 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the following examples. For a full list of training options, see the [YOLO Training documentation](../../modes/train.md).
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on COCO8
|
||||
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train YOLO26n on COCO8 using the command line
|
||||
yolo detect train data=coco8.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Below is an example of a mosaiced training batch from the COCO8 dataset:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch-1.avif" alt="COCO8 object detection dataset mosaic training batch" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image illustrates a training batch where multiple dataset images are combined using mosaic augmentation. Mosaic augmentation increases the diversity of objects and scenes within each batch, helping the model generalize better to various object sizes, aspect ratios, and backgrounds.
|
||||
|
||||
This technique is especially useful for small datasets like COCO8, as it maximizes the value of each image during training.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Special thanks to the [COCO Consortium](https://cocodataset.org/#home) for their ongoing contributions to the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What Is the Ultralytics COCO8 Dataset Used For?
|
||||
|
||||
The Ultralytics COCO8 dataset is designed for rapid testing and debugging of [object detection](https://www.ultralytics.com/glossary/object-detection) models. With only 8 images (4 for training, 4 for validation), it is ideal for verifying your [YOLO](https://docs.ultralytics.com/models/yolo26/) training pipelines and ensuring everything works as expected before scaling to larger datasets. Explore the [COCO8 YAML configuration](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8.yaml) for more details.
|
||||
|
||||
### How Do I Train a YOLO26 Model Using the COCO8 Dataset?
|
||||
|
||||
You can train a YOLO26 model on COCO8 using either Python or the CLI:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on COCO8
|
||||
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=coco8.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For additional training options, refer to the [YOLO Training documentation](../../modes/train.md).
|
||||
|
||||
### Why Should I Use Ultralytics Platform for Managing My COCO8 Training?
|
||||
|
||||
[Ultralytics Platform](https://platform.ultralytics.com/) streamlines dataset management, training, and deployment for [YOLO](https://docs.ultralytics.com/models/yolo26/) models—including COCO8. With features like cloud training, real-time monitoring, and intuitive dataset handling, HUB enables you to launch experiments with a single click and eliminates manual setup hassles. Learn more about [Ultralytics Platform](https://platform.ultralytics.com/) and how it can accelerate your computer vision projects.
|
||||
|
||||
### What Are the Benefits of Using Mosaic Augmentation in Training With the COCO8 Dataset?
|
||||
|
||||
Mosaic augmentation, as used in COCO8 training, combines multiple images into one during each batch. This increases the diversity of objects and backgrounds, helping your [YOLO](https://docs.ultralytics.com/models/yolo26/) model generalize better to new scenarios. Mosaic augmentation is especially valuable for small datasets, as it maximizes the information available in each training step. For more on this, see the [training guide](#usage).
|
||||
|
||||
### How Can I Validate My YOLO26 Model Trained on the COCO8 Dataset?
|
||||
|
||||
To validate your YOLO26 model after training on COCO8, use the model's validation commands in either Python or CLI. This evaluates your model's performance using standard metrics. For step-by-step instructions, visit the [YOLO Validation documentation](../../modes/val.md).
|
||||
@@ -1,157 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover Construction-PPE, a specialized dataset for detecting helmets, vests, gloves, boots, and goggles in real-world construction sites. Includes compliant and non-compliant scenarios for AI-powered safety monitoring.
|
||||
keywords: Construction-PPE, PPE dataset, safety compliance, construction workers, object detection, YOLO26, workplace safety, computer vision
|
||||
---
|
||||
|
||||
# Construction-PPE Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-construction-ppe-detection-dataset.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Construction-PPE Dataset In Colab"></a>
|
||||
|
||||
The Construction-PPE dataset is designed to improve safety compliance in construction sites by enabling detection of essential protective gear such as helmets, vests, gloves, boots, and goggles, along with annotations for missing equipment. Curated from real construction environments, it includes both compliant and non-compliant cases, making it a valuable resource for training AI models that monitor workplace safety.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/lFaVnrhMmaE"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to train Ultralytics YOLO on Personal Protective Equipment Dataset | VisionAI in Construction 👷
|
||||
</p>
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The Construction-PPE dataset is organized into three main subsets:
|
||||
|
||||
- **Training Set**: The primary collection of annotated construction images featuring workers with both complete and partial PPE usage.
|
||||
- **Validation Set**: A designated subset used to fine-tune and assess model performance during PPE detection and compliance monitoring.
|
||||
- **Test Set**: An independent subset reserved for evaluating the final model's effectiveness in detecting PPE and identifying compliance issues.
|
||||
|
||||
Each image is annotated in the [Ultralytics YOLO](../detect/index.md/#what-is-the-ultralytics-yolo-dataset-format-and-how-to-structure-it) format ensuring compatibility with state-of-the-art [object detection](../../tasks/detect.md) and [tracking](../../modes/track.md) pipelines.
|
||||
|
||||
The dataset provides **11 classes** divided into positive (worn PPE) and negative (missing PPE) categories. This dual-positive/negative structure enables models to detect properly worn gear **and** identify safety violations.
|
||||
|
||||
## Business Value
|
||||
|
||||
- Construction remains one of the most hazardous industries in the world, with over 51 out of 123 work related **fatal injuries** in the UK in 2023/2024 happening in construction. However, the issue is no longer an issue with lack of regulation with 42% of construction workers admitting to not always adhering to processes.
|
||||
- Construction is already governed by an extensive framework of health and safety (HSE) standards, but HSE teams are challenged with consistent enforcement. HSE teams are often stretched thin, balancing paperwork and audits and lacking the ability to monitor every corner of a busy and ever-changing environment in real time.
|
||||
- This is where computer vision based personal protective equipment (PPE) detection becomes invaluable. By automatically checking whether workers are wearing **helmets, vests and other personal protective equipment**, you can ensure HSE rules are not just present but effectively enforced consistently across all sites. Beyond compliance, computer vision provides leading indicators of risk by revealing how well crews follow safety practices, enabling organizations to spot downward trends in compliance and prevent incidents before they happen.
|
||||
- As a bonus, personal protective equipment detection has also been known to identify unauthorized site intruders, since **those not equipped with proper safety gear** are the first to trigger a notification. Ultimately, PPE detection is a simple yet powerful computer vision use-case that delivers full oversight, actionable insights and standardized reporting, empowering construction firms to reduce risk, protect workers and safeguard their projects.
|
||||
|
||||
## Applications
|
||||
|
||||
Construction-PPE powers a variety of safety-focused computer vision applications:
|
||||
|
||||
- **Automated compliance monitoring**: Train AI models to instantly check if workers are wearing required safety gear like helmets, vests, or gloves, reducing risks on site.
|
||||
- **Workplace safety analytics**: Track PPE usage over time, spot frequent violations, and generate insights to improve safety culture.
|
||||
- **Smart surveillance systems**: Connect detection models with cameras to send real-time alerts when PPE is missing, preventing accidents before they happen.
|
||||
- **Robotics and autonomous systems**: Enable drones or robots to perform PPE checks across large sites, supporting faster and safer inspections.
|
||||
- **Research and education**: Provide a real-world dataset for students and researchers exploring workplace safety and human-object interactions.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
The Construction-PPE dataset includes a YAML configuration file that defines the training and validation image paths along with the full list of object classes. You can access the `construction-ppe.yaml` file directly in the Ultralytics repository here: [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/construction-ppe.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/construction-ppe.yaml)
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/construction-ppe.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/construction-ppe.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
You can train a YOLO26n model on the Construction-PPE dataset for 100 epochs with an image size of 640. The following examples show how to get started quickly. For more options and advanced configurations, see the [Training guide](../../modes/train.md).
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load pretrained model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on Construction-PPE dataset
|
||||
model.train(data="construction-ppe.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=construction-ppe.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The dataset captures construction workers across varied environments, lighting conditions, and postures. Both **compliant** and **non-compliant** cases are included.
|
||||
|
||||
|
||||
|
||||
## License and Attribution
|
||||
|
||||
Construction-PPE is developed and released under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE), supporting open-source research and commercial applications with proper attribution.
|
||||
|
||||
If you use this dataset in your research, please cite it:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@dataset{Dalvi_Construction_PPE_Dataset_2025,
|
||||
author = {Mrunmayee Dalvi and Niyati Singh and Sahil Bhingarde and Ketaki Chalke},
|
||||
title = {Construction-PPE: Personal Protective Equipment Detection Dataset},
|
||||
month = {January},
|
||||
year = {2025},
|
||||
version = {1.0.0},
|
||||
license = {AGPL-3.0},
|
||||
url = {https://docs.ultralytics.com/datasets/detect/construction-ppe/},
|
||||
publisher = {Ultralytics}
|
||||
}
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### What makes the Construction-PPE dataset unique?
|
||||
|
||||
Unlike generic construction datasets, Construction-PPE explicitly includes **missing equipment classes**. This dual-labeling approach allows models to not only detect PPE but also flag violations in real-time.
|
||||
|
||||
### Which object categories are included?
|
||||
|
||||
The dataset covers helmets, vests, gloves, boots, goggles, and workers, along with their “missing PPE” counterparts. This ensures comprehensive compliance coverage.
|
||||
|
||||
### How can I train a YOLO model using the Construction-PPE dataset?
|
||||
|
||||
To train a YOLO26 model using the Construction-PPE dataset, you can use the following code snippets:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="construction-ppe.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=construction-ppe.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Is this dataset suitable for real-world applications?
|
||||
|
||||
Yes. Images are curated from real construction sites under diverse conditions. This makes it highly effective for building deployable workplace safety monitoring systems.
|
||||
|
||||
### What are the benefits of using the Construction-PPE dataset in AI projects?
|
||||
|
||||
The dataset enables real-time detection of personal protective equipment, helping monitor worker safety on construction sites. With classes for both worn and missing gear, it supports AI systems that can automatically flag safety violations, generate compliance insights, and reduce risks. It also provides a practical resource for developing computer vision solutions in workplace safety, robotics, and academic research.
|
||||
@@ -1,145 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Global Wheat Head Dataset to develop accurate wheat head detection models. Includes training images, annotations, and usage for crop management.
|
||||
keywords: Global Wheat Head Dataset, wheat head detection, wheat phenotyping, crop management, deep learning, object detection, training datasets
|
||||
---
|
||||
|
||||
# Global Wheat Head Dataset
|
||||
|
||||
The [Global Wheat Head Dataset](https://www.global-wheat.com/) is a collection of images designed to support the development of accurate wheat head detection models for applications in wheat phenotyping and crop management. Wheat heads, also known as spikes, are the grain-bearing parts of the wheat plant. Accurate estimation of wheat head density and size is essential for assessing crop health, maturity, and yield potential. The dataset, created by a collaboration of nine research institutes from seven countries, covers multiple growing regions to ensure models generalize well across different environments.
|
||||
|
||||
## Key Features
|
||||
|
||||
- The dataset contains over 3,000 training images from Europe (France, UK, Switzerland) and North America (Canada).
|
||||
- It includes approximately 1,000 test images from Australia, Japan, and China.
|
||||
- Images are outdoor field images, capturing the natural variability in wheat head appearances.
|
||||
- Annotations include wheat head bounding boxes to support [object detection](https://docs.ultralytics.com/tasks/detect/) tasks.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The Global Wheat Head Dataset is organized into two main subsets:
|
||||
|
||||
1. **Training Set**: This subset contains over 3,000 images from Europe and North America. The images are labeled with wheat head bounding boxes, providing ground truth for training object detection models.
|
||||
2. **Test Set**: This subset consists of approximately 1,000 images from Australia, Japan, and China. These images are used for evaluating the performance of trained models on unseen genotypes, environments, and observational conditions.
|
||||
|
||||
## Applications
|
||||
|
||||
The Global Wheat Head Dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in wheat head detection tasks. The dataset's diverse set of images, capturing a wide range of appearances, environments, and conditions, make it a valuable resource for researchers and practitioners in the field of [plant phenotyping](https://www.ultralytics.com/blog/computer-vision-in-agriculture-transforming-fruit-detection-and-precision-farming) and crop management.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the Global Wheat Head Dataset, the `GlobalWheat2020.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/GlobalWheat2020.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/GlobalWheat2020.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the Global Wheat Head Dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="GlobalWheat2020.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=GlobalWheat2020.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The Global Wheat Head Dataset contains a diverse set of outdoor field images, capturing the natural variability in wheat head appearances, environments, and conditions. Here are some examples of data from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Wheat Head Detection**: This image demonstrates an example of wheat head detection, where wheat heads are annotated with bounding boxes. The dataset provides a variety of images to facilitate the development of models for this task.
|
||||
|
||||
The example showcases the variety and complexity of the data in the Global Wheat Head Dataset and highlights the importance of accurate wheat head detection for applications in wheat phenotyping and crop management.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Global Wheat Head Dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{david2020global,
|
||||
title={Global Wheat Head Detection (GWHD) Dataset: A Large and Diverse Dataset of High-Resolution RGB-Labelled Images to Develop and Benchmark Wheat Head Detection Methods},
|
||||
author={David, Etienne and Madec, Simon and Sadeghi-Tehran, Pouria and Aasen, Helge and Zheng, Bangyou and Liu, Shouyang and Kirchgessner, Norbert and Ishikawa, Goro and Nagasawa, Koichi and Badhon, Minhajul and others},
|
||||
journal={arXiv preprint arXiv:2005.02162},
|
||||
year={2020}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the researchers and institutions that contributed to the creation and maintenance of the Global Wheat Head Dataset as a valuable resource for the plant phenotyping and crop management research community. For more information about the dataset and its creators, visit the [Global Wheat Head Dataset website](https://www.global-wheat.com/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Global Wheat Head Dataset used for?
|
||||
|
||||
The Global Wheat Head Dataset is primarily used for developing and training deep learning models aimed at wheat head detection. This is crucial for applications in [wheat phenotyping](https://www.ultralytics.com/blog/from-farm-to-table-how-ai-drives-innovation-in-agriculture) and crop management, allowing for more accurate estimations of wheat head density, size, and overall crop yield potential. Accurate detection methods help in assessing crop health and maturity, essential for efficient crop management.
|
||||
|
||||
### How do I train a YOLO26n model on the Global Wheat Head Dataset?
|
||||
|
||||
To train a YOLO26n model on the Global Wheat Head Dataset, you can use the following code snippets. Make sure you have the `GlobalWheat2020.yaml` configuration file specifying dataset paths and classes:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="GlobalWheat2020.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=GlobalWheat2020.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the key features of the Global Wheat Head Dataset?
|
||||
|
||||
Key features of the Global Wheat Head Dataset include:
|
||||
|
||||
- Over 3,000 training images from Europe (France, UK, Switzerland) and North America (Canada).
|
||||
- Approximately 1,000 test images from Australia, Japan, and China.
|
||||
- High variability in wheat head appearances due to different growing environments.
|
||||
- Detailed annotations with wheat head bounding boxes to aid [object detection](https://www.ultralytics.com/glossary/object-detection) models.
|
||||
|
||||
These features facilitate the development of robust models capable of generalization across multiple regions.
|
||||
|
||||
### Where can I find the configuration YAML file for the Global Wheat Head Dataset?
|
||||
|
||||
The configuration YAML file for the Global Wheat Head Dataset, named `GlobalWheat2020.yaml`, is available on GitHub. You can access it at <https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml>. This file contains necessary information about dataset paths, classes, and other configuration details needed for model training in [Ultralytics YOLO](https://docs.ultralytics.com/models/yolo26/).
|
||||
|
||||
### Why is wheat head detection important in crop management?
|
||||
|
||||
Wheat head detection is critical in crop management because it enables accurate estimation of wheat head density and size, which are essential for evaluating crop health, maturity, and yield potential. By leveraging [deep learning models](https://docs.ultralytics.com/models/) trained on datasets like the Global Wheat Head Dataset, farmers and researchers can better monitor and manage crops, leading to improved productivity and optimized resource use in agricultural practices. This technological advancement supports [sustainable agriculture](https://www.ultralytics.com/blog/real-time-crop-health-monitoring-with-ultralytics-yolo11) and food security initiatives.
|
||||
|
||||
For more information on applications of AI in agriculture, visit [AI in Agriculture](https://www.ultralytics.com/solutions/ai-in-agriculture).
|
||||
@@ -1,169 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover HomeObjects-3K, a rich indoor object detection dataset with 12 classes like bed, sofa, TV, and laptop. Ideal for computer vision in smart homes, robotics, and AR.
|
||||
keywords: HomeObjects-3K, indoor dataset, household items, object detection, computer vision, YOLO26, smart home AI, robotics dataset
|
||||
---
|
||||
|
||||
# HomeObjects-3K Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-homeobjects-dataset.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="HomeObjects-3K Dataset In Colab"></a>
|
||||
|
||||
The HomeObjects-3K dataset is a curated collection of common household object images, designed for training, testing, and [benchmarking](../../modes/benchmark.md) [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models. Featuring ~3,000 images and 12 distinct object classes, this dataset is ideal for research and applications in indoor scene understanding, smart home devices, [robotics](https://www.ultralytics.com/glossary/robotics), and augmented reality.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/v3iqOYoRBFQ"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on HomeObjects-3K Dataset | Detection, Validation & ONNX Export 🚀
|
||||
</p>
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The HomeObjects-3K dataset is organized into the following subsets:
|
||||
|
||||
- **Training Set**: Comprises 2,285 annotated images featuring objects such as sofas, chairs, tables, lamps, and more.
|
||||
- **Validation Set**: Includes 404 annotated images designated for evaluating model performance.
|
||||
|
||||
Each image is labeled using bounding boxes aligned with the [Ultralytics YOLO](../detect/index.md/#what-is-the-ultralytics-yolo-dataset-format-and-how-to-structure-it) format. The diversity of indoor lighting, object scale, and orientations makes it robust for real-world deployment scenarios.
|
||||
|
||||
## Object Classes
|
||||
|
||||
The dataset supports 12 everyday object categories, covering furniture, electronics, and decorative items. These classes are chosen to reflect common items encountered in indoor domestic environments and support vision tasks like [object detection](../../tasks/detect.md) and [object tracking](../../modes/track.md).
|
||||
|
||||
!!! Tip "HomeObjects-3K classes"
|
||||
|
||||
0. bed
|
||||
1. sofa
|
||||
2. chair
|
||||
3. table
|
||||
4. lamp
|
||||
5. tv
|
||||
6. laptop
|
||||
7. wardrobe
|
||||
8. window
|
||||
9. door
|
||||
10. potted plant
|
||||
11. photo frame
|
||||
|
||||
## Applications
|
||||
|
||||
HomeObjects-3K enables a wide spectrum of applications in indoor computer vision, spanning both research and real-world product development:
|
||||
|
||||
- **Indoor object detection**: Use models like [Ultralytics YOLO26](../../models/yolo26.md) to find and locate common home items like beds, chairs, lamps, and laptops in images. This helps with real-time understanding of indoor scenes.
|
||||
|
||||
- **Scene layout parsing**: In robotics and smart home systems, this helps devices understand how rooms are arranged, where objects like doors, windows, and furniture are, so they can navigate safely and interact with their environment properly.
|
||||
|
||||
- **AR applications**: Power [object recognition](http://ultralytics.com/glossary/image-recognition) features in apps that use augmented reality. For example, detect TVs or wardrobes and show extra information or effects on them.
|
||||
|
||||
- **Education and research**: Support learning and academic projects by giving students and researchers a ready-to-use dataset for practicing indoor object detection with real-world examples.
|
||||
|
||||
- **Home inventory and asset tracking**: Automatically detect and list home items in photos or videos, useful for managing belongings, organizing spaces, or visualizing furniture in real estate.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
The configuration for the HomeObjects-3K dataset is provided through a YAML file. This file outlines essential information such as image paths for train and validation directories, and the list of object classes.
|
||||
You can access the `HomeObjects-3K.yaml` file directly from the Ultralytics repository at: [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/HomeObjects-3K.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/HomeObjects-3K.yaml)
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/HomeObjects-3K.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/HomeObjects-3K.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
You can train a YOLO26n model on the HomeObjects-3K dataset for 100 epochs using an image size of 640. The examples below show how to get started. For more training options and detailed settings, check the [Training](../../modes/train.md) guide.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load pretrained model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on HomeObjects-3K dataset
|
||||
model.train(data="HomeObjects-3K.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=HomeObjects-3K.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The dataset features a rich collection of indoor scene images that capture a wide range of household objects in natural home environments. Below are sample visuals from the dataset, each paired with its corresponding annotations to illustrate object positions, scales, and spatial relationships.
|
||||
|
||||
|
||||
|
||||
## License and Attribution
|
||||
|
||||
HomeObjects-3K is developed and released by the **[Ultralytics team](https://www.ultralytics.com/about)** under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE), supporting open-source research and commercial use with proper attribution.
|
||||
|
||||
If you use this dataset in your research, please cite it using the mentioned details:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@dataset{Jocher_Ultralytics_Datasets_2025,
|
||||
author = {Jocher, Glenn and Rizwan, Muhammad},
|
||||
license = {AGPL-3.0},
|
||||
month = {May},
|
||||
title = {Ultralytics Datasets: HomeObjects-3K Detection Dataset},
|
||||
url = {https://docs.ultralytics.com/datasets/detect/homeobjects-3k/},
|
||||
version = {1.0.0},
|
||||
year = {2025}
|
||||
}
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the HomeObjects-3K dataset designed for?
|
||||
|
||||
HomeObjects-3K is crafted for advancing AI understanding of indoor scenes. It focuses on detecting everyday household items—like beds, sofas, TVs, and lamps—making it ideal for applications in smart homes, robotics, augmented reality, and interior monitoring systems. Whether you're training models for real-time edge devices or academic research, this dataset provides a balanced foundation.
|
||||
|
||||
### Which object categories are included, and why were they selected?
|
||||
|
||||
The dataset includes 12 of the most commonly encountered household items: bed, sofa, chair, table, lamp, tv, laptop, wardrobe, window, door, potted plant, and photo frame. These objects were chosen to reflect realistic indoor environments and to support multipurpose tasks such as robotic navigation, or scene generation in AR/VR applications.
|
||||
|
||||
### How can I train a YOLO model using the HomeObjects-3K dataset?
|
||||
|
||||
To train a YOLO model like YOLO26n, you'll just need the `HomeObjects-3K.yaml` configuration file and the [pretrained model](../../models/index.md) weights. Whether you're using Python or the CLI, training can be launched with a single command. You can customize parameters such as epochs, image size, and batch size depending on your target performance and hardware setup.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load pretrained model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on HomeObjects-3K dataset
|
||||
model.train(data="HomeObjects-3K.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=HomeObjects-3K.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Is this dataset suitable for beginner-level projects?
|
||||
|
||||
Absolutely. With clean labeling, and standardized YOLO-compatible annotations, HomeObjects-3K is an excellent entry point for students and hobbyists who want to explore real-world object detection in indoor scenarios. It also scales well for more complex applications in commercial environments.
|
||||
|
||||
### Where can I find the annotation format and YAML?
|
||||
|
||||
Refer to the [Dataset YAML](#dataset-yaml) section. The format is standard YOLO, making it compatible with most object detection pipelines.
|
||||
@@ -1,343 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn about dataset formats compatible with Ultralytics YOLO for robust object detection. Explore supported datasets and learn how to convert formats.
|
||||
keywords: Ultralytics, YOLO, object detection datasets, dataset formats, COCO, dataset conversion, training datasets
|
||||
---
|
||||
|
||||
# Object Detection Datasets Overview
|
||||
|
||||
Training a robust and accurate [object detection](https://www.ultralytics.com/glossary/object-detection) model requires a comprehensive dataset. This guide introduces various formats of datasets that are compatible with the Ultralytics YOLO model and provides insights into their structure, usage, and how to convert between different formats.
|
||||
|
||||
## Supported Dataset Formats
|
||||
|
||||
### Ultralytics YOLO format
|
||||
|
||||
The Ultralytics YOLO format is a dataset configuration format that allows you to define the dataset root directory, the relative paths to training/validation/testing image directories or `*.txt` files containing image paths, and a dictionary of class names. Here is an example:
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8.yaml"
|
||||
```
|
||||
|
||||
Labels for this format should be exported to YOLO format with one `*.txt` file per image. If there are no objects in an image, no `*.txt` file is required. The `*.txt` file should be formatted with one row per object in `class x_center y_center width height` format. Box coordinates must be in **normalized xywh** format (from 0 to 1). If your boxes are in pixels, you should divide `x_center` and `width` by image width, and `y_center` and `height` by image height. Class numbers should be zero-indexed (start with 0).
|
||||
|
||||
<p align="center"><img width="750" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/two-persons-tie.avif" alt="YOLO labeled image with bounding boxes on persons and tie"></p>
|
||||
|
||||
The label file corresponding to the above image contains 2 persons (class `0`) and a tie (class `27`):
|
||||
|
||||
<p align="center"><img width="428" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/two-persons-tie-1.avif" alt="YOLO format label file with normalized coordinates"></p>
|
||||
|
||||
When using the Ultralytics YOLO format, organize your training and validation images and labels as shown in the [COCO8 dataset](coco8.md) example below.
|
||||
|
||||
<p align="center"><img width="800" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/two-persons-tie-2.avif" alt="YOLO dataset directory structure with train and val folders"></p>
|
||||
|
||||
#### Usage Example
|
||||
|
||||
Here's how you can use YOLO format datasets to train your model:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco8.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Ultralytics NDJSON format
|
||||
|
||||
The NDJSON (Newline Delimited JSON) format provides an alternative way to define datasets for Ultralytics YOLO models. This format stores dataset metadata and annotations in a single file where each line contains a separate JSON object.
|
||||
|
||||
An NDJSON dataset file contains:
|
||||
|
||||
1. **Dataset record** (first line): Contains dataset metadata including task type, class names, and general information
|
||||
2. **Image records** (subsequent lines): Contains individual image data including dimensions, annotations, and file paths
|
||||
|
||||
!!! example "NDJSON Example"
|
||||
|
||||
=== "Dataset record (line 1)"
|
||||
|
||||
```json
|
||||
{
|
||||
"type": "dataset",
|
||||
"task": "detect",
|
||||
"name": "Example",
|
||||
"description": "COCO NDJSON example dataset",
|
||||
"url": "https://app.ultralytics.com/user/datasets/example",
|
||||
"class_names": { "0": "person", "1": "bicycle", "2": "car" },
|
||||
"bytes": 426342,
|
||||
"version": 0,
|
||||
"created_at": "2024-01-01T00:00:00Z",
|
||||
"updated_at": "2025-01-01T00:00:00Z"
|
||||
}
|
||||
```
|
||||
|
||||
=== "Detect"
|
||||
|
||||
```json
|
||||
{
|
||||
"type": "image",
|
||||
"file": "image1.jpg",
|
||||
"url": "https://www.url.com/path/to/image1.jpg",
|
||||
"width": 640,
|
||||
"height": 480,
|
||||
"split": "train",
|
||||
"annotations": {
|
||||
"boxes": [
|
||||
[0, 0.525, 0.376, 0.284, 0.418],
|
||||
[1, 0.735, 0.298, 0.193, 0.337]
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Format: `[class_id, x_center, y_center, width, height]`
|
||||
|
||||
=== "Segment"
|
||||
|
||||
```json
|
||||
{
|
||||
"type": "image",
|
||||
"file": "image1.jpg",
|
||||
"url": "https://www.url.com/path/to/image1.jpg",
|
||||
"width": 640,
|
||||
"height": 480,
|
||||
"split": "train",
|
||||
"annotations": {
|
||||
"segments": [
|
||||
[0, 0.681, 0.485, 0.670, 0.487, 0.676, 0.487, 0.688, 0.515],
|
||||
[1, 0.422, 0.315, 0.438, 0.330, 0.445, 0.328, 0.450, 0.320]
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Format: `[class_id, x1, y1, x2, y2, x3, y3, ...]`
|
||||
|
||||
=== "Pose"
|
||||
|
||||
```json
|
||||
{
|
||||
"type": "image",
|
||||
"file": "image1.jpg",
|
||||
"url": "https://www.url.com/path/to/image1.jpg",
|
||||
"width": 640,
|
||||
"height": 480,
|
||||
"split": "train",
|
||||
"annotations": {
|
||||
"pose": [
|
||||
[0, 0.523, 0.376, 0.283, 0.418, 0.374, 0.169, 2, 0.364, 0.178, 2],
|
||||
[0, 0.735, 0.298, 0.193, 0.337, 0.412, 0.225, 2, 0.408, 0.231, 2]
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Format: `[class_id, x_center, y_center, width, height, x1, y1, v1, x2, y2, v2, ...]`
|
||||
|
||||
Keypoints follow bbox as repeated `(x, y, v)` triplets where `v` is visibility: 0=not labeled, 1=labeled but occluded, 2=labeled and visible. The keypoint count is dataset-specific (e.g., COCO pose has 17 keypoints = 51 values after bbox).
|
||||
|
||||
=== "OBB"
|
||||
|
||||
```json
|
||||
{
|
||||
"type": "image",
|
||||
"file": "image1.jpg",
|
||||
"url": "https://www.url.com/path/to/image1.jpg",
|
||||
"width": 640,
|
||||
"height": 480,
|
||||
"split": "train",
|
||||
"annotations": {
|
||||
"obb": [
|
||||
[0, 0.480, 0.352, 0.568, 0.356, 0.572, 0.400, 0.484, 0.396],
|
||||
[1, 0.711, 0.274, 0.759, 0.278, 0.755, 0.322, 0.707, 0.318]
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Format: `[class_id, x1, y1, x2, y2, x3, y3, x4, y4]`
|
||||
|
||||
The four corner points define the oriented bounding box in clockwise order starting from the top-left corner. All coordinates are normalized (0-1).
|
||||
|
||||
=== "Classify"
|
||||
|
||||
```json
|
||||
{
|
||||
"type": "image",
|
||||
"file": "image1.jpg",
|
||||
"url": "https://www.url.com/path/to/image1.jpg",
|
||||
"width": 640,
|
||||
"height": 480,
|
||||
"split": "train",
|
||||
"annotations": {
|
||||
"classification": [0]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Format: `[class_id]`
|
||||
|
||||
#### Usage Example
|
||||
|
||||
To use an NDJSON dataset with YOLO26, simply specify the path to the `.ndjson` file:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train using NDJSON dataset
|
||||
results = model.train(data="path/to/dataset.ndjson", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training with NDJSON dataset
|
||||
yolo detect train data=path/to/dataset.ndjson model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
#### Advantages of NDJSON format
|
||||
|
||||
- **Single file**: All dataset information contained in one file
|
||||
- **Streaming**: Can process large datasets line-by-line without loading everything into memory
|
||||
- **Cloud integration**: Supports remote image URLs for cloud-based training
|
||||
- **Extensible**: Easy to add custom metadata fields
|
||||
- **Version control**: Single file format works well with git and version control systems
|
||||
|
||||
## Supported Datasets
|
||||
|
||||
Here is a list of the supported datasets and a brief description for each:
|
||||
|
||||
- [African-wildlife](african-wildlife.md): A dataset featuring images of African wildlife, including buffalo, elephant, rhino, and zebras.
|
||||
- [Argoverse](argoverse.md): A dataset containing 3D tracking and motion forecasting data from urban environments with rich annotations.
|
||||
- [Brain-tumor](brain-tumor.md): A dataset for detecting brain tumors includes MRI or CT scan images with details on tumor presence, location, and characteristics.
|
||||
- [COCO](coco.md): Common Objects in Context (COCO) is a large-scale [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and captioning dataset with 80 object categories.
|
||||
- [COCO8](coco8.md): A smaller subset of the first 4 images from COCO train and COCO val, suitable for quick tests.
|
||||
- [COCO8-Grayscale](coco8-grayscale.md): A grayscale version of COCO8 created by converting RGB to grayscale, useful for single-channel model evaluation.
|
||||
- [COCO8-Multispectral](coco8-multispectral.md): A 10-channel multispectral version of COCO8 created by interpolating RGB wavelengths, useful for spectral-aware model evaluation.
|
||||
- [COCO12-Formats](coco12-formats.md): A test dataset with 12 images covering all supported image formats (AVIF, BMP, DNG, HEIC, JP2, JPEG, JPG, MPO, PNG, TIF, TIFF, WebP) for validating image loading pipelines.
|
||||
- [COCO128](coco128.md): A smaller subset of the first 128 images from COCO train and COCO val, suitable for tests.
|
||||
- [Construction-PPE](construction-ppe.md): A dataset featuring construction site workers with labeled safety gear such as helmets, vests, gloves, boots, and goggles, including missing-equipment annotations like no_helmet, no_googles for real-world compliance monitoring.
|
||||
- [Global Wheat 2020](globalwheat2020.md): A dataset containing images of wheat heads for the Global Wheat Challenge 2020.
|
||||
- [HomeObjects-3K](homeobjects-3k.md): A dataset of indoor household items including beds, chairs, TVs, and more—ideal for applications in smart home automation, robotics, augmented reality, and room layout analysis.
|
||||
- [KITTI](kitti.md): A dataset featuring real-world driving scenes with stereo, LiDAR, and GPS/IMU data, used here for **2D object detection** tasks such as identifying cars, pedestrians, and cyclists in urban, rural, and highway environments.
|
||||
- [LVIS](lvis.md): A large-scale object detection, segmentation, and captioning dataset with 1203 object categories.
|
||||
- [Medical-pills](medical-pills.md): A dataset featuring images of medical-pills, annotated for applications such as pharmaceutical quality assurance, pill sorting, and regulatory compliance.
|
||||
- [Objects365](objects365.md): A high-quality, large-scale dataset for object detection with 365 object categories and over 600K annotated images.
|
||||
- [OpenImagesV7](open-images-v7.md): A comprehensive dataset by Google with 1.7M train images and 42k validation images.
|
||||
- [Roboflow 100](roboflow-100.md): A diverse object detection benchmark with 100 datasets spanning seven imagery domains for comprehensive model evaluation.
|
||||
- [Signature](signature.md): A dataset featuring images of various documents with annotated signatures, supporting document verification and fraud detection research.
|
||||
- [SKU-110K](sku-110k.md): A dataset featuring dense object detection in retail environments with over 11K images and 1.7 million [bounding boxes](https://www.ultralytics.com/glossary/bounding-box).
|
||||
- [TT100K](tt100k.md): Explore the Tsinghua-Tencent 100K (TT100K) traffic sign dataset with 100,000 street view images and 30,000+ annotated traffic signs for robust detection and classification.
|
||||
- [VisDrone](visdrone.md): A dataset containing object detection and multi-object tracking data from drone-captured imagery with over 10K images and video sequences.
|
||||
- [VOC](voc.md): The Pascal Visual Object Classes (VOC) dataset for object detection and segmentation with 20 object classes and over 11K images.
|
||||
- [xView](xview.md): A dataset for object detection in overhead imagery with 60 object categories and over 1 million annotated objects.
|
||||
|
||||
### Adding your own dataset
|
||||
|
||||
If you have your own dataset and would like to use it for training detection models with Ultralytics YOLO format, ensure that it follows the format specified above under "Ultralytics YOLO format". Convert your annotations to the required format and specify the paths, number of classes, and class names in the YAML configuration file.
|
||||
|
||||
## Port or Convert Label Formats
|
||||
|
||||
### COCO Dataset Format to YOLO Format
|
||||
|
||||
You can easily convert labels from the popular [COCO dataset](coco.md) format to the YOLO format using the following code snippet:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_coco
|
||||
|
||||
convert_coco(labels_dir="path/to/coco/annotations/")
|
||||
```
|
||||
|
||||
This conversion tool can be used to convert the COCO dataset or any dataset in the COCO format to the Ultralytics YOLO format. The process transforms the JSON-based COCO annotations into the simpler text-based YOLO format, making it compatible with [Ultralytics YOLO models](../../models/yolo26.md).
|
||||
|
||||
Remember to double-check if the dataset you want to use is compatible with your model and follows the necessary format conventions. Properly formatted datasets are crucial for training successful object detection models.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Ultralytics YOLO dataset format and how to structure it?
|
||||
|
||||
The Ultralytics YOLO format is a structured configuration for defining datasets in your training projects. It involves setting paths to your training, validation, and testing images and corresponding labels. For example:
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8.yaml"
|
||||
```
|
||||
|
||||
Labels are saved in `*.txt` files with one file per image, formatted as `class x_center y_center width height` with normalized coordinates. For a detailed guide, see the [COCO8 dataset example](coco8.md).
|
||||
|
||||
### How do I convert a COCO dataset to the YOLO format?
|
||||
|
||||
You can convert a COCO dataset to the YOLO format using the [Ultralytics conversion tools](../../reference/data/converter.md). Here's a quick method:
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_coco
|
||||
|
||||
convert_coco(labels_dir="path/to/coco/annotations/")
|
||||
```
|
||||
|
||||
This code will convert your COCO annotations to YOLO format, enabling seamless integration with Ultralytics YOLO models. For additional details, visit the [Port or Convert Label Formats](#port-or-convert-label-formats) section.
|
||||
|
||||
### Which datasets are supported by Ultralytics YOLO for object detection?
|
||||
|
||||
Ultralytics YOLO supports a wide range of datasets, including:
|
||||
|
||||
- [Argoverse](argoverse.md)
|
||||
- [COCO](coco.md)
|
||||
- [LVIS](lvis.md)
|
||||
- [COCO8](coco8.md)
|
||||
- [Global Wheat 2020](globalwheat2020.md)
|
||||
- [Objects365](objects365.md)
|
||||
- [OpenImagesV7](open-images-v7.md)
|
||||
|
||||
Each dataset page provides detailed information on the structure and usage tailored for efficient YOLO26 training. Explore the full list in the [Supported Datasets](#supported-datasets) section.
|
||||
|
||||
### How do I start training a YOLO26 model using my dataset?
|
||||
|
||||
To start training a YOLO26 model, ensure your dataset is formatted correctly and the paths are defined in a YAML file. Use the following script to begin training:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n.pt") # Load a pretrained model
|
||||
results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=path/to/your_dataset.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
Refer to the [Usage](#usage-example) section for more details on utilizing different modes, including CLI commands.
|
||||
|
||||
### Where can I find practical examples of using Ultralytics YOLO for object detection?
|
||||
|
||||
Ultralytics provides numerous examples and practical guides for using YOLO26 in diverse applications. For a comprehensive overview, visit the [Ultralytics Blog](https://www.ultralytics.com/blog) where you can find case studies, detailed tutorials, and community stories showcasing object detection, segmentation, and more with YOLO26. For specific examples, check the [Usage](../../modes/predict.md) section in the documentation.
|
||||
@@ -1,127 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics kitti dataset, a benchmark dataset for computer vision tasks such as 3D object detection, depth estimation, and autonomous driving perception.
|
||||
keywords: kitti, Ultralytics, dataset, object detection, 3D vision, YOLO26, training, validation, self-driving cars, computer vision
|
||||
---
|
||||
|
||||
# KITTI Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-kitti-detection-dataset.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open KITTI Dataset In Colab"></a>
|
||||
|
||||
The kitti dataset is one of the most influential benchmark datasets for autonomous driving and computer vision. Released by the Karlsruhe Institute of Technology and Toyota Technological Institute at Chicago, it contains stereo camera, LiDAR, and GPS/IMU data collected from real-world driving scenarios.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/NNeDlTbq9pA"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on the KITTI Dataset 🚀
|
||||
</p>
|
||||
|
||||
It is widely used for evaluating algorithms in object detection, depth estimation, optical flow, and visual odometry. The dataset is fully compatible with Ultralytics YOLO26 for 2D object detection tasks and can be easily integrated into the Ultralytics platform for training and evaluation.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
!!! warning
|
||||
|
||||
Kitti original test set is excluded here since it does not contain ground-truth annotations.
|
||||
|
||||
In total, the dataset includes 7,481 images, each paired with detailed annotations for objects such as cars, pedestrians, cyclists, and other road elements. The dataset is divided into two main subsets:
|
||||
|
||||
- **Training set:** Contains 5,985 images with annotated labels used for model training.
|
||||
- **Validation set:** Includes 1,496 images with corresponding annotations used for performance evaluation and benchmarking.
|
||||
|
||||
## Applications
|
||||
|
||||
Kitti dataset enables advancements in autonomous driving and robotics, supporting tasks like:
|
||||
|
||||
- **Autonomous vehicle perception**: Training models to detect and track vehicles, pedestrians, and obstacles for safe navigation in self-driving systems.
|
||||
- **3D scene understanding**: Supporting depth estimation, stereo vision, and 3D object localization to help machines understand spatial environments.
|
||||
- **Optical flow and motion prediction**: Enabling motion analysis to predict the movement of objects and improve trajectory planning in dynamic environments.
|
||||
- **Computer vision benchmarking**: Serving as a standard benchmark for evaluating performance across multiple vision tasks, including object detection, and tracking.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
Ultralytics defines the kitti dataset configuration using a YAML file. This file specifies dataset paths, class labels, and metadata required for training. The configuration file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/kitti.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/kitti.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/kitti.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/kitti.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the kitti dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the following commands. For more details, refer to the [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO26 model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train on kitti dataset
|
||||
results = model.train(data="kitti.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=kitti.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
You can also perform evaluation, [inference](../../modes/predict.md), and [export](../../modes/export.md) tasks directly from the command line or Python API using the same configuration file.
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The kitti dataset provides diverse driving scenarios. Each image includes bounding box annotations for 2D object detection tasks. The example showcase the dataset rich variety, enabling robust model generalization across diverse real-world conditions.
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/kitti-dataset-sample.avif" alt="KITTI dataset vehicle detection sample" width="800">
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the kitti dataset in your research, please cite the following paper:
|
||||
|
||||
!!! quote
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{Geiger2013IJRR,
|
||||
author = {Andreas Geiger and Philip Lenz and Christoph Stiller and Raquel Urtasun},
|
||||
title = {Vision meets Robotics: The KITTI Dataset},
|
||||
journal = {International Journal of Robotics Research (IJRR)},
|
||||
year = {2013}
|
||||
}
|
||||
```
|
||||
|
||||
We acknowledge the KITTI Vision Benchmark Suite for providing this comprehensive dataset that continues to shape progress in computer vision, robotics, and autonomous systems. Visit the [kitti website](https://www.cvlibs.net/datasets/kitti/) for more information.
|
||||
|
||||
## FAQs
|
||||
|
||||
### What is the kitti dataset used for?
|
||||
|
||||
The kitti dataset is primarily used for computer vision research in autonomous driving, supporting tasks like object detection, depth estimation, optical flow, and 3D localization.
|
||||
|
||||
### How many images are included in the kitti dataset?
|
||||
|
||||
The dataset includes 5,985 labeled training images and 1,496 validation images captured across urban, rural, and highway scenes. The original test set is excluded here since it does not contain ground-truth annotations.
|
||||
|
||||
### Which object classes are annotated in the dataset?
|
||||
|
||||
kitti includes annotations for objects such as cars, pedestrians, cyclists, trucks, trams, and miscellaneous road users.
|
||||
|
||||
### Can I train Ultralytics YOLO26 models using the kitti dataset?
|
||||
|
||||
Yes, kitti is fully compatible with Ultralytics YOLO26. You can [train](../../modes/train.md) and [validate](../../modes/val.md), models directly using the provided YAML configuration file.
|
||||
|
||||
### Where can I find the kitti dataset configuration file?
|
||||
|
||||
You can access the YAML file at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/kitti.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/kitti.yaml).
|
||||
@@ -1,159 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover the LVIS dataset by Facebook AI Research, a benchmark for object detection and instance segmentation with a large, diverse vocabulary. Learn how to utilize it.
|
||||
keywords: LVIS dataset, object detection, instance segmentation, Facebook AI Research, YOLO, computer vision, model training, LVIS examples
|
||||
---
|
||||
|
||||
# LVIS Dataset
|
||||
|
||||
The [LVIS dataset](https://www.lvisdataset.org/) is a large-scale, fine-grained vocabulary-level annotation dataset developed and released by Facebook AI Research (FAIR). It is primarily used as a research benchmark for object detection and [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) with a large vocabulary of categories, aiming to drive further advancements in computer vision field.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/cfTKj96TjSE"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> YOLO World training workflow with LVIS dataset
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
<img width="640" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/lvis-dataset-example-images.avif" alt="LVIS large vocabulary instance segmentation dataset">
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
||||
- LVIS contains 160k images and 2M instance annotations for object detection, segmentation, and captioning tasks.
|
||||
- The dataset comprises 1203 object categories, including common objects like cars, bicycles, and animals, as well as more specific categories such as umbrellas, handbags, and sports equipment.
|
||||
- Annotations include object bounding boxes, segmentation masks, and captions for each image.
|
||||
- LVIS provides standardized evaluation metrics like [mean Average Precision](https://www.ultralytics.com/glossary/mean-average-precision-map) (mAP) for object detection, and mean Average [Recall](https://www.ultralytics.com/glossary/recall) (mAR) for segmentation tasks, making it suitable for comparing model performance.
|
||||
- LVIS uses exactly the same images as [COCO](./coco.md) dataset, but with different splits and different annotations.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The LVIS dataset is split into three subsets:
|
||||
|
||||
1. **Train**: This subset contains 100k images for training object detection, segmentation, and captioning models.
|
||||
2. **Val**: This subset has 20k images used for validation purposes during model training.
|
||||
3. **Minival**: This subset is exactly the same as COCO val2017 set which has 5k images used for validation purposes during model training.
|
||||
4. **Test**: This subset consists of 20k images used for testing and benchmarking the trained models. Ground truth annotations for this subset are not publicly available, and the results are submitted to the [LVIS evaluation server](https://eval.ai/web/challenges/challenge-page/675/overview) for performance evaluation.
|
||||
|
||||
## Applications
|
||||
|
||||
The LVIS dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object detection (such as [YOLO](../../models/yolo26.md), [Faster R-CNN](https://arxiv.org/abs/1506.01497), and [SSD](https://arxiv.org/abs/1512.02325)), instance segmentation (such as [Mask R-CNN](https://arxiv.org/abs/1703.06870)). The dataset's diverse set of object categories, large number of annotated images, and standardized evaluation metrics make it an essential resource for computer vision researchers and practitioners.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the LVIS dataset, the `lvis.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/lvis.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/lvis.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/lvis.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/lvis.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the LVIS dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="lvis.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=lvis.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The LVIS dataset contains a diverse set of images with various object categories and complex scenes. Here are some examples of images from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the LVIS dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the LVIS dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@inproceedings{gupta2019lvis,
|
||||
title={LVIS: A Dataset for Large Vocabulary Instance Segmentation},
|
||||
author={Gupta, Agrim and Dollar, Piotr and Girshick, Ross},
|
||||
booktitle={Proceedings of the {IEEE} Conference on Computer Vision and Pattern Recognition},
|
||||
year={2019}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the LVIS Consortium for creating and maintaining this valuable resource for the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. For more information about the LVIS dataset and its creators, visit the [LVIS dataset website](https://www.lvisdataset.org/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the LVIS dataset, and how is it used in computer vision?
|
||||
|
||||
The [LVIS dataset](https://www.lvisdataset.org/) is a large-scale dataset with fine-grained vocabulary-level annotations developed by Facebook AI Research (FAIR). It is primarily used for object detection and instance segmentation, featuring over 1203 object categories and 2 million instance annotations. Researchers and practitioners use it to train and benchmark models like Ultralytics YOLO for advanced computer vision tasks. The dataset's extensive size and diversity make it an essential resource for pushing the boundaries of model performance in detection and segmentation.
|
||||
|
||||
### How can I train a YOLO26n model using the LVIS dataset?
|
||||
|
||||
To train a YOLO26n model on the LVIS dataset for 100 epochs with an image size of 640, follow the example below. This process utilizes Ultralytics' framework, which offers comprehensive training features.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="lvis.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=lvis.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For detailed training configurations, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### How does the LVIS dataset differ from the COCO dataset?
|
||||
|
||||
The images in the LVIS dataset are the same as those in the [COCO dataset](./coco.md), but the two differ in terms of splitting and annotations. LVIS provides a larger and more detailed vocabulary with 1203 object categories compared to COCO's 80 categories. Additionally, LVIS focuses on annotation completeness and diversity, aiming to push the limits of [object detection](https://www.ultralytics.com/glossary/object-detection) and instance segmentation models by offering more nuanced and comprehensive data.
|
||||
|
||||
### Why should I use Ultralytics YOLO for training on the LVIS dataset?
|
||||
|
||||
Ultralytics YOLO models, including the latest YOLO26, are optimized for real-time object detection with state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed. They support a wide range of annotations, such as the fine-grained ones provided by the LVIS dataset, making them ideal for advanced computer vision applications. Moreover, Ultralytics offers seamless integration with various [training](../../modes/train.md), [validation](../../modes/val.md), and [prediction](../../modes/predict.md) modes, ensuring efficient model development and deployment.
|
||||
|
||||
### Can I see some sample annotations from the LVIS dataset?
|
||||
|
||||
Yes, the LVIS dataset includes a variety of images with diverse object categories and complex scenes. Here is an example of a sample image along with its annotations:
|
||||
|
||||
|
||||
|
||||
This mosaiced image demonstrates a training batch composed of multiple dataset images combined into one. Mosaicing increases the variety of objects and scenes within each training batch, enhancing the model's ability to generalize across different contexts. For more details on the LVIS dataset, explore the [LVIS dataset documentation](#key-features).
|
||||
@@ -1,153 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the medical-pills detection dataset with labeled images. Essential for training AI models for pharmaceutical identification and automation.
|
||||
keywords: medical-pills dataset, pill detection, pharmaceutical imaging, AI in healthcare, computer vision, object detection, medical automation, dataset for training
|
||||
---
|
||||
|
||||
# Medical Pills Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-medical-pills-dataset.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Medical Pills Dataset In Colab"></a>
|
||||
|
||||
The medical-pills detection dataset is a proof-of-concept (POC) dataset, carefully curated to demonstrate the potential of AI in pharmaceutical applications. It contains labeled images specifically designed to train [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) [models](https://docs.ultralytics.com/models/) for identifying medical-pills.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/8gePl_Zcs5c"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to train Ultralytics YOLO26 Model on Medical Pills Detection Dataset in <a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-medical-pills-dataset.ipynb">Google Colab</a>
|
||||
</p>
|
||||
|
||||
This dataset serves as a foundational resource for automating essential [tasks](https://docs.ultralytics.com/tasks/) such as quality control, packaging automation, and efficient sorting in pharmaceutical workflows. By integrating this dataset into projects, researchers and developers can explore innovative [solutions](https://docs.ultralytics.com/solutions/) that enhance [accuracy](https://www.ultralytics.com/glossary/accuracy), streamline operations, and ultimately contribute to improved healthcare outcomes.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The medical-pills dataset is divided into two subsets:
|
||||
|
||||
- **Training set**: Consisting of 92 images, each annotated with the class `pill`.
|
||||
- **Validation set**: Comprising 23 images with corresponding annotations.
|
||||
|
||||
## Applications
|
||||
|
||||
Using computer vision for medical-pills detection enables automation in the pharmaceutical industry, supporting tasks like:
|
||||
|
||||
- **Pharmaceutical Sorting**: Automating the sorting of pills based on size, shape, or color to enhance production efficiency.
|
||||
- **AI Research and Development**: Serving as a benchmark for developing and testing computer vision algorithms in pharmaceutical use cases.
|
||||
- **Digital Inventory Systems**: Powering smart inventory solutions by integrating automated pill recognition for real-time stock monitoring and replenishment planning.
|
||||
- **Quality Control**: Ensuring consistency in pill production by identifying defects, irregularities, or contamination.
|
||||
- **Counterfeit Detection**: Helping identify potentially counterfeit medications by analyzing visual characteristics against known standards.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML configuration file is provided to define the dataset's structure, including paths and classes. For the medical-pills dataset, the `medical-pills.yaml` file can be accessed at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/medical-pills.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/medical-pills.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/medical-pills.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/medical-pills.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the medical-pills dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the following examples. For detailed arguments, refer to the model's [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="medical-pills.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=medical-pills.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/best.pt") # load a fine-tuned model
|
||||
|
||||
# Inference using the model
|
||||
results = model.predict("https://ultralytics.com/assets/medical-pills-sample.jpg")
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start prediction with a fine-tuned *.pt model
|
||||
yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/medical-pills-sample.jpg"
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The medical-pills dataset features labeled images showcasing the diversity of pills. Below is an example of a labeled image from the dataset:
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: Displayed is a training batch comprising mosaiced dataset images. Mosaicing enhances training diversity by consolidating multiple images into one, improving model generalization.
|
||||
|
||||
## Integration with Other Datasets
|
||||
|
||||
For more comprehensive pharmaceutical analysis, consider combining the medical-pills dataset with other related datasets like [package-seg](../segment/package-seg.md) for packaging identification or medical imaging datasets like [brain-tumor](brain-tumor.md) to develop end-to-end healthcare AI solutions.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
The dataset is available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).
|
||||
|
||||
If you use the Medical-pills dataset in your research or development work, please cite it using the mentioned details:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@dataset{Jocher_Ultralytics_Datasets_2024,
|
||||
author = {Jocher, Glenn and Rizwan, Muhammad},
|
||||
license = {AGPL-3.0},
|
||||
month = {Dec},
|
||||
title = {Ultralytics Datasets: Medical-pills Detection Dataset},
|
||||
url = {https://docs.ultralytics.com/datasets/detect/medical-pills/},
|
||||
version = {1.0.0},
|
||||
year = {2024}
|
||||
}
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the structure of the medical-pills dataset?
|
||||
|
||||
The dataset includes 92 images for training and 23 images for validation. Each image is annotated with the class `pill`, enabling effective training and evaluation of models for pharmaceutical applications.
|
||||
|
||||
### How can I train a YOLO26 model on the medical-pills dataset?
|
||||
|
||||
You can train a YOLO26 model for 100 epochs with an image size of 640px using the Python or CLI methods provided. Refer to the [Training Example](#usage) section for detailed instructions and check the [YOLO26 documentation](../../models/yolo26.md) for more information on model capabilities.
|
||||
|
||||
### What are the benefits of using the medical-pills dataset in AI projects?
|
||||
|
||||
The dataset enables automation in pill detection, contributing to counterfeit prevention, quality assurance, and pharmaceutical process optimization. It also serves as a valuable resource for developing AI solutions that can improve medication safety and supply chain efficiency.
|
||||
|
||||
### How do I perform inference on the medical-pills dataset?
|
||||
|
||||
Inference can be done using Python or CLI methods with a fine-tuned YOLO26 model. Refer to the [Inference Example](#usage) section for code snippets and the [Predict mode documentation](../../modes/predict.md) for additional options.
|
||||
|
||||
### Where can I find the YAML configuration file for the medical-pills dataset?
|
||||
|
||||
The YAML file is available at [medical-pills.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/medical-pills.yaml), containing dataset paths, classes, and additional configuration details essential for training models on this dataset.
|
||||
@@ -1,152 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Objects365 Dataset with 2M images and 30M bounding boxes across 365 categories. Enhance your object detection models with diverse, high-quality data.
|
||||
keywords: Objects365 dataset, object detection, machine learning, deep learning, computer vision, annotated images, bounding boxes, YOLO26, high-resolution images, dataset configuration
|
||||
---
|
||||
|
||||
# Objects365 Dataset
|
||||
|
||||
The [Objects365](https://www.objects365.org/) dataset is a large-scale, high-quality dataset designed to foster object detection research with a focus on diverse objects in the wild. Created by a team of [Megvii](https://en.megvii.com/) researchers, the dataset offers a wide range of high-resolution images with a comprehensive set of annotated bounding boxes covering 365 object categories.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/J-RH22rwx1A"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on the Objects365 Dataset with Ultralytics | 2M Annotations 🚀
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
||||
- Objects365 contains 365 object categories, with 2 million images and over 30 million bounding boxes.
|
||||
- The dataset includes diverse objects in various scenarios, providing a rich and challenging benchmark for object detection tasks.
|
||||
- Annotations include bounding boxes for objects, making it suitable for training and evaluating object detection models.
|
||||
- Objects365 pretrained models significantly outperform ImageNet pretrained models, leading to better generalization on various tasks.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The Objects365 dataset is organized into a single set of images with corresponding annotations:
|
||||
|
||||
- **Images**: The dataset includes 2 million high-resolution images, each containing a variety of objects across 365 categories.
|
||||
- **Annotations**: The images are annotated with over 30 million bounding boxes, providing comprehensive ground truth information for [object detection](https://docs.ultralytics.com/tasks/detect/) tasks.
|
||||
|
||||
## Applications
|
||||
|
||||
The Objects365 dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object detection tasks. The dataset's diverse set of object categories and high-quality annotations make it a valuable resource for researchers and practitioners in the field of [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the Objects365 Dataset, the `Objects365.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Objects365.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Objects365.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/Objects365.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/Objects365.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the Objects365 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Objects365.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Objects365.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The Objects365 dataset contains a diverse set of high-resolution images with objects from 365 categories, providing rich context for [object detection](https://www.ultralytics.com/glossary/object-detection) tasks. Here are some examples of the images in the dataset:
|
||||
|
||||
|
||||
|
||||
- **Objects365**: This image demonstrates an example of object detection, where objects are annotated with bounding boxes. The dataset provides a wide range of images to facilitate the development of models for this task.
|
||||
|
||||
The example showcases the variety and complexity of the data in the Objects365 dataset and highlights the importance of accurate object detection for computer vision applications.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Objects365 dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@inproceedings{shao2019objects365,
|
||||
title={Objects365: A Large-scale, High-quality Dataset for Object Detection},
|
||||
author={Shao, Shuai and Li, Zeming and Zhang, Tianyuan and Peng, Chao and Yu, Gang and Li, Jing and Zhang, Xiangyu and Sun, Jian},
|
||||
booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
|
||||
pages={8425--8434},
|
||||
year={2019}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the team of researchers who created and maintain the Objects365 dataset as a valuable resource for the computer vision research community. For more information about the Objects365 dataset and its creators, visit the [Objects365 dataset website](https://www.objects365.org/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Objects365 dataset used for?
|
||||
|
||||
The [Objects365 dataset](https://www.objects365.org/) is designed for object detection tasks in [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision. It provides a large-scale, high-quality dataset with 2 million annotated images and 30 million bounding boxes across 365 categories. Leveraging such a diverse dataset helps improve the performance and generalization of object detection models, making it invaluable for research and development in the field.
|
||||
|
||||
### How can I train a YOLO26 model on the Objects365 dataset?
|
||||
|
||||
To train a YOLO26n model using the Objects365 dataset for 100 epochs with an image size of 640, follow these instructions:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Objects365.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Objects365.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
Refer to the [Training](../../modes/train.md) page for a comprehensive list of available arguments.
|
||||
|
||||
### Why should I use the Objects365 dataset for my object detection projects?
|
||||
|
||||
The Objects365 dataset offers several advantages for object detection tasks:
|
||||
|
||||
1. **Diversity**: It includes 2 million images with objects in diverse scenarios, covering 365 categories.
|
||||
2. **High-quality Annotations**: Over 30 million bounding boxes provide comprehensive ground truth data.
|
||||
3. **Performance**: Models pretrained on Objects365 significantly outperform those trained on datasets like [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), leading to better generalization.
|
||||
|
||||
### Where can I find the YAML configuration file for the Objects365 dataset?
|
||||
|
||||
The YAML configuration file for the Objects365 dataset is available at [Objects365.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Objects365.yaml). This file contains essential information such as dataset paths and class labels, crucial for setting up your training environment.
|
||||
|
||||
### How does the dataset structure of Objects365 enhance object detection modeling?
|
||||
|
||||
The [Objects365 dataset](https://www.objects365.org/) is organized with 2 million high-resolution images and comprehensive annotations of over 30 million bounding boxes. This structure ensures a robust dataset for training [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object detection, offering a wide variety of objects and scenarios. Such diversity and volume help in developing models that are more accurate and capable of generalizing well to real-world applications. For more details on the dataset structure, refer to the [Dataset YAML](#dataset-yaml) section.
|
||||
@@ -1,237 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the comprehensive Open Images V7 dataset by Google. Learn about its annotations, applications, and use YOLO26 pretrained models for computer vision tasks.
|
||||
keywords: Open Images V7, Google dataset, computer vision, YOLO26 models, object detection, image segmentation, visual relationships, AI research, Ultralytics
|
||||
---
|
||||
|
||||
# Open Images V7 Dataset
|
||||
|
||||
[Open Images V7](https://storage.googleapis.com/openimages/web/index.html) is a versatile and expansive dataset championed by Google. Aimed at propelling research in the realm of [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv), it boasts a vast collection of images annotated with a plethora of data, including image-level labels, object bounding boxes, object segmentation masks, visual relationships, and localized narratives.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/u3pLlgzUeV8"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> <a href="https://www.ultralytics.com/glossary/object-detection">Object Detection</a> using OpenImagesV7 Pretrained Model
|
||||
</p>
|
||||
|
||||
## Open Images V7 Pretrained Models
|
||||
|
||||
| Model | size<br><sup>(pixels)</sup> | mAP<sup>val<br>50-95</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>A100 TensorRT<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
|
||||
| ----------------------------------------------------------------------------------------- | --------------------------- | -------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
|
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
|
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
|
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
|
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
|
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
|
||||
|
||||
You can use these pretrained models for inference or fine-tuning as follows.
|
||||
|
||||
!!! example "Pretrained Model Usage Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load an Open Images Dataset V7 pretrained YOLOv8n model
|
||||
model = YOLO("yolov8n-oiv7.pt")
|
||||
|
||||
# Run prediction
|
||||
results = model.predict(source="image.jpg")
|
||||
|
||||
# Start training from the pretrained checkpoint
|
||||
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Predict using an Open Images Dataset V7 pretrained model
|
||||
yolo detect predict source=image.jpg model=yolov8n-oiv7.pt
|
||||
|
||||
# Start training from an Open Images Dataset V7 pretrained checkpoint
|
||||
yolo detect train data=coco8.yaml model=yolov8n-oiv7.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
|
||||
|
||||
## Key Features
|
||||
|
||||
- Encompasses ~9M images annotated in various ways to suit multiple computer vision tasks.
|
||||
- Houses a staggering 16M bounding boxes across 600 object classes in 1.9M images. These boxes are primarily hand-drawn by experts ensuring high [precision](https://www.ultralytics.com/glossary/precision).
|
||||
- Visual relationship annotations totaling 3.3M are available, detailing 1,466 unique relationship triplets, object properties, and human activities.
|
||||
- V5 introduced segmentation masks for 2.8M objects across 350 classes.
|
||||
- V6 introduced 675k localized narratives that amalgamate voice, text, and mouse traces highlighting described objects.
|
||||
- V7 introduced 66.4M point-level labels on 1.4M images, spanning 5,827 classes.
|
||||
- Encompasses 61.4M image-level labels across a diverse set of 20,638 classes.
|
||||
- Provides a unified platform for [image classification](https://www.ultralytics.com/glossary/image-classification), object detection, relationship detection, [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation), and multimodal image descriptions.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
Open Images V7 is structured in multiple components catering to varied computer vision challenges:
|
||||
|
||||
- **Images**: About 9 million images, often showcasing intricate scenes with an average of 8.3 objects per image.
|
||||
- **Bounding Boxes**: Over 16 million boxes that demarcate objects across 600 categories.
|
||||
- **Segmentation Masks**: These detail the exact boundary of 2.8M objects across 350 classes.
|
||||
- **Visual Relationships**: 3.3M annotations indicating object relationships, properties, and actions.
|
||||
- **Localized Narratives**: 675k descriptions combining voice, text, and mouse traces.
|
||||
- **Point-Level Labels**: 66.4M labels across 1.4M images, suitable for zero/few-shot [semantic segmentation](https://www.ultralytics.com/glossary/semantic-segmentation).
|
||||
|
||||
## Applications
|
||||
|
||||
Open Images V7 is a cornerstone for training and evaluating state-of-the-art models in various computer vision tasks. The dataset's broad scope and high-quality annotations make it indispensable for researchers and developers specializing in [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
|
||||
Some key applications include:
|
||||
|
||||
- **Advanced Object Detection**: Train models to identify and locate multiple objects in complex scenes with high accuracy.
|
||||
- **Semantic Understanding**: Develop systems that comprehend visual relationships between objects.
|
||||
- **Image Segmentation**: Create precise pixel-level masks for objects, enabling detailed scene analysis.
|
||||
- **Multi-modal Learning**: Combine visual data with text descriptions for richer AI understanding.
|
||||
- **Zero-shot Learning**: Leverage the extensive class coverage to identify objects not seen during training.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
Ultralytics maintains an `open-images-v7.yaml` file that specifies the dataset paths, class names, and other configuration details required for training.
|
||||
|
||||
!!! example "OpenImagesV7.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/open-images-v7.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the Open Images V7 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! warning
|
||||
|
||||
The complete Open Images V7 dataset comprises 1,743,042 training images and 41,620 validation images, requiring approximately **561 GB of storage space** upon download.
|
||||
|
||||
Executing the commands provided below will trigger an automatic download of the full dataset if it's not already present locally. Before running the below example it's crucial to:
|
||||
|
||||
- Verify that your device has enough storage capacity.
|
||||
- Ensure a robust and speedy internet connection.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a COCO-pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on the Open Images V7 dataset
|
||||
results = model.train(data="open-images-v7.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a COCO-pretrained YOLO26n model on the Open Images V7 dataset
|
||||
yolo detect train data=open-images-v7.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
Illustrations of the dataset help provide insights into its richness:
|
||||
|
||||
|
||||
|
||||
- **Open Images V7**: This image exemplifies the depth and detail of annotations available, including bounding boxes, relationships, and segmentation masks.
|
||||
|
||||
Researchers can gain invaluable insights into the array of computer vision challenges that the dataset addresses, from basic object detection to intricate relationship identification. The [diversity of annotations](https://docs.ultralytics.com/datasets/explorer/) makes Open Images V7 particularly valuable for developing models that can understand complex visual scenes.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
For those employing Open Images V7 in their work, it's prudent to cite the relevant papers and acknowledge the creators:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{OpenImages,
|
||||
author = {Alina Kuznetsova and Hassan Rom and Neil Alldrin and Jasper Uijlings and Ivan Krasin and Jordi Pont-Tuset and Shahab Kamali and Stefan Popov and Matteo Malloci and Alexander Kolesnikov and Tom Duerig and Vittorio Ferrari},
|
||||
title = {The Open Images Dataset V4: Unified image classification, object detection, and visual relationship detection at scale},
|
||||
year = {2020},
|
||||
journal = {IJCV}
|
||||
}
|
||||
```
|
||||
|
||||
A heartfelt acknowledgment goes out to the Google AI team for creating and maintaining the Open Images V7 dataset. For a deep dive into the dataset and its offerings, navigate to the [official Open Images V7 website](https://storage.googleapis.com/openimages/web/index.html).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Open Images V7 dataset?
|
||||
|
||||
Open Images V7 is an extensive and versatile dataset created by Google, designed to advance research in computer vision. It includes image-level labels, object bounding boxes, object segmentation masks, visual relationships, and localized narratives, making it ideal for various computer vision tasks such as object detection, segmentation, and relationship detection.
|
||||
|
||||
### How do I train a YOLO26 model on the Open Images V7 dataset?
|
||||
|
||||
To train a YOLO26 model on the Open Images V7 dataset, you can use both Python and CLI commands. Here's an example of training the YOLO26n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a COCO-pretrained YOLO26n model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model on the Open Images V7 dataset
|
||||
results = model.train(data="open-images-v7.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a COCO-pretrained YOLO26n model on the Open Images V7 dataset
|
||||
yolo detect train data=open-images-v7.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details on arguments and settings, refer to the [Training](../../modes/train.md) page.
|
||||
|
||||
### What are some key features of the Open Images V7 dataset?
|
||||
|
||||
The Open Images V7 dataset includes approximately 9 million images with various annotations:
|
||||
|
||||
- **Bounding Boxes**: 16 million bounding boxes across 600 object classes.
|
||||
- **Segmentation Masks**: Masks for 2.8 million objects across 350 classes.
|
||||
- **Visual Relationships**: 3.3 million annotations indicating relationships, properties, and actions.
|
||||
- **Localized Narratives**: 675,000 descriptions combining voice, text, and mouse traces.
|
||||
- **Point-Level Labels**: 66.4 million labels across 1.4 million images.
|
||||
- **Image-Level Labels**: 61.4 million labels across 20,638 classes.
|
||||
|
||||
### What pretrained models are available for the Open Images V7 dataset?
|
||||
|
||||
Ultralytics provides several YOLOv8 pretrained models for the Open Images V7 dataset, each with different sizes and performance metrics:
|
||||
|
||||
| Model | size<br><sup>(pixels)</sup> | mAP<sup>val<br>50-95</sup> | Speed<br><sup>CPU ONNX<br>(ms)</sup> | Speed<br><sup>A100 TensorRT<br>(ms)</sup> | params<br><sup>(M)</sup> | FLOPs<br><sup>(B)</sup> |
|
||||
| ----------------------------------------------------------------------------------------- | --------------------------- | -------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
|
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
|
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
|
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
|
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
|
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.4.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
|
||||
|
||||
### What applications can the Open Images V7 dataset be used for?
|
||||
|
||||
The Open Images V7 dataset supports a variety of computer vision tasks including:
|
||||
|
||||
- **[Image Classification](https://www.ultralytics.com/glossary/image-classification)**
|
||||
- **Object Detection**
|
||||
- **Instance Segmentation**
|
||||
- **Visual Relationship Detection**
|
||||
- **Multimodal Image Descriptions**
|
||||
|
||||
Its comprehensive annotations and broad scope make it suitable for training and evaluating advanced [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models, as highlighted in practical use cases detailed in our [applications](#applications) section.
|
||||
@@ -1,182 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Roboflow 100 dataset featuring 100 diverse datasets designed to test object detection models across various domains, from healthcare to video games.
|
||||
keywords: Roboflow 100, Ultralytics, object detection, dataset, benchmarking, machine learning, computer vision, diverse datasets, model evaluation
|
||||
---
|
||||
|
||||
# Roboflow 100 Dataset
|
||||
|
||||
Roboflow 100, sponsored by [Intel](https://www.intel.com/), is a groundbreaking [object detection](../../tasks/detect.md) benchmark dataset. It includes 100 diverse datasets sampled from over 90,000 public datasets available on Roboflow Universe. This benchmark is specifically designed to test the adaptability of [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models, like [Ultralytics YOLO models](../../models/yolo26.md), to various domains, including healthcare, aerial imagery, and video games.
|
||||
|
||||
!!! question "Licensing"
|
||||
|
||||
Ultralytics offers two licensing options to accommodate different use cases:
|
||||
|
||||
- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/license) open-source license is ideal for students and enthusiasts, promoting open collaboration and knowledge sharing. See the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for more details and visit our [AGPL-3.0 License page](https://www.ultralytics.com/legal/agpl-3-0-software-license).
|
||||
- **Enterprise License**: Designed for commercial use, this license allows for the seamless integration of Ultralytics software and AI models into commercial products and services. If your scenario involves commercial applications, please reach out via [Ultralytics Licensing](https://www.ultralytics.com/license).
|
||||
|
||||
<p align="center">
|
||||
<img width="640" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/roboflow-100-overview.avif" alt="Roboflow 100 diverse object detection benchmark">
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
||||
- **Diverse Domains**: Includes 100 datasets across seven distinct domains: Aerial, Video games, Microscopic, Underwater, Documents, Electromagnetic, and Real World.
|
||||
- **Scale**: The benchmark comprises 224,714 images across 805 classes, representing over 11,170 hours of [data labeling](https://www.ultralytics.com/glossary/data-labeling) effort.
|
||||
- **Standardization**: All images are [preprocessed](https://www.ultralytics.com/glossary/data-preprocessing) and resized to 640x640 pixels for consistent evaluation.
|
||||
- **Clean Evaluation**: Focuses on eliminating class ambiguity and filters out underrepresented classes to ensure cleaner [model evaluation](../../guides/model-evaluation-insights.md).
|
||||
- **Annotations**: Includes [bounding boxes](https://www.ultralytics.com/glossary/bounding-box) for objects, suitable for [training](../../modes/train.md) and evaluating object detection models using metrics like [mAP](https://www.ultralytics.com/glossary/mean-average-precision-map).
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The Roboflow 100 dataset is organized into seven categories, each containing a unique collection of datasets, images, and classes:
|
||||
|
||||
- **Aerial**: 7 datasets, 9,683 images, 24 classes.
|
||||
- **Video Games**: 7 datasets, 11,579 images, 88 classes.
|
||||
- **Microscopic**: 11 datasets, 13,378 images, 28 classes.
|
||||
- **Underwater**: 5 datasets, 18,003 images, 39 classes.
|
||||
- **Documents**: 8 datasets, 24,813 images, 90 classes.
|
||||
- **Electromagnetic**: 12 datasets, 36,381 images, 41 classes.
|
||||
- **Real World**: 50 datasets, 110,615 images, 495 classes.
|
||||
|
||||
This structure provides a diverse and extensive testing ground for [object detection](https://www.ultralytics.com/glossary/object-detection) models, reflecting a wide array of real-world application scenarios found in various [Ultralytics Solutions](https://www.ultralytics.com/solutions).
|
||||
|
||||
## Benchmarking
|
||||
|
||||
Dataset [benchmarking](../../modes/benchmark.md) involves evaluating the performance of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models on specific datasets using standardized metrics. Common metrics include [accuracy](https://www.ultralytics.com/glossary/accuracy), mean Average Precision (mAP), and [F1-score](https://www.ultralytics.com/glossary/f1-score). You can learn more about these in our [YOLO Performance Metrics guide](../../guides/yolo-performance-metrics.md).
|
||||
|
||||
!!! tip "Benchmarking Results"
|
||||
|
||||
Benchmarking results using the provided script will be stored in the `ultralytics-benchmarks/` directory, specifically in `evaluation.txt`.
|
||||
|
||||
!!! example "Benchmarking Example"
|
||||
|
||||
The following script demonstrates how to programmatically benchmark an Ultralytics YOLO model (e.g., YOLO26n) on all 100 datasets within the Roboflow 100 benchmark using the `RF100Benchmark` class.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
import os
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
from ultralytics.utils.benchmarks import RF100Benchmark
|
||||
|
||||
# Initialize RF100Benchmark and set API key
|
||||
benchmark = RF100Benchmark()
|
||||
benchmark.set_key(api_key="YOUR_ROBOFLOW_API_KEY")
|
||||
|
||||
# Parse dataset and define file paths
|
||||
names, cfg_yamls = benchmark.parse_dataset()
|
||||
val_log_file = Path("ultralytics-benchmarks") / "validation.txt"
|
||||
eval_log_file = Path("ultralytics-benchmarks") / "evaluation.txt"
|
||||
|
||||
# Run benchmarks on each dataset in RF100
|
||||
for ind, path in enumerate(cfg_yamls):
|
||||
path = Path(path)
|
||||
if path.exists():
|
||||
# Fix YAML file and run training
|
||||
benchmark.fix_yaml(str(path))
|
||||
os.system(f"yolo detect train data={path} model=yolo26s.pt epochs=1 batch=16")
|
||||
|
||||
# Run validation and evaluate
|
||||
os.system(f"yolo detect val data={path} model=runs/detect/train/weights/best.pt > {val_log_file} 2>&1")
|
||||
benchmark.evaluate(str(path), str(val_log_file), str(eval_log_file), ind)
|
||||
|
||||
# Remove the 'runs' directory
|
||||
runs_dir = Path.cwd() / "runs"
|
||||
shutil.rmtree(runs_dir)
|
||||
else:
|
||||
print("YAML file path does not exist")
|
||||
continue
|
||||
|
||||
print("RF100 Benchmarking completed!")
|
||||
```
|
||||
|
||||
## Applications
|
||||
|
||||
Roboflow 100 is invaluable for various applications related to [computer vision](https://www.ultralytics.com/blog/everything-you-need-to-know-about-computer-vision-in-2025) and [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl). Researchers and engineers can leverage this benchmark to:
|
||||
|
||||
- Evaluate the performance of object detection models in a multi-domain context.
|
||||
- Test the adaptability and [robustness](<https://en.wikipedia.org/wiki/Robustness_(computer_science)>) of models to real-world scenarios beyond common [benchmark datasets](https://www.ultralytics.com/glossary/benchmark-dataset) like [COCO](https://cocodataset.org/#home) or [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/).
|
||||
- Benchmark the capabilities of object detection models across diverse datasets, including specialized areas like healthcare, aerial imagery, and video games.
|
||||
- Compare model performance across different [neural network](https://www.ultralytics.com/glossary/neural-network-nn) architectures and [optimization](https://www.ultralytics.com/glossary/optimization-algorithm) techniques.
|
||||
- Identify domain-specific challenges that may require specialized [model training tips](../../guides/model-training-tips.md) or [fine-tuning](https://www.ultralytics.com/glossary/fine-tuning) approaches like [transfer learning](https://www.ultralytics.com/glossary/transfer-learning).
|
||||
|
||||
For more ideas and inspiration on real-world applications, explore [our guides on practical projects](../../guides/index.md) or check out [Ultralytics Platform](https://platform.ultralytics.com) for streamlined [model training](../../modes/train.md) and [deployment](../../guides/model-deployment-options.md).
|
||||
|
||||
## Usage
|
||||
|
||||
The Roboflow 100 dataset, including metadata and download links, is available on the official [Roboflow 100 GitHub repository](https://github.com/roboflow/roboflow-100-benchmark). You can access and utilize the dataset directly from there for your benchmarking needs. The Ultralytics `RF100Benchmark` utility simplifies the process of downloading and preparing these datasets for use with Ultralytics models.
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
Roboflow 100 consists of datasets with diverse images captured from various angles and domains. Below are examples of annotated images included in the RF100 benchmark, showcasing the variety of objects and scenes. Techniques like [data augmentation](https://www.ultralytics.com/glossary/data-augmentation) can further enhance the diversity during training.
|
||||
|
||||
<p align="center">
|
||||
<img width="640" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/sample-data-annotations.avif" alt="Roboflow 100 sample images with annotations">
|
||||
</p>
|
||||
|
||||
The diversity seen in the Roboflow 100 benchmark represents a significant advancement from traditional benchmarks, which often focus on optimizing a single metric within a limited domain. This comprehensive approach aids in developing more robust and versatile [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models capable of performing well across a multitude of different scenarios.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Roboflow 100 dataset in your research or development work, please cite the original paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{rf100benchmark,
|
||||
Author = {Floriana Ciaglia and Francesco Saverio Zuppichini and Paul Guerrie and Mark McQuade and Jacob Solawetz},
|
||||
Title = {Roboflow 100: A Rich, Multi-Domain Object Detection Benchmark},
|
||||
Year = {2022},
|
||||
Eprint = {arXiv:2211.13523},
|
||||
url = {https://arxiv.org/abs/2211.13523}
|
||||
}
|
||||
```
|
||||
|
||||
We extend our gratitude to the Roboflow team and all contributors for their significant efforts in creating and maintaining the Roboflow 100 dataset as a valuable resource for the computer vision community.
|
||||
|
||||
If you are interested in exploring more datasets to enhance your object detection and machine learning projects, feel free to visit [our comprehensive dataset collection](../index.md), which includes a variety of other [detection datasets](../detect/index.md).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Roboflow 100 dataset, and why is it significant for object detection?
|
||||
|
||||
The **Roboflow 100** dataset is a benchmark for [object detection](../../tasks/detect.md) models. It comprises 100 diverse datasets sourced from Roboflow Universe, covering domains like healthcare, aerial imagery, and video games. Its significance lies in providing a standardized way to test model adaptability and robustness across a wide range of real-world scenarios, moving beyond traditional, often domain-limited, benchmarks.
|
||||
|
||||
### Which domains are covered by the Roboflow 100 dataset?
|
||||
|
||||
The **Roboflow 100** dataset spans seven diverse domains, offering unique challenges for [object detection](https://www.ultralytics.com/glossary/object-detection) models:
|
||||
|
||||
1. **Aerial**: 7 datasets (e.g., satellite imagery, drone views).
|
||||
2. **Video Games**: 7 datasets (e.g., objects from various game environments).
|
||||
3. **Microscopic**: 11 datasets (e.g., cells, particles).
|
||||
4. **Underwater**: 5 datasets (e.g., marine life, submerged objects).
|
||||
5. **Documents**: 8 datasets (e.g., text regions, form elements).
|
||||
6. **Electromagnetic**: 12 datasets (e.g., radar signatures, spectral data visualizations).
|
||||
7. **Real World**: 50 datasets (a broad category including everyday objects, scenes, retail, etc.).
|
||||
|
||||
This variety makes RF100 an excellent resource for assessing the [generalizability](<https://en.wikipedia.org/wiki/Generalization_(learning)>) of computer vision models.
|
||||
|
||||
### What should I include when citing the Roboflow 100 dataset in my research?
|
||||
|
||||
When using the Roboflow 100 dataset, please cite the original paper to give credit to the creators. Here is the recommended BibTeX citation:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{rf100benchmark,
|
||||
Author = {Floriana Ciaglia and Francesco Saverio Zuppichini and Paul Guerrie and Mark McQuade and Jacob Solawetz},
|
||||
Title = {Roboflow 100: A Rich, Multi-Domain Object Detection Benchmark},
|
||||
Year = {2022},
|
||||
Eprint = {arXiv:2211.13523},
|
||||
url = {https://arxiv.org/abs/2211.13523}
|
||||
}
|
||||
```
|
||||
|
||||
For further exploration, consider visiting our [comprehensive dataset collection](../index.md) or browsing other [detection datasets](../detect/index.md) compatible with Ultralytics models.
|
||||
@@ -1,179 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover the Signature Detection Dataset for training models to identify and verify human signatures in various documents. Perfect for document verification and fraud prevention.
|
||||
keywords: Signature Detection Dataset, document verification, fraud detection, computer vision, YOLO26, Ultralytics, annotated signatures, training dataset
|
||||
---
|
||||
|
||||
# Signature Detection Dataset
|
||||
|
||||
This dataset focuses on detecting human written signatures within documents. It includes a variety of document types with annotated signatures, providing valuable insights for applications in document verification and fraud detection. Essential for training [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) algorithms, this dataset aids in identifying signatures in various document formats, supporting research and practical applications in document analysis.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The signature detection dataset is split into two subsets:
|
||||
|
||||
- **Training set**: Contains 143 images, each with corresponding annotations.
|
||||
- **Validation set**: Includes 35 images, each with paired annotations.
|
||||
|
||||
## Applications
|
||||
|
||||
This dataset can be applied in various computer vision tasks such as [object detection](https://www.ultralytics.com/glossary/object-detection), [object tracking](https://docs.ultralytics.com/modes/track/), and document analysis. Specifically, it can be used to train and evaluate models for identifying signatures in documents, which has significant applications in:
|
||||
|
||||
- **Document Verification**: Automating the verification process for legal and financial documents
|
||||
- **Fraud Detection**: Identifying potentially forged or unauthorized signatures
|
||||
- **Digital Document Processing**: Streamlining workflows in administrative and legal sectors
|
||||
- **Banking and Finance**: Enhancing security in check processing and loan document verification
|
||||
- **Archival Research**: Supporting historical document analysis and cataloging
|
||||
|
||||
Additionally, it serves as a valuable resource for educational purposes, enabling students and researchers to study signature characteristics across different document types.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file defines the dataset configuration, including paths and classes information. For the signature detection dataset, the `signature.yaml` file is located at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/signature.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/signature.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/signature.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/signature.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the signature detection dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the provided code samples. For a comprehensive list of available parameters, refer to the model's [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="signature.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=signature.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/best.pt") # load a signature-detection fine-tuned model
|
||||
|
||||
# Inference using the model
|
||||
results = model.predict("https://ultralytics.com/assets/signature-s.mp4", conf=0.75)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start prediction with a finetuned *.pt model
|
||||
yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/signature-s.mp4" conf=0.75
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The signature detection dataset comprises a wide variety of images showcasing different document types and annotated signatures. Below are examples of images from the dataset, each accompanied by its corresponding annotations.
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: Here, we present a training batch consisting of mosaiced dataset images. Mosaicing, a training technique, combines multiple images into one, enriching batch diversity. This method helps enhance the model's ability to generalize across different signature sizes, aspect ratios, and contexts.
|
||||
|
||||
This example illustrates the variety and complexity of images in the signature Detection Dataset, emphasizing the benefits of including mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
The dataset has been released available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Signature Detection Dataset, and how can it be used?
|
||||
|
||||
The Signature Detection Dataset is a collection of annotated images aimed at detecting human signatures within various document types. It can be applied in computer vision tasks such as [object detection](https://www.ultralytics.com/glossary/object-detection) and tracking, primarily for document verification, fraud detection, and archival research. This dataset helps train models to recognize signatures in different contexts, making it valuable for both research and practical applications in [smart document analysis](https://www.ultralytics.com/blog/using-ultralytics-yolo11-for-smart-document-analysis).
|
||||
|
||||
### How do I train a YOLO26n model on the Signature Detection Dataset?
|
||||
|
||||
To train a YOLO26n model on the Signature Detection Dataset, follow these steps:
|
||||
|
||||
1. Download the `signature.yaml` dataset configuration file from [signature.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/signature.yaml).
|
||||
2. Use the following Python script or CLI command to start training:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="signature.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=signature.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details, refer to the [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the main applications of the Signature Detection Dataset?
|
||||
|
||||
The Signature Detection Dataset can be used for:
|
||||
|
||||
1. **Document Verification**: Automatically verifying the presence and authenticity of human signatures in documents.
|
||||
2. **Fraud Detection**: Identifying forged or fraudulent signatures in legal and financial documents.
|
||||
3. **Archival Research**: Assisting historians and archivists in the digital analysis and cataloging of historical documents.
|
||||
4. **Education**: Supporting academic research and teaching in the fields of computer vision and [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml).
|
||||
5. **Financial Services**: Enhancing security in banking transactions and loan processing by verifying signature authenticity.
|
||||
|
||||
### How can I perform inference using a model trained on the Signature Detection Dataset?
|
||||
|
||||
To perform inference using a model trained on the Signature Detection Dataset, follow these steps:
|
||||
|
||||
1. Load your fine-tuned model.
|
||||
2. Use the below Python script or CLI command to perform inference:
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load the fine-tuned model
|
||||
model = YOLO("path/to/best.pt")
|
||||
|
||||
# Perform inference
|
||||
results = model.predict("https://ultralytics.com/assets/signature-s.mp4", conf=0.75)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect predict model='path/to/best.pt' imgsz=640 source="https://ultralytics.com/assets/signature-s.mp4" conf=0.75
|
||||
```
|
||||
|
||||
### What is the structure of the Signature Detection Dataset, and where can I find more information?
|
||||
|
||||
The Signature Detection Dataset is divided into two subsets:
|
||||
|
||||
- **Training Set**: Contains 143 images with annotations.
|
||||
- **Validation Set**: Includes 35 images with annotations.
|
||||
|
||||
For detailed information, you can refer to the [Dataset Structure](#dataset-structure) section. Additionally, view the complete dataset configuration in the `signature.yaml` file located at [signature.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/signature.yaml).
|
||||
@@ -1,189 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the SKU-110k dataset of densely packed retail shelf images, perfect for training and evaluating deep learning models in object detection tasks.
|
||||
keywords: SKU-110k, dataset, object detection, retail shelf images, deep learning, computer vision, model training
|
||||
---
|
||||
|
||||
# SKU-110k Dataset
|
||||
|
||||
The [SKU-110k](https://github.com/eg4000/SKU110K_CVPR19) dataset is a collection of densely packed retail shelf images, designed to support research in [object detection](https://www.ultralytics.com/glossary/object-detection) tasks. Developed by Eran Goldman et al., the dataset contains over 110,000 unique store keeping unit (SKU) categories with densely packed objects, often looking similar or even identical, positioned in proximity.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/_gRqR-miFPE"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train YOLOv10 on SKU-110k Dataset using Ultralytics | Retail Dataset
|
||||
</p>
|
||||
|
||||
|
||||
|
||||
## Key Features
|
||||
|
||||
- SKU-110k contains images of store shelves from around the world, featuring densely packed objects that pose challenges for state-of-the-art object detectors.
|
||||
- The dataset includes over 110,000 unique SKU categories, providing a diverse range of object appearances.
|
||||
- Annotations include bounding boxes for objects and SKU category labels.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The SKU-110k dataset is organized into three main subsets:
|
||||
|
||||
1. **Training set**: This subset contains 8,219 images and annotations used for training object detection models.
|
||||
2. **Validation set**: This subset consists of 588 images and annotations used for model validation during training.
|
||||
3. **Test set**: This subset includes 2,936 images designed for the final evaluation of trained object detection models.
|
||||
|
||||
## Applications
|
||||
|
||||
The SKU-110k dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object detection tasks, especially in densely packed scenes such as retail shelf displays. Its applications include:
|
||||
|
||||
- Retail inventory management and automation
|
||||
- Product recognition in e-commerce platforms
|
||||
- Planogram compliance verification
|
||||
- Self-checkout systems in stores
|
||||
- Robotic picking and sorting in warehouses
|
||||
|
||||
The dataset's diverse set of SKU categories and densely packed object arrangements make it a valuable resource for researchers and practitioners in the field of [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the SKU-110K dataset, the `SKU-110K.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/SKU-110K.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/SKU-110K.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/SKU-110K.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/SKU-110K.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the SKU-110K dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="SKU-110K.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=SKU-110K.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The SKU-110k dataset contains a diverse set of retail shelf images with densely packed objects, providing rich context for object detection tasks. Here are some examples of data from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Densely packed retail shelf image**: This image demonstrates an example of densely packed objects in a retail shelf setting. Objects are annotated with bounding boxes and SKU category labels.
|
||||
|
||||
The example showcases the variety and complexity of the data in the SKU-110k dataset and highlights the importance of high-quality data for object detection tasks. The dense arrangement of products presents unique challenges for detection algorithms, making this dataset particularly valuable for developing robust retail-focused computer vision solutions.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the SKU-110k dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@inproceedings{goldman2019dense,
|
||||
author = {Eran Goldman and Roei Herzig and Aviv Eisenschtat and Jacob Goldberger and Tal Hassner},
|
||||
title = {Precise Detection in Densely Packed Scenes},
|
||||
booktitle = {Proc. Conf. Comput. Vision Pattern Recognition (CVPR)},
|
||||
year = {2019}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge Eran Goldman et al. for creating and maintaining the SKU-110k dataset as a valuable resource for the computer vision research community. For more information about the SKU-110k dataset and its creators, visit the [SKU-110k dataset GitHub repository](https://github.com/eg4000/SKU110K_CVPR19).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the SKU-110k dataset and why is it important for object detection?
|
||||
|
||||
The SKU-110k dataset consists of densely packed retail shelf images designed to aid research in object detection tasks. Developed by Eran Goldman et al., it includes over 110,000 unique SKU categories. Its importance lies in its ability to challenge state-of-the-art object detectors with diverse object appearances and proximity, making it an invaluable resource for researchers and practitioners in computer vision. Learn more about the dataset's structure and applications in our [SKU-110k Dataset](#sku-110k-dataset) section.
|
||||
|
||||
### How do I train a YOLO26 model using the SKU-110k dataset?
|
||||
|
||||
Training a YOLO26 model on the SKU-110k dataset is straightforward. Here's an example to train a YOLO26n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="SKU-110K.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=SKU-110K.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the main subsets of the SKU-110k dataset?
|
||||
|
||||
The SKU-110k dataset is organized into three main subsets:
|
||||
|
||||
1. **Training set**: Contains 8,219 images and annotations used for training object detection models.
|
||||
2. **Validation set**: Consists of 588 images and annotations used for model validation during training.
|
||||
3. **Test set**: Includes 2,936 images designed for the final evaluation of trained object detection models.
|
||||
|
||||
Refer to the [Dataset Structure](#dataset-structure) section for more details.
|
||||
|
||||
### How do I configure the SKU-110k dataset for training?
|
||||
|
||||
The SKU-110k dataset configuration is defined in a YAML file, which includes details about the dataset's paths, classes, and other relevant information. The `SKU-110K.yaml` file is maintained at [SKU-110K.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/SKU-110K.yaml). For example, you can train a model using this configuration as shown in our [Usage](#usage) section.
|
||||
|
||||
### What are the key features of the SKU-110k dataset in the context of [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl)?
|
||||
|
||||
The SKU-110k dataset features images of store shelves from around the world, showcasing densely packed objects that pose significant challenges for object detectors:
|
||||
|
||||
- Over 110,000 unique SKU categories
|
||||
- Diverse object appearances
|
||||
- Annotations include bounding boxes and SKU category labels
|
||||
|
||||
These features make the SKU-110k dataset particularly valuable for training and evaluating deep learning models in object detection tasks. For more details, see the [Key Features](#key-features) section.
|
||||
|
||||
### How do I cite the SKU-110k dataset in my research?
|
||||
|
||||
If you use the SKU-110k dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@inproceedings{goldman2019dense,
|
||||
author = {Eran Goldman and Roei Herzig and Aviv Eisenschtat and Jacob Goldberger and Tal Hassner},
|
||||
title = {Precise Detection in Densely Packed Scenes},
|
||||
booktitle = {Proc. Conf. Comput. Vision Pattern Recognition (CVPR)},
|
||||
year = {2019}
|
||||
}
|
||||
```
|
||||
|
||||
More information about the dataset can be found in the [Citations and Acknowledgments](#citations-and-acknowledgments) section.
|
||||
@@ -1,234 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Tsinghua-Tencent 100K (TT100K) traffic sign dataset with 100,000 street view images and 30,000+ annotated traffic signs for robust detection and classification.
|
||||
keywords: TT100K, Tsinghua-Tencent 100K, traffic sign detection, YOLO26, dataset, object detection, street view, traffic signs, Chinese traffic signs
|
||||
---
|
||||
|
||||
# TT100K Dataset
|
||||
|
||||
The [Tsinghua-Tencent 100K (TT100K)](https://cg.cs.tsinghua.edu.cn/traffic-sign/) is a large-scale traffic sign benchmark dataset created from 100,000 Tencent Street View panoramas. This dataset is specifically designed for traffic sign detection and classification in real-world conditions, providing researchers and developers with a comprehensive resource for building robust traffic sign recognition systems.
|
||||
|
||||
The dataset contains **100,000 images** with over **30,000 traffic sign instances** across **221 different categories**. These images capture large variations in illuminance, weather conditions, viewing angles, and distances, making it ideal for training models that need to perform reliably in diverse real-world scenarios.
|
||||
|
||||
This dataset is particularly valuable for:
|
||||
|
||||
- Autonomous driving systems
|
||||
- Advanced driver assistance systems (ADAS)
|
||||
- Traffic monitoring applications
|
||||
- Urban planning and traffic analysis
|
||||
- Computer vision research in real-world conditions
|
||||
|
||||
## Key Features
|
||||
|
||||
The TT100K dataset provides several key advantages:
|
||||
|
||||
- **Scale**: 100,000 high-resolution images (2048×2048 pixels)
|
||||
- **Diversity**: 221 traffic sign categories covering Chinese traffic signs
|
||||
- **Real-world conditions**: Large variations in weather, illumination, and viewing angles
|
||||
- **Rich annotations**: Each sign includes class label, bounding box, and pixel mask
|
||||
- **Comprehensive coverage**: Includes prohibitory, warning, mandatory, and informative signs
|
||||
- **Train/Test split**: Pre-defined splits for consistent evaluation
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The TT100K dataset is split into three subsets:
|
||||
|
||||
1. **Training Set**:
|
||||
The primary collection of traffic-scene images used to train models for detecting and classifying different types of traffic signs.
|
||||
2. **Validation Set**:
|
||||
A subset used during model development to monitor performance and tune hyperparameters.
|
||||
3. **Test Set**:
|
||||
A held-out collection of images used to evaluate the final model's ability to detect and classify traffic signs in real-world scenarios.
|
||||
|
||||
The TT100K dataset includes 221 traffic sign categories organized into several major groups:
|
||||
|
||||
**Speed Limit Signs (pl*, pm*)**
|
||||
|
||||
1. **pl\_**: Prohibitory speed limits (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
|
||||
2. **pm\_**: Minimum speed limits (pm5, pm10, pm20, pm30, pm40, pm50, pm55)
|
||||
|
||||
**Prohibitory Signs (p*, pn*, pr\_)**
|
||||
|
||||
1. **p1-p28**: General prohibitory signs (no entry, no parking, no stopping, etc.)
|
||||
2. **pn/pne**: No entry and no parking signs
|
||||
3. **pr**: Various restriction signs (pr10, pr20, pr30, pr40, pr50, etc.)
|
||||
|
||||
**Warning Signs (w\_)**
|
||||
|
||||
1. **w1-w66**: Warning signs for various road hazards, conditions, and situations
|
||||
2. Includes pedestrian crossings, sharp turns, slippery roads, animals, construction, etc.
|
||||
|
||||
**Height/Width Limit Signs (ph*, pb*)**
|
||||
|
||||
1. **ph\_**: Height limit signs (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, etc.)
|
||||
2. **pb\_**: Width limit signs
|
||||
|
||||
**Informative Signs (i*, il*, io, ip)**
|
||||
|
||||
1. **i1-i15**: General informative signs
|
||||
2. **il\_**: Speed limit information (il60, il80, il100, il110)
|
||||
3. **io**: Other informative signs
|
||||
4. **ip**: Information plates
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the TT100K dataset, the `TT100K.yaml` file includes automatic download and conversion functionality.
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/TT100K.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/TT100K.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26 model on the TT100K dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. The dataset will be automatically downloaded and converted to YOLO format on first use.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model - dataset will auto-download on first run
|
||||
results = model.train(data="TT100K.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
# Dataset will auto-download and convert on first run
|
||||
yolo detect train data=TT100K.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are typical examples from the TT100K dataset:
|
||||
|
||||
1. **Urban environments**: Street scenes with multiple traffic signs at various distances
|
||||
2. **Highway scenes**: High-speed road signs including speed limits and direction indicators
|
||||
3. **Complex intersections**: Multiple signs in close proximity with varying orientations
|
||||
4. **Challenging conditions**: Signs under different lighting (day/night), weather (rain/fog), and viewing angles
|
||||
|
||||
The dataset includes:
|
||||
|
||||
1. **Close-up signs**: Large, clearly visible signs occupying significant image area
|
||||
2. **Distant signs**: Small signs requiring fine-grained detection capabilities
|
||||
3. **Partially occluded signs**: Signs partially blocked by vehicles, trees, or other objects
|
||||
4. **Multiple signs per image**: Images containing several different sign types
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the TT100K dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@InProceedings{Zhu_2016_CVPR,
|
||||
author = {Zhu, Zhe and Liang, Dun and Zhang, Songhai and Huang, Xiaolei and Li, Baoli and Hu, Shimin},
|
||||
title = {Traffic-Sign Detection and Classification in the Wild},
|
||||
booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
|
||||
month = {June},
|
||||
year = {2016}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the Tsinghua University and Tencent collaboration for creating and maintaining this valuable resource for the computer vision and autonomous driving communities. For more information about the TT100K dataset, visit the [official dataset website](https://cg.cs.tsinghua.edu.cn/traffic-sign/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the TT100K dataset used for?
|
||||
|
||||
The Tsinghua-Tencent 100K (TT100K) dataset is specifically designed for traffic sign detection and classification in real-world conditions. It's primarily used for:
|
||||
|
||||
1. Training autonomous driving perception systems
|
||||
2. Developing Advanced Driver Assistance Systems (ADAS)
|
||||
3. Research in robust object detection under varying conditions
|
||||
4. Benchmarking traffic sign recognition algorithms
|
||||
5. Testing model performance on small objects in large images
|
||||
|
||||
With 100,000 diverse street view images and 221 traffic sign categories, it provides a comprehensive testbed for real-world traffic sign detection.
|
||||
|
||||
### How many traffic sign categories are in TT100K?
|
||||
|
||||
The TT100K dataset contains **221 different traffic sign categories**, including:
|
||||
|
||||
1. **Speed limits**: pl5 through pl120 (prohibitory limits) and pm5 through pm55 (minimum speeds)
|
||||
2. **Prohibitory signs**: 28+ general prohibition types (p1-p28) plus restrictions (pr\*, pn, pne)
|
||||
3. **Warning signs**: 60+ warning categories (w1-w66)
|
||||
4. **Height/width limits**: ph* and pb* series for physical restrictions
|
||||
5. **Informative signs**: i1-i15, il\*, io, ip for guidance and information
|
||||
|
||||
This comprehensive coverage includes most traffic signs found in Chinese road networks.
|
||||
|
||||
### How can I train a YOLO26n model using the TT100K dataset?
|
||||
|
||||
To train a YOLO26n model on the TT100K dataset for 100 epochs with an image size of 640, use the example below.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="TT100K.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=TT100K.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For detailed training configurations, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### What makes TT100K challenging compared to other datasets?
|
||||
|
||||
TT100K presents several unique challenges:
|
||||
|
||||
1. **Scale variation**: Signs range from very small (distant highway signs) to large (close-up urban signs)
|
||||
2. **Real-world conditions**: Extreme variations in lighting, weather, and viewing angles
|
||||
3. **High resolution**: 2048×2048 pixel images require significant processing power
|
||||
4. **Class imbalance**: Some sign types are much more common than others
|
||||
5. **Dense scenes**: Multiple signs may appear in a single image
|
||||
6. **Partial occlusion**: Signs may be partially blocked by vehicles, vegetation, or structures
|
||||
|
||||
These challenges make TT100K a valuable benchmark for developing robust detection algorithms.
|
||||
|
||||
### How do I handle the large image sizes in TT100K?
|
||||
|
||||
The TT100K dataset uses 2048×2048 pixel images, which can be resource-intensive. Here are recommended strategies:
|
||||
|
||||
**For Training:**
|
||||
|
||||
```python
|
||||
# Option 1: Resize to standard YOLO size
|
||||
model.train(data="TT100K.yaml", imgsz=640, batch=16)
|
||||
|
||||
# Option 2: Use larger size for better small object detection
|
||||
model.train(data="TT100K.yaml", imgsz=1280, batch=4)
|
||||
|
||||
# Option 3: Multi-scale training
|
||||
model.train(data="TT100K.yaml", imgsz=640, scale=0.5) # trains at varying scales
|
||||
```
|
||||
|
||||
**Recommendations:**
|
||||
|
||||
- Start with `imgsz=640` for initial experiments
|
||||
- Use `imgsz=1280` if you have sufficient GPU memory (24GB+)
|
||||
- Consider tiling strategies for very small signs
|
||||
- Use gradient accumulation to simulate larger batch sizes
|
||||
@@ -1,179 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the VisDrone Dataset, a large-scale benchmark for drone-based image and video analysis with over 2.6 million annotations for objects like pedestrians and vehicles.
|
||||
keywords: VisDrone, drone dataset, computer vision, object detection, object tracking, crowd counting, machine learning, deep learning
|
||||
---
|
||||
|
||||
# VisDrone Dataset
|
||||
|
||||
The [VisDrone Dataset](https://github.com/VisDrone/VisDrone-Dataset) is a large-scale benchmark created by the AISKYEYE team at the Lab of [Machine Learning](https://www.ultralytics.com/glossary/machine-learning-ml) and Data Mining, Tianjin University, China. It contains carefully annotated ground truth data for various computer vision tasks related to drone-based image and video analysis.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/9ymyH4H1fG4"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on the VisDrone Dataset | Aerial Detection | Complete Tutorial 🚀
|
||||
</p>
|
||||
|
||||
VisDrone is composed of 288 video clips with 261,908 frames and 10,209 static images, captured by various drone-mounted cameras. The dataset covers a wide range of aspects, including location (14 different cities across China), environment (urban and rural), objects (pedestrians, vehicles, bicycles, etc.), and density (sparse and crowded scenes). The dataset was collected using various drone platforms under different scenarios and weather and lighting conditions. These frames are manually annotated with over 2.6 million bounding boxes of targets such as pedestrians, cars, bicycles, and tricycles. Attributes like scene visibility, object class, and occlusion are also provided for better data utilization.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The VisDrone dataset is organized into five main subsets, each focusing on a specific task:
|
||||
|
||||
1. **Task 1**: Object detection in images
|
||||
2. **Task 2**: Object detection in videos
|
||||
3. **Task 3**: Single-object tracking
|
||||
4. **Task 4**: [Multi-object tracking](../index.md#multi-object-tracking)
|
||||
5. **Task 5**: Crowd counting
|
||||
|
||||
## Applications
|
||||
|
||||
The VisDrone dataset is widely used for training and evaluating deep learning models in drone-based [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks such as object detection, object tracking, and crowd counting. The dataset's diverse set of sensor data, object annotations, and attributes make it a valuable resource for researchers and practitioners in the field of drone-based computer vision.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the Visdrone dataset, the `VisDrone.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VisDrone.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VisDrone.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/VisDrone.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/VisDrone.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the VisDrone dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VisDrone.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The VisDrone dataset contains a diverse set of images and videos captured by drone-mounted cameras. Here are some examples of data from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Task 1**: [Object detection](https://www.ultralytics.com/glossary/object-detection) in images - This image demonstrates an example of object detection in images, where objects are annotated with [bounding boxes](https://www.ultralytics.com/glossary/bounding-box). The dataset provides a wide variety of images taken from different locations, environments, and densities to facilitate the development of models for this task.
|
||||
|
||||
The example showcases the variety and complexity of the data in the VisDrone dataset and highlights the importance of high-quality sensor data for drone-based computer vision tasks.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the VisDrone dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@ARTICLE{9573394,
|
||||
author={Zhu, Pengfei and Wen, Longyin and Du, Dawei and Bian, Xiao and Fan, Heng and Hu, Qinghua and Ling, Haibin},
|
||||
journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
|
||||
title={Detection and Tracking Meet Drones Challenge},
|
||||
year={2021},
|
||||
volume={},
|
||||
number={},
|
||||
pages={1-1},
|
||||
doi={10.1109/TPAMI.2021.3119563}}
|
||||
```
|
||||
|
||||
We would like to acknowledge the AISKYEYE team at the Lab of Machine Learning and [Data Mining](https://www.ultralytics.com/glossary/data-mining), Tianjin University, China, for creating and maintaining the VisDrone dataset as a valuable resource for the drone-based computer vision research community. For more information about the VisDrone dataset and its creators, visit the [VisDrone Dataset GitHub repository](https://github.com/VisDrone/VisDrone-Dataset).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the VisDrone Dataset and what are its key features?
|
||||
|
||||
The [VisDrone Dataset](https://github.com/VisDrone/VisDrone-Dataset) is a large-scale benchmark created by the AISKYEYE team at Tianjin University, China. It is designed for various computer vision tasks related to drone-based image and video analysis. Key features include:
|
||||
|
||||
- **Composition**: 288 video clips with 261,908 frames and 10,209 static images.
|
||||
- **Annotations**: Over 2.6 million bounding boxes for objects like pedestrians, cars, bicycles, and tricycles.
|
||||
- **Diversity**: Collected across 14 cities, in urban and rural settings, under different weather and lighting conditions.
|
||||
- **Tasks**: Split into five main tasks—object detection in images and videos, single-object and multi-object tracking, and crowd counting.
|
||||
|
||||
### How can I use the VisDrone Dataset to train a YOLO26 model with Ultralytics?
|
||||
|
||||
To train a YOLO26 model on the VisDrone dataset for 100 epochs with an image size of 640, you can follow these steps:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VisDrone.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For additional configuration options, please refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the main subsets of the VisDrone dataset and their applications?
|
||||
|
||||
The VisDrone dataset is divided into five main subsets, each tailored for a specific computer vision task:
|
||||
|
||||
1. **Task 1**: Object detection in images.
|
||||
2. **Task 2**: Object detection in videos.
|
||||
3. **Task 3**: Single-object tracking.
|
||||
4. **Task 4**: Multi-object tracking.
|
||||
5. **Task 5**: Crowd counting.
|
||||
|
||||
These subsets are widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in drone-based applications such as surveillance, traffic monitoring, and public safety.
|
||||
|
||||
### Where can I find the configuration file for the VisDrone dataset in Ultralytics?
|
||||
|
||||
The configuration file for the VisDrone dataset, `VisDrone.yaml`, can be found in the Ultralytics repository at the following link:
|
||||
[VisDrone.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VisDrone.yaml).
|
||||
|
||||
### How can I cite the VisDrone dataset if I use it in my research?
|
||||
|
||||
If you use the VisDrone dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@ARTICLE{9573394,
|
||||
author={Zhu, Pengfei and Wen, Longyin and Du, Dawei and Bian, Xiao and Fan, Heng and Hu, Qinghua and Ling, Haibin},
|
||||
journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
|
||||
title={Detection and Tracking Meet Drones Challenge},
|
||||
year={2021},
|
||||
volume={},
|
||||
number={},
|
||||
pages={1-1},
|
||||
doi={10.1109/TPAMI.2021.3119563}
|
||||
}
|
||||
```
|
||||
@@ -1,148 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover the PASCAL VOC dataset, essential for object detection, segmentation, and classification. Learn key features, applications, and usage tips.
|
||||
keywords: PASCAL VOC, VOC dataset, object detection, segmentation, classification, YOLO, Faster R-CNN, Mask R-CNN, image annotations, computer vision
|
||||
---
|
||||
|
||||
# VOC Dataset
|
||||
|
||||
The [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) (Visual Object Classes) dataset is a well-known object detection, segmentation, and classification dataset. It is designed to encourage research on a wide variety of object categories and is commonly used for benchmarking computer vision models. It is an essential dataset for researchers and developers working on object detection, segmentation, and classification tasks.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/yrHzL8RyY6g"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on the Pascal VOC Dataset | Object Detection 🚀
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
||||
- VOC dataset includes two main challenges: VOC2007 and VOC2012.
|
||||
- The dataset comprises 20 object categories, including common objects like cars, bicycles, and animals, as well as more specific categories such as boats, sofas, and dining tables.
|
||||
- Annotations include object bounding boxes and class labels for object detection and classification tasks, and segmentation masks for the segmentation tasks.
|
||||
- VOC provides standardized evaluation metrics like [mean Average Precision](https://www.ultralytics.com/glossary/mean-average-precision-map) (mAP) for object detection and classification, making it suitable for comparing model performance.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The VOC dataset is split into three subsets:
|
||||
|
||||
1. **Train**: This subset contains images for training object detection, segmentation, and classification models.
|
||||
2. **Validation**: This subset has images used for validation purposes during model training.
|
||||
3. **Test**: This subset consists of images used for testing and benchmarking the trained models. Ground truth annotations for this subset are not publicly available, and the results were historically submitted to the PASCAL VOC evaluation server for performance evaluation.
|
||||
|
||||
## Applications
|
||||
|
||||
The VOC dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in object detection (such as [Ultralytics YOLO](https://docs.ultralytics.com/models/yolo26/), [Faster R-CNN](https://arxiv.org/abs/1506.01497), and [SSD](https://arxiv.org/abs/1512.02325)), [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) (such as [Mask R-CNN](https://arxiv.org/abs/1703.06870)), and [image classification](https://www.ultralytics.com/glossary/image-classification). The dataset's diverse set of object categories, large number of annotated images, and standardized evaluation metrics make it an essential resource for [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) researchers and practitioners.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the VOC dataset, the `VOC.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/VOC.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/VOC.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n model on the VOC dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VOC.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The VOC dataset contains a diverse set of images with various object categories and complex scenes. Here are some examples of images from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the VOC dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the VOC dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{everingham2010pascal,
|
||||
title={The PASCAL Visual Object Classes (VOC) Challenge},
|
||||
author={Mark Everingham and Luc Van Gool and Christopher K. I. Williams and John Winn and Andrew Zisserman},
|
||||
year={2010},
|
||||
eprint={0909.5206},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the PASCAL VOC Consortium for creating and maintaining this valuable resource for the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. For more information about the VOC dataset and its creators, visit the [PASCAL VOC dataset website](http://host.robots.ox.ac.uk/pascal/VOC/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the PASCAL VOC dataset and why is it important for computer vision tasks?
|
||||
|
||||
The [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) (Visual Object Classes) dataset is a renowned benchmark for [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and classification in computer vision. It includes comprehensive annotations like bounding boxes, class labels, and segmentation masks across 20 different object categories. Researchers use it widely to evaluate the performance of models like Faster R-CNN, YOLO, and Mask R-CNN due to its standardized evaluation metrics such as mean Average Precision (mAP).
|
||||
|
||||
### How do I train a YOLO26 model using the VOC dataset?
|
||||
|
||||
To train a YOLO26 model with the VOC dataset, you need the dataset configuration in a YAML file. Here's an example to start training a YOLO26n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VOC.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What are the primary challenges included in the VOC dataset?
|
||||
|
||||
The VOC dataset includes two main challenges: VOC2007 and VOC2012. These challenges test object detection, segmentation, and classification across 20 diverse object categories. Each image is meticulously annotated with bounding boxes, class labels, and segmentation masks. The challenges provide standardized metrics like mAP, facilitating the comparison and benchmarking of different computer vision models.
|
||||
|
||||
### How does the PASCAL VOC dataset enhance model benchmarking and evaluation?
|
||||
|
||||
The PASCAL VOC dataset enhances model benchmarking and evaluation through its detailed annotations and standardized metrics like mean Average [Precision](https://www.ultralytics.com/glossary/precision) (mAP). These metrics are crucial for assessing the performance of object detection and classification models. The dataset's diverse and complex images ensure comprehensive model evaluation across various real-world scenarios.
|
||||
|
||||
### How do I use the VOC dataset for [semantic segmentation](https://www.ultralytics.com/glossary/semantic-segmentation) in YOLO models?
|
||||
|
||||
To use the VOC dataset for semantic segmentation tasks with YOLO models, you need to configure the dataset properly in a YAML file. The YAML file defines paths and classes needed for training segmentation models. Check the VOC dataset YAML configuration file at [VOC.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml) for detailed setups. For segmentation tasks, you would use a segmentation-specific model like `yolo26n-seg.pt` instead of the detection model.
|
||||
@@ -1,188 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the xView dataset, a rich resource of 1M+ object instances in high-resolution satellite imagery. Enhance detection, learning efficiency, and more.
|
||||
keywords: xView dataset, overhead imagery, satellite images, object detection, high resolution, bounding boxes, computer vision, TensorFlow, PyTorch, dataset structure
|
||||
---
|
||||
|
||||
# xView Dataset
|
||||
|
||||
The [xView](http://xviewdataset.org/) dataset is one of the largest publicly available datasets of overhead imagery, containing images from complex scenes around the world annotated using bounding boxes. The goal of the xView dataset is to accelerate progress in four [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) frontiers:
|
||||
|
||||
1. Reduce minimum resolution for detection.
|
||||
2. Improve learning efficiency.
|
||||
3. Enable discovery of more object classes.
|
||||
4. Improve detection of fine-grained classes.
|
||||
|
||||
xView builds on the success of challenges like [Common Objects in Context (COCO)](../detect/coco.md) and aims to leverage computer vision to analyze the growing amount of available imagery from space in order to understand the visual world in new ways and address a range of important applications.
|
||||
|
||||
!!! warning "Manual Download Required"
|
||||
|
||||
The xView dataset is **not** automatically downloaded by Ultralytics scripts. You **must** manually download the dataset first from the official source:
|
||||
|
||||
- **Source:** DIUx xView 2018 Challenge by U.S. National Geospatial-Intelligence Agency (NGA)
|
||||
- **URL:** [https://challenge.xviewdataset.org](https://challenge.xviewdataset.org)
|
||||
|
||||
**Important:** After downloading the necessary files (e.g., `train_images.tif`, `val_images.tif`, `xView_train.geojson`), you need to extract them and place them into the correct directory structure, typically expected under a `datasets/xView/` folder, **before** running the training commands provided below. Ensure the dataset is properly set up as per the challenge instructions.
|
||||
|
||||
## Key Features
|
||||
|
||||
- xView contains over 1 million object instances across 60 classes.
|
||||
- The dataset has a resolution of 0.3 meters, providing higher resolution imagery than most public satellite imagery datasets.
|
||||
- xView features a diverse collection of small, rare, fine-grained, and multi-type objects with [bounding box](https://www.ultralytics.com/glossary/bounding-box) annotation.
|
||||
- Comes with a pretrained baseline model using the [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) object detection API and an example for [PyTorch](https://www.ultralytics.com/glossary/pytorch).
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The xView dataset is composed of satellite images collected from WorldView-3 satellites at a 0.3m ground sample distance. It contains over 1 million objects across 60 classes in over 1,400 km² of imagery. The dataset is particularly valuable for [remote sensing](https://www.ultralytics.com/blog/using-computer-vision-to-analyze-satellite-imagery) applications and environmental monitoring.
|
||||
|
||||
## Applications
|
||||
|
||||
The xView dataset is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models for object detection in overhead imagery. The dataset's diverse set of object classes and high-resolution imagery make it a valuable resource for researchers and practitioners in the field of computer vision, especially for satellite imagery analysis. Applications include:
|
||||
|
||||
- Military and defense reconnaissance
|
||||
- Urban planning and development
|
||||
- Environmental monitoring
|
||||
- Disaster response and assessment
|
||||
- Infrastructure mapping and management
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the xView dataset, the `xView.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/xView.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/xView.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/xView.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/xView.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a model on the xView dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="xView.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=xView.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The xView dataset contains high-resolution satellite images with a diverse set of objects annotated using bounding boxes. Here are some examples of data from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Overhead Imagery**: This image demonstrates an example of [object detection](https://www.ultralytics.com/glossary/object-detection) in overhead imagery, where objects are annotated with bounding boxes. The dataset provides high-resolution satellite images to facilitate the development of models for this task.
|
||||
|
||||
The example showcases the variety and complexity of the data in the xView dataset and highlights the importance of high-quality satellite imagery for object detection tasks.
|
||||
|
||||
## Related Datasets
|
||||
|
||||
If you're working with satellite imagery, you might also be interested in exploring these related datasets:
|
||||
|
||||
- [DOTA-v2](../obb/dota-v2.md): A dataset for oriented object detection in aerial images
|
||||
- [VisDrone](../detect/visdrone.md): A dataset for object detection and tracking in drone-captured imagery
|
||||
- [Argoverse](../detect/argoverse.md): A dataset for autonomous driving with 3D tracking annotations
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the xView dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lam2018xview,
|
||||
title={xView: Objects in Context in Overhead Imagery},
|
||||
author={Darius Lam and Richard Kuzma and Kevin McGee and Samuel Dooley and Michael Laielli and Matthew Klaric and Yaroslav Bulatov and Brendan McCord},
|
||||
year={2018},
|
||||
eprint={1802.07856},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the [Defense Innovation Unit](https://www.diu.mil/) (DIU) and the creators of the xView dataset for their valuable contribution to the computer vision research community. For more information about the xView dataset and its creators, visit the [xView dataset website](http://xviewdataset.org/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the xView dataset and how does it benefit computer vision research?
|
||||
|
||||
The [xView](http://xviewdataset.org/) dataset is one of the largest publicly available collections of high-resolution overhead imagery, containing over 1 million object instances across 60 classes. It is designed to enhance various facets of computer vision research such as reducing the minimum resolution for detection, improving learning efficiency, discovering more object classes, and advancing fine-grained object detection.
|
||||
|
||||
### How can I use Ultralytics YOLO to train a model on the xView dataset?
|
||||
|
||||
To train a model on the xView dataset using [Ultralytics YOLO](https://docs.ultralytics.com/models/yolo26/), follow these steps:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="xView.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=xView.yaml model=yolo26n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For detailed arguments and settings, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the key features of the xView dataset?
|
||||
|
||||
The xView dataset stands out due to its comprehensive set of features:
|
||||
|
||||
- Over 1 million object instances across 60 distinct classes.
|
||||
- High-resolution imagery at 0.3 meters.
|
||||
- Diverse object types including small, rare, and fine-grained objects, all annotated with bounding boxes.
|
||||
- Availability of a pretrained baseline model and examples in [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) and PyTorch.
|
||||
|
||||
### What is the dataset structure of xView, and how is it annotated?
|
||||
|
||||
The xView dataset contains high-resolution satellite imagery captured by WorldView-3 satellites at a 0.3m ground sample distance, covering over 1 million objects across 60 distinct classes within approximately 1,400 km² of annotated imagery. Each object is labeled with bounding boxes, making the dataset highly suitable for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models for object detection in overhead views. For a detailed breakdown, refer to the [Dataset Structure section](#dataset-structure).
|
||||
|
||||
### How do I cite the xView dataset in my research?
|
||||
|
||||
If you utilize the xView dataset in your research, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lam2018xview,
|
||||
title={xView: Objects in Context in Overhead Imagery},
|
||||
author={Darius Lam and Richard Kuzma and Kevin McGee and Samuel Dooley and Michael Laielli and Matthew Klaric and Yaroslav Bulatov and Brendan McCord},
|
||||
year={2018},
|
||||
eprint={1802.07856},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
For more information about the xView dataset, visit the official [xView dataset website](http://xviewdataset.org/).
|
||||
@@ -1,395 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics Explorer API for dataset exploration with SQL queries, vector similarity search, and semantic search. Learn installation and usage tips.
|
||||
keywords: Ultralytics, Explorer API, dataset exploration, SQL queries, similarity search, semantic search, Python API, embeddings, data analysis
|
||||
---
|
||||
|
||||
# Ultralytics Explorer API
|
||||
|
||||
!!! warning "Community Note ⚠️"
|
||||
|
||||
As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
|
||||
|
||||
## Introduction
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/docs/en/datasets/explorer/explorer.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
|
||||
The Explorer API is a Python API for exploring your datasets. It supports filtering and searching your dataset using SQL queries, vector similarity search, and semantic search.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/3VryynorQeo?start=279"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Ultralytics Explorer API Overview
|
||||
</p>
|
||||
|
||||
## Installation
|
||||
|
||||
Explorer depends on external libraries for some of its functionality. These are automatically installed when you use Explorer. To manually install these dependencies, use the following command:
|
||||
|
||||
```bash
|
||||
pip install ultralytics[explorer]
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# Create an Explorer object
|
||||
explorer = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
|
||||
# Create embeddings for your dataset
|
||||
explorer.create_embeddings_table()
|
||||
|
||||
# Search for similar images to a given image/images
|
||||
df = explorer.get_similar(img="path/to/image.jpg")
|
||||
|
||||
# Or search for similar images to a given index/indices
|
||||
df = explorer.get_similar(idx=0)
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
[Embeddings](https://www.ultralytics.com/glossary/embeddings) table for a given dataset and model pair is only created once and reused. These use [LanceDB](https://lancedb.github.io/lancedb/) under the hood, which scales on-disk, so you can create and reuse embeddings for large datasets like COCO without running out of memory.
|
||||
|
||||
In case you want to force update the embeddings table, you can pass `force=True` to `create_embeddings_table` method.
|
||||
|
||||
You can directly access the LanceDB table object to perform advanced analysis. Learn more about it in the [Working with Embeddings Table section](#4-working-with-embeddings-table)
|
||||
|
||||
## 1. Similarity Search
|
||||
|
||||
Similarity search is a technique for finding similar images to a given image. It is based on the idea that similar images will have similar embeddings. Once the embeddings table is built, you can get run semantic search in any of the following ways:
|
||||
|
||||
- On a given index or list of indices in the dataset: `exp.get_similar(idx=[1,10], limit=10)`
|
||||
- On any image or list of images not in the dataset: `exp.get_similar(img=["path/to/img1", "path/to/img2"], limit=10)`
|
||||
|
||||
In case of multiple inputs, the aggregate of their embeddings is used.
|
||||
|
||||
You get a pandas DataFrame with the `limit` number of most similar data points to the input, along with their distance in the embedding space. You can use this dataset to perform further filtering.
|
||||
|
||||
!!! example "Semantic Search"
|
||||
|
||||
=== "Using Images"
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
similar = exp.get_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
|
||||
print(similar.head())
|
||||
|
||||
# Search using multiple indices
|
||||
similar = exp.get_similar(
|
||||
img=["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/bus.jpg"],
|
||||
limit=10,
|
||||
)
|
||||
print(similar.head())
|
||||
```
|
||||
|
||||
=== "Using Dataset Indices"
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
similar = exp.get_similar(idx=1, limit=10)
|
||||
print(similar.head())
|
||||
|
||||
# Search using multiple indices
|
||||
similar = exp.get_similar(idx=[1, 10], limit=10)
|
||||
print(similar.head())
|
||||
```
|
||||
|
||||
### Plotting Similar Images
|
||||
|
||||
You can also plot the similar images using the `plot_similar` method. This method takes the same arguments as `get_similar` and plots the similar images in a grid.
|
||||
|
||||
!!! example "Plotting Similar Images"
|
||||
|
||||
=== "Using Images"
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
plt = exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
=== "Using Dataset Indices"
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
plt = exp.plot_similar(idx=1, limit=10)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
## 2. Ask AI (Natural Language Querying)
|
||||
|
||||
This feature lets you filter your dataset using natural language, without writing SQL. The AI-powered query generator converts your prompt into a query and returns matching results. For example, you can ask: "show me 100 images with exactly one person and 2 dogs. There can be other objects too" and it will generate the query and show you those results.
|
||||
Note: This feature uses LLMs, so results are probabilistic and may be inaccurate.
|
||||
|
||||
!!! example "Ask AI"
|
||||
|
||||
```python
|
||||
from ultralytics.data.explorer import plot_query_result
|
||||
|
||||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
df = exp.ask_ai("show me 100 images with exactly one person and 2 dogs. There can be other objects too")
|
||||
print(df.head())
|
||||
|
||||
# plot the results
|
||||
plt = plot_query_result(df)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
## 3. SQL Querying
|
||||
|
||||
You can run SQL queries on your dataset using the `sql_query` method. This method takes a SQL query as input and returns a pandas DataFrame with the results.
|
||||
|
||||
!!! example "SQL Query"
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
df = exp.sql_query("WHERE labels LIKE '%person%' AND labels LIKE '%dog%'")
|
||||
print(df.head())
|
||||
```
|
||||
|
||||
### Plotting SQL Query Results
|
||||
|
||||
You can also plot the results of a SQL query using the `plot_sql_query` method. This method takes the same arguments as `sql_query` and plots the results in a grid.
|
||||
|
||||
!!! example "Plotting SQL Query Results"
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
# plot the SQL Query
|
||||
exp.plot_sql_query("WHERE labels LIKE '%person%' AND labels LIKE '%dog%' LIMIT 10")
|
||||
```
|
||||
|
||||
## 4. Working with Embeddings Table
|
||||
|
||||
You can also work with the embeddings table directly. Once the embeddings table is created, you can access it using the `Explorer.table`
|
||||
|
||||
!!! tip
|
||||
|
||||
Explorer works on [LanceDB](https://lancedb.github.io/lancedb/) tables internally. You can access this table directly, using `Explorer.table` object and run raw queries, push down pre- and post-filters, etc.
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
exp = Explorer()
|
||||
exp.create_embeddings_table()
|
||||
table = exp.table
|
||||
```
|
||||
|
||||
Here are some examples of what you can do with the table:
|
||||
|
||||
### Get raw Embeddings
|
||||
|
||||
!!! example
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
exp = Explorer()
|
||||
exp.create_embeddings_table()
|
||||
table = exp.table
|
||||
|
||||
embeddings = table.to_pandas()["vector"]
|
||||
print(embeddings)
|
||||
```
|
||||
|
||||
### Advanced Querying with pre- and post-filters
|
||||
|
||||
!!! example
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
exp = Explorer(model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
table = exp.table
|
||||
|
||||
# Dummy embedding
|
||||
embedding = [i for i in range(256)]
|
||||
rs = table.search(embedding).metric("cosine").where("").limit(10)
|
||||
```
|
||||
|
||||
### Create Vector Index
|
||||
|
||||
When using large datasets, you can also create a dedicated vector index for faster querying. This is done using the `create_index` method on LanceDB table.
|
||||
|
||||
```python
|
||||
table.create_index(num_partitions=..., num_sub_vectors=...)
|
||||
```
|
||||
|
||||
## 5. Embeddings Applications
|
||||
|
||||
You can use the embeddings table to perform a variety of exploratory analysis. Here are some examples:
|
||||
|
||||
### Similarity Index
|
||||
|
||||
Explorer comes with a `similarity_index` operation:
|
||||
|
||||
- It tries to estimate how similar each data point is with the rest of the dataset.
|
||||
- It does that by counting how many image embeddings lie closer than `max_dist` to the current image in the generated embedding space, considering `top_k` similar images at a time.
|
||||
|
||||
It returns a pandas DataFrame with the following columns:
|
||||
|
||||
- `idx`: Index of the image in the dataset
|
||||
- `im_file`: Path to the image file
|
||||
- `count`: Number of images in the dataset that are closer than `max_dist` to the current image
|
||||
- `sim_im_files`: List of paths to the `count` similar images
|
||||
|
||||
!!! tip
|
||||
|
||||
For a given dataset, model, `max_dist` & `top_k` the similarity index once generated will be reused. In case, your dataset has changed, or you simply need to regenerate the similarity index, you can pass `force=True`.
|
||||
|
||||
!!! example "Similarity Index"
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
exp = Explorer()
|
||||
exp.create_embeddings_table()
|
||||
|
||||
sim_idx = exp.similarity_index()
|
||||
```
|
||||
|
||||
You can use similarity index to build custom conditions to filter out the dataset. For example, you can filter out images that are not similar to any other image in the dataset using the following code:
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
|
||||
sim_count = np.array(sim_idx["count"])
|
||||
sim_idx["im_file"][sim_count > 30]
|
||||
```
|
||||
|
||||
### Visualize Embedding Space
|
||||
|
||||
You can also visualize the embedding space using the plotting tool of your choice. For example here is a simple example using matplotlib:
|
||||
|
||||
```python
|
||||
import matplotlib.pyplot as plt
|
||||
from sklearn.decomposition import PCA
|
||||
|
||||
# Reduce dimensions using PCA to 3 components for visualization in 3D
|
||||
pca = PCA(n_components=3)
|
||||
reduced_data = pca.fit_transform(embeddings)
|
||||
|
||||
# Create a 3D scatter plot using Matplotlib Axes3D
|
||||
fig = plt.figure(figsize=(8, 6))
|
||||
ax = fig.add_subplot(111, projection="3d")
|
||||
|
||||
# Scatter plot
|
||||
ax.scatter(reduced_data[:, 0], reduced_data[:, 1], reduced_data[:, 2], alpha=0.5)
|
||||
ax.set_title("3D Scatter Plot of Reduced 256-Dimensional Data (PCA)")
|
||||
ax.set_xlabel("Component 1")
|
||||
ax.set_ylabel("Component 2")
|
||||
ax.set_zlabel("Component 3")
|
||||
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Start creating your own CV dataset exploration reports using the Explorer API. For inspiration, check out the [VOC Exploration Example](explorer.md).
|
||||
|
||||
## Apps Built Using Ultralytics Explorer
|
||||
|
||||
Try our [GUI Demo](dashboard.md) based on Explorer API
|
||||
|
||||
## Coming Soon
|
||||
|
||||
- [ ] Merge specific labels from datasets. Example - Import all `person` labels from COCO and `car` labels from Cityscapes
|
||||
- [ ] Remove images that have a higher similarity index than the given threshold
|
||||
- [ ] Automatically persist new datasets after merging/removing entries
|
||||
- [ ] Advanced Dataset Visualizations
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Ultralytics Explorer API used for?
|
||||
|
||||
The Ultralytics Explorer API is designed for comprehensive dataset exploration. It allows users to filter and search datasets using SQL queries, vector similarity search, and semantic search. This powerful Python API can handle large datasets, making it ideal for various [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks using Ultralytics models.
|
||||
|
||||
### How do I install the Ultralytics Explorer API?
|
||||
|
||||
To install the Ultralytics Explorer API along with its dependencies, use the following command:
|
||||
|
||||
```bash
|
||||
pip install ultralytics[explorer]
|
||||
```
|
||||
|
||||
This will automatically install all necessary external libraries for the Explorer API functionality. For additional setup details, refer to the [installation section](#installation) of our documentation.
|
||||
|
||||
### How can I use the Ultralytics Explorer API for similarity search?
|
||||
|
||||
You can use the Ultralytics Explorer API to perform similarity searches by creating an embeddings table and querying it for similar images. Here's a basic example:
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# Create an Explorer object
|
||||
explorer = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
explorer.create_embeddings_table()
|
||||
|
||||
# Search for similar images to a given image
|
||||
similar_images_df = explorer.get_similar(img="path/to/image.jpg")
|
||||
print(similar_images_df.head())
|
||||
```
|
||||
|
||||
For more details, please visit the [Similarity Search section](#1-similarity-search).
|
||||
|
||||
### What are the benefits of using LanceDB with Ultralytics Explorer?
|
||||
|
||||
LanceDB, used under the hood by Ultralytics Explorer, provides scalable, on-disk embeddings tables. This ensures that you can create and reuse embeddings for large datasets like COCO without running out of memory. These tables are only created once and can be reused, enhancing efficiency in data handling.
|
||||
|
||||
### How does the Ask AI feature work in the Ultralytics Explorer API?
|
||||
|
||||
The Ask AI feature allows users to filter datasets using natural language queries. This feature leverages LLMs to convert these queries into SQL queries behind the scenes. Here's an example:
|
||||
|
||||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
# Create an Explorer object
|
||||
explorer = Explorer(data="coco128.yaml", model="yolo26n.pt")
|
||||
explorer.create_embeddings_table()
|
||||
|
||||
# Query with natural language
|
||||
query_result = explorer.ask_ai("show me 100 images with exactly one person and 2 dogs. There can be other objects too")
|
||||
print(query_result.head())
|
||||
```
|
||||
|
||||
For more examples, check out the [Ask AI section](#2-ask-ai-natural-language-querying).
|
||||
@@ -1,127 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Unlock advanced data exploration with Ultralytics Explorer GUI. Utilize semantic search, run SQL queries, and ask AI for natural language data insights.
|
||||
keywords: Ultralytics Explorer GUI, semantic search, vector similarity, SQL queries, AI, natural language search, data exploration, machine learning, OpenAI, LLMs
|
||||
---
|
||||
|
||||
# Explorer GUI
|
||||
|
||||
!!! warning "Community Note ⚠️"
|
||||
|
||||
As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
|
||||
|
||||
Explorer GUI is built on the [Ultralytics Explorer API](api.md). It allows you to run semantic/vector similarity search, SQL queries, and natural language queries using the Ask AI feature powered by LLMs.
|
||||
|
||||
<p>
|
||||
<img width="1709" alt="Ultralytics Explorer GUI main dashboard interface" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-1.avif">
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/3VryynorQeo?start=306"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Ultralytics Explorer Dashboard Overview
|
||||
</p>
|
||||
|
||||
### Installation
|
||||
|
||||
```bash
|
||||
pip install ultralytics[explorer]
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
The Ask AI feature uses OpenAI, so you will be prompted to set the OpenAI API key when you first run the GUI.
|
||||
Set it with `yolo settings openai_api_key="..."`.
|
||||
|
||||
## Vector Semantic Similarity Search
|
||||
|
||||
[Semantic search](https://www.ultralytics.com/glossary/semantic-search) is a technique for finding similar images to a given image. It is based on the idea that similar images will have similar [embeddings](https://www.ultralytics.com/glossary/embeddings). In the UI, you can select one or more images and search for the images similar to them. This can be useful when you want to find images similar to a given image or a set of images that don't perform as expected.
|
||||
|
||||
For example, in this VOC Exploration dashboard, the user selects a few airplane images:
|
||||
|
||||
<p>
|
||||
<img width="1710" alt="Explorer selecting airplane images for similarity search" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-2.avif">
|
||||
</p>
|
||||
|
||||
After running the similarity search, you should see similar results:
|
||||
|
||||
<p>
|
||||
<img width="1710" alt="Ultralytics Explorer semantic similarity search" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-3.avif">
|
||||
</p>
|
||||
|
||||
## Ask AI
|
||||
|
||||
This feature lets you filter your dataset using natural language, without writing SQL. The AI-powered query generator converts your prompt into a query and returns matching results. For example, you can ask: "show me 100 images with exactly one person and 2 dogs. There can be other objects too" and it will generate the query and show you those results. Here is an example output when asked: "Show 10 images with exactly 5 persons":
|
||||
|
||||
<p>
|
||||
<img width="1709" alt="Explorer Ask AI results for images with 5 persons" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-4.avif">
|
||||
</p>
|
||||
|
||||
Note: This feature uses [Large Language Models](https://www.ultralytics.com/glossary/large-language-model-llm), so results are probabilistic and may be inaccurate.
|
||||
|
||||
## Run SQL queries on your CV datasets
|
||||
|
||||
You can run SQL queries on your dataset to filter it. It also works if you only provide the WHERE clause. For example, the following WHERE clause returns images that contain at least one person and one dog:
|
||||
|
||||
```sql
|
||||
WHERE labels LIKE '%person%' AND labels LIKE '%dog%'
|
||||
```
|
||||
|
||||
<p>
|
||||
<img width="1707" alt="Explorer SQL query filtering images with person and dog" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-5.avif">
|
||||
</p>
|
||||
|
||||
This demo was built using the Explorer API, which you can use to create your own exploratory notebooks or scripts for gaining insights into your datasets. To get started, check out the [Explorer API documentation](api.md).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is Ultralytics Explorer GUI and how do I install it?
|
||||
|
||||
Ultralytics Explorer GUI is a powerful interface that unlocks advanced data exploration capabilities using the [Ultralytics Explorer API](api.md). It allows you to run semantic/vector similarity search, SQL queries, and natural language queries using the Ask AI feature powered by [Large Language Models](https://www.ultralytics.com/glossary/large-language-model-llm) (LLMs).
|
||||
|
||||
To install the Explorer GUI, you can use pip:
|
||||
|
||||
```bash
|
||||
pip install ultralytics[explorer]
|
||||
```
|
||||
|
||||
Note: To use the Ask AI feature, you'll need to set the OpenAI API key: `yolo settings openai_api_key="..."`.
|
||||
|
||||
### How does the semantic search feature in Ultralytics Explorer GUI work?
|
||||
|
||||
The semantic search feature in Ultralytics Explorer GUI allows you to find images similar to a given image based on their embeddings. This technique is useful for identifying and exploring images that share visual similarities. To use this feature, select one or more images in the UI and execute a search for similar images. The result will display images that closely resemble the selected ones, facilitating efficient dataset exploration and [anomaly detection](https://www.ultralytics.com/glossary/anomaly-detection).
|
||||
|
||||
Learn more about semantic search and other features by visiting the [Feature Overview](#vector-semantic-similarity-search) section.
|
||||
|
||||
### Can I use natural language to filter datasets in Ultralytics Explorer GUI?
|
||||
|
||||
Yes, with the Ask AI feature powered by large language models (LLMs), you can filter your datasets using natural language queries. You don't need to be proficient in SQL. For instance, you can ask "Show me 100 images with exactly one person and 2 dogs. There can be other objects too," and the AI will generate the appropriate query under the hood to deliver the desired results.
|
||||
|
||||
### How do I run SQL queries on datasets using Ultralytics Explorer GUI?
|
||||
|
||||
Ultralytics Explorer GUI allows you to run SQL queries directly on your dataset to filter and manage data efficiently. To run a query, navigate to the SQL query section in the GUI and write your query. For example, to show images with at least one person and one dog, you could use:
|
||||
|
||||
```sql
|
||||
WHERE labels LIKE '%person%' AND labels LIKE '%dog%'
|
||||
```
|
||||
|
||||
You can also provide only the WHERE clause, making the querying process more flexible.
|
||||
|
||||
For more details, refer to the [SQL Queries Section](#run-sql-queries-on-your-cv-datasets).
|
||||
|
||||
### What are the benefits of using Ultralytics Explorer GUI for data exploration?
|
||||
|
||||
Ultralytics Explorer GUI enhances data exploration with features like semantic search, SQL querying, and natural language interactions through the Ask AI feature. These capabilities allow users to:
|
||||
|
||||
- Efficiently find visually similar images.
|
||||
- Filter datasets using complex SQL queries.
|
||||
- Utilize AI to perform natural language searches, eliminating the need for advanced SQL expertise.
|
||||
|
||||
These features make it a versatile tool for developers, researchers, and data scientists looking to gain deeper insights into their datasets.
|
||||
|
||||
Explore more about these features in the [Explorer GUI Documentation](#explorer-gui).
|
||||
@@ -1,277 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Dive into advanced data exploration with Ultralytics Explorer. Perform semantic searches, execute SQL queries, and leverage AI-powered natural language insights for seamless data analysis.
|
||||
keywords: Ultralytics Explorer, data exploration, semantic search, vector similarity, SQL queries, AI, natural language queries, machine learning, OpenAI, LLMs, Ultralytics Platform
|
||||
---
|
||||
|
||||
# VOC Exploration Example
|
||||
|
||||
<div align="center">
|
||||
|
||||
<a href="https://www.ultralytics.com/events/yolovision" target="_blank"><img width="100%" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/ultralytics-yolov8-banner.avif" alt="Ultralytics YOLO banner"></a>
|
||||
<a href="https://docs.ultralytics.com/zh/">中文</a> |
|
||||
<a href="https://docs.ultralytics.com/ko/">한국어</a> |
|
||||
<a href="https://docs.ultralytics.com/ja/">日本語</a> |
|
||||
<a href="https://docs.ultralytics.com/ru/">Русский</a> |
|
||||
<a href="https://docs.ultralytics.com/de/">Deutsch</a> |
|
||||
<a href="https://docs.ultralytics.com/fr/">Français</a> |
|
||||
<a href="https://docs.ultralytics.com/es">Español</a> |
|
||||
<a href="https://docs.ultralytics.com/pt/">Português</a> |
|
||||
<a href="https://docs.ultralytics.com/tr/">Türkçe</a> |
|
||||
<a href="https://docs.ultralytics.com/vi/">Tiếng Việt</a> |
|
||||
<a href="https://docs.ultralytics.com/ar/">العربية</a>
|
||||
<br>
|
||||
|
||||
<br>
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yml/badge.svg" alt="Ultralytics CI"></a>
|
||||
<a href="https://clickpy.clickhouse.com/dashboard/ultralytics"><img src="https://static.pepy.tech/badge/ultralytics" alt="Ultralytics Downloads"></a>
|
||||
<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="Ultralytics YOLO Citation"></a>
|
||||
<a href="https://discord.com/invite/ultralytics"><img alt="Ultralytics Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
|
||||
<a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a>
|
||||
<a href="https://www.reddit.com/r/ultralytics/"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
|
||||
<br>
|
||||
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run Ultralytics on Gradient"></a>
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Ultralytics In Colab"></a>
|
||||
<a href="https://www.kaggle.com/models/ultralytics/yolo26"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open Ultralytics In Kaggle"></a>
|
||||
<a href="https://mybinder.org/v2/gh/ultralytics/ultralytics/HEAD?labpath=examples%2Ftutorial.ipynb"><img src="https://mybinder.org/badge_logo.svg" alt="Open Ultralytics In Binder"></a>
|
||||
<br>
|
||||
</div>
|
||||
|
||||
Welcome to the Ultralytics Explorer API notebook. This notebook introduces the resources available for exploring datasets with semantic search, vector search, and SQL queries.
|
||||
|
||||
Try `yolo explorer` (powered by the Explorer API)
|
||||
|
||||
Install `ultralytics` and run `yolo explorer` in your terminal to run custom queries and semantic search in your browser.
|
||||
|
||||
!!! warning "Community Note ⚠️"
|
||||
|
||||
As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
|
||||
|
||||
## Setup
|
||||
|
||||
Install `ultralytics` and the required [dependencies](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml), then check software and hardware.
|
||||
|
||||
```bash
|
||||
!uv pip install ultralytics[explorer] openai
|
||||
yolo checks
|
||||
```
|
||||
|
||||
## Similarity Search
|
||||
|
||||
Utilize the power of vector similarity search to find the similar data points in your dataset along with their distance in the embedding space. Simply create an embeddings table for the given dataset-model pair. It is only needed once, and it is reused automatically.
|
||||
|
||||
```python
|
||||
exp = Explorer("VOC.yaml", model="yolo26n.pt")
|
||||
exp.create_embeddings_table()
|
||||
```
|
||||
|
||||
Once the embeddings table is built, you can run semantic search in any of the following ways:
|
||||
|
||||
- On a given index/list of indices in the dataset, e.g., `exp.get_similar(idx=[1, 10], limit=10)`
|
||||
- On any image/ list of images not in the dataset - exp.get_similar(img=["path/to/img1", "path/to/img2"], limit=10) In case of multiple inputs, the aggregate of their embeddings is used.
|
||||
|
||||
You get a pandas DataFrame with the limit number of most similar data points to the input, along with their distance in the embedding space. You can use this dataset to perform further filtering.
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Search dataset by index
|
||||
similar = exp.get_similar(idx=1, limit=10)
|
||||
similar.head()
|
||||
```
|
||||
|
||||
You can use the also plot the similar samples directly using the `plot_similar` util
|
||||
|
||||
|
||||
|
||||
```python
|
||||
exp.plot_similar(idx=6500, limit=20)
|
||||
exp.plot_similar(idx=[100, 101], limit=10) # Can also pass list of idxs or imgs
|
||||
|
||||
exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limit=10, labels=False) # Can also pass external images
|
||||
```
|
||||
|
||||
|
||||
|
||||
## Ask AI: Search or Filter with Natural Language
|
||||
|
||||
You can prompt the Explorer object with the kind of data points you want to see, and it will try to return a DataFrame with those results. Because it is powered by LLMs, it does not always get it right. In that case, it will return `None`.
|
||||
|
||||
|
||||
|
||||
```python
|
||||
df = exp.ask_ai("show me images containing more than 10 objects with at least 2 persons")
|
||||
df.head(5)
|
||||
```
|
||||
|
||||
To plot these results, you can use the `plot_query_result` utility. Example:
|
||||
|
||||
```python
|
||||
plt = plot_query_result(exp.ask_ai("show me 10 images containing exactly 2 persons"))
|
||||
Image.fromarray(plt)
|
||||
```
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# plot
|
||||
from PIL import Image
|
||||
from ultralytics.data.explorer import plot_query_result
|
||||
|
||||
plt = plot_query_result(exp.ask_ai("show me 10 images containing exactly 2 persons"))
|
||||
Image.fromarray(plt)
|
||||
```
|
||||
|
||||
## Run SQL Queries on Your Dataset
|
||||
|
||||
Sometimes you might want to investigate certain entries in your dataset. For this, Explorer allows you to execute SQL queries. It accepts either of the following formats:
|
||||
|
||||
- Queries beginning with "WHERE" will automatically select all columns. This can be thought of as a shorthand query.
|
||||
- You can also write full queries where you can specify which columns to select.
|
||||
|
||||
This can be used to investigate model performance and specific data points. For example:
|
||||
|
||||
- let's say your model struggles on images that have humans and dogs. You can write a query like this to select the points that have at least 2 humans AND at least one dog.
|
||||
|
||||
You can combine SQL query and semantic search to filter down to specific type of results
|
||||
|
||||
```python
|
||||
table = exp.sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10")
|
||||
exp.plot_sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10", labels=True)
|
||||
```
|
||||
|
||||
|
||||
|
||||
```python
|
||||
table = exp.sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10")
|
||||
print(table)
|
||||
```
|
||||
|
||||
Just like similarity search, you also get a util to directly plot the sql queries using `exp.plot_sql_query`
|
||||
|
||||
|
||||
|
||||
```python
|
||||
exp.plot_sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10", labels=True)
|
||||
```
|
||||
|
||||
## Working with embeddings Table (Advanced)
|
||||
|
||||
Explorer works on [LanceDB](https://lancedb.github.io/lancedb/) tables internally. You can access this table directly, using `Explorer.table` object and run raw queries, push down pre- and post-filters, etc.
|
||||
|
||||
```python
|
||||
table = exp.table
|
||||
print(table.schema)
|
||||
```
|
||||
|
||||
### Run raw queries¶
|
||||
|
||||
Vector Search finds the nearest vectors from the database. In a recommendation system or search engine, you can find similar products from the one you searched. In LLM and other AI applications, each data point can be presented by the embeddings generated from some models, it returns the most relevant features.
|
||||
|
||||
A search in high-dimensional vector space, is to find K-Nearest-Neighbors (KNN) of the query vector.
|
||||
|
||||
Metric In LanceDB, a Metric is the way to describe the distance between a pair of vectors. Currently, it supports the following metrics:
|
||||
|
||||
- L2
|
||||
- Cosine
|
||||
- Dot Explorer's similarity search uses L2 by default. You can run queries on tables directly, or use the lance format to build custom utilities to manage datasets. More details on available LanceDB table ops in the [docs](https://lancedb.github.io/lancedb/)
|
||||
|
||||
|
||||
|
||||
```python
|
||||
dummy_img_embedding = [i for i in range(256)]
|
||||
table.search(dummy_img_embedding).limit(5).to_pandas()
|
||||
```
|
||||
|
||||
### Interconversion to popular data formats
|
||||
|
||||
```python
|
||||
df = table.to_pandas()
|
||||
pa_table = table.to_arrow()
|
||||
```
|
||||
|
||||
### Work with Embeddings
|
||||
|
||||
You can access the raw embedding from lancedb Table and analyze it. The image embeddings are stored in column `vector`
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
|
||||
embeddings = table.to_pandas()["vector"].tolist()
|
||||
embeddings = np.array(embeddings)
|
||||
```
|
||||
|
||||
### Scatterplot
|
||||
|
||||
One of the preliminary steps in analyzing embeddings is by plotting them in 2D space via dimensionality reduction. Let's try an example
|
||||
|
||||
|
||||
|
||||
```python
|
||||
import matplotlib.pyplot as plt
|
||||
from sklearn.decomposition import PCA # pip install scikit-learn
|
||||
|
||||
# Reduce dimensions using PCA to 3 components for visualization in 3D
|
||||
pca = PCA(n_components=3)
|
||||
reduced_data = pca.fit_transform(embeddings)
|
||||
|
||||
# Create a 3D scatter plot using Matplotlib's Axes3D
|
||||
fig = plt.figure(figsize=(8, 6))
|
||||
ax = fig.add_subplot(111, projection="3d")
|
||||
|
||||
# Scatter plot
|
||||
ax.scatter(reduced_data[:, 0], reduced_data[:, 1], reduced_data[:, 2], alpha=0.5)
|
||||
ax.set_title("3D Scatter Plot of Reduced 256-Dimensional Data (PCA)")
|
||||
ax.set_xlabel("Component 1")
|
||||
ax.set_ylabel("Component 2")
|
||||
ax.set_zlabel("Component 3")
|
||||
|
||||
plt.show()
|
||||
```
|
||||
|
||||
### Similarity Index
|
||||
|
||||
Here's a simple example of an operation powered by the embeddings table. Explorer comes with a `similarity_index` operation-
|
||||
|
||||
- It tries to estimate how similar each data point is with the rest of the dataset.
|
||||
- It does that by counting how many image embeddings lie closer than max_dist to the current image in the generated embedding space, considering top_k similar images at a time.
|
||||
|
||||
For a given dataset, model, `max_dist` & `top_k` the similarity index once generated will be reused. In case, your dataset has changed, or you simply need to regenerate the similarity index, you can pass `force=True`. Similar to vector and SQL search, this also comes with a util to directly plot it. Let's look
|
||||
|
||||
```python
|
||||
sim_idx = exp.similarity_index(max_dist=0.2, top_k=0.01)
|
||||
exp.plot_similarity_index(max_dist=0.2, top_k=0.01)
|
||||
```
|
||||
|
||||
|
||||
|
||||
at the plot first
|
||||
|
||||
```python
|
||||
exp.plot_similarity_index(max_dist=0.2, top_k=0.01)
|
||||
```
|
||||
|
||||
Now let's look at the output of the operation
|
||||
|
||||
```python
|
||||
sim_idx = exp.similarity_index(max_dist=0.2, top_k=0.01, force=False)
|
||||
|
||||
sim_idx
|
||||
```
|
||||
|
||||
Let's create a query to see what data points have similarity count of more than 30 and plot images similar to them.
|
||||
|
||||
```python
|
||||
import numpy as np
|
||||
|
||||
sim_count = np.array(sim_idx["count"])
|
||||
sim_idx["im_file"][sim_count > 30]
|
||||
```
|
||||
|
||||
You should see something like this
|
||||
|
||||
|
||||
|
||||
```python
|
||||
exp.plot_similar(idx=[7146, 14035]) # Using avg embeddings of 2 images
|
||||
```
|
||||
@@ -1,113 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover Ultralytics Explorer for semantic search, SQL queries, vector similarity, and natural language dataset exploration.
|
||||
keywords: Ultralytics Explorer, CV datasets, semantic search, SQL queries, vector similarity, dataset visualization, python API, machine learning, computer vision
|
||||
---
|
||||
|
||||
# Ultralytics Explorer
|
||||
|
||||
!!! warning "Community Note ⚠️"
|
||||
|
||||
As of **`ultralytics>=8.3.10`**, Ultralytics Explorer support is deprecated. Similar (and expanded) dataset exploration features are available in [Ultralytics Platform](https://platform.ultralytics.com/).
|
||||
|
||||
<p>
|
||||
<img width="1709" alt="Ultralytics Explorer dataset visualization GUI" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/explorer-dashboard-screenshot-1.avif">
|
||||
</p>
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/docs/en/datasets/explorer/explorer.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
|
||||
|
||||
Ultralytics Explorer is a tool for exploring CV datasets using semantic search, SQL queries, vector similarity search, and natural language prompts. It also provides a Python API for accessing the same functionality.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/3VryynorQeo"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Ultralytics Explorer API | Semantic Search, SQL Queries & Ask AI Features
|
||||
</p>
|
||||
|
||||
## Installation of Optional Dependencies
|
||||
|
||||
Explorer depends on external libraries for some of its functionality. These are automatically installed when you use Explorer. To manually install these dependencies, use the following command:
|
||||
|
||||
```bash
|
||||
pip install ultralytics[explorer]
|
||||
```
|
||||
|
||||
!!! tip
|
||||
|
||||
Explorer works on embedding/semantic search & SQL querying and is powered by [LanceDB](https://lancedb.com/) serverless vector database. Unlike traditional in-memory DBs, it is persisted on disk without sacrificing performance, so you can scale locally to large datasets like COCO without running out of memory.
|
||||
|
||||
## Explorer API
|
||||
|
||||
This is a Python API for exploring your datasets. It also powers the GUI Explorer. You can use this to create your own exploratory notebooks or scripts to get insights into your datasets.
|
||||
|
||||
Explore the full capabilities and usage examples in the [Explorer API documentation](api.md).
|
||||
|
||||
## GUI Explorer Usage
|
||||
|
||||
The GUI demo runs in your browser allowing you to create [embeddings](https://www.ultralytics.com/glossary/embeddings) for your dataset and search for similar images, run SQL queries and perform semantic search. It can be run using the following command:
|
||||
|
||||
```bash
|
||||
yolo explorer
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
The Ask AI feature uses OpenAI, so you'll be prompted to set the API key for OpenAI when you first run the GUI.
|
||||
You can set it like this - `yolo settings openai_api_key="..."`
|
||||
|
||||
<p>
|
||||
<img width="1709" alt="Ultralytics Explorer OpenAI Integration" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/ultralytics-explorer-openai-integration.avif">
|
||||
</p>
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is Ultralytics Explorer and how can it help with CV datasets?
|
||||
|
||||
Ultralytics Explorer is a powerful tool designed for exploring [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) (CV) datasets through semantic search, SQL queries, vector similarity search, and even natural language. This versatile tool provides both a GUI and a Python API, allowing users to seamlessly interact with their datasets. By leveraging technologies like [LanceDB](https://lancedb.com/), Ultralytics Explorer ensures efficient, scalable access to large datasets without excessive memory usage. Whether you're performing detailed dataset analysis or exploring data patterns, Ultralytics Explorer streamlines the entire process.
|
||||
|
||||
Learn more about the [Explorer API](api.md).
|
||||
|
||||
### How do I install the dependencies for Ultralytics Explorer?
|
||||
|
||||
To manually install the optional dependencies needed for Ultralytics Explorer, you can use the following `pip` command:
|
||||
|
||||
```bash
|
||||
pip install ultralytics[explorer]
|
||||
```
|
||||
|
||||
These dependencies are essential for the full functionality of semantic search and SQL querying. By including libraries powered by [LanceDB](https://lancedb.com/), the installation ensures that the database operations remain efficient and scalable, even for large datasets like [COCO](../detect/coco.md).
|
||||
|
||||
### How can I use the GUI version of Ultralytics Explorer?
|
||||
|
||||
Using the GUI version of Ultralytics Explorer is straightforward. After installing the necessary dependencies, you can launch the GUI with the following command:
|
||||
|
||||
```bash
|
||||
yolo explorer
|
||||
```
|
||||
|
||||
The GUI provides a user-friendly interface for creating dataset embeddings, searching for similar images, running SQL queries, and conducting semantic searches. Additionally, the integration with OpenAI's Ask AI feature allows you to query datasets using natural language, enhancing the flexibility and ease of use.
|
||||
|
||||
For storage and scalability information, check out our [installation instructions](#installation-of-optional-dependencies).
|
||||
|
||||
### What is the Ask AI feature in Ultralytics Explorer?
|
||||
|
||||
The Ask AI feature in Ultralytics Explorer allows users to interact with their datasets using natural language queries. Powered by [OpenAI](https://www.ultralytics.com/blog/openai-gpt-4o-showcases-ai-potential), this feature enables you to ask complex questions and receive insightful answers without needing to write SQL queries or similar commands. To use this feature, you'll need to set your OpenAI API key the first time you run the GUI:
|
||||
|
||||
```bash
|
||||
yolo settings openai_api_key="YOUR_API_KEY"
|
||||
```
|
||||
|
||||
For more on this feature and how to integrate it, see our [GUI Explorer Usage](#gui-explorer-usage) section.
|
||||
|
||||
### Can I run Ultralytics Explorer in Google Colab?
|
||||
|
||||
Yes, Ultralytics Explorer can be run in Google Colab, providing a convenient and powerful environment for dataset exploration. You can start by opening the provided Colab notebook, which is pre-configured with all the necessary settings:
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/docs/en/datasets/explorer/explorer.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
|
||||
|
||||
This setup allows you to explore your datasets fully, taking advantage of Google's cloud resources. Learn more in our [Google Colab Guide](../../integrations/google-colab.md).
|
||||
@@ -1,239 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore Ultralytics' diverse datasets for vision tasks like detection, segmentation, classification, and more. Enhance your projects with high-quality annotated data.
|
||||
keywords: Ultralytics, datasets, computer vision, object detection, instance segmentation, pose estimation, image classification, multi-object tracking
|
||||
---
|
||||
|
||||
# Datasets Overview
|
||||
|
||||
Ultralytics provides support for various datasets to facilitate computer vision tasks such as detection, [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation), pose estimation, classification, and multi-object tracking. Below is a list of the main Ultralytics datasets, followed by a summary of each computer vision task and the respective datasets.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/YDXKa1EljmU"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Ultralytics Datasets Overview
|
||||
</p>
|
||||
|
||||
## [Object Detection](detect/index.md)
|
||||
|
||||
[Bounding box](https://www.ultralytics.com/glossary/bounding-box) object detection is a computer vision technique that involves detecting and localizing objects in an image by drawing a bounding box around each object.
|
||||
|
||||
- [African-wildlife](detect/african-wildlife.md): A dataset featuring images of African wildlife, including buffalo, elephants, rhinos, and zebras.
|
||||
- [Argoverse](detect/argoverse.md): A dataset containing 3D tracking and motion forecasting data from urban environments with rich annotations.
|
||||
- [Brain-tumor](detect/brain-tumor.md): A dataset for detecting brain tumors that includes MRI or CT scan images with details on tumor presence, location, and characteristics.
|
||||
- [COCO](detect/coco.md): Common Objects in Context (COCO) is a large-scale object detection, segmentation, and captioning dataset with 80 object categories.
|
||||
- [COCO8](detect/coco8.md): A smaller subset of the first 4 images from COCO train and COCO val, suitable for quick tests.
|
||||
- [COCO8-Grayscale](detect/coco8-grayscale.md): A grayscale version of COCO8 created by converting RGB to grayscale, useful for single-channel model evaluation.
|
||||
- [COCO8-Multispectral](detect/coco8-multispectral.md): A 10-channel multispectral version of COCO8 created by interpolating RGB wavelengths, useful for spectral-aware model evaluation.
|
||||
- [COCO128](detect/coco128.md): A smaller subset of the first 128 images from COCO train and COCO val, suitable for tests.
|
||||
- [Construction-PPE](detect/construction-ppe.md): A dataset of construction site imagery annotated with key safety gear such as helmets, vests, gloves, boots, and goggles, along with labels for missing equipment, supporting the development of AI models for compliance and worker protection.
|
||||
- [Global Wheat 2020](detect/globalwheat2020.md): A dataset containing images of wheat heads for the Global Wheat Challenge 2020.
|
||||
- [HomeObjects-3K](detect/homeobjects-3k.md): A dataset of annotated indoor scenes featuring 12 common household items, ideal for developing and testing computer vision models in smart home systems, robotics, and augmented reality.
|
||||
- [KITTI](detect/kitti.md) New: A well-known autonomous driving dataset featuring stereo, LiDAR, and GPS/IMU inputs, used for 2D object detection in varied road scenes.
|
||||
- [LVIS](detect/lvis.md): A large-scale object detection, segmentation, and captioning dataset with 1203 object categories.
|
||||
- [Medical-pills](detect/medical-pills.md): A dataset containing labeled images of medical pills, designed to aid in tasks like pharmaceutical quality control, sorting, and ensuring compliance with industry standards.
|
||||
- [Objects365](detect/objects365.md): A high-quality, large-scale dataset for object detection with 365 object categories and over 600K annotated images.
|
||||
- [OpenImagesV7](detect/open-images-v7.md): A comprehensive dataset by Google with 1.7M train images and 42k validation images.
|
||||
- [RF100](detect/roboflow-100.md): A diverse object detection benchmark with 100 datasets spanning seven imagery domains for comprehensive model evaluation.
|
||||
- [Signature](detect/signature.md): A dataset featuring images of various documents with annotated signatures, supporting document verification and fraud detection research.
|
||||
- [SKU-110K](detect/sku-110k.md): A dataset featuring dense object detection in retail environments with over 11K images and 1.7 million bounding boxes.
|
||||
- [VisDrone](detect/visdrone.md): A dataset containing object detection and multi-object tracking data from drone-captured imagery with over 10K images and video sequences.
|
||||
- [VOC](detect/voc.md): The Pascal Visual Object Classes (VOC) dataset for object detection and segmentation with 20 object classes and over 11K images.
|
||||
- [xView](detect/xview.md): A dataset for object detection in overhead imagery with 60 object categories and over 1 million annotated objects.
|
||||
|
||||
## [Instance Segmentation](segment/index.md)
|
||||
|
||||
Instance segmentation is a computer vision technique that involves identifying and localizing objects in an image at the pixel level. Unlike semantic segmentation which only classifies each pixel, [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) distinguishes between different instances of the same class.
|
||||
|
||||
- [Carparts-seg](segment/carparts-seg.md): Purpose-built dataset for identifying vehicle parts, catering to design, manufacturing, and research needs. It serves for both object detection and segmentation tasks.
|
||||
- [COCO](segment/coco.md): A large-scale dataset designed for object detection, segmentation, and captioning tasks with over 200K labeled images.
|
||||
- [COCO8-seg](segment/coco8-seg.md): A smaller dataset for instance segmentation tasks, containing a subset of 8 COCO images with segmentation annotations.
|
||||
- [COCO128-seg](segment/coco128-seg.md): A smaller dataset for instance segmentation tasks, containing a subset of 128 COCO images with segmentation annotations.
|
||||
- [Crack-seg](segment/crack-seg.md): Specifically crafted dataset for detecting cracks on roads and walls, applicable for both object detection and segmentation tasks.
|
||||
- [Package-seg](segment/package-seg.md): Tailored dataset for identifying packages in warehouses or industrial settings, suitable for both object detection and segmentation applications.
|
||||
|
||||
## [Pose Estimation](pose/index.md)
|
||||
|
||||
Pose estimation is a technique used to determine the pose of the object relative to the camera or the world coordinate system. This involves identifying key points or joints on objects, particularly humans or animals.
|
||||
|
||||
- [COCO](pose/coco.md): A large-scale dataset with human pose annotations designed for pose estimation tasks.
|
||||
- [COCO8-pose](pose/coco8-pose.md): A smaller dataset for pose estimation tasks, containing a subset of 8 COCO images with human pose annotations.
|
||||
- [Dog-pose](pose/dog-pose.md): A comprehensive dataset featuring approximately 6,000 images focused on dogs, annotated with 24 keypoints per dog, tailored for pose estimation tasks.
|
||||
- [Hand-Keypoints](pose/hand-keypoints.md): A concise dataset featuring over 26,000 images centered on human hands, annotated with 21 keypoints per hand, designed for pose estimation tasks.
|
||||
- [Tiger-pose](pose/tiger-pose.md): A compact dataset consisting of 263 images focused on tigers, annotated with 12 keypoints per tiger for pose estimation tasks.
|
||||
|
||||
## [Classification](classify/index.md)
|
||||
|
||||
[Image classification](https://www.ultralytics.com/glossary/image-classification) is a computer vision task that involves categorizing an image into one or more predefined classes or categories based on its visual content.
|
||||
|
||||
- [Caltech 101](classify/caltech101.md): A dataset containing images of 101 object categories for image classification tasks.
|
||||
- [Caltech 256](classify/caltech256.md): An extended version of Caltech 101 with 256 object categories and more challenging images.
|
||||
- [CIFAR-10](classify/cifar10.md): A dataset of 60K 32x32 color images in 10 classes, with 6K images per class.
|
||||
- [CIFAR-100](classify/cifar100.md): An extended version of CIFAR-10 with 100 object categories and 600 images per class.
|
||||
- [Fashion-MNIST](classify/fashion-mnist.md): A dataset consisting of 70,000 grayscale images of 10 fashion categories for image classification tasks.
|
||||
- [ImageNet](classify/imagenet.md): A large-scale dataset for object detection and image classification with over 14 million images and 20,000 categories.
|
||||
- [ImageNet-10](classify/imagenet10.md): A smaller subset of ImageNet with 10 categories for faster experimentation and testing.
|
||||
- [Imagenette](classify/imagenette.md): A smaller subset of ImageNet that contains 10 easily distinguishable classes for quicker training and testing.
|
||||
- [Imagewoof](classify/imagewoof.md): A more challenging subset of ImageNet containing 10 dog breed categories for image classification tasks.
|
||||
- [MNIST](classify/mnist.md): A dataset of 70,000 grayscale images of handwritten digits for image classification tasks.
|
||||
- [MNIST160](classify/mnist.md): First 8 images of each MNIST category from the MNIST dataset. Dataset contains 160 images total.
|
||||
|
||||
## [Oriented Bounding Boxes (OBB)](obb/index.md)
|
||||
|
||||
Oriented Bounding Boxes (OBB) is a method in computer vision for detecting angled objects in images using rotated bounding boxes, often applied to aerial and satellite imagery. Unlike traditional bounding boxes, OBB can better fit objects at various orientations.
|
||||
|
||||
- [DOTA-v2](obb/dota-v2.md): A popular OBB aerial imagery dataset with 1.7 million instances and 11,268 images.
|
||||
- [DOTA8](obb/dota8.md): A smaller subset of the first 8 images from the DOTAv1 split set, 4 for training and 4 for validation, suitable for quick tests.
|
||||
|
||||
## [Multi-Object Tracking](track/index.md)
|
||||
|
||||
Multi-object tracking is a computer vision technique that involves detecting and tracking multiple objects over time in a video sequence. This task extends object detection by maintaining consistent identities of objects across frames.
|
||||
|
||||
- [Argoverse](detect/argoverse.md): A dataset containing 3D tracking and motion forecasting data from urban environments with rich annotations for multi-object tracking tasks.
|
||||
- [VisDrone](detect/visdrone.md): A dataset containing object detection and multi-object tracking data from drone-captured imagery with over 10K images and video sequences.
|
||||
|
||||
## Contribute New Datasets
|
||||
|
||||
Contributing a new dataset involves several steps to ensure that it aligns well with the existing infrastructure. Below are the necessary steps:
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/yMR7BgwHQ3g?start=427"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Contribute to Ultralytics Datasets
|
||||
</p>
|
||||
|
||||
### Steps to Contribute a New Dataset
|
||||
|
||||
1. **Collect Images**: Gather the images that belong to the dataset. These could be collected from various sources, such as public databases or your own collection.
|
||||
2. **Annotate Images**: Annotate these images with bounding boxes, segments, or keypoints, depending on the task.
|
||||
3. **Export Annotations**: Convert these annotations into the YOLO `*.txt` file format which Ultralytics supports.
|
||||
4. **Organize Dataset**: Arrange your dataset into the correct folder structure. You should have `images/` and `labels/` top-level directories, and within each, a `train/` and `val/` subdirectory.
|
||||
|
||||
```
|
||||
dataset/
|
||||
├── images/
|
||||
│ ├── train/
|
||||
│ └── val/
|
||||
└── labels/
|
||||
├── train/
|
||||
└── val/
|
||||
```
|
||||
|
||||
5. **Create a `data.yaml` File**: In your dataset's root directory, create a `data.yaml` file that describes the dataset, classes, and other necessary information.
|
||||
6. **Optimize Images (Optional)**: If you want to reduce the size of the dataset for more efficient processing, you can optimize the images using the code below. This is not required, but recommended for smaller dataset sizes and faster download speeds.
|
||||
7. **Zip Dataset**: Compress the entire dataset folder into a zip file.
|
||||
8. **Document and PR**: Create a documentation page describing your dataset and how it fits into the existing framework. After that, submit a Pull Request (PR). Refer to [Ultralytics Contribution Guidelines](https://docs.ultralytics.com/help/contributing/) for more details on how to submit a PR.
|
||||
|
||||
### Example Code to Optimize and Zip a Dataset
|
||||
|
||||
!!! example "Optimize and Zip a Dataset"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from pathlib import Path
|
||||
|
||||
from ultralytics.data.utils import compress_one_image
|
||||
from ultralytics.utils.downloads import zip_directory
|
||||
|
||||
# Define dataset directory
|
||||
path = Path("path/to/dataset")
|
||||
|
||||
# Optimize images in dataset (optional)
|
||||
for f in path.rglob("*.jpg"):
|
||||
compress_one_image(f)
|
||||
|
||||
# Zip dataset into 'path/to/dataset.zip'
|
||||
zip_directory(path)
|
||||
```
|
||||
|
||||
By following these steps, you can contribute a new dataset that integrates well with Ultralytics' existing structure.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What datasets does Ultralytics support for object detection?
|
||||
|
||||
Ultralytics supports a wide variety of datasets for [object detection](https://www.ultralytics.com/glossary/object-detection), including:
|
||||
|
||||
- [COCO](detect/coco.md): A large-scale object detection, segmentation, and captioning dataset with 80 object categories.
|
||||
- [LVIS](detect/lvis.md): An extensive dataset with 1203 object categories, designed for more fine-grained object detection and segmentation.
|
||||
- [Argoverse](detect/argoverse.md): A dataset containing 3D tracking and motion forecasting data from urban environments with rich annotations.
|
||||
- [VisDrone](detect/visdrone.md): A dataset with object detection and multi-object tracking data from drone-captured imagery.
|
||||
- [SKU-110K](detect/sku-110k.md): Featuring dense object detection in retail environments with over 11K images.
|
||||
|
||||
These datasets facilitate training robust [Ultralytics YOLO](https://docs.ultralytics.com/models/) models for various object detection applications.
|
||||
|
||||
### How do I contribute a new dataset to Ultralytics?
|
||||
|
||||
Contributing a new dataset involves several steps:
|
||||
|
||||
1. **Collect Images**: Gather images from public databases or personal collections.
|
||||
2. **Annotate Images**: Apply bounding boxes, segments, or keypoints, depending on the task.
|
||||
3. **Export Annotations**: Convert annotations into the YOLO `*.txt` format.
|
||||
4. **Organize Dataset**: Use the folder structure with `train/` and `val/` directories, each containing `images/` and `labels/` subdirectories.
|
||||
5. **Create a `data.yaml` File**: Include dataset descriptions, classes, and other relevant information.
|
||||
6. **Optimize Images (Optional)**: Reduce dataset size for efficiency.
|
||||
7. **Zip Dataset**: Compress the dataset into a zip file.
|
||||
8. **Document and PR**: Describe your dataset and submit a Pull Request following [Ultralytics Contribution Guidelines](https://docs.ultralytics.com/help/contributing/).
|
||||
|
||||
Visit [Contribute New Datasets](#contribute-new-datasets) for a comprehensive guide.
|
||||
|
||||
### Why should I use Ultralytics Platform for my dataset?
|
||||
|
||||
[Ultralytics Platform](https://platform.ultralytics.com/) offers powerful features for dataset management and analysis, including:
|
||||
|
||||
- **Seamless Dataset Management**: Upload, organize, and manage your datasets in one place.
|
||||
- **Immediate Training Integration**: Use uploaded datasets directly for model training without additional setup.
|
||||
- **Visualization Tools**: Explore and visualize your dataset images and annotations.
|
||||
- **Dataset Analysis**: Get insights into your dataset distribution and characteristics.
|
||||
|
||||
The platform streamlines the transition from dataset management to model training, making the entire process more efficient. Learn more about [Ultralytics Platform Datasets](https://docs.ultralytics.com/platform/data/).
|
||||
|
||||
### What are the unique features of Ultralytics YOLO models for computer vision?
|
||||
|
||||
Ultralytics YOLO models provide several unique features for [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) tasks:
|
||||
|
||||
- **Real-time Performance**: High-speed inference and training capabilities for time-sensitive applications.
|
||||
- **Versatility**: Support for detection, segmentation, classification, and pose estimation tasks in a unified framework.
|
||||
- **Pretrained Models**: Access to high-performing, pretrained models for various applications, reducing training time.
|
||||
- **Extensive Community Support**: Active community and comprehensive documentation for troubleshooting and development.
|
||||
- **Easy Integration**: Simple API for integrating with existing projects and workflows.
|
||||
|
||||
Discover more about YOLO models on the [Ultralytics Models](https://docs.ultralytics.com/models/) page.
|
||||
|
||||
### How can I optimize and zip a dataset using Ultralytics tools?
|
||||
|
||||
To optimize and zip a dataset using Ultralytics tools, follow this example code:
|
||||
|
||||
!!! example "Optimize and Zip a Dataset"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from pathlib import Path
|
||||
|
||||
from ultralytics.data.utils import compress_one_image
|
||||
from ultralytics.utils.downloads import zip_directory
|
||||
|
||||
# Define dataset directory
|
||||
path = Path("path/to/dataset")
|
||||
|
||||
# Optimize images in dataset (optional)
|
||||
for f in path.rglob("*.jpg"):
|
||||
compress_one_image(f)
|
||||
|
||||
# Zip dataset into 'path/to/dataset.zip'
|
||||
zip_directory(path)
|
||||
```
|
||||
|
||||
This process helps reduce dataset size for more efficient storage and faster download speeds. Learn more on how to [Optimize and Zip a Dataset](#example-code-to-optimize-and-zip-a-dataset).
|
||||
@@ -1,250 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the DOTA dataset for object detection in aerial images, featuring 1.7M Oriented Bounding Boxes across 18 categories. Ideal for aerial image analysis.
|
||||
keywords: DOTA dataset, object detection, aerial images, oriented bounding boxes, OBB, DOTA v1.0, DOTA v1.5, DOTA v2.0, multiscale detection, Ultralytics
|
||||
---
|
||||
|
||||
# DOTA Dataset with OBB
|
||||
|
||||
[DOTA](https://captain-whu.github.io/DOTA/index.html) stands as a specialized dataset, emphasizing [object detection](https://www.ultralytics.com/glossary/object-detection) in aerial images. Originating from the DOTA series of datasets, it offers annotated images capturing a diverse array of aerial scenes with [Oriented Bounding Boxes (OBB)](https://docs.ultralytics.com/datasets/obb/).
|
||||
|
||||
|
||||
|
||||
## Key Features
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/JjQ-URE0LJE"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on the DOTA Dataset for Oriented Bounding Boxes in Google Colab
|
||||
</p>
|
||||
|
||||
- Collection from various sensors and platforms, with image sizes ranging from 800 × 800 to 20,000 × 20,000 pixels.
|
||||
- Features more than 1.7M oriented bounding boxes across 18 categories.
|
||||
- Encompasses multiscale object detection thanks to the wide spread of object sizes per image.
|
||||
- Instances are annotated by experts using arbitrary (8 d.o.f.) quadrilaterals, capturing objects of different scales, orientations, and shapes.
|
||||
|
||||
## Dataset Versions
|
||||
|
||||
### DOTA-v1.0
|
||||
|
||||
- Contains 15 common categories.
|
||||
- Comprises 2,806 images with 188,282 instances.
|
||||
- Split ratios: 1/2 for training, 1/6 for validation, and 1/3 for testing.
|
||||
|
||||
### DOTA-v1.5
|
||||
|
||||
- Incorporates the same images as DOTA-v1.0.
|
||||
- Very small instances (less than 10 pixels) are also annotated.
|
||||
- Addition of a new category: "container crane".
|
||||
- A total of 403,318 instances.
|
||||
- Released for the [DOAI Challenge 2019 on Object Detection in Aerial Images](https://captain-whu.github.io/DOAI2019/challenge.html).
|
||||
|
||||
### DOTA-v2.0
|
||||
|
||||
- Collections from Google Earth, GF-2 Satellite, and other aerial images.
|
||||
- Contains 18 common categories.
|
||||
- Comprises 11,268 images with a whopping 1,793,658 instances.
|
||||
- New categories introduced: "airport" and "helipad".
|
||||
- Image splits:
|
||||
- Training: 1,830 images with 268,627 instances.
|
||||
- Validation: 593 images with 81,048 instances.
|
||||
- Test-dev: 2,792 images with 353,346 instances.
|
||||
- Test-challenge: 6,053 images with 1,090,637 instances.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
DOTA exhibits a structured layout tailored for OBB object detection challenges:
|
||||
|
||||
- **Images**: A vast collection of high-resolution aerial images capturing diverse terrains and structures.
|
||||
- **Oriented Bounding Boxes**: Annotations in the form of rotated rectangles encapsulating objects irrespective of their orientation, ideal for capturing objects like airplanes, ships, and buildings.
|
||||
|
||||
## Applications
|
||||
|
||||
DOTA serves as a benchmark for training and evaluating models specifically tailored for aerial image analysis. With the inclusion of OBB annotations, it provides a unique challenge, enabling the development of specialized [object detection](https://docs.ultralytics.com/tasks/detect/) models that cater to aerial imagery's nuances. The dataset is particularly valuable for applications in remote sensing, surveillance, and environmental monitoring.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A dataset YAML (Yet Another Markup Language) file specifies image/label roots, class names, and other important metadata. Ultralytics maintains official YAML files for the two most commonly used releases:
|
||||
|
||||
- [`DOTAv1.yaml`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/DOTAv1.yaml)
|
||||
- [`DOTAv1.5.yaml`](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/DOTAv1.5.yaml)
|
||||
|
||||
Use the YAML that matches the release you downloaded, or author a custom YAML if you are working with DOTA-v2 or another derivative.
|
||||
|
||||
!!! example "DOTAv1.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/DOTAv1.yaml"
|
||||
```
|
||||
|
||||
## Split DOTA images
|
||||
|
||||
The raw imagery routinely exceeds 10,000 pixels on a side, so tiling is required before feeding the data to YOLO. Use the helper below to slice the source imagery into overlapping 1024 × 1024 crops at multiple scales while keeping the annotations in sync.
|
||||
|
||||
!!! example "Split images"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.data.split_dota import split_test, split_trainval
|
||||
|
||||
# Split train and val set, with labels.
|
||||
split_trainval(
|
||||
data_root="path/to/DOTAv1.0/",
|
||||
save_dir="path/to/DOTAv1.0-split/",
|
||||
rates=[0.5, 1.0, 1.5], # multiscale
|
||||
gap=500,
|
||||
)
|
||||
# Split test set, without labels.
|
||||
split_test(
|
||||
data_root="path/to/DOTAv1.0/",
|
||||
save_dir="path/to/DOTAv1.0-split/",
|
||||
rates=[0.5, 1.0, 1.5], # multiscale
|
||||
gap=500,
|
||||
)
|
||||
```
|
||||
|
||||
!!! tip
|
||||
|
||||
Keep the output directory organized in the standard YOLO layout (`images/train`, `labels/train`, etc.) so you can reference it directly from the dataset YAML.
|
||||
|
||||
## Usage
|
||||
|
||||
To train a model on the DOTA v1 dataset, you can utilize the following code snippets. Always refer to your model's documentation for a thorough list of available arguments. For those looking to experiment with a smaller subset first, consider using the [DOTA8 dataset](https://docs.ultralytics.com/datasets/obb/dota8/), which contains just 8 images for quick testing.
|
||||
|
||||
!!! warning
|
||||
|
||||
Please note that all images and associated annotations in the DOTAv1 dataset can be used for academic purposes, but commercial use is prohibited. Your understanding and respect for the dataset creators' wishes are greatly appreciated!
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLO26n-OBB model from scratch
|
||||
model = YOLO("yolo26n-obb.yaml")
|
||||
|
||||
# Train the model on the DOTAv1 dataset
|
||||
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLO26n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolo26n-obb.pt epochs=100 imgsz=1024
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
Having a glance at the dataset illustrates its depth:
|
||||
|
||||
|
||||
|
||||
- **DOTA examples**: This snapshot underlines the complexity of aerial scenes and the significance of Oriented [Bounding Box](https://www.ultralytics.com/glossary/bounding-box) annotations, capturing objects in their natural orientation.
|
||||
|
||||
The dataset's richness offers invaluable insights into object detection challenges exclusive to aerial imagery. The [DOTA-v2.0 dataset](https://www.ultralytics.com/blog/exploring-the-best-computer-vision-datasets-in-2025) has become particularly popular for remote sensing and aerial surveillance projects due to its comprehensive annotations and diverse object categories.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use DOTA in your work, please cite the relevant research papers:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{9560031,
|
||||
author={Ding, Jian and Xue, Nan and Xia, Gui-Song and Bai, Xiang and Yang, Wen and Yang, Michael and Belongie, Serge and Luo, Jiebo and Datcu, Mihai and Pelillo, Marcello and Zhang, Liangpei},
|
||||
journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
|
||||
title={Object Detection in Aerial Images: A Large-Scale Benchmark and Challenges},
|
||||
year={2021},
|
||||
volume={},
|
||||
number={},
|
||||
pages={1-1},
|
||||
doi={10.1109/TPAMI.2021.3117983}
|
||||
}
|
||||
```
|
||||
|
||||
A special note of gratitude to the team behind the DOTA datasets for their commendable effort in curating this dataset. For an exhaustive understanding of the dataset and its nuances, please visit the [official DOTA website](https://captain-whu.github.io/DOTA/index.html).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the DOTA dataset and why is it important for object detection in aerial images?
|
||||
|
||||
The [DOTA dataset](https://captain-whu.github.io/DOTA/index.html) is a specialized dataset focused on object detection in aerial images. It features Oriented Bounding Boxes (OBB), providing annotated images from diverse aerial scenes. DOTA's diversity in object orientation, scale, and shape across its 1.7M annotations and 18 categories makes it ideal for developing and evaluating models tailored for aerial imagery analysis, such as those used in surveillance, environmental monitoring, and disaster management.
|
||||
|
||||
### How does the DOTA dataset handle different scales and orientations in images?
|
||||
|
||||
DOTA utilizes Oriented Bounding Boxes (OBB) for annotation, which are represented by rotated rectangles encapsulating objects regardless of their orientation. This method ensures that objects, whether small or at different angles, are accurately captured. The dataset's multiscale images, ranging from 800 × 800 to 20,000 × 20,000 pixels, further allow for the detection of both small and large objects effectively. This approach is particularly valuable for aerial imagery where objects appear at various angles and scales.
|
||||
|
||||
### How can I train a model using the DOTA dataset?
|
||||
|
||||
To train a model on the DOTA dataset, you can use the following example with [Ultralytics YOLO](https://docs.ultralytics.com/tasks/obb/):
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLO26n-OBB model from scratch
|
||||
model = YOLO("yolo26n-obb.yaml")
|
||||
|
||||
# Train the model on the DOTAv1 dataset
|
||||
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLO26n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolo26n-obb.pt epochs=100 imgsz=1024
|
||||
```
|
||||
|
||||
For more details on how to split and preprocess the DOTA images, refer to the [split DOTA images section](#split-dota-images).
|
||||
|
||||
### What are the differences between DOTA-v1.0, DOTA-v1.5, and DOTA-v2.0?
|
||||
|
||||
- **DOTA-v1.0**: Includes 15 common categories across 2,806 images with 188,282 instances. The dataset is split into training, validation, and testing sets.
|
||||
- **DOTA-v1.5**: Builds upon DOTA-v1.0 by annotating very small instances (less than 10 pixels) and adding a new category, "container crane," totaling 403,318 instances.
|
||||
- **DOTA-v2.0**: Expands further with annotations from Google Earth and GF-2 Satellite, featuring 11,268 images and 1,793,658 instances. It includes new categories like "airport" and "helipad."
|
||||
|
||||
For a detailed comparison and additional specifics, check the [dataset versions section](#dataset-versions).
|
||||
|
||||
### How can I prepare high-resolution DOTA images for training?
|
||||
|
||||
DOTA images, which can be very large, are split into smaller resolutions for manageable training. Here's a Python snippet to split images:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.data.split_dota import split_test, split_trainval
|
||||
|
||||
# split train and val set, with labels.
|
||||
split_trainval(
|
||||
data_root="path/to/DOTAv1.0/",
|
||||
save_dir="path/to/DOTAv1.0-split/",
|
||||
rates=[0.5, 1.0, 1.5], # multiscale
|
||||
gap=500,
|
||||
)
|
||||
# split test set, without labels.
|
||||
split_test(
|
||||
data_root="path/to/DOTAv1.0/",
|
||||
save_dir="path/to/DOTAv1.0-split/",
|
||||
rates=[0.5, 1.0, 1.5], # multiscale
|
||||
gap=500,
|
||||
)
|
||||
```
|
||||
|
||||
This process facilitates better training efficiency and model performance. For detailed instructions, visit the [split DOTA images section](#split-dota-images).
|
||||
@@ -1,141 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the DOTA8 dataset - a small, versatile oriented object detection dataset ideal for testing and debugging object detection models using Ultralytics YOLO26.
|
||||
keywords: DOTA8 dataset, Ultralytics, YOLO26, object detection, debugging, training models, oriented object detection, dataset YAML
|
||||
---
|
||||
|
||||
# DOTA8 Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) DOTA8 is a small but versatile oriented [object detection](https://www.ultralytics.com/glossary/object-detection) dataset composed of the first 8 images of the split DOTAv1 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging object detection models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
- **Images**: 8 aerial tiles (4 train, 4 val) sourced from DOTAv1.
|
||||
- **Classes**: Inherits the 15 DOTAv1 categories such as plane, ship, and large vehicle.
|
||||
- **Labels**: YOLO-format oriented bounding boxes saved as `.txt` files beside each image.
|
||||
- **Recommended layout**:
|
||||
|
||||
```
|
||||
datasets/dota8/
|
||||
├── images/
|
||||
│ ├── train/
|
||||
│ └── val/
|
||||
└── labels/
|
||||
├── train/
|
||||
└── val/
|
||||
```
|
||||
|
||||
This dataset is intended for use with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the DOTA8 dataset, the `dota8.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dota8.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dota8.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/dota8.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/dota8.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-obb model on the DOTA8 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-obb.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo obb train data=dota8.yaml model=yolo26n-obb.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are some examples of images from the DOTA8 dataset, along with their corresponding annotations:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch.avif" alt="DOTA8 oriented bounding box dataset training mosaic" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the DOTA8 dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the DOTA dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{9560031,
|
||||
author={Ding, Jian and Xue, Nan and Xia, Gui-Song and Bai, Xiang and Yang, Wen and Yang, Michael and Belongie, Serge and Luo, Jiebo and Datcu, Mihai and Pelillo, Marcello and Zhang, Liangpei},
|
||||
journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
|
||||
title={Object Detection in Aerial Images: A Large-Scale Benchmark and Challenges},
|
||||
year={2021},
|
||||
volume={},
|
||||
number={},
|
||||
pages={1-1},
|
||||
doi={10.1109/TPAMI.2021.3117983}
|
||||
}
|
||||
```
|
||||
|
||||
A special note of gratitude to the team behind the DOTA datasets for their commendable effort in curating this dataset. For an exhaustive understanding of the dataset and its nuances, please visit the [official DOTA website](https://captain-whu.github.io/DOTA/index.html).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the DOTA8 dataset and how can it be used?
|
||||
|
||||
The DOTA8 dataset is a small, versatile oriented object detection dataset made up of the first 8 images from the DOTAv1 split set, with 4 images designated for training and 4 for validation. It's ideal for testing and debugging object detection models like Ultralytics YOLO26. Due to its manageable size and diversity, it helps in identifying pipeline errors and running sanity checks before deploying larger datasets. Learn more about object detection with [Ultralytics YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
### How do I train a YOLO26 model using the DOTA8 dataset?
|
||||
|
||||
To train a YOLO26n-obb model on the DOTA8 dataset for 100 epochs with an image size of 640, you can use the following code snippets. For comprehensive argument options, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-obb.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo obb train data=dota8.yaml model=yolo26n-obb.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What are the key features of the DOTA dataset and where can I access the YAML file?
|
||||
|
||||
The DOTA dataset is known for its large-scale benchmark and the challenges it presents for object detection in aerial images. The DOTA8 subset is a smaller, manageable dataset ideal for initial tests. You can access the `dota8.yaml` file, which contains paths, classes, and configuration details, at this [GitHub link](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dota8.yaml).
|
||||
|
||||
### How does mosaicing enhance model training with the DOTA8 dataset?
|
||||
|
||||
Mosaicing combines multiple images into one during training, increasing the variety of objects and contexts within each batch. This improves a model's ability to generalize to different object sizes, aspect ratios, and scenes. This technique can be visually demonstrated through a training batch composed of mosaiced DOTA8 dataset images, helping in robust model development. Explore more about mosaicing and training techniques on our [Training](../../modes/train.md) page.
|
||||
|
||||
### Why should I use Ultralytics YOLO26 for object detection tasks?
|
||||
|
||||
Ultralytics YOLO26 provides state-of-the-art real-time object detection capabilities, including features like oriented bounding boxes (OBB), [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation), and a highly versatile training pipeline. It's suitable for various applications and offers pretrained models for efficient fine-tuning. Explore further about the advantages and usage in the [Ultralytics YOLO26 documentation](https://github.com/ultralytics/ultralytics).
|
||||
@@ -1,157 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover OBB dataset formats for Ultralytics YOLO models. Learn about their structure, application, and format conversions to enhance your object detection training.
|
||||
keywords: Oriented Bounding Box, OBB Datasets, YOLO, Ultralytics, Object Detection, Dataset Formats
|
||||
---
|
||||
|
||||
# Oriented Bounding Box (OBB) Datasets Overview
|
||||
|
||||
Training a precise [object detection](https://www.ultralytics.com/glossary/object-detection) model with oriented bounding boxes (OBB) requires a thorough dataset. This guide explains the various OBB dataset formats compatible with Ultralytics YOLO models, offering insights into their structure, application, and methods for format conversions.
|
||||
|
||||
## Supported OBB Dataset Formats
|
||||
|
||||
### YOLO OBB Format
|
||||
|
||||
The YOLO OBB format designates bounding boxes by their four corner points with coordinates normalized between 0 and 1. It follows this format:
|
||||
|
||||
```bash
|
||||
class_index x1 y1 x2 y2 x3 y3 x4 y4
|
||||
```
|
||||
|
||||
Internally, YOLO processes losses and outputs in the `xywhr` format, which represents the [bounding box](https://www.ultralytics.com/glossary/bounding-box)'s center point (xy), width, height, and rotation.
|
||||
|
||||
<p align="center"><img width="800" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/obb-format-examples.avif" alt="Oriented bounding box annotation format examples"></p>
|
||||
|
||||
An example of a `*.txt` label file for the above image, which contains an object of class `0` in OBB format, could look like:
|
||||
|
||||
```bash
|
||||
0 0.780811 0.743961 0.782371 0.74686 0.777691 0.752174 0.776131 0.749758
|
||||
```
|
||||
|
||||
### Dataset YAML format
|
||||
|
||||
The Ultralytics framework uses a YAML file format to define the dataset and model configuration for training OBB models. Here is an example of the YAML format used for defining an OBB dataset:
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/dota8.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/dota8.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a model using these OBB formats:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLO26n-OBB model from scratch
|
||||
model = YOLO("yolo26n-obb.yaml")
|
||||
|
||||
# Train the model on the DOTAv1 dataset
|
||||
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLO26n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolo26n-obb.pt epochs=100 imgsz=1024
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
||||
Currently, the following datasets with oriented bounding boxes are supported:
|
||||
|
||||
- [DOTA-v1](dota-v2.md#dota-v10): The first version of the DOTA dataset, providing a comprehensive set of aerial images with oriented bounding boxes for object detection.
|
||||
- [DOTA-v1.5](dota-v2.md#dota-v15): An intermediate version of the DOTA dataset, offering additional annotations and improvements over DOTA-v1 for enhanced object detection tasks.
|
||||
- [DOTA-v2](dota-v2.md#dota-v20): DOTA (A Large-scale Dataset for Object Detection in Aerial Images) version 2, emphasizes detection from aerial perspectives and contains oriented bounding boxes with 1.7 million instances and 11,268 images.
|
||||
- [DOTA8](dota8.md): A small, 8-image subset of the full DOTA dataset suitable for testing workflows and Continuous Integration (CI) checks of OBB training in the `ultralytics` repository.
|
||||
|
||||
### Incorporating your own OBB dataset
|
||||
|
||||
For those looking to introduce their own datasets with oriented bounding boxes, ensure compatibility with the "YOLO OBB format" mentioned above. Convert your annotations to this required format and detail the paths, classes, and class names in a corresponding YAML configuration file.
|
||||
|
||||
## Convert Label Formats
|
||||
|
||||
### DOTA Dataset Format to YOLO OBB Format
|
||||
|
||||
Transitioning labels from the DOTA dataset format to the YOLO OBB format can be achieved with this script:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_dota_to_yolo_obb
|
||||
|
||||
convert_dota_to_yolo_obb("path/to/DOTA")
|
||||
```
|
||||
|
||||
This conversion mechanism is instrumental for datasets in the DOTA format, ensuring alignment with the [Ultralytics YOLO](../../models/yolo26.md) OBB format.
|
||||
|
||||
It's imperative to validate the compatibility of the dataset with your model and adhere to the necessary format conventions. Properly structured datasets are pivotal for training efficient object detection models with oriented bounding boxes.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What are Oriented Bounding Boxes (OBB) and how are they used in Ultralytics YOLO models?
|
||||
|
||||
Oriented Bounding Boxes (OBB) are a type of bounding box annotation where the box can be rotated to align more closely with the object being detected, rather than just being axis-aligned. This is particularly useful in aerial or satellite imagery where objects might not be aligned with the image axes. In [Ultralytics YOLO](../../tasks/obb.md) models, OBBs are represented by their four corner points in the YOLO OBB format. This allows for more accurate object detection since the bounding boxes can rotate to fit the objects better.
|
||||
|
||||
### How do I convert my existing DOTA dataset labels to YOLO OBB format for use with Ultralytics YOLO26?
|
||||
|
||||
You can convert DOTA dataset labels to YOLO OBB format using the [`convert_dota_to_yolo_obb`](../../reference/data/converter.md) function from Ultralytics. This conversion ensures compatibility with the Ultralytics YOLO models, enabling you to leverage the OBB capabilities for enhanced object detection. Here's a quick example:
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_dota_to_yolo_obb
|
||||
|
||||
convert_dota_to_yolo_obb("path/to/DOTA")
|
||||
```
|
||||
|
||||
This script will reformat your DOTA annotations into a YOLO-compatible format.
|
||||
|
||||
### How do I train a YOLO26 model with oriented bounding boxes (OBB) on my dataset?
|
||||
|
||||
Training a YOLO26 model with OBBs involves ensuring your dataset is in the YOLO OBB format and then using the [Ultralytics API](../../usage/python.md) to train the model. Here's an example in both Python and CLI:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLO26n-OBB model from scratch
|
||||
model = YOLO("yolo26n-obb.yaml")
|
||||
|
||||
# Train the model on the custom dataset
|
||||
results = model.train(data="your_dataset.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLO26n-OBB model on the custom dataset
|
||||
yolo obb train data=your_dataset.yaml model=yolo26n-obb.yaml epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
This ensures your model leverages the detailed OBB annotations for improved detection [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
|
||||
### What datasets are currently supported for OBB training in Ultralytics YOLO models?
|
||||
|
||||
Currently, Ultralytics supports the following datasets for OBB training:
|
||||
|
||||
- [DOTA-v1](dota-v2.md): The first version of the DOTA dataset, providing a comprehensive set of aerial images with oriented bounding boxes for object detection.
|
||||
- [DOTA-v1.5](dota-v2.md): An intermediate version of the DOTA dataset, offering additional annotations and improvements over DOTA-v1 for enhanced object detection tasks.
|
||||
- [DOTA-v2](dota-v2.md): This dataset includes 1.7 million instances with oriented bounding boxes and 11,268 images, primarily focusing on aerial object detection.
|
||||
- [DOTA8](dota8.md): A smaller, 8-image subset of the DOTA dataset used for testing and [continuous integration](../../help/CI.md) (CI) checks.
|
||||
|
||||
These datasets are tailored for scenarios where OBBs offer a significant advantage, such as aerial and satellite image analysis.
|
||||
|
||||
### Can I use my own dataset with oriented bounding boxes for YOLO26 training, and if so, how?
|
||||
|
||||
Yes, you can use your own dataset with oriented bounding boxes for YOLO26 training. Ensure your dataset annotations are converted to the YOLO OBB format, which involves defining bounding boxes by their four corner points. You can then create a [YAML configuration file](../../usage/cfg.md) specifying the dataset paths, classes, and other necessary details. For more information on creating and configuring your datasets, refer to the [Supported Datasets](#supported-datasets) section.
|
||||
@@ -1,152 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the COCO-Pose dataset for advanced pose estimation. Learn about datasets, pretrained models, metrics, and applications for training with YOLO.
|
||||
keywords: COCO-Pose, pose estimation, dataset, keypoints, COCO Keypoints 2017, YOLO, deep learning, computer vision
|
||||
---
|
||||
|
||||
# COCO-Pose Dataset
|
||||
|
||||
The [COCO-Pose](https://cocodataset.org/#keypoints-2017) dataset is a specialized version of the COCO (Common Objects in Context) dataset, designed for pose estimation tasks. It leverages the COCO Keypoints 2017 images and labels to enable the training of models like YOLO for pose estimation tasks.
|
||||
|
||||
|
||||
|
||||
## COCO-Pose Pretrained Models
|
||||
|
||||
{% include "macros/yolo-pose-perf.md" %}
|
||||
|
||||
## Key Features
|
||||
|
||||
- COCO-Pose builds upon the COCO Keypoints 2017 dataset which contains 200K images labeled with keypoints for pose estimation tasks.
|
||||
- The dataset supports 17 keypoints for human figures, facilitating detailed pose estimation.
|
||||
- Like COCO, it provides standardized evaluation metrics, including Object Keypoint Similarity (OKS) for pose estimation tasks, making it suitable for comparing model performance.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The COCO-Pose dataset is split into three subsets:
|
||||
|
||||
1. **Train2017**: This subset contains 56599 images from the COCO dataset, annotated for training pose estimation models.
|
||||
2. **Val2017**: This subset has 2346 images used for validation purposes during model training.
|
||||
3. **Test2017**: This subset consists of images used for testing and benchmarking the trained models. Ground truth annotations for this subset are not publicly available, and the results are submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7384) for performance evaluation.
|
||||
|
||||
## Applications
|
||||
|
||||
The COCO-Pose dataset is specifically used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in keypoint detection and pose estimation tasks, such as OpenPose. The dataset's large number of annotated images and standardized evaluation metrics make it an essential resource for [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) researchers and practitioners focused on pose estimation.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO-Pose dataset, the `coco-pose.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco-pose.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco-pose.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-pose model on the COCO-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The COCO-Pose dataset contains a diverse set of images with human figures annotated with keypoints. Here are some examples of images from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the COCO-Pose dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO-Pose dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the COCO-Pose dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO-Pose dataset and how is it used with Ultralytics YOLO for pose estimation?
|
||||
|
||||
The [COCO-Pose](https://cocodataset.org/#keypoints-2017) dataset is a specialized version of the COCO (Common Objects in Context) dataset designed for pose estimation tasks. It builds upon the COCO Keypoints 2017 images and annotations, allowing for the training of models like Ultralytics YOLO for detailed pose estimation. For instance, you can use the COCO-Pose dataset to train a YOLO26n-pose model by loading a pretrained model and training it with a YAML configuration. For training examples, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### How can I train a YOLO26 model on the COCO-Pose dataset?
|
||||
|
||||
Training a YOLO26 model on the COCO-Pose dataset can be accomplished using either Python or CLI commands. For example, to train a YOLO26n-pose model for 100 epochs with an image size of 640, you can follow the steps below:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details on the training process and available arguments, check the [training page](../../modes/train.md).
|
||||
|
||||
### What are the different metrics provided by the COCO-Pose dataset for evaluating model performance?
|
||||
|
||||
The COCO-Pose dataset provides several standardized evaluation metrics for pose estimation tasks, similar to the original COCO dataset. Key metrics include the Object Keypoint Similarity (OKS), which evaluates the [accuracy](https://www.ultralytics.com/glossary/accuracy) of predicted keypoints against ground truth annotations. These metrics allow for thorough performance comparisons between different models. For instance, the COCO-Pose pretrained models such as YOLO26n-pose, YOLO26s-pose, and others have specific performance metrics listed in the documentation, like mAP<sup>pose</sup>50-95 and mAP<sup>pose</sup>50.
|
||||
|
||||
### How is the dataset structured and split for the COCO-Pose dataset?
|
||||
|
||||
The COCO-Pose dataset is split into three subsets:
|
||||
|
||||
1. **Train2017**: Contains 56599 COCO images, annotated for training pose estimation models.
|
||||
2. **Val2017**: 2346 images for validation purposes during model training.
|
||||
3. **Test2017**: Images used for testing and benchmarking trained models. Ground truth annotations for this subset are not publicly available; results are submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7403) for performance evaluation.
|
||||
|
||||
These subsets help organize the training, validation, and testing phases effectively. For configuration details, explore the `coco-pose.yaml` file available on [GitHub](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml).
|
||||
|
||||
### What are the key features and applications of the COCO-Pose dataset?
|
||||
|
||||
The COCO-Pose dataset extends the COCO Keypoints 2017 annotations to include 17 keypoints for human figures, enabling detailed pose estimation. Standardized evaluation metrics (e.g., OKS) facilitate comparisons across different models. Applications of the COCO-Pose dataset span various domains, such as sports analytics, healthcare, and human-computer interaction, wherever detailed pose estimation of human figures is required. For practical use, leveraging pretrained models like those provided in the documentation (e.g., YOLO26n-pose) can significantly streamline the process ([Key Features](#key-features)).
|
||||
|
||||
If you use the COCO-Pose dataset in your research or development work, please cite the paper with the following [BibTeX entry](#citations-and-acknowledgments).
|
||||
@@ -1,137 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the compact, versatile COCO8-Pose dataset for testing and debugging object detection models. Ideal for quick experiments with YOLO26.
|
||||
keywords: COCO8-Pose, Ultralytics, pose detection dataset, object detection, YOLO26, machine learning, computer vision, training data
|
||||
---
|
||||
|
||||
# COCO8-Pose Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) COCO8-Pose is a small but versatile pose detection dataset composed of the first 8 images of the COCO train 2017 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging [object detection](https://www.ultralytics.com/glossary/object-detection) models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
- **Total images**: 8 (4 train / 4 val).
|
||||
- **Classes**: 1 (person) with 17 keypoints per annotation.
|
||||
- **Recommended directory layout**: `datasets/coco8-pose/images/{train,val}` and `datasets/coco8-pose/labels/{train,val}` with YOLO-format keypoints stored as `.txt` files.
|
||||
|
||||
This dataset is intended for use with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO8-Pose dataset, the `coco8-pose.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8-pose.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-pose.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-pose model on the COCO8-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco8-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are some examples of images from the COCO8-Pose dataset, along with their corresponding annotations:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch-5.avif" alt="COCO8-pose keypoint estimation dataset mosaic" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the COCO8-Pose dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO8-Pose dataset, and how is it used with Ultralytics YOLO26?
|
||||
|
||||
The COCO8-Pose dataset is a small, versatile pose detection dataset that includes the first 8 images from the COCO train 2017 set, with 4 images for training and 4 for validation. It's designed for testing and debugging object detection models and experimenting with new detection approaches. This dataset is ideal for quick experiments with [Ultralytics YOLO26](../../models/yolo26.md). For more details on dataset configuration, check out the [dataset YAML file](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml).
|
||||
|
||||
### How do I train a YOLO26 model using the COCO8-Pose dataset in Ultralytics?
|
||||
|
||||
To train a YOLO26n-pose model on the COCO8-Pose dataset for 100 epochs with an image size of 640, follow these examples:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose train data=coco8-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of training arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the benefits of using the COCO8-Pose dataset?
|
||||
|
||||
The COCO8-Pose dataset offers several benefits:
|
||||
|
||||
- **Compact Size**: With only 8 images, it is easy to manage and perfect for quick experiments.
|
||||
- **Diverse Data**: Despite its small size, it includes a variety of scenes, useful for thorough pipeline testing.
|
||||
- **Error Debugging**: Ideal for identifying training errors and performing sanity checks before scaling up to larger datasets.
|
||||
|
||||
For more about its features and usage, see the [Dataset Introduction](#introduction) section.
|
||||
|
||||
### How does mosaicing benefit the YOLO26 training process using the COCO8-Pose dataset?
|
||||
|
||||
Mosaicing, demonstrated in the sample images of the COCO8-Pose dataset, combines multiple images into one, increasing the variety of objects and scenes within each training batch. This technique helps improve the model's ability to generalize across various object sizes, aspect ratios, and contexts, ultimately enhancing model performance. See the [Sample Images and Annotations](#sample-images-and-annotations) section for example images.
|
||||
|
||||
### Where can I find the COCO8-Pose dataset YAML file and how do I use it?
|
||||
|
||||
The COCO8-Pose dataset YAML file can be found at <https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml>. This file defines the dataset configuration, including paths, classes, and other relevant information. Use this file with the YOLO26 training scripts as mentioned in the [Train Example](#how-do-i-train-a-yolo26-model-using-the-coco8-pose-dataset-in-ultralytics) section.
|
||||
|
||||
For more FAQs and detailed documentation, visit the [Ultralytics Documentation](https://docs.ultralytics.com/).
|
||||
@@ -1,175 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover the Dog-Pose dataset for pose detection. Featuring 6,773 training and 1,703 test images, it is a robust dataset for training YOLO26 models.
|
||||
keywords: Dog-Pose, Ultralytics, pose detection dataset, YOLO26, machine learning, computer vision, training data
|
||||
---
|
||||
|
||||
# Dog-Pose Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
The [Ultralytics](https://www.ultralytics.com/) Dog-Pose dataset is a high-quality and extensive dataset specifically curated for dog keypoint estimation. With 6,773 training images and 1,703 test images, this dataset provides a solid foundation for training robust pose estimation models.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/ZhjO32tZUek"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train Ultralytics YOLO26 on the Stanford Dog Pose Estimation Dataset | Step-by-Step Tutorial
|
||||
</p>
|
||||
|
||||
Each annotated image includes 24 keypoints with 3 dimensions per keypoint (x, y, visibility), making it a valuable resource for advanced research and development in computer vision.
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/ultralytics-dogs.avif" alt="Ultralytics Dog-pose display image" width="800">
|
||||
|
||||
This dataset is intended for use with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
- **Split**: 6,773 train / 1,703 test images with matching YOLO-format label files.
|
||||
- **Keypoints**: 24 per dog with `(x, y, visibility)` triplets.
|
||||
- **Layout**:
|
||||
|
||||
```
|
||||
datasets/dog-pose/
|
||||
├── images/{train,test}
|
||||
└── labels/{train,test}
|
||||
```
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It includes paths, keypoint details, and other relevant information. In the case of the Dog-pose dataset, The `dog-pose.yaml` is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dog-pose.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dog-pose.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/dog-pose.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/dog-pose.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-pose model on the Dog-pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="dog-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=dog-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are some examples of images from the Dog-pose dataset, along with their corresponding annotations:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch-2-dog-pose.avif" alt="Dog pose estimation dataset mosaic training batch" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the Dog-pose dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Dog-pose dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@inproceedings{khosla2011fgvc,
|
||||
title={Novel dataset for Fine-Grained Image Categorization},
|
||||
author={Aditya Khosla and Nityananda Jayadevaprakash and Bangpeng Yao and Li Fei-Fei},
|
||||
booktitle={First Workshop on Fine-Grained Visual Categorization (FGVC), IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
|
||||
year={2011}
|
||||
}
|
||||
@inproceedings{deng2009imagenet,
|
||||
title={ImageNet: A Large-Scale Hierarchical Image Database},
|
||||
author={Jia Deng and Wei Dong and Richard Socher and Li-Jia Li and Kai Li and Li Fei-Fei},
|
||||
booktitle={IEEE Computer Vision and Pattern Recognition (CVPR)},
|
||||
year={2009}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the Stanford team for creating and maintaining this valuable resource for the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. For more information about the Dog-pose dataset and its creators, visit the [Stanford Dogs Dataset website](http://vision.stanford.edu/aditya86/ImageNetDogs/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Dog-pose dataset, and how is it used with Ultralytics YOLO26?
|
||||
|
||||
The Dog-Pose dataset features 6,773 training and 1,703 test images annotated with 24 keypoints for dog pose estimation. It's designed for training and validating models with [Ultralytics YOLO26](../../models/yolo26.md), supporting applications like animal behavior analysis, pet monitoring, and veterinary studies. The dataset's comprehensive annotations make it ideal for developing accurate pose estimation models for canines.
|
||||
|
||||
### How do I train a YOLO26 model using the Dog-pose dataset in Ultralytics?
|
||||
|
||||
To train a YOLO26n-pose model on the Dog-pose dataset for 100 epochs with an image size of 640, follow these examples:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="dog-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose train data=dog-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of training arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the benefits of using the Dog-pose dataset?
|
||||
|
||||
The Dog-pose dataset offers several benefits:
|
||||
|
||||
**Large and Diverse Dataset**: With over 8,400 images, it provides substantial data covering a wide range of dog poses, breeds, and contexts, enabling robust model training and evaluation.
|
||||
|
||||
**Detailed Keypoint Annotations**: Each image includes 24 keypoints with 3 dimensions per keypoint (x, y, visibility), offering precise annotations for training accurate pose detection models.
|
||||
|
||||
**Real-World Scenarios**: Includes images from varied environments, enhancing the model's ability to generalize to real-world applications like [pet monitoring](https://www.ultralytics.com/blog/custom-training-ultralytics-yolo11-for-dog-pose-estimation) and behavior analysis.
|
||||
|
||||
**Transfer Learning Advantage**: The dataset works well with [transfer learning](https://www.ultralytics.com/blog/understanding-few-shot-zero-shot-and-transfer-learning) techniques, allowing models pretrained on human pose datasets to adapt to dog-specific features.
|
||||
|
||||
For more about its features and usage, see the [Dataset Introduction](#introduction) section.
|
||||
|
||||
### How does mosaicing benefit the YOLO26 training process using the Dog-pose dataset?
|
||||
|
||||
Mosaicing, as illustrated in the sample images from the Dog-pose dataset, merges multiple images into a single composite, enriching the diversity of objects and scenes in each training batch. This technique offers several benefits:
|
||||
|
||||
- Increases the variety of dog poses, sizes, and backgrounds in each batch
|
||||
- Improves the model's ability to detect dogs in different contexts and scales
|
||||
- Enhances generalization by exposing the model to more diverse visual patterns
|
||||
- Reduces overfitting by creating novel combinations of training examples
|
||||
|
||||
This approach leads to more robust models that perform better in real-world scenarios. For example images, refer to the [Sample Images and Annotations](#sample-images-and-annotations) section.
|
||||
|
||||
### Where can I find the Dog-pose dataset YAML file and how do I use it?
|
||||
|
||||
The Dog-pose dataset YAML file can be found at <https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/dog-pose.yaml>. This file defines the dataset configuration, including paths, classes, keypoint details, and other relevant information. The YAML specifies 24 keypoints with 3 dimensions per keypoint, making it suitable for detailed pose estimation tasks.
|
||||
|
||||
To use this file with YOLO26 training scripts, simply reference it in your training command as shown in the [Usage](#usage) section. The dataset will be automatically downloaded when first used, making setup straightforward.
|
||||
|
||||
For more FAQs and detailed documentation, visit the [Ultralytics Documentation](https://docs.ultralytics.com/).
|
||||
@@ -1,186 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the hand keypoints estimation dataset for advanced pose estimation. Learn about datasets, pretrained models, metrics, and applications for training with YOLO.
|
||||
keywords: Hand KeyPoints, pose estimation, dataset, keypoints, MediaPipe, YOLO, deep learning, computer vision
|
||||
---
|
||||
|
||||
# Hand Keypoints Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
The hand-keypoints dataset contains 26,768 images of hands annotated with keypoints, making it suitable for training models like Ultralytics YOLO for pose estimation tasks. The annotations were generated using the Google MediaPipe library, ensuring high [accuracy](https://www.ultralytics.com/glossary/accuracy) and consistency, and the dataset is compatible with [Ultralytics YOLO26](https://github.com/ultralytics/ultralytics) formats.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/fd6u1TW_AGY"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Hand Keypoints Estimation with Ultralytics YOLO26 | Human Hand Pose Estimation Tutorial
|
||||
</p>
|
||||
|
||||
## Hand Landmarks
|
||||
|
||||
|
||||
|
||||
## Keypoints
|
||||
|
||||
The dataset includes keypoints for hand detection. The keypoints are annotated as follows:
|
||||
|
||||
1. Wrist
|
||||
2. Thumb (4 points)
|
||||
3. Index finger (4 points)
|
||||
4. Middle finger (4 points)
|
||||
5. Ring finger (4 points)
|
||||
6. Little finger (4 points)
|
||||
|
||||
Each hand has a total of 21 keypoints.
|
||||
|
||||
## Key Features
|
||||
|
||||
- **Large Dataset**: 26,768 images with hand keypoint annotations.
|
||||
- **YOLO26 Compatibility**: Labels ship in YOLO keypoint format and are ready for use with YOLO26 models.
|
||||
- **21 Keypoints**: Detailed hand pose representation spanning the wrist and four points per finger.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The hand keypoint dataset is split into two subsets:
|
||||
|
||||
1. **Train**: This subset contains 18,776 images from the hand keypoints dataset, annotated for training pose estimation models.
|
||||
2. **Val**: This subset contains 7,992 images that can be used for validation purposes during model training.
|
||||
|
||||
## Applications
|
||||
|
||||
Hand keypoints can be used for [gesture recognition](https://www.ultralytics.com/blog/enhancing-hand-keypoints-estimation-with-ultralytics-yolo11), [AR/VR controls](https://docs.ultralytics.com/tasks/pose/), robotic manipulation, and hand movement analysis in healthcare. They can also be applied in animation for motion capture and biometric authentication systems for security. The detailed tracking of finger positions enables precise interaction with virtual objects and touchless control interfaces.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the Hand Keypoints dataset, the `hand-keypoints.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/hand-keypoints.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/hand-keypoints.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/hand-keypoints.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/hand-keypoints.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-pose model on the Hand Keypoints dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="hand-keypoints.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=hand-keypoints.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
The Hand keypoints dataset contains a diverse set of images with human hands annotated with keypoints. Here are some examples of images from the dataset, along with their corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the Hand Keypoints dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the hand-keypoints dataset in your research or development work, please acknowledge the following sources:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "Credits"
|
||||
|
||||
We would like to thank the following sources for providing the images used in this dataset:
|
||||
|
||||
- [11k Hands](https://sites.google.com/view/11khands)
|
||||
- [2000 Hand Gestures](https://www.kaggle.com/datasets/ritikagiridhar/2000-hand-gestures)
|
||||
- [Gesture Recognition](https://www.kaggle.com/datasets/imsparsh/gesture-recognition)
|
||||
|
||||
The images were collected and used under the respective licenses provided by each platform and are distributed under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-nc-sa/4.0/).
|
||||
|
||||
We would also like to acknowledge the creator of this dataset, [Rion Dsilva](https://www.linkedin.com/in/rion-dsilva-043464229/), for his great contribution to Vision AI research.
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I train a YOLO26 model on the Hand Keypoints dataset?
|
||||
|
||||
To train a YOLO26 model on the Hand Keypoints dataset, you can use either Python or the command line interface (CLI). Here's an example for training a YOLO26n-pose model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="hand-keypoints.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=hand-keypoints.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### What are the key features of the Hand Keypoints dataset?
|
||||
|
||||
The Hand Keypoints dataset is designed for advanced [pose estimation](https://docs.ultralytics.com/datasets/pose/) tasks and includes several key features:
|
||||
|
||||
- **Large Dataset**: Contains 26,768 images with hand keypoint annotations.
|
||||
- **YOLO26 Compatibility**: Ready for use with YOLO26 models.
|
||||
- **21 Keypoints**: Detailed hand pose representation, including wrist and finger joints.
|
||||
|
||||
For more details, you can explore the [Hand Keypoints Dataset](#introduction) section.
|
||||
|
||||
### What applications can benefit from using the Hand Keypoints dataset?
|
||||
|
||||
The Hand Keypoints dataset can be applied in various fields, including:
|
||||
|
||||
- **Gesture Recognition**: Enhancing human-computer interaction.
|
||||
- **AR/VR Controls**: Improving user experience in augmented and virtual reality.
|
||||
- **Robotic Manipulation**: Enabling precise control of robotic hands.
|
||||
- **Healthcare**: Analyzing hand movements for medical diagnostics.
|
||||
- **Animation**: Capturing motion for realistic animations.
|
||||
- **Biometric Authentication**: Enhancing security systems.
|
||||
|
||||
For more information, refer to the [Applications](#applications) section.
|
||||
|
||||
### How is the Hand Keypoints dataset structured?
|
||||
|
||||
The Hand Keypoints dataset is divided into two subsets:
|
||||
|
||||
1. **Train**: Contains 18,776 images for training pose estimation models.
|
||||
2. **Val**: Contains 7,992 images for validation purposes during model training.
|
||||
|
||||
This structure ensures a comprehensive training and validation process. For more details, see the [Dataset Structure](#dataset-structure) section.
|
||||
|
||||
### How do I use the dataset YAML file for training?
|
||||
|
||||
The dataset configuration is defined in a YAML file, which includes paths, classes, and other relevant information. The `hand-keypoints.yaml` file can be found at [hand-keypoints.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/hand-keypoints.yaml).
|
||||
|
||||
To use this YAML file for training, specify it in your training script or CLI command as shown in the training example above. For more details, refer to the [Dataset YAML](#dataset-yaml) section.
|
||||
@@ -1,216 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn about Ultralytics YOLO format for pose estimation datasets, supported formats, COCO-Pose, COCO8-Pose, Tiger-Pose, and how to add your own dataset.
|
||||
keywords: pose estimation, Ultralytics, YOLO format, COCO-Pose, COCO8-Pose, Tiger-Pose, dataset conversion, keypoints
|
||||
---
|
||||
|
||||
# Pose Estimation Datasets Overview
|
||||
|
||||
## Supported Dataset Formats
|
||||
|
||||
### Ultralytics YOLO format
|
||||
|
||||
The dataset label format used for training YOLO pose models is as follows:
|
||||
|
||||
1. One text file per image: Each image in the dataset has a corresponding text file with the same name as the image file and the ".txt" extension.
|
||||
2. One row per object: Each row in the text file corresponds to one object instance in the image.
|
||||
3. Object information per row: Each row contains the following information about the object instance:
|
||||
- Object class index: An integer representing the class of the object (e.g., 0 for person, 1 for car, etc.).
|
||||
- Object center coordinates: The x and y coordinates of the center of the object, normalized to be between 0 and 1.
|
||||
- Object width and height: The width and height of the object, normalized to be between 0 and 1.
|
||||
- Object keypoint coordinates: The keypoints of the object, normalized to be between 0 and 1.
|
||||
|
||||
Here is an example of the label format for a pose estimation task:
|
||||
|
||||
Format with 2D keypoints
|
||||
|
||||
```
|
||||
<class-index> <x> <y> <width> <height> <px1> <py1> <px2> <py2> ... <pxn> <pyn>
|
||||
```
|
||||
|
||||
Format with 3D keypoints (includes visibility per point)
|
||||
|
||||
```
|
||||
<class-index> <x> <y> <width> <height> <px1> <py1> <p1-visibility> <px2> <py2> <p2-visibility> <pxn> <pyn> <pn-visibility>
|
||||
```
|
||||
|
||||
In this format, `<class-index>` is the index of the class for the object, `<x> <y> <width> <height>` are the normalized coordinates of the [bounding box](https://www.ultralytics.com/glossary/bounding-box), and `<px1> <py1> <px2> <py2> ... <pxn> <pyn>` are the normalized keypoint coordinates. The visibility channel is optional but useful for datasets that annotate occlusion.
|
||||
|
||||
### Dataset YAML format
|
||||
|
||||
The Ultralytics framework uses a YAML file format to define the dataset and model configuration for training pose estimation models. Here is an example of the YAML format used for defining a pose dataset:
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8-pose.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-pose.yaml"
|
||||
```
|
||||
|
||||
The `train` and `val` fields specify the paths to the directories containing the training and validation images, respectively.
|
||||
|
||||
`names` is a dictionary of class names. The order of the names should match the order of the object class indices in the YOLO dataset files.
|
||||
|
||||
(Optional) if the points are symmetric then need flip_idx, like left-right side of human or face. For example if we assume five keypoints of facial landmark: [left eye, right eye, nose, left mouth, right mouth], and the original index is [0, 1, 2, 3, 4], then flip_idx is [1, 0, 2, 4, 3] (just exchange the left-right index, i.e. 0-1 and 3-4, and do not modify others like nose in this example).
|
||||
|
||||
## Usage
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco8-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
||||
This section outlines the datasets that are compatible with Ultralytics YOLO format and can be used for training [pose estimation](https://docs.ultralytics.com/tasks/pose/) models:
|
||||
|
||||
### COCO-Pose
|
||||
|
||||
- **Description**: COCO-Pose is a large-scale [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and pose estimation dataset. It is a subset of the popular COCO dataset and focuses on human pose estimation. COCO-Pose includes multiple keypoints for each human instance.
|
||||
- **Label Format**: Same as Ultralytics YOLO format as described above, with keypoints for human poses.
|
||||
- **Number of Classes**: 1 (Human).
|
||||
- **Keypoints**: 17 keypoints including nose, eyes, ears, shoulders, elbows, wrists, hips, knees, and ankles.
|
||||
- **Usage**: Suitable for training human pose estimation models.
|
||||
- **Additional Notes**: The dataset is rich and diverse, containing over 200k labeled images.
|
||||
- [Read more about COCO-Pose](coco.md)
|
||||
|
||||
### COCO8-Pose
|
||||
|
||||
- **Description**: [Ultralytics](https://www.ultralytics.com/) COCO8-Pose is a small, but versatile pose detection dataset composed of the first 8 images of the COCO train 2017 set, 4 for training and 4 for validation.
|
||||
- **Label Format**: Same as Ultralytics YOLO format as described above, with keypoints for human poses.
|
||||
- **Number of Classes**: 1 (Human).
|
||||
- **Keypoints**: 17 keypoints including nose, eyes, ears, shoulders, elbows, wrists, hips, knees, and ankles.
|
||||
- **Usage**: Suitable for testing and debugging object detection models, or for experimenting with new detection approaches.
|
||||
- **Additional Notes**: COCO8-Pose is ideal for sanity checks and [CI checks](https://docs.ultralytics.com/help/CI/).
|
||||
- [Read more about COCO8-Pose](coco8-pose.md)
|
||||
|
||||
### Dog-Pose
|
||||
|
||||
- **Description**: The Dog Pose dataset contains 6,773 training and 1,703 test images, providing a diverse and extensive resource for canine keypoint estimation.
|
||||
- **Label Format**: Follows the Ultralytics YOLO format, with annotations for multiple keypoints specific to dog anatomy.
|
||||
- **Number of Classes**: 1 (Dog).
|
||||
- **Keypoints**: Includes 24 keypoints tailored to dog poses, such as limbs, joints, and head positions.
|
||||
- **Usage**: Ideal for training models to estimate dog poses in various scenarios, from research to [real-world applications](https://www.ultralytics.com/blog/custom-training-ultralytics-yolo11-for-dog-pose-estimation).
|
||||
- [Read more about Dog-Pose](dog-pose.md)
|
||||
|
||||
### Hand Keypoints
|
||||
|
||||
- **Description**: The hand keypoints pose dataset comprises nearly 26K images, with 18,776 images allocated for training and 7,992 for validation.
|
||||
- **Label Format**: Same as the Ultralytics YOLO format described above, but with 21 keypoints for a human hand and a visibility dimension.
|
||||
- **Number of Classes**: 1 (Hand).
|
||||
- **Keypoints**: 21 keypoints.
|
||||
- **Usage**: Great for human hand pose estimation and [gesture recognition](https://www.ultralytics.com/blog/enhancing-hand-keypoints-estimation-with-ultralytics-yolo11).
|
||||
- [Read more about Hand Keypoints](hand-keypoints.md)
|
||||
|
||||
### Tiger-Pose
|
||||
|
||||
- **Description**: The [Ultralytics](https://www.ultralytics.com/) Tiger Pose dataset comprises 263 images sourced from a [YouTube video](https://www.youtube.com/watch?v=MIBAT6BGE6U&pp=ygUbVGlnZXIgd2Fsa2luZyByZWZlcmVuY2UubXA0), with 210 images allocated for training and 53 for validation.
|
||||
- **Label Format**: Same as Ultralytics YOLO format as described above, with 12 keypoints for animal pose and no visible dimension.
|
||||
- **Number of Classes**: 1 (Tiger).
|
||||
- **Keypoints**: 12 keypoints.
|
||||
- **Usage**: Great for animal pose or any other pose that is not human-based.
|
||||
- [Read more about Tiger-Pose](tiger-pose.md)
|
||||
|
||||
### Adding your own dataset
|
||||
|
||||
If you have your own dataset and would like to use it for training pose estimation models with Ultralytics YOLO format, ensure that it follows the format specified above under "Ultralytics YOLO format". Convert your annotations to the required format and specify the paths, number of classes, and class names in the YAML configuration file.
|
||||
|
||||
### Conversion Tool
|
||||
|
||||
Ultralytics provides a convenient conversion tool to convert labels from the popular [COCO dataset](https://docs.ultralytics.com/datasets/detect/coco/) format to YOLO format:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_coco
|
||||
|
||||
convert_coco(labels_dir="path/to/coco/annotations/", use_keypoints=True)
|
||||
```
|
||||
|
||||
This conversion tool can be used to convert the COCO dataset or any dataset in the COCO format to the Ultralytics YOLO format. The `use_keypoints` parameter specifies whether to include keypoints (for pose estimation) in the converted labels.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Ultralytics YOLO format for pose estimation?
|
||||
|
||||
The Ultralytics YOLO format for pose estimation datasets involves labeling each image with a corresponding text file. Each row of the text file stores information about an object instance:
|
||||
|
||||
- Object class index
|
||||
- Object center coordinates (normalized x and y)
|
||||
- Object width and height (normalized)
|
||||
- Object keypoint coordinates (normalized pxn and pyn)
|
||||
|
||||
For 2D poses, keypoints include pixel coordinates. For 3D, each keypoint also has a visibility flag. For more details, see [Ultralytics YOLO format](#ultralytics-yolo-format).
|
||||
|
||||
### How do I use the COCO-Pose dataset with Ultralytics YOLO?
|
||||
|
||||
To use the [COCO-Pose dataset](https://docs.ultralytics.com/datasets/pose/coco/) with Ultralytics YOLO:
|
||||
|
||||
1. Download the dataset and prepare your label files in the YOLO format.
|
||||
2. Create a YAML configuration file specifying paths to training and validation images, keypoint shape, and class names.
|
||||
3. Use the configuration file for training:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n-pose.pt") # load pretrained model
|
||||
results = model.train(data="coco-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
For more information, visit [COCO-Pose](coco.md) and [train](../../modes/train.md) sections.
|
||||
|
||||
### How can I add my own dataset for pose estimation in Ultralytics YOLO?
|
||||
|
||||
To add your dataset:
|
||||
|
||||
1. Convert your annotations to the Ultralytics YOLO format.
|
||||
2. Create a YAML configuration file specifying the dataset paths, number of classes, and class names.
|
||||
3. Use the configuration file to train your model:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n-pose.pt")
|
||||
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
For complete steps, check the [Adding your own dataset](#adding-your-own-dataset) section.
|
||||
|
||||
### What is the purpose of the dataset YAML file in Ultralytics YOLO?
|
||||
|
||||
The dataset YAML file in Ultralytics YOLO defines the dataset and model configuration for training. It specifies paths to training, validation, and test images, keypoint shapes, class names, and other configuration options. This structured format helps streamline [dataset management](https://docs.ultralytics.com/datasets/explorer/) and model training. Here is an example YAML format:
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-pose.yaml"
|
||||
```
|
||||
|
||||
Read more about creating YAML configuration files in [Dataset YAML format](#dataset-yaml-format).
|
||||
|
||||
### How can I convert COCO dataset labels to Ultralytics YOLO format for pose estimation?
|
||||
|
||||
Ultralytics provides a conversion tool to convert COCO dataset labels to the YOLO format, including keypoint information:
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_coco
|
||||
|
||||
convert_coco(labels_dir="path/to/coco/annotations/", use_keypoints=True)
|
||||
```
|
||||
|
||||
This tool helps seamlessly integrate COCO datasets into YOLO projects. For details, refer to the [Conversion Tool](#conversion-tool) section and the [data preprocessing guide](https://docs.ultralytics.com/guides/preprocessing_annotated_data/).
|
||||
@@ -1,170 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore Ultralytics Tiger-Pose dataset with 263 diverse images. Ideal for testing, training, and refining pose estimation algorithms.
|
||||
keywords: Ultralytics, Tiger-Pose, dataset, pose estimation, YOLO26, training data, machine learning, neural networks
|
||||
---
|
||||
|
||||
# Tiger-Pose Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) introduces the Tiger-Pose dataset, a versatile collection designed for pose estimation tasks. This dataset comprises 263 images sourced from a [YouTube video](https://www.youtube.com/watch?v=MIBAT6BGE6U&pp=ygUbVGlnZXIgd2Fsa2luZyByZWZlcmVuY2UubXA0), with 210 images allocated for training and 53 for validation. It serves as an excellent resource for testing and troubleshooting pose estimation algorithms.
|
||||
|
||||
Despite its manageable training split of 210 images, the Tiger-Pose dataset offers diversity, making it suitable for assessing training pipelines, identifying potential errors, and serving as a valuable preliminary step before working with larger datasets for [pose estimation](https://docs.ultralytics.com/tasks/pose/).
|
||||
|
||||
This dataset is intended for use with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
- **Total images**: 263 (210 train / 53 val).
|
||||
- **Keypoints**: 12 per tiger (no visibility flag).
|
||||
- **Directory layout**: YOLO-format keypoints stored under `labels/{train,val}` alongside `images/{train,val}` directories.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/Gc6K5eKrTNQ"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Train YOLO26 Pose Model on Tiger-Pose Dataset Using Ultralytics Platform
|
||||
</p>
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file serves as the means to specify the configuration details of a dataset. It encompasses crucial data such as file paths, class definitions, and other pertinent information. Specifically, for the `tiger-pose.yaml` file, you can check [Ultralytics Tiger-Pose Dataset Configuration File](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/tiger-pose.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/tiger-pose.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/tiger-pose.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-pose model on the Tiger-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="tiger-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=tiger-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are some examples of images from the Tiger-Pose dataset, along with their corresponding annotations:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch-4.avif" alt="Tiger pose estimation dataset mosaic training batch" width="100%">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the Tiger-Pose dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Inference Example
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/best.pt") # load a tiger-pose trained model
|
||||
|
||||
# Run inference
|
||||
results = model.predict(source="https://youtu.be/MIBAT6BGE6U", show=True)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Run inference using a tiger-pose trained model
|
||||
yolo pose predict source="https://youtu.be/MIBAT6BGE6U" show=True model="path/to/best.pt"
|
||||
```
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
The dataset has been released available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Ultralytics Tiger-Pose dataset used for?
|
||||
|
||||
The Ultralytics Tiger-Pose dataset is designed for pose estimation tasks, consisting of 263 images sourced from a [YouTube video](https://www.youtube.com/watch?v=MIBAT6BGE6U&pp=ygUbVGlnZXIgd2Fsa2luZyByZWZlcmVuY2UubXA0). The dataset is divided into 210 training images and 53 validation images. It is particularly useful for testing, training, and refining pose estimation algorithms using [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
### How do I train a YOLO26 model on the Tiger-Pose dataset?
|
||||
|
||||
To train a YOLO26n-pose model on the Tiger-Pose dataset for 100 epochs with an image size of 640, use the following code snippets. For more details, visit the [Training](../../modes/train.md) page:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="tiger-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=tiger-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What configurations does the `tiger-pose.yaml` file include?
|
||||
|
||||
The `tiger-pose.yaml` file is used to specify the configuration details of the Tiger-Pose dataset. It includes crucial data such as file paths and class definitions. To see the exact configuration, you can check out the [Ultralytics Tiger-Pose Dataset Configuration File](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/tiger-pose.yaml).
|
||||
|
||||
### How can I run inference using a YOLO26 model trained on the Tiger-Pose dataset?
|
||||
|
||||
To perform inference using a YOLO26 model trained on the Tiger-Pose dataset, you can use the following code snippets. For a detailed guide, visit the [Prediction](../../modes/predict.md) page:
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("path/to/best.pt") # load a tiger-pose trained model
|
||||
|
||||
# Run inference
|
||||
results = model.predict(source="https://youtu.be/MIBAT6BGE6U", show=True)
|
||||
```
|
||||
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Run inference using a tiger-pose trained model
|
||||
yolo pose predict source="https://youtu.be/MIBAT6BGE6U" show=True model="path/to/best.pt"
|
||||
```
|
||||
|
||||
### What are the benefits of using the Tiger-Pose dataset for pose estimation?
|
||||
|
||||
The Tiger-Pose dataset, despite its manageable size of 210 images for training, provides a diverse collection of images that are ideal for testing pose estimation pipelines. The dataset helps identify potential errors and acts as a preliminary step before working with larger datasets. Additionally, the dataset supports the training and refinement of pose estimation algorithms using advanced tools like [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics), enhancing model performance and [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
@@ -1,178 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Carparts Segmentation Dataset for automotive AI applications. Enhance your segmentation models with rich, annotated data using Ultralytics YOLO.
|
||||
keywords: Carparts Segmentation Dataset, computer vision, automotive AI, vehicle maintenance, Ultralytics, YOLO, segmentation models, deep learning, object segmentation
|
||||
---
|
||||
|
||||
# Carparts Segmentation Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-carparts-segmentation-dataset.ipynb" target="_blank"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Carparts Segmentation Dataset In Colab"></a>
|
||||
|
||||
The Carparts Segmentation Dataset, available on Roboflow Universe, is a curated collection of images and videos designed for [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) applications, specifically focusing on [segmentation tasks](https://docs.ultralytics.com/tasks/segment/). Hosted on Roboflow Universe, this dataset provides a diverse set of visuals captured from multiple perspectives, offering valuable [annotated](https://www.ultralytics.com/glossary/data-labeling) examples for training and testing segmentation models.
|
||||
|
||||
Whether you're working on [automotive research](https://www.ultralytics.com/solutions/ai-in-automotive), developing AI solutions for vehicle maintenance, or exploring computer vision applications, the Carparts Segmentation Dataset serves as a valuable resource for enhancing the [accuracy](https://www.ultralytics.com/glossary/accuracy) and efficiency of your projects using models like [Ultralytics YOLO](../../models/yolo26.md).
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/7lZa3Yi2kbo"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Carparts <a href="https://www.ultralytics.com/glossary/instance-segmentation">Instance Segmentation</a> with Ultralytics YOLO26.
|
||||
</p>
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The data distribution within the Carparts Segmentation Dataset is organized as follows:
|
||||
|
||||
- **Training set**: Includes 3156 images, each accompanied by its corresponding annotations. This set is used for [training](https://www.ultralytics.com/glossary/training-data) the [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) [model](https://www.ultralytics.com/glossary/foundation-model).
|
||||
- **Testing set**: Comprises 276 images, with each one paired with its respective annotations. This set is used to evaluate the model's performance after training using [test data](https://www.ultralytics.com/glossary/test-data).
|
||||
- **Validation set**: Consists of 401 images, each having corresponding annotations. This set is used during training to tune [hyperparameters](https://docs.ultralytics.com/guides/hyperparameter-tuning/) and prevent [overfitting](https://www.ultralytics.com/glossary/overfitting) using [validation data](https://www.ultralytics.com/glossary/validation-data).
|
||||
|
||||
## Applications
|
||||
|
||||
Carparts Segmentation finds applications in various domains including:
|
||||
|
||||
- **Automotive Quality Control**: Identifying defects or inconsistencies in car parts during manufacturing ([AI in Manufacturing](https://www.ultralytics.com/solutions/ai-in-manufacturing)).
|
||||
- **Auto Repair**: Assisting mechanics in identifying parts for repair or replacement.
|
||||
- **E-commerce Cataloging**: Automatically tagging and categorizing car parts in online stores for [e-commerce](https://en.wikipedia.org/wiki/E-commerce) platforms.
|
||||
- **Traffic Monitoring**: Analyzing vehicle components in traffic surveillance footage.
|
||||
- **Autonomous Vehicles**: Enhancing the perception systems of [self-driving cars](https://www.ultralytics.com/blog/ai-in-self-driving-cars) to better understand surrounding vehicles.
|
||||
- **Insurance Processing**: Automating damage assessment by identifying affected car parts during insurance claims.
|
||||
- **Recycling**: Sorting vehicle components for efficient recycling processes.
|
||||
- **Smart City Initiatives**: Contributing data for urban planning and traffic management systems within [Smart Cities](https://en.wikipedia.org/wiki/Smart_city).
|
||||
|
||||
By accurately identifying and categorizing different vehicle components, carparts segmentation streamlines processes and contributes to increased efficiency and automation across these industries.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A [YAML](https://www.ultralytics.com/glossary/yaml) (Yet Another Markup Language) file defines the dataset configuration, including paths, class names, and other essential details. For the Carparts Segmentation dataset, the `carparts-seg.yaml` file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/carparts-seg.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/carparts-seg.yaml). You can learn more about the YAML format at [yaml.org](https://yaml.org/).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/carparts-seg.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/carparts-seg.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train an [Ultralytics YOLO26](../../models/yolo26.md) model on the Carparts Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the following code snippets. Refer to the model [Training guide](../../modes/train.md) for a comprehensive list of available arguments and explore [model training tips](https://docs.ultralytics.com/guides/model-training-tips/) for best practices.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained segmentation model like YOLO26n-seg
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model on the Carparts Segmentation dataset
|
||||
results = model.train(data="carparts-seg.yaml", epochs=100, imgsz=640)
|
||||
|
||||
# After training, you can validate the model's performance on the validation set
|
||||
results = model.val()
|
||||
|
||||
# Or perform prediction on new images or videos
|
||||
results = model.predict("path/to/your/image.jpg")
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model using the Command Line Interface
|
||||
# Specify the dataset config file, model, number of epochs, and image size
|
||||
yolo segment train data=carparts-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
|
||||
# Validate the trained model using the validation set
|
||||
yolo segment val data=carparts-seg.yaml model=path/to/best.pt
|
||||
|
||||
# Predict using the trained model on a specific image source
|
||||
yolo segment predict model=path/to/best.pt source=path/to/your/image.jpg
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The Carparts Segmentation dataset includes a diverse array of images and videos captured from various perspectives. Below are examples showcasing the data and its corresponding annotations:
|
||||
|
||||
|
||||
|
||||
- The image demonstrates [object segmentation](https://docs.ultralytics.com/tasks/segment/) within a car image sample. Annotated [bounding boxes](https://www.ultralytics.com/glossary/bounding-box) with masks highlight the identified car parts (e.g., headlights, grille).
|
||||
- The dataset features a variety of images captured under different conditions (locations, lighting, object densities), providing a comprehensive resource for training robust car part segmentation models.
|
||||
- This example underscores the dataset's complexity and the importance of [high-quality data](https://www.ultralytics.com/blog/the-importance-of-high-quality-computer-vision-datasets) for computer vision tasks, especially in specialized domains like automotive component analysis. Techniques like [data augmentation](https://www.ultralytics.com/glossary/data-augmentation) can further enhance model generalization.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you utilize the Carparts Segmentation dataset in your research or development efforts, please cite the original source:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{ car-seg-un1pm_dataset,
|
||||
title = { car-seg Dataset },
|
||||
type = { Open Source Dataset },
|
||||
author = { Gianmarco Russo },
|
||||
url = { https://universe.roboflow.com/gianmarco-russo-vt9xr/car-seg-un1pm },
|
||||
journal = { Roboflow Universe },
|
||||
publisher = { Roboflow },
|
||||
year = { 2023 },
|
||||
month = { nov },
|
||||
note = { visited on 2024-01-24 },
|
||||
}
|
||||
```
|
||||
|
||||
We acknowledge the contribution of Gianmarco Russo and the Roboflow team in creating and maintaining this valuable dataset for the computer vision community. For more datasets, visit the [Ultralytics Datasets collection](https://docs.ultralytics.com/datasets/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Carparts Segmentation Dataset?
|
||||
|
||||
The Carparts Segmentation Dataset is a specialized collection of images and videos for training computer vision models to perform [segmentation](https://docs.ultralytics.com/tasks/segment/) on car parts. It includes diverse visuals with detailed annotations, suitable for automotive AI applications.
|
||||
|
||||
### How can I use the Carparts Segmentation Dataset with Ultralytics YOLO26?
|
||||
|
||||
You can train an [Ultralytics YOLO26](../../models/yolo26.md) segmentation model using this dataset. Load a pretrained model (e.g., `yolo26n-seg.pt`) and initiate training using the provided Python or CLI examples, referencing the `carparts-seg.yaml` configuration file. Check the [Training Guide](../../modes/train.md) for detailed instructions.
|
||||
|
||||
!!! example "Train Example Snippet"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="carparts-seg.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo segment train data=carparts-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What are some applications of Carparts Segmentation?
|
||||
|
||||
Carparts Segmentation is useful in:
|
||||
|
||||
- **Automotive Quality Control**: Ensuring parts meet standards ([AI in Manufacturing](https://www.ultralytics.com/solutions/ai-in-manufacturing)).
|
||||
- **Auto Repair**: Identifying parts needing service.
|
||||
- **E-commerce**: Cataloging parts online.
|
||||
- **Autonomous Vehicles**: Improving vehicle perception ([AI in Automotive](https://www.ultralytics.com/solutions/ai-in-automotive)).
|
||||
- **Insurance**: Assessing vehicle damage automatically.
|
||||
- **Recycling**: Sorting parts efficiently.
|
||||
|
||||
### Where can I find the dataset configuration file for Carparts Segmentation?
|
||||
|
||||
The dataset configuration file, `carparts-seg.yaml`, which contains details about the dataset paths and classes, is located in the Ultralytics GitHub repository: [carparts-seg.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/carparts-seg.yaml).
|
||||
|
||||
### Why should I use the Carparts Segmentation Dataset?
|
||||
|
||||
This dataset offers rich, annotated data crucial for developing accurate [segmentation models](https://docs.ultralytics.com/tasks/segment/) for automotive applications. Its diversity helps improve model robustness and performance in real-world scenarios like automated vehicle inspection, enhancing safety systems, and supporting autonomous driving technology. Using high-quality, domain-specific datasets like this accelerates AI development.
|
||||
@@ -1,156 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the COCO-Seg dataset, an extension of COCO, with detailed segmentation annotations. Learn how to train YOLO models with COCO-Seg.
|
||||
keywords: COCO-Seg, dataset, YOLO models, instance segmentation, object detection, COCO dataset, YOLO26, computer vision, Ultralytics, machine learning
|
||||
---
|
||||
|
||||
# COCO-Seg Dataset
|
||||
|
||||
The [COCO-Seg](https://cocodataset.org/#home) dataset, an extension of the COCO (Common Objects in Context) dataset, is specially designed to aid research in object [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation). It uses the same images as COCO but introduces more detailed segmentation annotations. This dataset is a crucial resource for researchers and developers working on instance segmentation tasks, especially for training [Ultralytics YOLO](https://docs.ultralytics.com/models/) models.
|
||||
|
||||
## COCO-Seg Pretrained Models
|
||||
|
||||
{% include "macros/yolo-seg-perf.md" %}
|
||||
|
||||
## Key Features
|
||||
|
||||
- COCO-Seg retains the original 330K images from COCO.
|
||||
- The dataset consists of the same 80 object categories found in the original COCO dataset.
|
||||
- Annotations now include more detailed instance segmentation masks for each object in the images.
|
||||
- COCO-Seg provides standardized evaluation metrics like [mean Average Precision](https://www.ultralytics.com/glossary/mean-average-precision-map) (mAP) for object detection, and mean Average [Recall](https://www.ultralytics.com/glossary/recall) (mAR) for instance segmentation tasks, enabling effective comparison of model performance.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The COCO-Seg dataset is partitioned into three subsets:
|
||||
|
||||
1. **Train2017**: 118K images for training instance segmentation models.
|
||||
2. **Val2017**: 5K images used for validation during model development.
|
||||
3. **Test2017**: 20K images used for benchmarking. Ground-truth annotations for this subset are not publicly available, so predictions must be submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7383) for scoring.
|
||||
|
||||
## Applications
|
||||
|
||||
COCO-Seg is widely used for training and evaluating [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models in instance segmentation, such as the YOLO models. The large number of annotated images, the diversity of object categories, and the standardized evaluation metrics make it an indispensable resource for [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) researchers and practitioners.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO-Seg dataset, the `coco.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-seg model on the COCO-Seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
COCO-Seg, like its predecessor COCO, contains a diverse set of images with various object categories and complex scenes. However, COCO-Seg introduces more detailed instance segmentation masks for each object in the images. Here are some examples of images from the dataset, along with their corresponding instance segmentation masks:
|
||||
|
||||
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. [Mosaicing](https://docs.ultralytics.com/guides/hyperparameter-tuning/) is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This aids the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the COCO-Seg dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO-Seg dataset in your research or development work, please cite the original COCO paper and acknowledge the extension to COCO-Seg:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We extend our thanks to the COCO Consortium for creating and maintaining this invaluable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO-Seg dataset and how does it differ from the original COCO dataset?
|
||||
|
||||
The [COCO-Seg](https://cocodataset.org/#home) dataset is an extension of the original COCO (Common Objects in Context) dataset, specifically designed for instance segmentation tasks. While it uses the same images as the COCO dataset, COCO-Seg includes more detailed segmentation annotations, making it a powerful resource for researchers and developers focusing on [object instance segmentation](https://docs.ultralytics.com/tasks/segment/).
|
||||
|
||||
### How can I train a YOLO26 model using the COCO-Seg dataset?
|
||||
|
||||
To train a YOLO26n-seg model on the COCO-Seg dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a detailed list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What are the key features of the COCO-Seg dataset?
|
||||
|
||||
The COCO-Seg dataset includes several key features:
|
||||
|
||||
- Retains the original 330K images from the COCO dataset.
|
||||
- Annotates the same 80 object categories found in the original COCO.
|
||||
- Provides more detailed instance segmentation masks for each object.
|
||||
- Uses standardized evaluation metrics such as mean Average [Precision](https://www.ultralytics.com/glossary/precision) (mAP) for [object detection](https://www.ultralytics.com/glossary/object-detection) and mean Average Recall (mAR) for instance segmentation tasks.
|
||||
|
||||
### What pretrained models are available for COCO-Seg, and what are their performance metrics?
|
||||
|
||||
The COCO-Seg dataset supports multiple pretrained YOLO26 segmentation models with varying performance metrics. Here's a summary of the available models and their key metrics:
|
||||
|
||||
{% include "macros/yolo-seg-perf.md" %}
|
||||
|
||||
These models range from the lightweight YOLO26n-seg to the more powerful YOLO26x-seg, offering different trade-offs between speed and accuracy to suit various application requirements. For more information on model selection, visit the [Ultralytics models page](https://docs.ultralytics.com/models/).
|
||||
|
||||
### How is the COCO-Seg dataset structured and what subsets does it contain?
|
||||
|
||||
The COCO-Seg dataset is partitioned into three subsets for specific training and evaluation needs:
|
||||
|
||||
1. **Train2017**: Contains 118K images used primarily for training instance segmentation models.
|
||||
2. **Val2017**: Comprises 5K images utilized for validation during the training process.
|
||||
3. **Test2017**: Encompasses 20K images reserved for testing and benchmarking trained models. Note that ground truth annotations for this subset are not publicly available, and performance results are submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7383) for assessment.
|
||||
|
||||
For smaller experimentation needs, you might also consider using the [COCO8-seg dataset](https://docs.ultralytics.com/datasets/segment/coco8-seg/), which is a compact version containing just 8 images from the COCO train 2017 set.
|
||||
@@ -1,130 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover the COCO128-Seg dataset by Ultralytics, a compact yet diverse segmentation dataset ideal for testing and training YOLO26 models.
|
||||
keywords: COCO128-Seg, Ultralytics, segmentation dataset, YOLO26, COCO 2017, model training, computer vision, dataset configuration
|
||||
---
|
||||
|
||||
# COCO128-Seg Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) COCO128-Seg is a small but versatile [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) dataset composed of the first 128 images of the COCO train 2017 set. This dataset is ideal for testing and debugging segmentation models, or for experimenting with new detection approaches. With 128 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
- **Images**: 128 total. The default YAML reuses the same directory for train and val so you can quickly iterate, but you can duplicate or customize the split if desired.
|
||||
- **Classes**: Same 80 object categories as COCO.
|
||||
- **Labels**: YOLO-format polygons saved beside each image inside `labels/{train,val}`.
|
||||
|
||||
This dataset is intended for use with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO128-Seg dataset, the `coco128-seg.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco128-seg.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco128-seg.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco128-seg.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco128-seg.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-seg model on the COCO128-Seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco128-seg.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco128-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are some examples of images from the COCO128-Seg dataset, along with their corresponding annotations:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch-2.avif" alt="COCO128-seg instance segmentation dataset mosaic" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the COCO128-Seg dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO128-Seg dataset, and how is it used in Ultralytics YOLO26?
|
||||
|
||||
The **COCO128-Seg dataset** is a compact instance segmentation dataset by Ultralytics, consisting of the first 128 images from the COCO train 2017 set. This dataset is tailored for testing and debugging segmentation models or experimenting with new detection methods. It is particularly useful with Ultralytics [YOLO26](https://github.com/ultralytics/ultralytics) and [Platform](https://platform.ultralytics.com/) for rapid iteration and pipeline error-checking before scaling to larger datasets. For detailed usage, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### How can I train a YOLO26n-seg model using the COCO128-Seg dataset?
|
||||
|
||||
To train a **YOLO26n-seg** model on the COCO128-Seg dataset for 100 epochs with an image size of 640, you can use Python or CLI commands. Here's a quick example:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # Load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco128-seg.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco128-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a thorough explanation of available arguments and configuration options, you can check the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### Why is the COCO128-Seg dataset important for model development and debugging?
|
||||
|
||||
The **COCO128-Seg dataset** offers a balanced combination of manageability and diversity with 128 images, making it perfect for quickly testing and debugging segmentation models or experimenting with new detection techniques. Its moderate size allows for fast training iterations while providing enough diversity to validate training pipelines before scaling to larger datasets. Learn more about supported dataset formats in the [Ultralytics segmentation dataset guide](https://docs.ultralytics.com/datasets/segment/).
|
||||
|
||||
### Where can I find the YAML configuration file for the COCO128-Seg dataset?
|
||||
|
||||
The YAML configuration file for the **COCO128-Seg dataset** is available in the Ultralytics repository. You can access the file directly at <https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco128-seg.yaml>. The YAML file includes essential information about dataset paths, classes, and configuration settings required for model training and validation.
|
||||
|
||||
### What are some benefits of using mosaicing during training with the COCO128-Seg dataset?
|
||||
|
||||
Using **mosaicing** during training helps increase the diversity and variety of objects and scenes in each training batch. This technique combines multiple images into a single composite image, enhancing the model's ability to generalize to different object sizes, aspect ratios, and contexts within the scene. Mosaicing is beneficial for improving a model's robustness and [accuracy](https://www.ultralytics.com/glossary/accuracy), especially when working with moderately-sized datasets like COCO128-Seg. For an example of mosaiced images, see the [Sample Images and Annotations](#sample-images-and-annotations) section.
|
||||
@@ -1,130 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Discover the versatile and manageable COCO8-Seg dataset by Ultralytics, ideal for testing and debugging segmentation models or new detection approaches.
|
||||
keywords: COCO8-Seg, Ultralytics, segmentation dataset, YOLO26, COCO 2017, model training, computer vision, dataset configuration
|
||||
---
|
||||
|
||||
# COCO8-Seg Dataset
|
||||
|
||||
## Introduction
|
||||
|
||||
[Ultralytics](https://www.ultralytics.com/) COCO8-Seg is a small but versatile [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) dataset composed of the first 8 images of the COCO train 2017 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging segmentation models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
- **Images**: 8 total (4 train / 4 val).
|
||||
- **Classes**: 80 COCO categories.
|
||||
- **Labels**: YOLO-format polygons stored under `labels/{train,val}` matching each image file.
|
||||
|
||||
This dataset is intended for use with [Ultralytics Platform](https://platform.ultralytics.com/) and [YOLO26](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO8-Seg dataset, the `coco8-seg.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-seg.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-seg.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8-seg.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-seg.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train a YOLO26n-seg model on the COCO8-Seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco8-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
||||
Here are some examples of images from the COCO8-Seg dataset, along with their corresponding annotations:
|
||||
|
||||
<img src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/mosaiced-training-batch-2.avif" alt="COCO8-seg instance segmentation dataset mosaic" width="800">
|
||||
|
||||
- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
|
||||
|
||||
The example showcases the variety and complexity of the images in the COCO8-Seg dataset and the benefits of using mosaicing during the training process.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the COCO dataset in your research or development work, please cite the following paper:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lin2015microsoft,
|
||||
title={Microsoft COCO: Common Objects in Context},
|
||||
author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
|
||||
year={2015},
|
||||
eprint={1405.0312},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO8-Seg dataset, and how is it used in Ultralytics YOLO26?
|
||||
|
||||
The **COCO8-Seg dataset** is a compact instance segmentation dataset by Ultralytics, consisting of the first 8 images from the COCO train 2017 set—4 images for training and 4 for validation. This dataset is tailored for testing and debugging segmentation models or experimenting with new detection methods. It is particularly useful with Ultralytics [YOLO26](https://github.com/ultralytics/ultralytics) and [Platform](https://platform.ultralytics.com/) for rapid iteration and pipeline error-checking before scaling to larger datasets. For detailed usage, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### How can I train a YOLO26n-seg model using the COCO8-Seg dataset?
|
||||
|
||||
To train a **YOLO26n-seg** model on the COCO8-Seg dataset for 100 epochs with an image size of 640, you can use Python or CLI commands. Here's a quick example:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # Load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco8-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a thorough explanation of available arguments and configuration options, you can check the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### Why is the COCO8-Seg dataset important for model development and debugging?
|
||||
|
||||
The **COCO8-Seg dataset** offers a compact yet diverse set of 8 images, making it perfect for quickly testing and debugging segmentation models or experimenting with new detection techniques. Its small size allows for fast sanity checks and early pipeline validation, helping identify issues before scaling to larger datasets. Learn more about supported dataset formats in the [Ultralytics segmentation dataset guide](https://docs.ultralytics.com/datasets/segment/).
|
||||
|
||||
### Where can I find the YAML configuration file for the COCO8-Seg dataset?
|
||||
|
||||
The YAML configuration file for the **COCO8-Seg dataset** is available in the Ultralytics repository. You can access the file directly at <https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-seg.yaml>. The YAML file includes essential information about dataset paths, classes, and configuration settings required for model training and validation.
|
||||
|
||||
### What are some benefits of using mosaicing during training with the COCO8-Seg dataset?
|
||||
|
||||
Using **mosaicing** during training helps increase the diversity and variety of objects and scenes in each training batch. This technique combines multiple images into a single composite image, enhancing the model's ability to generalize to different object sizes, aspect ratios, and contexts within the scene. Mosaicing is beneficial for improving a model's robustness and [accuracy](https://www.ultralytics.com/glossary/accuracy), especially when working with small datasets like COCO8-Seg. For an example of mosaiced images, see the [Sample Images and Annotations](#sample-images-and-annotations) section.
|
||||
@@ -1,156 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the extensive Crack Segmentation Dataset, ideal for transportation safety, infrastructure maintenance, and self-driving car model development using Ultralytics YOLO.
|
||||
keywords: Crack Segmentation Dataset, Ultralytics, transportation safety, public safety, self-driving cars, computer vision, road safety, infrastructure maintenance, dataset, YOLO, segmentation, deep learning
|
||||
---
|
||||
|
||||
# Crack Segmentation Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-crack-segmentation-dataset.ipynb" target="_blank"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Crack Segmentation Dataset In Colab"></a>
|
||||
|
||||
The Crack Segmentation Dataset, available on Roboflow Universe, is an extensive resource designed for individuals involved in transportation and public safety studies. It is also beneficial for developing [self-driving car](https://www.ultralytics.com/blog/ai-in-self-driving-cars) models or exploring various [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) applications. This dataset is part of the broader collection available on the Ultralytics [Datasets Hub](../../datasets/index.md).
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/C4mc40YKm-g"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Crack segmentation using Ultralytics YOLOv9.
|
||||
</p>
|
||||
|
||||
Comprising 4029 static images captured from diverse road and wall scenarios, this dataset is a valuable asset for crack segmentation tasks. Whether you are researching transportation infrastructure or aiming to enhance the [accuracy](https://www.ultralytics.com/glossary/accuracy) of autonomous driving systems, this dataset provides a rich collection of images for training [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models.
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The Crack Segmentation Dataset is organized into three subsets:
|
||||
|
||||
- **Training set**: 3717 images with corresponding annotations.
|
||||
- **Testing set**: 112 images with corresponding annotations.
|
||||
- **Validation set**: 200 images with corresponding annotations.
|
||||
|
||||
## Applications
|
||||
|
||||
Crack segmentation finds practical applications in [infrastructure maintenance](https://www.ultralytics.com/blog/using-ai-for-crack-detection-and-segmentation), aiding in the identification and assessment of structural damage in buildings, bridges, and roads. It also plays a crucial role in enhancing [road safety](https://www.who.int/news-room/fact-sheets/detail/road-traffic-injuries) by enabling automated systems to detect pavement cracks for timely repairs.
|
||||
|
||||
In industrial settings, crack detection using deep learning models like [Ultralytics YOLO26](../../models/yolo26.md) helps ensure building integrity in construction, prevents costly downtimes in [manufacturing](https://www.ultralytics.com/solutions/ai-in-manufacturing), and makes road inspections safer and more effective. Automatically identifying and classifying cracks allows maintenance teams to prioritize repairs efficiently, contributing to better [model evaluation insights](../../guides/model-evaluation-insights.md).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A [YAML](https://www.ultralytics.com/glossary/yaml) (Yet Another Markup Language) file defines the dataset configuration. It includes details about the dataset's paths, classes, and other relevant information. For the Crack Segmentation dataset, the `crack-seg.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/crack-seg.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/crack-seg.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/crack-seg.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/crack-seg.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train the Ultralytics YOLO26n-seg model on the Crack Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the following [Python](https://www.python.org/) or CLI snippets. Refer to the model [Training](../../modes/train.md) documentation page for a comprehensive list of available arguments and configurations like [hyperparameter tuning](../../guides/hyperparameter-tuning.md).
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
# Using a pretrained model like yolo26n-seg.pt is recommended for faster convergence
|
||||
model = YOLO("yolo26n-seg.pt")
|
||||
|
||||
# Train the model on the Crack Segmentation dataset
|
||||
# Ensure 'crack-seg.yaml' is accessible or provide the full path
|
||||
results = model.train(data="crack-seg.yaml", epochs=100, imgsz=640)
|
||||
|
||||
# After training, the model can be used for prediction or exported
|
||||
# results = model.predict(source='path/to/your/images')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model using the Command Line Interface
|
||||
# Ensure the dataset YAML file 'crack-seg.yaml' is correctly configured and accessible
|
||||
yolo segment train data=crack-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The Crack Segmentation dataset contains a diverse collection of images captured from various perspectives, showcasing different types of cracks on roads and walls. Here are some examples:
|
||||
|
||||
|
||||
|
||||
- This image demonstrates [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation), featuring annotated [bounding boxes](https://www.ultralytics.com/glossary/bounding-box) with masks outlining identified cracks. The dataset includes images from different locations and environments, making it a comprehensive resource for developing robust models for this task. Techniques like [data augmentation](https://www.ultralytics.com/glossary/data-augmentation) can further enhance dataset diversity. Learn more about instance segmentation and tracking in our [guide](../../guides/instance-segmentation-and-tracking.md).
|
||||
|
||||
- The example highlights the diversity within the Crack Segmentation dataset, emphasizing the importance of high-quality data for training effective computer vision models.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you use the Crack Segmentation dataset in your research or development work, please cite the source appropriately. The dataset was made available via Roboflow:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{ crack-bphdr_dataset,
|
||||
title = { crack Dataset },
|
||||
type = { Open Source Dataset },
|
||||
author = { University },
|
||||
url = { https://universe.roboflow.com/university-bswxt/crack-bphdr },
|
||||
journal = { Roboflow Universe },
|
||||
publisher = { Roboflow },
|
||||
year = { 2022 },
|
||||
month = { dec },
|
||||
note = { visited on 2024-01-23 },
|
||||
}
|
||||
```
|
||||
|
||||
We acknowledge the team at Roboflow for making the Crack Segmentation dataset available, providing a valuable resource for the computer vision community, particularly for projects related to road safety and infrastructure assessment.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Crack Segmentation Dataset?
|
||||
|
||||
The Crack Segmentation Dataset is a collection of 4029 static images designed for transportation and public safety studies. It's suitable for tasks like [self-driving car](https://www.ultralytics.com/blog/ai-in-self-driving-cars) model development and [infrastructure maintenance](https://www.ultralytics.com/blog/using-ai-for-crack-detection-and-segmentation). It includes training, testing, and validation sets for crack detection and [segmentation](../../tasks/segment.md) tasks.
|
||||
|
||||
### How do I train a model using the Crack Segmentation Dataset with Ultralytics YOLO26?
|
||||
|
||||
To train an [Ultralytics YOLO26](../../models/yolo26.md) model on this dataset, use the provided Python or CLI examples. Detailed instructions and parameters are available on the model [Training](../../modes/train.md) page. You can manage your training process using tools like [Ultralytics Platform](https://platform.ultralytics.com).
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model (recommended)
|
||||
model = YOLO("yolo26n-seg.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="crack-seg.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained model via CLI
|
||||
yolo segment train data=crack-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Why use the Crack Segmentation Dataset for self-driving car projects?
|
||||
|
||||
This dataset is valuable for self-driving car projects due to its diverse images of roads and walls, covering various real-world scenarios. This diversity improves the robustness of models trained for crack detection, which is crucial for road safety and infrastructure assessment. The detailed annotations aid in [developing models](../../guides/model-training-tips.md) that can accurately identify potential road hazards.
|
||||
|
||||
### What features does Ultralytics YOLO offer for crack segmentation?
|
||||
|
||||
Ultralytics YOLO provides real-time [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and classification capabilities, making it highly suitable for crack segmentation tasks. It efficiently handles large datasets and complex scenarios. The framework includes comprehensive modes for [Training](../../modes/train.md), [Prediction](../../modes/predict.md), and [Exporting](../../modes/export.md) models. YOLO's [anchor-free detection](https://www.ultralytics.com/blog/benefits-ultralytics-yolo11-being-anchor-free-detector) approach can improve performance on irregular shapes like cracks, and performance can be measured using standard [metrics](../../guides/yolo-performance-metrics.md).
|
||||
|
||||
### How do I cite the Crack Segmentation Dataset?
|
||||
|
||||
If using this dataset in your work, please cite it using the provided BibTeX entry above to give appropriate credit to the creators.
|
||||
@@ -1,212 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the supported dataset formats for Ultralytics YOLO and learn how to prepare and use datasets for training object segmentation models.
|
||||
keywords: Ultralytics, YOLO, instance segmentation, dataset formats, auto-annotation, COCO, segmentation models, training data
|
||||
---
|
||||
|
||||
# Instance Segmentation Datasets Overview
|
||||
|
||||
Instance segmentation is a computer vision task that involves identifying and delineating individual objects within an image. This guide provides an overview of dataset formats supported by Ultralytics YOLO for instance segmentation tasks, along with instructions on how to prepare, convert, and use these datasets for training your models.
|
||||
|
||||
## Supported Dataset Formats
|
||||
|
||||
### Ultralytics YOLO format
|
||||
|
||||
The dataset label format used for training YOLO segmentation models is as follows:
|
||||
|
||||
1. One text file per image: Each image in the dataset has a corresponding text file with the same name as the image file and the ".txt" extension.
|
||||
2. One row per object: Each row in the text file corresponds to one object instance in the image.
|
||||
3. Object information per row: Each row contains the following information about the object instance:
|
||||
- Object class index: An integer representing the class of the object (e.g., 0 for person, 1 for car, etc.).
|
||||
- Object bounding coordinates: The bounding coordinates around the mask area, normalized to be between 0 and 1.
|
||||
|
||||
The format for a single row in the segmentation dataset file is as follows:
|
||||
|
||||
```
|
||||
<class-index> <x1> <y1> <x2> <y2> ... <xn> <yn>
|
||||
```
|
||||
|
||||
In this format, `<class-index>` is the index of the class for the object, and `<x1> <y1> <x2> <y2> ... <xn> <yn>` are the normalized polygon coordinates of the object's segmentation mask (values are in `[0, 1]` relative to image width and height). The coordinates are separated by spaces.
|
||||
|
||||
Here is an example of the YOLO dataset format for a single image with two objects made up of a 3-point segment and a 5-point segment.
|
||||
|
||||
```
|
||||
0 0.681 0.485 0.670 0.487 0.676 0.487
|
||||
1 0.504 0.000 0.501 0.004 0.498 0.004 0.493 0.010 0.492 0.0104
|
||||
```
|
||||
|
||||
!!! tip
|
||||
|
||||
- The length of each row does **not** have to be equal.
|
||||
- Each segmentation label must have a **minimum of 3 `(x, y)` points**: `<class-index> <x1> <y1> <x2> <y2> <x3> <y3>`
|
||||
|
||||
### Dataset YAML format
|
||||
|
||||
The Ultralytics framework uses a YAML file format to define the dataset and model configuration for training Segmentation Models. Here is an example of the YAML format used for defining a segmentation dataset:
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/coco8-seg.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-seg.yaml"
|
||||
```
|
||||
|
||||
The `train` and `val` fields specify the paths to the directories containing the training and validation images, respectively.
|
||||
|
||||
`names` is a dictionary of class names. The order of the names should match the order of the object class indices in the YOLO dataset files.
|
||||
|
||||
## Usage
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco8-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
||||
Ultralytics YOLO supports various datasets for instance segmentation tasks. Here's a list of the most commonly used ones:
|
||||
|
||||
- [Carparts-seg](carparts-seg.md): A specialized dataset focused on the segmentation of car parts, ideal for automotive applications. It includes a variety of vehicles with detailed annotations of individual car components.
|
||||
- [COCO](coco.md): A comprehensive dataset for [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and captioning, featuring over 200K labeled images across a wide range of categories.
|
||||
- [COCO8-seg](coco8-seg.md): A compact, 8-image subset of COCO designed for quick testing of segmentation model training, ideal for CI checks and workflow validation in the `ultralytics` repository.
|
||||
- [COCO128-seg](coco128-seg.md): A smaller dataset for [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) tasks, containing a subset of 128 COCO images with segmentation annotations.
|
||||
- [Crack-seg](crack-seg.md): A dataset tailored for the segmentation of cracks in various surfaces. Essential for infrastructure maintenance and quality control, it provides detailed imagery for training models to identify structural weaknesses.
|
||||
- [Package-seg](package-seg.md): A dataset dedicated to the segmentation of different types of packaging materials and shapes. It's particularly useful for logistics and warehouse automation, aiding in the development of systems for package handling and sorting.
|
||||
|
||||
### Adding your own dataset
|
||||
|
||||
If you have your own dataset and would like to use it for training segmentation models with Ultralytics YOLO format, ensure that it follows the format specified above under "Ultralytics YOLO format". Convert your annotations to the required format and specify the paths, number of classes, and class names in the YAML configuration file. Keep `images/` and `labels/` as separate folders at the same level, with matching subfolder structure; placing label `.txt` files in the image folder can cause the model to miss labels.
|
||||
|
||||
## Port or Convert Label Formats
|
||||
|
||||
### COCO Dataset Format to YOLO Format
|
||||
|
||||
You can easily convert labels from the popular COCO dataset format to the YOLO format using the following code snippet:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_coco
|
||||
|
||||
convert_coco(labels_dir="path/to/coco/annotations/", use_segments=True)
|
||||
```
|
||||
|
||||
This conversion tool can be used to convert the COCO dataset or any dataset in the COCO format to the Ultralytics YOLO format.
|
||||
|
||||
Remember to double-check if the dataset you want to use is compatible with your model and follows the necessary format conventions. Properly formatted datasets are crucial for training successful segmentation models.
|
||||
|
||||
## Auto-Annotation
|
||||
|
||||
Auto-annotation is an essential feature that allows you to generate a segmentation dataset using a pretrained detection model. It enables you to quickly and accurately annotate a large number of images without the need for manual labeling, saving time and effort.
|
||||
|
||||
### Generate Segmentation Dataset Using a Detection Model
|
||||
|
||||
To auto-annotate your dataset using the Ultralytics framework, you can use the `auto_annotate` function as shown below:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")
|
||||
```
|
||||
|
||||
{% include "macros/sam-auto-annotate.md" %}
|
||||
|
||||
The `auto_annotate` function takes the path to your images, along with optional arguments for specifying the pretrained detection models i.e. [YOLO26](../../models/yolo26.md), [YOLO11](../../models/yolo11.md) or other [models](../../models/index.md) and segmentation models i.e, [SAM](../../models/sam.md), [SAM2](../../models/sam-2.md) or [MobileSAM](../../models/mobile-sam.md), the device to run the models on, and the output directory for saving the annotated results.
|
||||
|
||||
By leveraging the power of pretrained models, auto-annotation can significantly reduce the time and effort required for creating high-quality segmentation datasets. This feature is particularly useful for researchers and developers working with large image collections, as it allows them to focus on model development and evaluation rather than manual annotation.
|
||||
|
||||
### Visualize Dataset Annotations
|
||||
|
||||
Before training your model, it's often helpful to visualize your dataset annotations to ensure they're correct. Ultralytics provides a utility function for this purpose:
|
||||
|
||||
```python
|
||||
from ultralytics.data.utils import visualize_image_annotations
|
||||
|
||||
label_map = { # Define the label map with all annotated class labels.
|
||||
0: "person",
|
||||
1: "car",
|
||||
}
|
||||
|
||||
# Visualize
|
||||
visualize_image_annotations(
|
||||
"path/to/image.jpg", # Input image path.
|
||||
"path/to/annotations.txt", # Annotation file path for the image.
|
||||
label_map,
|
||||
)
|
||||
```
|
||||
|
||||
This function draws bounding boxes, labels objects with class names, and adjusts text color for better readability, helping you identify and correct any annotation errors before training.
|
||||
|
||||
### Converting Segmentation Masks to YOLO Format
|
||||
|
||||
If you have segmentation masks in binary format, you can convert them to the YOLO segmentation format using:
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_segment_masks_to_yolo_seg
|
||||
|
||||
# For datasets like COCO with 80 classes
|
||||
convert_segment_masks_to_yolo_seg(masks_dir="path/to/masks_dir", output_dir="path/to/output_dir", classes=80)
|
||||
```
|
||||
|
||||
This utility converts binary mask images into the YOLO segmentation format and saves them in the specified output directory.
|
||||
|
||||
## FAQ
|
||||
|
||||
### What dataset formats does Ultralytics YOLO support for instance segmentation?
|
||||
|
||||
Ultralytics YOLO supports several dataset formats for instance segmentation, with the primary format being its own Ultralytics YOLO format. Each image in your dataset needs a corresponding text file with object information segmented into multiple rows (one row per object), listing the class index and normalized bounding coordinates. For more detailed instructions on the YOLO dataset format, visit the [Instance Segmentation Datasets Overview](#instance-segmentation-datasets-overview).
|
||||
|
||||
### How can I convert COCO dataset annotations to the YOLO format?
|
||||
|
||||
Converting COCO format annotations to YOLO format is straightforward using Ultralytics tools. You can use the `convert_coco` function from the `ultralytics.data.converter` module:
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_coco
|
||||
|
||||
convert_coco(labels_dir="path/to/coco/annotations/", use_segments=True)
|
||||
```
|
||||
|
||||
This script converts your COCO dataset annotations to the required YOLO format, making it suitable for training your YOLO models. For more details, refer to [Port or Convert Label Formats](#coco-dataset-format-to-yolo-format).
|
||||
|
||||
### How do I prepare a YAML file for training Ultralytics YOLO models?
|
||||
|
||||
To prepare a YAML file for training YOLO models with Ultralytics, you need to define the dataset paths and class names. Here's an example YAML configuration:
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/coco8-seg.yaml"
|
||||
```
|
||||
|
||||
Ensure you update the paths and class names according to your dataset. For more information, check the [Dataset YAML Format](#dataset-yaml-format) section.
|
||||
|
||||
### What is the auto-annotation feature in Ultralytics YOLO?
|
||||
|
||||
Auto-annotation in Ultralytics YOLO allows you to generate segmentation annotations for your dataset using a pretrained detection model. This significantly reduces the need for manual labeling. You can use the `auto_annotate` function as follows:
|
||||
|
||||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt") # or sam_model="mobile_sam.pt"
|
||||
```
|
||||
|
||||
This function automates the annotation process, making it faster and more efficient. For more details, explore the [Auto-Annotate Reference](https://docs.ultralytics.com/reference/data/annotator/#ultralytics.data.annotator.auto_annotate).
|
||||
@@ -1,165 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Explore the Package Segmentation Dataset. Optimize logistics and enhance vision models with curated images for package identification and sorting.
|
||||
keywords: Package Segmentation Dataset, computer vision, package identification, logistics, warehouse automation, segmentation models, training data, Ultralytics YOLO
|
||||
---
|
||||
|
||||
# Package Segmentation Dataset
|
||||
|
||||
<a href="https://colab.research.google.com/github/ultralytics/notebooks/blob/main/notebooks/how-to-train-ultralytics-yolo-on-package-segmentation-dataset.ipynb" target="_blank"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Package Segmentation Dataset In Colab"></a>
|
||||
|
||||
The Package Segmentation Dataset, available on Roboflow Universe, is a curated collection of images specifically tailored for tasks related to package segmentation within the field of [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv). This dataset is designed to assist researchers, developers, and enthusiasts working on projects involving package identification, sorting, and handling, primarily focusing on [image segmentation](https://www.ultralytics.com/glossary/image-segmentation) tasks.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/im7xBCnPURg"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Train Package Segmentation Model using Ultralytics YOLO26 | Industrial Packages 🎉
|
||||
</p>
|
||||
|
||||
Containing a diverse set of images showcasing various packages in different contexts and environments, the dataset serves as a valuable resource for training and evaluating segmentation models. Whether you are engaged in logistics, warehouse automation, or any application requiring precise package analysis, the Package Segmentation Dataset provides a targeted and comprehensive set of images to enhance the performance of your computer vision algorithms. Explore more datasets for segmentation tasks on our [datasets overview page](https://docs.ultralytics.com/datasets/segment/).
|
||||
|
||||
## Dataset Structure
|
||||
|
||||
The distribution of data in the Package Segmentation Dataset is structured as follows:
|
||||
|
||||
- **Training set**: Encompasses 1920 images accompanied by their corresponding annotations.
|
||||
- **Testing set**: Consists of 89 images, each paired with its respective annotations.
|
||||
- **Validation set**: Comprises 188 images, each with corresponding annotations.
|
||||
|
||||
## Applications
|
||||
|
||||
Package segmentation, facilitated by the Package Segmentation Dataset, is crucial for optimizing logistics, enhancing last-mile delivery, improving manufacturing quality control, and contributing to smart city solutions. From e-commerce to security applications, this dataset is a key resource, fostering innovation in computer vision for diverse and efficient package analysis applications.
|
||||
|
||||
### Smart Warehouses and Logistics
|
||||
|
||||
In modern warehouses, [vision AI solutions](https://www.ultralytics.com/solutions) can streamline operations by automating package identification and sorting. Computer vision models trained on this dataset can quickly detect and segment packages in real-time, even in challenging environments with dim lighting or cluttered spaces. This leads to faster processing times, reduced errors, and improved overall efficiency in [logistics operations](https://www.ultralytics.com/blog/ultralytics-yolo11-the-key-to-computer-vision-in-logistics).
|
||||
|
||||
### Quality Control and Damage Detection
|
||||
|
||||
Package segmentation models can be used to identify damaged packages by analyzing their shape and appearance. By detecting irregularities or deformations in package outlines, these models help ensure that only intact packages proceed through the supply chain, reducing customer complaints and return rates. This is a key aspect of [quality control in manufacturing](https://www.ultralytics.com/blog/improving-manufacturing-with-computer-vision) and is vital for maintaining product integrity.
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
A YAML (Yet Another Markup Language) file defines the dataset configuration, including paths, classes, and other essential details. For the Package Segmentation dataset, the `package-seg.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/package-seg.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/package-seg.yaml).
|
||||
|
||||
!!! example "ultralytics/cfg/datasets/package-seg.yaml"
|
||||
|
||||
```yaml
|
||||
--8<-- "ultralytics/cfg/datasets/package-seg.yaml"
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
To train an [Ultralytics YOLO26n](https://docs.ultralytics.com/models/yolo26/) model on the Package Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training page](../../modes/train.md).
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n-seg.pt") # load a pretrained segmentation model (recommended for training)
|
||||
|
||||
# Train the model on the Package Segmentation dataset
|
||||
results = model.train(data="package-seg.yaml", epochs=100, imgsz=640)
|
||||
|
||||
# Validate the model
|
||||
results = model.val()
|
||||
|
||||
# Perform inference on an image
|
||||
results = model("path/to/image.jpg")
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Load a pretrained segmentation model and start training
|
||||
yolo segment train data=package-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
|
||||
|
||||
# Resume training from the last checkpoint
|
||||
yolo segment train data=package-seg.yaml model=path/to/last.pt resume=True
|
||||
|
||||
# Validate the trained model
|
||||
yolo segment val data=package-seg.yaml model=path/to/best.pt
|
||||
|
||||
# Perform inference using the trained model
|
||||
yolo segment predict model=path/to/best.pt source=path/to/image.jpg
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
||||
The Package Segmentation dataset comprises a varied collection of images captured from multiple perspectives. Below are instances of data from the dataset, accompanied by their respective segmentation masks:
|
||||
|
||||
|
||||
|
||||
- This image displays an instance of package segmentation, featuring annotated masks outlining recognized package objects. The dataset incorporates a diverse collection of images taken in different locations, environments, and densities. It serves as a comprehensive resource for developing models specific to this [segmentation task](https://docs.ultralytics.com/tasks/segment/).
|
||||
- The example emphasizes the diversity and complexity present in the dataset, underscoring the significance of high-quality data for computer vision tasks involving package segmentation.
|
||||
|
||||
## Benefits of Using YOLO26 for Package Segmentation
|
||||
|
||||
[Ultralytics YOLO26](https://docs.ultralytics.com/models/yolo26/) offers several advantages for package segmentation tasks:
|
||||
|
||||
1. **Speed and Accuracy Balance**: YOLO26 achieves high precision and efficiency, making it ideal for [real-time inference](https://www.ultralytics.com/glossary/real-time-inference) in fast-paced logistics environments. It provides a strong balance compared to models like [YOLOv8](https://docs.ultralytics.com/models/yolov8/).
|
||||
|
||||
2. **Adaptability**: Models trained with YOLO26 can adapt to various warehouse conditions, from dim lighting to cluttered spaces, ensuring robust performance.
|
||||
|
||||
3. **Scalability**: During peak periods like holiday seasons, YOLO26 models can efficiently scale to handle increased package volumes without compromising performance or [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
|
||||
4. **Integration Capabilities**: YOLO26 can be easily integrated with existing warehouse management systems and deployed across various platforms using formats like [ONNX](https://docs.ultralytics.com/integrations/onnx/) or [TensorRT](https://docs.ultralytics.com/integrations/tensorrt/), facilitating end-to-end automated solutions.
|
||||
|
||||
## Citations and Acknowledgments
|
||||
|
||||
If you integrate the Package Segmentation dataset into your research or development initiatives, please cite the source appropriately:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{ factory_package_dataset,
|
||||
title = { factory_package Dataset },
|
||||
type = { Open Source Dataset },
|
||||
author = { factorypackage },
|
||||
url = { https://universe.roboflow.com/factorypackage/factory_package },
|
||||
journal = { Roboflow Universe },
|
||||
publisher = { Roboflow },
|
||||
year = { 2024 },
|
||||
month = { jan },
|
||||
note = { visited on 2024-01-24 },
|
||||
}
|
||||
```
|
||||
|
||||
We express our gratitude to the creators of the Package Segmentation dataset for their contribution to the computer vision community. For further exploration of datasets and model training, consider visiting our [Ultralytics Datasets](https://docs.ultralytics.com/datasets/) page and our guide on [model training tips](https://docs.ultralytics.com/guides/model-training-tips/).
|
||||
|
||||
## FAQ
|
||||
|
||||
### What is the Package Segmentation Dataset and how can it help in computer vision projects?
|
||||
|
||||
- The Package Segmentation Dataset is a curated collection of images tailored for tasks involving package [image segmentation](https://www.ultralytics.com/glossary/image-segmentation). It includes diverse images of packages in various contexts, making it invaluable for training and evaluating segmentation models. This dataset is particularly useful for applications in logistics, warehouse automation, and any project requiring precise package analysis.
|
||||
|
||||
### How do I train an Ultralytics YOLO26 model on the Package Segmentation Dataset?
|
||||
|
||||
- You can train an [Ultralytics YOLO26](https://docs.ultralytics.com/models/yolo26/) model using both Python and CLI methods. Use the code snippets provided in the [Usage](#usage) section. Refer to the model [Training page](../../modes/train.md) for more details on arguments and configurations.
|
||||
|
||||
### What are the components of the Package Segmentation Dataset, and how is it structured?
|
||||
|
||||
- The dataset is structured into three main components:
|
||||
- **Training set**: Contains 1920 images with annotations.
|
||||
- **Testing set**: Comprises 89 images with corresponding annotations.
|
||||
- **Validation set**: Includes 188 images with annotations.
|
||||
- This structure ensures a balanced dataset for thorough model training, validation, and testing, following best practices outlined in [model evaluation guides](https://docs.ultralytics.com/guides/model-evaluation-insights/).
|
||||
|
||||
### Why should I use Ultralytics YOLO26 with the Package Segmentation Dataset?
|
||||
|
||||
- Ultralytics YOLO26 provides state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed for real-time [object detection](https://www.ultralytics.com/glossary/object-detection) and segmentation tasks. Using it with the Package Segmentation Dataset allows you to leverage YOLO26's capabilities for precise package segmentation, which is especially beneficial for industries like [logistics](https://www.ultralytics.com/blog/ultralytics-yolo11-the-key-to-computer-vision-in-logistics) and warehouse automation.
|
||||
|
||||
### How can I access and use the package-seg.yaml file for the Package Segmentation Dataset?
|
||||
|
||||
- The `package-seg.yaml` file is hosted on Ultralytics' GitHub repository and contains essential information about the dataset's paths, classes, and configuration. You can view or download it at <https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/package-seg.yaml>. This file is crucial for configuring your models to utilize the dataset efficiently. For more insights and practical examples, explore our [Python Usage](https://docs.ultralytics.com/usage/python/) section.
|
||||
@@ -1,142 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn how to use Multi-Object Tracking with YOLO. Explore dataset formats, tracking algorithms, and implementation examples using Python or CLI for real-time object tracking.
|
||||
keywords: YOLO, Multi-Object Tracking, Tracking Datasets, Python Tracking Example, CLI Tracking Example, Object Detection, Ultralytics, AI, Machine Learning, BoT-SORT, ByteTrack
|
||||
---
|
||||
|
||||
# Multi-object Tracking Datasets Overview
|
||||
|
||||
Multi-object tracking is a critical component in video analytics that identifies objects and maintains unique IDs for each detected object across video frames. Ultralytics YOLO provides powerful tracking capabilities that can be applied to various domains including surveillance, sports analytics, and traffic monitoring.
|
||||
|
||||
## Dataset Format (Coming Soon)
|
||||
|
||||
Ultralytics tracking currently reuses detection, segmentation, or pose models without requiring tracker-specific training. Native tracker-training support is under active development.
|
||||
|
||||
## Available Trackers
|
||||
|
||||
Ultralytics YOLO supports the following tracking algorithms:
|
||||
|
||||
- [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Use `botsort.yaml` to enable this tracker (default)
|
||||
- [ByteTrack](https://github.com/FoundationVision/ByteTrack) - Use `bytetrack.yaml` to enable this tracker
|
||||
|
||||
## Usage
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n.pt")
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.7, show=True)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo track model=yolo26n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.1 iou=0.7 show=True
|
||||
```
|
||||
|
||||
## Persisting Tracks Between Frames
|
||||
|
||||
For continuous tracking across video frames, you can use the `persist=True` parameter:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
import cv2
|
||||
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load the YOLO model
|
||||
model = YOLO("yolo26n.pt")
|
||||
|
||||
# Open the video file
|
||||
cap = cv2.VideoCapture("path/to/video.mp4")
|
||||
|
||||
while cap.isOpened():
|
||||
success, frame = cap.read()
|
||||
if success:
|
||||
# Run tracking with persistence between frames
|
||||
results = model.track(frame, persist=True)
|
||||
|
||||
# Visualize the results
|
||||
annotated_frame = results[0].plot()
|
||||
cv2.imshow("Tracking", annotated_frame)
|
||||
|
||||
if cv2.waitKey(1) & 0xFF == ord("q"):
|
||||
break
|
||||
else:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
cv2.destroyAllWindows()
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I use Multi-Object Tracking with Ultralytics YOLO?
|
||||
|
||||
To use Multi-Object Tracking with Ultralytics YOLO, you can start by using the Python or CLI examples provided. Here is how you can get started:
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n.pt") # Load the YOLO26 model
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.7, show=True)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo track model=yolo26n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.1 iou=0.7 show=True
|
||||
```
|
||||
|
||||
These commands load the YOLO26 model and use it for tracking objects in the given video source with specific confidence (`conf`) and [Intersection over Union](https://www.ultralytics.com/glossary/intersection-over-union-iou) (`iou`) thresholds. For more details, refer to the [track mode documentation](../../modes/track.md).
|
||||
|
||||
### What are the upcoming features for training trackers in Ultralytics?
|
||||
|
||||
Ultralytics is continuously enhancing its AI models. An upcoming feature will enable the training of standalone trackers. Until then, Multi-Object Detector leverages pretrained detection, segmentation, or Pose models for tracking without requiring standalone training. Stay updated by following our [blog](https://www.ultralytics.com/blog) or checking the [upcoming features](../../reference/trackers/track.md).
|
||||
|
||||
### Why should I use Ultralytics YOLO for multi-object tracking?
|
||||
|
||||
Ultralytics YOLO is a state-of-the-art [object detection](https://www.ultralytics.com/glossary/object-detection) model known for its real-time performance and high [accuracy](https://www.ultralytics.com/glossary/accuracy). Using YOLO for multi-object tracking provides several advantages:
|
||||
|
||||
- **Real-time tracking:** Achieve efficient and high-speed tracking ideal for dynamic environments.
|
||||
- **Flexibility with pretrained models:** No need to train from scratch; simply use pretrained detection, segmentation, or Pose models.
|
||||
- **Ease of use:** Simple API integration with both Python and CLI makes setting up tracking pipelines straightforward.
|
||||
- **Extensive documentation and community support:** Ultralytics provides comprehensive documentation and an active community forum to troubleshoot issues and enhance your tracking models.
|
||||
|
||||
For more details on setting up and using YOLO for tracking, visit our [track usage guide](../../modes/track.md).
|
||||
|
||||
### Can I use custom datasets for multi-object tracking with Ultralytics YOLO?
|
||||
|
||||
Yes, you can use custom datasets for multi-object tracking with Ultralytics YOLO. While support for standalone tracker training is an upcoming feature, you can already use pretrained models on your custom datasets. Prepare your datasets in the appropriate format compatible with YOLO and follow the documentation to integrate them.
|
||||
|
||||
### How do I interpret the results from the Ultralytics YOLO tracking model?
|
||||
|
||||
After running a tracking job with Ultralytics YOLO, the results include various data points such as tracked object IDs, their bounding boxes, and the confidence scores. Here's a brief overview of how to interpret these results:
|
||||
|
||||
- **Tracked IDs:** Each object is assigned a unique ID, which helps in tracking it across frames.
|
||||
- **Bounding boxes:** These indicate the location of tracked objects within the frame.
|
||||
- **Confidence scores:** These reflect the model's confidence in detecting the tracked object.
|
||||
|
||||
For detailed guidance on interpreting and visualizing these results, refer to the [results handling guide](../../reference/engine/results.md).
|
||||
|
||||
### How can I customize the tracker configuration?
|
||||
|
||||
You can customize the tracker by creating a modified version of the tracker configuration file. Copy an existing tracker config file from [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers), modify the parameters as needed, and specify this file when running the tracker:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n.pt")
|
||||
results = model.track(source="video.mp4", tracker="custom_tracker.yaml")
|
||||
```
|
||||
@@ -1,330 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn to create line graphs, bar plots, and pie charts using Python with guided instructions and code snippets. Maximize your data visualization skills!
|
||||
keywords: Ultralytics, YOLO26, data visualization, line graphs, bar plots, pie charts, Python, analytics, tutorial, guide
|
||||
---
|
||||
|
||||
# Analytics using Ultralytics YOLO26
|
||||
|
||||
## Introduction
|
||||
|
||||
This guide provides a comprehensive overview of three fundamental types of [data visualizations](https://www.ultralytics.com/glossary/data-visualization): line graphs, bar plots, and pie charts. Each section includes step-by-step instructions and code snippets on how to create these visualizations using Python.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/tVuLIMt4DMY"
|
||||
title="YouTube video player" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to generate Analytical Graphs using Ultralytics | Line Graphs, Bar Plots, Area and Pie Charts
|
||||
</p>
|
||||
|
||||
### Visual Samples
|
||||
|
||||
| Line Graph | Bar Plot | Pie Chart |
|
||||
| :----------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------: |
|
||||
|  |  |  |
|
||||
|
||||
### Why Graphs are Important
|
||||
|
||||
- Line graphs are ideal for tracking changes over short and long periods and for comparing changes for multiple groups over the same period.
|
||||
- Bar plots, on the other hand, are suitable for comparing quantities across different categories and showing relationships between a category and its numerical value.
|
||||
- Lastly, pie charts are effective for illustrating proportions among categories and showing parts of a whole.
|
||||
|
||||
!!! example "Analytics using Ultralytics YOLO"
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo solutions analytics show=True
|
||||
|
||||
# Pass the source
|
||||
yolo solutions analytics source="path/to/video.mp4"
|
||||
|
||||
# Generate the pie chart
|
||||
yolo solutions analytics analytics_type="pie" show=True
|
||||
|
||||
# Generate the bar plots
|
||||
yolo solutions analytics analytics_type="bar" show=True
|
||||
|
||||
# Generate the area plots
|
||||
yolo solutions analytics analytics_type="area" show=True
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
import cv2
|
||||
|
||||
from ultralytics import solutions
|
||||
|
||||
cap = cv2.VideoCapture("path/to/video.mp4")
|
||||
assert cap.isOpened(), "Error reading video file"
|
||||
|
||||
# Video writer
|
||||
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
|
||||
out = cv2.VideoWriter(
|
||||
"analytics_output.avi",
|
||||
cv2.VideoWriter_fourcc(*"MJPG"),
|
||||
fps,
|
||||
(1280, 720), # this is fixed
|
||||
)
|
||||
|
||||
# Initialize analytics object
|
||||
analytics = solutions.Analytics(
|
||||
show=True, # display the output
|
||||
analytics_type="line", # pass the analytics type, could be "pie", "bar" or "area".
|
||||
model="yolo26n.pt", # path to the YOLO26 model file
|
||||
# classes=[0, 2], # display analytics for specific detection classes
|
||||
)
|
||||
|
||||
# Process video
|
||||
frame_count = 0
|
||||
while cap.isOpened():
|
||||
success, im0 = cap.read()
|
||||
if success:
|
||||
frame_count += 1
|
||||
results = analytics(im0, frame_count) # update analytics graph every frame
|
||||
|
||||
# print(results) # access the output
|
||||
|
||||
out.write(results.plot_im) # write the video file
|
||||
else:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
out.release()
|
||||
cv2.destroyAllWindows() # destroy all opened windows
|
||||
```
|
||||
|
||||
### `Analytics` Arguments
|
||||
|
||||
Here's a table outlining the Analytics arguments:
|
||||
|
||||
{% from "macros/solutions-args.md" import param_table %}
|
||||
{{ param_table(["model", "analytics_type"]) }}
|
||||
|
||||
You can also leverage different [`track`](../modes/track.md) arguments in the `Analytics` solution.
|
||||
|
||||
{% from "macros/track-args.md" import param_table %}
|
||||
{{ param_table(["tracker", "conf", "iou", "classes", "verbose", "device"]) }}
|
||||
|
||||
Additionally, the following visualization arguments are supported:
|
||||
|
||||
{% from "macros/visualization-args.md" import param_table %}
|
||||
{{ param_table(["show", "line_width"]) }}
|
||||
|
||||
## Conclusion
|
||||
|
||||
Understanding when and how to use different types of visualizations is crucial for effective data analysis. Line graphs, bar plots, and pie charts are fundamental tools that can help you convey your data's story more clearly and effectively. The Ultralytics YOLO26 Analytics solution provides a streamlined way to generate these visualizations from your [object detection](https://www.ultralytics.com/glossary/object-detection) and tracking results, making it easier to extract meaningful insights from your visual data.
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I create a line graph using Ultralytics YOLO26 Analytics?
|
||||
|
||||
To create a line graph using Ultralytics YOLO26 Analytics, follow these steps:
|
||||
|
||||
1. Load a YOLO26 model and open your video file.
|
||||
2. Initialize the `Analytics` class with the type set to "line."
|
||||
3. Iterate through video frames, updating the line graph with relevant data, such as object counts per frame.
|
||||
4. Save the output video displaying the line graph.
|
||||
|
||||
Example:
|
||||
|
||||
```python
|
||||
import cv2
|
||||
|
||||
from ultralytics import solutions
|
||||
|
||||
cap = cv2.VideoCapture("path/to/video.mp4")
|
||||
assert cap.isOpened(), "Error reading video file"
|
||||
|
||||
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
|
||||
|
||||
out = cv2.VideoWriter(
|
||||
"ultralytics_analytics.avi",
|
||||
cv2.VideoWriter_fourcc(*"MJPG"),
|
||||
fps,
|
||||
(1280, 720), # this is fixed
|
||||
)
|
||||
|
||||
analytics = solutions.Analytics(
|
||||
analytics_type="line",
|
||||
show=True,
|
||||
)
|
||||
|
||||
frame_count = 0
|
||||
while cap.isOpened():
|
||||
success, im0 = cap.read()
|
||||
if success:
|
||||
frame_count += 1
|
||||
results = analytics(im0, frame_count) # update analytics graph every frame
|
||||
out.write(results.plot_im) # write the video file
|
||||
else:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
out.release()
|
||||
cv2.destroyAllWindows()
|
||||
```
|
||||
|
||||
For further details on configuring the `Analytics` class, visit the [Analytics using Ultralytics YOLO26](#analytics-using-ultralytics-yolo26) section.
|
||||
|
||||
### What are the benefits of using Ultralytics YOLO26 for creating bar plots?
|
||||
|
||||
Using Ultralytics YOLO26 for creating bar plots offers several benefits:
|
||||
|
||||
1. **Real-time Data Visualization**: Seamlessly integrate [object detection](https://www.ultralytics.com/glossary/object-detection) results into bar plots for dynamic updates.
|
||||
2. **Ease of Use**: Simple API and functions make it straightforward to implement and visualize data.
|
||||
3. **Customization**: Customize titles, labels, colors, and more to fit your specific requirements.
|
||||
4. **Efficiency**: Efficiently handle large amounts of data and update plots in real-time during video processing.
|
||||
|
||||
Use the following example to generate a bar plot:
|
||||
|
||||
```python
|
||||
import cv2
|
||||
|
||||
from ultralytics import solutions
|
||||
|
||||
cap = cv2.VideoCapture("path/to/video.mp4")
|
||||
assert cap.isOpened(), "Error reading video file"
|
||||
|
||||
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
|
||||
|
||||
out = cv2.VideoWriter(
|
||||
"ultralytics_analytics.avi",
|
||||
cv2.VideoWriter_fourcc(*"MJPG"),
|
||||
fps,
|
||||
(1280, 720), # this is fixed
|
||||
)
|
||||
|
||||
analytics = solutions.Analytics(
|
||||
analytics_type="bar",
|
||||
show=True,
|
||||
)
|
||||
|
||||
frame_count = 0
|
||||
while cap.isOpened():
|
||||
success, im0 = cap.read()
|
||||
if success:
|
||||
frame_count += 1
|
||||
results = analytics(im0, frame_count) # update analytics graph every frame
|
||||
out.write(results.plot_im) # write the video file
|
||||
else:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
out.release()
|
||||
cv2.destroyAllWindows()
|
||||
```
|
||||
|
||||
To learn more, visit the [Bar Plot](#visual-samples) section in the guide.
|
||||
|
||||
### Why should I use Ultralytics YOLO26 for creating pie charts in my data visualization projects?
|
||||
|
||||
Ultralytics YOLO26 is an excellent choice for creating pie charts because:
|
||||
|
||||
1. **Integration with Object Detection**: Directly integrate object detection results into pie charts for immediate insights.
|
||||
2. **User-Friendly API**: Simple to set up and use with minimal code.
|
||||
3. **Customizable**: Various customization options for colors, labels, and more.
|
||||
4. **Real-time Updates**: Handle and visualize data in real-time, which is ideal for video analytics projects.
|
||||
|
||||
Here's a quick example:
|
||||
|
||||
```python
|
||||
import cv2
|
||||
|
||||
from ultralytics import solutions
|
||||
|
||||
cap = cv2.VideoCapture("path/to/video.mp4")
|
||||
assert cap.isOpened(), "Error reading video file"
|
||||
|
||||
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
|
||||
|
||||
out = cv2.VideoWriter(
|
||||
"ultralytics_analytics.avi",
|
||||
cv2.VideoWriter_fourcc(*"MJPG"),
|
||||
fps,
|
||||
(1280, 720), # this is fixed
|
||||
)
|
||||
|
||||
analytics = solutions.Analytics(
|
||||
analytics_type="pie",
|
||||
show=True,
|
||||
)
|
||||
|
||||
frame_count = 0
|
||||
while cap.isOpened():
|
||||
success, im0 = cap.read()
|
||||
if success:
|
||||
frame_count += 1
|
||||
results = analytics(im0, frame_count) # update analytics graph every frame
|
||||
out.write(results.plot_im) # write the video file
|
||||
else:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
out.release()
|
||||
cv2.destroyAllWindows()
|
||||
```
|
||||
|
||||
For more information, refer to the [Pie Chart](#visual-samples) section in the guide.
|
||||
|
||||
### Can Ultralytics YOLO26 be used to track objects and dynamically update visualizations?
|
||||
|
||||
Yes, Ultralytics YOLO26 can be used to track objects and dynamically update visualizations. It supports tracking multiple objects in real-time and can update various visualizations like line graphs, bar plots, and pie charts based on the tracked objects' data.
|
||||
|
||||
Example for tracking and updating a line graph:
|
||||
|
||||
```python
|
||||
import cv2
|
||||
|
||||
from ultralytics import solutions
|
||||
|
||||
cap = cv2.VideoCapture("path/to/video.mp4")
|
||||
assert cap.isOpened(), "Error reading video file"
|
||||
|
||||
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
|
||||
|
||||
out = cv2.VideoWriter(
|
||||
"ultralytics_analytics.avi",
|
||||
cv2.VideoWriter_fourcc(*"MJPG"),
|
||||
fps,
|
||||
(1280, 720), # this is fixed
|
||||
)
|
||||
|
||||
analytics = solutions.Analytics(
|
||||
analytics_type="line",
|
||||
show=True,
|
||||
)
|
||||
|
||||
frame_count = 0
|
||||
while cap.isOpened():
|
||||
success, im0 = cap.read()
|
||||
if success:
|
||||
frame_count += 1
|
||||
results = analytics(im0, frame_count) # update analytics graph every frame
|
||||
out.write(results.plot_im) # write the video file
|
||||
else:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
out.release()
|
||||
cv2.destroyAllWindows()
|
||||
```
|
||||
|
||||
To learn about the complete functionality, see the [Tracking](../modes/track.md) section.
|
||||
|
||||
### What makes Ultralytics YOLO26 different from other object detection solutions like [OpenCV](https://www.ultralytics.com/glossary/opencv) and [TensorFlow](https://www.ultralytics.com/glossary/tensorflow)?
|
||||
|
||||
Ultralytics YOLO26 stands out from other object detection solutions like OpenCV and TensorFlow for multiple reasons:
|
||||
|
||||
1. **State-of-the-art [Accuracy](https://www.ultralytics.com/glossary/accuracy)**: YOLO26 provides superior accuracy in object detection, segmentation, and classification tasks.
|
||||
2. **Ease of Use**: User-friendly API allows for quick implementation and integration without extensive coding.
|
||||
3. **Real-time Performance**: Optimized for high-speed inference, suitable for real-time applications.
|
||||
4. **Diverse Applications**: Supports various tasks including multi-object tracking, custom model training, and exporting to different formats like ONNX, TensorRT, and CoreML.
|
||||
5. **Comprehensive Documentation**: Extensive [documentation](https://docs.ultralytics.com/) and [blog resources](https://www.ultralytics.com/blog) to guide users through every step.
|
||||
|
||||
For more detailed comparisons and use cases, explore our [Ultralytics Blog](https://www.ultralytics.com/blog/ai-use-cases-transforming-your-future).
|
||||
@@ -1,227 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
description: Learn how to run YOLO26 on AzureML. Quickstart instructions for terminal and notebooks to harness Azure's cloud computing for efficient model training.
|
||||
keywords: YOLO26, AzureML, machine learning, cloud computing, quickstart, terminal, notebooks, model training, Python SDK, AI, Ultralytics
|
||||
---
|
||||
|
||||
# YOLO26 🚀 on AzureML
|
||||
|
||||
## What is Azure?
|
||||
|
||||
[Azure](https://azure.microsoft.com/) is Microsoft's [cloud computing](https://www.ultralytics.com/glossary/cloud-computing) platform, designed to help organizations move their workloads to the cloud from on-premises data centers. With the full spectrum of cloud services including those for computing, databases, analytics, [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml), and networking, users can pick and choose from these services to develop and scale new applications, or run existing applications, in the public cloud.
|
||||
|
||||
## What is Azure Machine Learning (AzureML)?
|
||||
|
||||
Azure Machine Learning, commonly referred to as AzureML, is a fully managed cloud service that enables data scientists and developers to efficiently embed predictive analytics into their applications, helping organizations use massive data sets and bring all the benefits of the cloud to machine learning. AzureML offers a variety of services and capabilities aimed at making machine learning accessible, easy to use, and scalable. It provides capabilities like automated machine learning, drag-and-drop model training, as well as a robust Python SDK so that developers can make the most out of their machine learning models.
|
||||
|
||||
## How Does AzureML Benefit YOLO Users?
|
||||
|
||||
For users of YOLO (You Only Look Once), AzureML provides a robust, scalable, and efficient platform to both train and deploy machine learning models. Whether you are looking to run quick prototypes or scale up to handle more extensive data, AzureML's flexible and user-friendly environment offers various tools and services to fit your needs. You can leverage AzureML to:
|
||||
|
||||
- Easily manage large datasets and computational resources for training.
|
||||
- Utilize built-in tools for data preprocessing, feature selection, and model training.
|
||||
- Collaborate more efficiently with capabilities for MLOps (Machine Learning Operations), including but not limited to monitoring, auditing, and versioning of models and data.
|
||||
|
||||
In the subsequent sections, you will find a quickstart guide detailing how to run YOLO26 object detection models using AzureML, either from a compute terminal or a notebook.
|
||||
|
||||
## Prerequisites
|
||||
|
||||
Before you can get started, make sure you have access to an AzureML workspace. If you don't have one, you can create a new [AzureML workspace](https://learn.microsoft.com/azure/machine-learning/concept-workspace?view=azureml-api-2) by following Azure's official documentation. This workspace acts as a centralized place to manage all AzureML resources.
|
||||
|
||||
## Create a compute instance
|
||||
|
||||
From your AzureML workspace, select Compute > Compute instances > New, select the instance with the resources you need.
|
||||
|
||||
<p align="center">
|
||||
<img width="1280" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/create-compute-arrow.avif" alt="Create Azure Compute Instance">
|
||||
</p>
|
||||
|
||||
## Quickstart from Terminal
|
||||
|
||||
Start your compute and open a Terminal:
|
||||
|
||||
<p align="center">
|
||||
<img width="480" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/open-terminal.avif" alt="Open Terminal">
|
||||
</p>
|
||||
|
||||
### Create virtualenv
|
||||
|
||||
Create a conda virtual environment with your preferred Python version and install pip in it. Python 3.13.1 currently has dependency issues in AzureML, so use Python 3.12 instead.
|
||||
|
||||
```bash
|
||||
conda create --name yolo26env -y python=3.12
|
||||
conda activate yolo26env
|
||||
conda install pip -y
|
||||
```
|
||||
|
||||
Install the required dependencies:
|
||||
|
||||
```bash
|
||||
cd ultralytics
|
||||
pip install -r requirements.txt
|
||||
pip install ultralytics
|
||||
pip install onnx
|
||||
```
|
||||
|
||||
### Perform YOLO26 tasks
|
||||
|
||||
Predict:
|
||||
|
||||
```bash
|
||||
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'
|
||||
```
|
||||
|
||||
Train a detection model for 10 [epochs](https://www.ultralytics.com/glossary/epoch) with an initial learning_rate of 0.01:
|
||||
|
||||
```bash
|
||||
yolo train data=coco8.yaml model=yolo26n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
You can find more [instructions to use the Ultralytics CLI here](../quickstart.md#use-ultralytics-with-cli).
|
||||
|
||||
## Quickstart from a Notebook
|
||||
|
||||
### Create a new IPython kernel
|
||||
|
||||
Open the compute Terminal.
|
||||
|
||||
<p align="center">
|
||||
<img width="480" src="https://cdn.jsdelivr.net/gh/ultralytics/assets@main/docs/open-terminal.avif" alt="Open Terminal">
|
||||
</p>
|
||||
|
||||
From your compute terminal, create a new ipykernel using Python 3.12 that will be used by your notebook to manage dependencies:
|
||||
|
||||
```bash
|
||||
conda create --name yolo26env -y python=3.12
|
||||
conda activate yolo26env
|
||||
conda install pip -y
|
||||
conda install ipykernel -y
|
||||
python -m ipykernel install --user --name yolo26env --display-name "yolo26env"
|
||||
```
|
||||
|
||||
Close your terminal and create a new notebook. From your notebook, select the newly created kernel.
|
||||
|
||||
Then open a notebook cell and install the required dependencies:
|
||||
|
||||
```bash
|
||||
%%bash
|
||||
source activate yolo26env
|
||||
cd ultralytics
|
||||
pip install -r requirements.txt
|
||||
pip install ultralytics
|
||||
pip install onnx
|
||||
```
|
||||
|
||||
Note that you need to run `source activate yolo26env` in every `%%bash` cell to ensure the cell uses the intended environment.
|
||||
|
||||
Run some predictions using the [Ultralytics CLI](../quickstart.md#use-ultralytics-with-cli):
|
||||
|
||||
```bash
|
||||
%%bash
|
||||
source activate yolo26env
|
||||
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'
|
||||
```
|
||||
|
||||
Or with the [Ultralytics Python interface](../quickstart.md#use-ultralytics-with-python), for example to train the model:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolo26n.pt") # load an official YOLO26n model
|
||||
|
||||
# Use the model
|
||||
model.train(data="coco8.yaml", epochs=3) # train the model
|
||||
metrics = model.val() # evaluate model performance on the validation set
|
||||
results = model("https://ultralytics.com/images/bus.jpg") # predict on an image
|
||||
path = model.export(format="onnx") # export the model to ONNX format
|
||||
```
|
||||
|
||||
You can use either the Ultralytics CLI or Python interface for running YOLO26 tasks, as described in the terminal section above.
|
||||
|
||||
By following these steps, you should be able to get YOLO26 running quickly on AzureML for quick trials. For more advanced uses, you may refer to the full AzureML documentation linked at the beginning of this guide.
|
||||
|
||||
## Explore More with AzureML
|
||||
|
||||
This guide serves as an introduction to get you up and running with YOLO26 on AzureML. However, it only scratches the surface of what AzureML can offer. To delve deeper and unlock the full potential of AzureML for your machine learning projects, consider exploring the following resources:
|
||||
|
||||
- [Create a Data Asset](https://learn.microsoft.com/azure/machine-learning/how-to-create-data-assets): Learn how to set up and manage your data assets effectively within the AzureML environment.
|
||||
- [Initiate an AzureML Job](https://learn.microsoft.com/azure/machine-learning/how-to-train-model): Get a comprehensive understanding of how to kickstart your machine learning training jobs on AzureML.
|
||||
- [Register a Model](https://learn.microsoft.com/azure/machine-learning/how-to-manage-models): Familiarize yourself with model management practices including registration, versioning, and deployment.
|
||||
- [Train YOLO26 with AzureML Python SDK](https://medium.com/@ouphi/how-to-train-the-yolov8-model-with-azure-machine-learning-python-sdk-8268696be8ba): Explore a step-by-step guide on using the AzureML Python SDK to train your YOLO26 models.
|
||||
- [Train YOLO26 with AzureML CLI](https://medium.com/@ouphi/how-to-train-the-yolov8-model-with-azureml-and-the-az-cli-73d3c870ba8e): Discover how to utilize the command-line interface for streamlined training and management of YOLO26 models on AzureML.
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I run YOLO26 on AzureML for model training?
|
||||
|
||||
Running YOLO26 on AzureML for model training involves several steps:
|
||||
|
||||
1. **Create a Compute Instance**: From your AzureML workspace, navigate to Compute > Compute instances > New, and select the required instance.
|
||||
|
||||
2. **Set Up the Environment**: Start your compute instance, open a terminal, and create a Conda environment. Set your Python version (Python 3.13.1 is not supported yet):
|
||||
|
||||
```bash
|
||||
conda create --name yolo26env -y python=3.12
|
||||
conda activate yolo26env
|
||||
conda install pip -y
|
||||
pip install ultralytics onnx
|
||||
```
|
||||
|
||||
3. **Run YOLO26 Tasks**: Use the Ultralytics CLI to train your model:
|
||||
```bash
|
||||
yolo train data=coco8.yaml model=yolo26n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
For more details, you can refer to the [instructions to use the Ultralytics CLI](../quickstart.md#use-ultralytics-with-cli).
|
||||
|
||||
### What are the benefits of using AzureML for YOLO26 training?
|
||||
|
||||
AzureML provides a robust and efficient ecosystem for training YOLO26 models:
|
||||
|
||||
- **Scalability**: Easily scale your compute resources as your data and model complexity grows.
|
||||
- **MLOps Integration**: Utilize features like versioning, monitoring, and auditing to streamline ML operations.
|
||||
- **Collaboration**: Share and manage resources within teams, enhancing collaborative workflows.
|
||||
|
||||
These advantages make AzureML an ideal platform for projects ranging from quick prototypes to large-scale deployments. For more tips, check out [AzureML Jobs](https://learn.microsoft.com/azure/machine-learning/how-to-train-model).
|
||||
|
||||
### How do I troubleshoot common issues when running YOLO26 on AzureML?
|
||||
|
||||
Troubleshooting common issues with YOLO26 on AzureML can involve the following steps:
|
||||
|
||||
- **Dependency Issues**: Ensure all required packages are installed. Refer to the `requirements.txt` file for dependencies.
|
||||
- **Environment Setup**: Verify that your conda environment is correctly activated before running commands.
|
||||
- **Resource Allocation**: Make sure your compute instances have sufficient resources to handle the training workload.
|
||||
|
||||
For additional guidance, review our [YOLO Common Issues](https://docs.ultralytics.com/guides/yolo-common-issues/) documentation.
|
||||
|
||||
### Can I use both the Ultralytics CLI and Python interface on AzureML?
|
||||
|
||||
Yes, AzureML allows you to use both the Ultralytics CLI and the Python interface seamlessly:
|
||||
|
||||
- **CLI**: Ideal for quick tasks and running standard scripts directly from the terminal.
|
||||
|
||||
```bash
|
||||
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'
|
||||
```
|
||||
|
||||
- **Python Interface**: Useful for more complex tasks requiring custom coding and integration within notebooks.
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolo26n.pt")
|
||||
model.train(data="coco8.yaml", epochs=3)
|
||||
```
|
||||
|
||||
For step-by-step instructions, refer to the [CLI quickstart guide](../quickstart.md#use-ultralytics-with-cli) and the [Python quickstart guide](../quickstart.md#use-ultralytics-with-python).
|
||||
|
||||
### What is the advantage of using Ultralytics YOLO26 over other [object detection](https://www.ultralytics.com/glossary/object-detection) models?
|
||||
|
||||
Ultralytics YOLO26 offers several unique advantages over competing object detection models:
|
||||
|
||||
- **Speed**: Faster inference and training times compared to models like Faster R-CNN and SSD.
|
||||
- **[Accuracy](https://www.ultralytics.com/glossary/accuracy)**: High accuracy in detection tasks with features like anchor-free design and enhanced augmentation strategies.
|
||||
- **Ease of Use**: Intuitive API and CLI for quick setup, making it accessible both to beginners and experts.
|
||||
|
||||
To explore more about YOLO26's features, visit the [Ultralytics YOLO](https://www.ultralytics.com/yolo) page for detailed insights.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user