diff --git a/ultralytics/.github/ISSUE_TEMPLATE/bug-report.yml b/ultralytics/.github/ISSUE_TEMPLATE/bug-report.yml
new file mode 100755
index 0000000..203250b
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,96 @@
+name: ๐ Bug Report
+# title: " "
+description: Problems with YOLOv8
+labels: [bug, triage]
+body:
+ - type: markdown
+ attributes:
+ value: |
+ Thank you for submitting a YOLOv8 ๐ 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 YOLOv8 [issues](https://github.com/ultralytics/ultralytics/issues) and found no similar bug report.
+ required: true
+
+ - type: dropdown
+ attributes:
+ label: YOLOv8 Component
+ description: |
+ Please select the part of YOLOv8 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: Provide console output with error messages and/or screenshots of the bug.
+ placeholder: |
+ ๐ก ProTip! Include as much information as possible (screenshots, logs, tracebacks etc.) to receive the most helpful response.
+ validations:
+ required: true
+
+ - type: textarea
+ attributes:
+ label: Environment
+ description: Please specify the software and hardware you used to produce the bug.
+ placeholder: |
+ Paste output of `yolo checks` or `ultralytics.checks()` command, i.e.:
+ ```
+ Ultralytics YOLOv8.0.181 ๐ Python-3.11.2 torch-2.0.1 CPU (Apple M2)
+ 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 M2
+ CUDA None
+ ```
+ validations:
+ required: false
+
+ - 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: false
+
+ - 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 YOLOv8 for everyone, especially if you have a good understanding of how to implement a fix or feature.
+ See the YOLOv8 [Contributing Guide](https://docs.ultralytics.com/help/contributing) to get started.
+ options:
+ - label: Yes I'd like to help by submitting a PR!
diff --git a/ultralytics/.github/ISSUE_TEMPLATE/bug-report.yml:Zone.Identifier b/ultralytics/.github/ISSUE_TEMPLATE/bug-report.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/bug-report.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/ISSUE_TEMPLATE/config.yml b/ultralytics/.github/ISSUE_TEMPLATE/config.yml
new file mode 100755
index 0000000..9018a62
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,11 @@
+blank_issues_enabled: true
+contact_links:
+ - name: ๐ Docs
+ url: https://docs.ultralytics.com/
+ about: Full Ultralytics YOLOv8 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
diff --git a/ultralytics/.github/ISSUE_TEMPLATE/config.yml:Zone.Identifier b/ultralytics/.github/ISSUE_TEMPLATE/config.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/config.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/ISSUE_TEMPLATE/feature-request.yml b/ultralytics/.github/ISSUE_TEMPLATE/feature-request.yml
new file mode 100755
index 0000000..76fc7b1
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,50 @@
+name: ๐ Feature Request
+description: Suggest a YOLOv8 idea
+# title: " "
+labels: [enhancement]
+body:
+ - type: markdown
+ attributes:
+ value: |
+ Thank you for submitting a YOLOv8 ๐ 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 YOLOv8 [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 YOLOv8?
+ 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 YOLOv8 for everyone, especially if you have a good understanding of how to implement a fix or feature.
+ See the YOLOv8 [Contributing Guide](https://docs.ultralytics.com/help/contributing) to get started.
+ options:
+ - label: Yes I'd like to help by submitting a PR!
diff --git a/ultralytics/.github/ISSUE_TEMPLATE/feature-request.yml:Zone.Identifier b/ultralytics/.github/ISSUE_TEMPLATE/feature-request.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/feature-request.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/ISSUE_TEMPLATE/question.yml b/ultralytics/.github/ISSUE_TEMPLATE/question.yml
new file mode 100755
index 0000000..090bc5d
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/question.yml
@@ -0,0 +1,33 @@
+name: โ Question
+description: Ask a YOLOv8 question
+# title: " "
+labels: [question]
+body:
+ - type: markdown
+ attributes:
+ value: |
+ Thank you for asking a YOLOv8 โ 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/ultralytics/ultralytics/discussions) to see if a similar question already exists.
+ options:
+ - label: >
+ I have searched the YOLOv8 [issues](https://github.com/ultralytics/ultralytics/issues) and [discussions](https://github.com/ultralytics/ultralytics/discussions) and found no similar questions.
+ required: true
+
+ - type: textarea
+ attributes:
+ label: Question
+ description: What is your question?
+ placeholder: |
+ ๐ก ProTip! Include as much information as possible (screenshots, logs, tracebacks etc.) to receive the most helpful response.
+ validations:
+ required: true
+
+ - type: textarea
+ attributes:
+ label: Additional
+ description: Anything else you would like to share?
diff --git a/ultralytics/.github/ISSUE_TEMPLATE/question.yml:Zone.Identifier b/ultralytics/.github/ISSUE_TEMPLATE/question.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/ISSUE_TEMPLATE/question.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/dependabot.yml b/ultralytics/.github/dependabot.yml
new file mode 100755
index 0000000..2d4ae31
--- /dev/null
+++ b/ultralytics/.github/dependabot.yml
@@ -0,0 +1,27 @@
+# Ultralytics YOLO ๐, AGPL-3.0 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: weekly
+ time: "04:00"
+ open-pull-requests-limit: 10
+ reviewers:
+ - glenn-jocher
+ labels:
+ - dependencies
+
+ - package-ecosystem: github-actions
+ directory: "/.github/workflows"
+ schedule:
+ interval: weekly
+ time: "04:00"
+ open-pull-requests-limit: 5
+ reviewers:
+ - glenn-jocher
+ labels:
+ - dependencies
diff --git a/ultralytics/.github/dependabot.yml:Zone.Identifier b/ultralytics/.github/dependabot.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/dependabot.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/ci.yaml b/ultralytics/.github/workflows/ci.yaml
new file mode 100755
index 0000000..81e5f1c
--- /dev/null
+++ b/ultralytics/.github/workflows/ci.yaml
@@ -0,0 +1,280 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# YOLO Continuous Integration (CI) GitHub Actions tests
+
+name: Ultralytics CI
+
+on:
+ push:
+ branches: [main]
+ pull_request:
+ branches: [main]
+ schedule:
+ - cron: '0 0 * * *' # runs at 00:00 UTC every day
+ workflow_dispatch:
+ inputs:
+ hub:
+ description: 'Run HUB'
+ default: false
+ type: boolean
+ benchmarks:
+ description: 'Run Benchmarks'
+ default: false
+ type: boolean
+ tests:
+ description: 'Run Tests'
+ default: false
+ type: boolean
+ gpu:
+ description: 'Run GPU'
+ default: false
+ type: boolean
+ conda:
+ description: 'Run Conda'
+ default: false
+ 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-version: ['3.11']
+ steps:
+ - uses: actions/checkout@v4
+ - uses: actions/setup-python@v5
+ with:
+ python-version: ${{ matrix.python-version }}
+ cache: 'pip' # caching pip dependencies
+ - name: Install requirements
+ shell: bash # for Windows compatibility
+ run: |
+ python -m pip install --upgrade pip wheel
+ pip install -e . --extra-index-url https://download.pytorch.org/whl/cpu
+ - name: Check environment
+ run: |
+ yolo checks
+ 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:
+ os: [ubuntu-latest]
+ python-version: ['3.10']
+ model: [yolov8n]
+ steps:
+ - uses: actions/checkout@v4
+ - uses: actions/setup-python@v5
+ with:
+ python-version: ${{ matrix.python-version }}
+ cache: 'pip' # caching pip dependencies
+ - name: Install requirements
+ shell: bash # for Windows compatibility
+ run: |
+ python -m pip install --upgrade pip wheel
+ pip install -e ".[export]" coverage --extra-index-url https://download.pytorch.org/whl/cpu
+ # Fix SavedModel issue "partially initialized module 'jax' has no attribute 'version' (most likely due to a circular import)" in https://github.com/google/jax/discussions/14036
+ # pip install -U 'jax!=0.4.15' 'jaxlib!=0.4.15'
+ yolo export format=tflite imgsz=32 || true
+ - name: Check environment
+ run: |
+ yolo checks
+ 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.318
+ - 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.286
+ - 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.166
+ - 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.185
+ - 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@v3
+ with:
+ flags: Benchmarks
+ env:
+ CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+ - name: Benchmark Summary
+ run: |
+ cat benchmarks.log
+ echo "$(cat benchmarks.log)" >> $GITHUB_STEP_SUMMARY
+
+ Tests:
+ if: github.event_name != 'workflow_dispatch' || github.event.inputs.tests == 'true'
+ timeout-minutes: 60
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-latest]
+ python-version: ['3.11']
+ torch: [latest]
+ include:
+ - os: ubuntu-latest
+ python-version: '3.8' # torch 1.8.0 requires python >=3.6, <=3.8
+ torch: '1.8.0' # min torch version CI https://pypi.org/project/torchvision/
+ steps:
+ - uses: actions/checkout@v4
+ - uses: actions/setup-python@v5
+ with:
+ python-version: ${{ matrix.python-version }}
+ cache: 'pip' # caching pip dependencies
+ - name: Install requirements
+ shell: bash # for Windows compatibility
+ run: | # CoreML must be installed before export due to protobuf error from AutoInstall
+ python -m pip install --upgrade pip wheel
+ torch=""
+ if [ "${{ matrix.torch }}" == "1.8.0" ]; then
+ torch="torch==1.8.0 torchvision==0.9.0"
+ fi
+ pip install -e . $torch pytest-cov "coremltools>=7.0" --extra-index-url https://download.pytorch.org/whl/cpu
+ - name: Check environment
+ run: |
+ yolo checks
+ pip list
+ - name: Pytest tests
+ shell: bash # for Windows compatibility
+ run: |
+ slow=""
+ if [[ "${{ github.event_name }}" == "schedule" ]] || [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+ pip install mlflow pycocotools 'ray[tune]'
+ slow="--slow"
+ fi
+ pytest $slow --cov=ultralytics/ --cov-report xml tests/
+ - name: Upload Coverage Reports to CodeCov
+ if: github.repository == 'ultralytics/ultralytics' # && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11'
+ uses: codecov/codecov-action@v3
+ with:
+ flags: Tests
+ env:
+ CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+ 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@v4
+ - name: Install requirements
+ run: pip install -e .
+ - name: Check environment
+ run: |
+ yolo checks
+ pip list
+ - name: Pytest tests
+ run: pytest --cov=ultralytics/ --cov-report xml tests/test_cuda.py
+ - name: Upload Coverage Reports to CodeCov
+ uses: codecov/codecov-action@v3
+ with:
+ flags: GPU
+ env:
+ CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+ Conda:
+ if: github.repository == 'ultralytics/ultralytics' && (github.event_name == 'schedule_disabled' || github.event.inputs.conda == 'true')
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-latest]
+ python-version: ['3.11']
+ defaults:
+ run:
+ shell: bash -el {0}
+ steps:
+ - uses: conda-incubator/setup-miniconda@v3
+ with:
+ python-version: ${{ matrix.python-version }}
+ mamba-version: "*"
+ channels: conda-forge,defaults
+ channel-priority: true
+ activate-environment: anaconda-client-env
+ - name: Install Libmamba
+ run: |
+ conda config --set solver libmamba
+ - name: Install Ultralytics package from conda-forge
+ run: |
+ conda install -c pytorch -c conda-forge pytorch torchvision ultralytics openvino
+ - name: Install pip packages
+ run: |
+ pip install pytest 'coremltools>=7.0'
+ - name: Check environment
+ run: |
+ conda list
+ - name: Test CLI
+ run: |
+ yolo predict model=yolov8n.pt imgsz=320
+ yolo train model=yolov8n.pt data=coco8.yaml epochs=1 imgsz=32
+ yolo val model=yolov8n.pt data=coco8.yaml imgsz=32
+ yolo export model=yolov8n.pt format=torchscript imgsz=160
+ - name: Test Python
+ run: |
+ python -c "
+ from ultralytics import YOLO
+ model = YOLO('yolov8n.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
+ run: |
+ git clone https://github.com/ultralytics/ultralytics
+ pytest ultralytics/tests
+
+ Summary:
+ runs-on: ubuntu-latest
+ needs: [HUB, Benchmarks, Tests, GPU, Conda] # Add job names that you want to check for failure
+ if: always() # This ensures the job runs even if previous jobs fail
+ steps:
+ - name: Check for failure and notify
+ if: (needs.HUB.result == 'failure' || needs.Benchmarks.result == 'failure' || needs.Tests.result == 'failure' || needs.GPU.result == 'failure' || needs.Conda.result == 'failure') && github.repository == 'ultralytics/ultralytics' && (github.event_name == 'schedule' || github.event_name == 'push')
+ uses: slackapi/slack-github-action@v1.24.0
+ with:
+ payload: |
+ {"text": " 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"}
+ env:
+ SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
diff --git a/ultralytics/.github/workflows/ci.yaml:Zone.Identifier b/ultralytics/.github/workflows/ci.yaml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/ci.yaml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/cla.yml b/ultralytics/.github/workflows/cla.yml
new file mode 100755
index 0000000..2d9bfe9
--- /dev/null
+++ b/ultralytics/.github/workflows/cla.yml
@@ -0,0 +1,37 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+
+name: CLA Assistant
+on:
+ issue_comment:
+ types:
+ - created
+ pull_request_target:
+ types:
+ - reopened
+ - opened
+ - synchronize
+
+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.3.1
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ # must be repository secret token
+ PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+ with:
+ path-to-signatures: 'signatures/version1/cla.json'
+ path-to-document: 'https://docs.ultralytics.com/help/CLA' # CLA document
+ # branch should not be protected
+ branch: 'main'
+ 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. โ
+ #custom-notsigned-prcomment: 'pull request comment with Introductory message to ask new contributors to sign'
diff --git a/ultralytics/.github/workflows/cla.yml:Zone.Identifier b/ultralytics/.github/workflows/cla.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/cla.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/codeql.yaml b/ultralytics/.github/workflows/codeql.yaml
new file mode 100755
index 0000000..5dc86e8
--- /dev/null
+++ b/ultralytics/.github/workflows/codeql.yaml
@@ -0,0 +1,42 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+
+name: "CodeQL"
+
+on:
+ schedule:
+ - cron: '0 0 1 * *'
+ workflow_dispatch:
+
+jobs:
+ analyze:
+ name: Analyze
+ runs-on: ${{ 'ubuntu-latest' }}
+ permissions:
+ actions: read
+ contents: read
+ security-events: write
+
+ strategy:
+ fail-fast: false
+ matrix:
+ language: ['python']
+ # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+
+ # Initializes the CodeQL tools for scanning.
+ - name: Initialize CodeQL
+ uses: github/codeql-action/init@v3
+ with:
+ languages: ${{ matrix.language }}
+ # If you wish to specify custom queries, you can do so here or in a config file.
+ # By default, queries listed here will override any specified in a config file.
+ # Prefix the list here with "+" to use these queries and those in the config file.
+ # queries: security-extended,security-and-quality
+
+ - name: Perform CodeQL Analysis
+ uses: github/codeql-action/analyze@v3
+ with:
+ category: "/language:${{matrix.language}}"
diff --git a/ultralytics/.github/workflows/codeql.yaml:Zone.Identifier b/ultralytics/.github/workflows/codeql.yaml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/codeql.yaml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/docker.yaml b/ultralytics/.github/workflows/docker.yaml
new file mode 100755
index 0000000..2875c45
--- /dev/null
+++ b/ultralytics/.github/workflows/docker.yaml
@@ -0,0 +1,148 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest images on DockerHub https://hub.docker.com/r/ultralytics
+
+name: Publish Docker Images
+
+on:
+ push:
+ branches: [main]
+ workflow_dispatch:
+ inputs:
+ Dockerfile:
+ type: boolean
+ description: Use Dockerfile
+ default: true
+ Dockerfile-cpu:
+ type: boolean
+ description: Use Dockerfile-cpu
+ Dockerfile-arm64:
+ type: boolean
+ description: Use Dockerfile-arm64
+ Dockerfile-jetson:
+ type: boolean
+ description: Use Dockerfile-jetson
+ Dockerfile-python:
+ type: boolean
+ description: Use Dockerfile-python
+ Dockerfile-conda:
+ type: boolean
+ description: Use Dockerfile-conda
+ push:
+ type: boolean
+ description: Push images to Docker Hub
+ default: true
+
+jobs:
+ docker:
+ if: github.repository == 'ultralytics/ultralytics'
+ name: Push
+ runs-on: ubuntu-latest
+ strategy:
+ fail-fast: false
+ max-parallel: 6
+ matrix:
+ include:
+ - dockerfile: "Dockerfile"
+ tags: "latest"
+ platforms: "linux/amd64"
+ - dockerfile: "Dockerfile-cpu"
+ tags: "latest-cpu"
+ platforms: "linux/amd64"
+ - dockerfile: "Dockerfile-arm64"
+ tags: "latest-arm64"
+ platforms: "linux/arm64"
+ - dockerfile: "Dockerfile-jetson"
+ tags: "latest-jetson"
+ platforms: "linux/arm64"
+ - dockerfile: "Dockerfile-python"
+ tags: "latest-python"
+ platforms: "linux/amd64"
+ # - dockerfile: "Dockerfile-conda"
+ # tags: "latest-conda"
+ # platforms: "linux/amd64"
+ steps:
+ - name: Checkout repo
+ uses: actions/checkout@v4
+ with:
+ fetch-depth: 0 # copy full .git directory to access full git history in Docker images
+
+ - name: Set up QEMU
+ uses: docker/setup-qemu-action@v3
+
+ - 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: 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 "exists=true" >> $GITHUB_OUTPUT
+ elif [[ "$MESSAGE" == *"404"* ]]; then
+ echo "Tag $VERSION_TAG does not exist on DockerHub."
+ echo "exists=false" >> $GITHUB_OUTPUT
+ else
+ echo "Unexpected response from DockerHub. Please check manually."
+ echo "exists=false" >> $GITHUB_OUTPUT
+ fi
+ env:
+ VERSION_TAG: ${{ steps.get_version.outputs.version_tag }}
+
+ - name: Build Image
+ if: github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true'
+ run: |
+ docker build --platform ${{ matrix.platforms }} -f docker/${{ matrix.dockerfile }} \
+ -t ultralytics/ultralytics:${{ matrix.tags }} \
+ -t ultralytics/ultralytics:${{ steps.get_version.outputs.version_tag }} .
+
+ - name: Run Tests
+ if: (github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true') && matrix.platforms == 'linux/amd64' && matrix.dockerfile != 'Dockerfile-conda' # arm64 images not supported on GitHub CI runners
+ run: docker run ultralytics/ultralytics:${{ matrix.tags }} /bin/bash -c "pip install pytest && pytest tests"
+
+ - name: Run Benchmarks
+ # WARNING: Dockerfile (GPU) error on TF.js export 'module 'numpy' has no attribute 'object'.
+ if: (github.event_name == 'push' || github.event.inputs[matrix.dockerfile] == 'true') && matrix.platforms == 'linux/amd64' && matrix.dockerfile != 'Dockerfile' && matrix.dockerfile != 'Dockerfile-conda' # arm64 images not supported on GitHub CI runners
+ run: docker run ultralytics/ultralytics:${{ matrix.tags }} yolo benchmark model=yolov8n.pt imgsz=160 verbose=0.318
+
+ - name: Push Docker Image with Ultralytics version tag
+ if: (github.event_name == 'push' || (github.event.inputs[matrix.dockerfile] == 'true' && github.event.inputs.push == 'true')) && steps.check_tag.outputs.exists == 'false' && matrix.dockerfile != 'Dockerfile-conda'
+ run: |
+ docker push ultralytics/ultralytics:${{ steps.get_version.outputs.version_tag }}
+
+ - name: Push Docker Image with latest tag
+ if: github.event_name == 'push' || (github.event.inputs[matrix.dockerfile] == 'true' && github.event.inputs.push == 'true')
+ run: |
+ docker push ultralytics/ultralytics:${{ matrix.tags }}
+ if [[ "${{ matrix.tags }}" == "latest" ]]; then
+ t=ultralytics/ultralytics:latest-runner
+ docker build -f docker/Dockerfile-runner -t $t .
+ docker push $t
+ fi
+
+ - name: Notify on failure
+ if: github.event_name == 'push' && failure() # do not notify on cancelled() as cancelling is performed by hand
+ uses: slackapi/slack-github-action@v1.24.0
+ with:
+ payload: |
+ {"text": " 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"}
+ env:
+ SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
diff --git a/ultralytics/.github/workflows/docker.yaml:Zone.Identifier b/ultralytics/.github/workflows/docker.yaml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/docker.yaml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/greetings.yml b/ultralytics/.github/workflows/greetings.yml
new file mode 100755
index 0000000..224fe57
--- /dev/null
+++ b/ultralytics/.github/workflows/greetings.yml
@@ -0,0 +1,58 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+
+name: Greetings
+
+on:
+ pull_request_target:
+ types: [opened]
+ issues:
+ types: [opened]
+
+jobs:
+ greeting:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/first-interaction@v1
+ with:
+ repo-token: ${{ secrets.GITHUB_TOKEN }}
+ pr-message: |
+ ๐ Hello @${{ github.actor }}, thank you for submitting an Ultralytics YOLOv8 ๐ PR! To allow your work to be integrated as seamlessly as possible, we advise you to:
+
+ - โ Verify your PR is **up-to-date** with `ultralytics/ultralytics` `main` branch. If your PR is behind you can update your code by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
+ - โ Verify all YOLOv8 Continuous Integration (CI) **checks are passing**.
+ - โ Update YOLOv8 [Docs](https://docs.ultralytics.com) for any new or updated features.
+ - โ Reduce changes to the absolute **minimum** required for your bug fix or feature addition. _"It is not daily increase but daily decrease, hack away the unessential. The closer to the source, the less wastage there is."_ โ Bruce Lee
+
+ See our [Contributing Guide](https://docs.ultralytics.com/help/contributing) for details and let us know if you have any questions!
+
+ issue-message: |
+ ๐ Hello @${{ github.actor }}, thank you for your interest in Ultralytics YOLOv8 ๐! 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/yolov5/tutorials/tips_for_best_training_results/).
+
+ Join the vibrant [Ultralytics Discord](https://ultralytics.com/discord) ๐ง community for real-time conversations and collaborations. This platform offers a perfect space to inquire, showcase your work, and connect with fellow Ultralytics users.
+
+ ## Install
+
+ Pip install the `ultralytics` package including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/).
+
+ ```bash
+ pip install ultralytics
+ ```
+
+ ## Environments
+
+ YOLOv8 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:
+ - **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/)
+
+ ## Status
+
+
+
+ If this badge is green, all [Ultralytics CI](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml?query=event%3Aschedule) tests are currently passing. CI tests verify correct operation of all YOLOv8 [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.
diff --git a/ultralytics/.github/workflows/greetings.yml:Zone.Identifier b/ultralytics/.github/workflows/greetings.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/greetings.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/links.yml b/ultralytics/.github/workflows/links.yml
new file mode 100755
index 0000000..a5ddf70
--- /dev/null
+++ b/ultralytics/.github/workflows/links.yml
@@ -0,0 +1,78 @@
+# Ultralytics YOLO ๐, AGPL-3.0 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:
+# - 403(OpenVINO, 'forbidden')
+# - 429(Instagram, 'too many requests')
+# - 500(Zenodo, 'cached')
+# - 502(Zenodo, 'bad gateway')
+# - 999(LinkedIn, 'unknown status code')
+
+name: Check Broken links
+
+on:
+ workflow_dispatch:
+ schedule:
+ - cron: '0 0 * * *' # runs at 00:00 UTC every day
+
+jobs:
+ Links:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Download and install lychee
+ run: |
+ LYCHEE_URL=$(curl -s https://api.github.com/repos/lycheeverse/lychee/releases/latest | grep "browser_download_url" | grep "x86_64-unknown-linux-gnu.tar.gz" | cut -d '"' -f 4)
+ curl -L $LYCHEE_URL -o lychee.tar.gz
+ tar xzf lychee.tar.gz
+ sudo mv lychee /usr/local/bin
+
+ - name: Test Markdown and HTML links with retry
+ uses: nick-invision/retry@v2
+ with:
+ timeout_minutes: 5
+ retry_wait_seconds: 60
+ max_attempts: 3
+ command: |
+ lychee --accept 403,429,500,502,999 \
+ --exclude-loopback \
+ --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 \
+ --exclude-mail \
+ --github-token ${{ secrets.GITHUB_TOKEN }} \
+ './**/*.md' './**/*.html'
+
+ - name: Test Markdown, HTML, YAML, Python and Notebook links with retry
+ if: github.event_name == 'workflow_dispatch'
+ uses: nick-invision/retry@v2
+ with:
+ timeout_minutes: 5
+ retry_wait_seconds: 60
+ max_attempts: 3
+ command: |
+ lychee --accept 429,999 \
+ --exclude-loopback \
+ --exclude 'https?://(www\.)?(linkedin\.com|twitter\.com|instagram\.com|kaggle\.com|fonts\.gstatic\.com|url\.com)' \
+ --exclude-path '**/ci.yaml' \
+ --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 \
+ --exclude-mail \
+ --github-token ${{ secrets.GITHUB_TOKEN }} \
+ './**/*.md' './**/*.html' './**/*.yml' './**/*.yaml' './**/*.py' './**/*.ipynb'
diff --git a/ultralytics/.github/workflows/links.yml:Zone.Identifier b/ultralytics/.github/workflows/links.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/links.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/publish.yml b/ultralytics/.github/workflows/publish.yml
new file mode 100755
index 0000000..8f62cb5
--- /dev/null
+++ b/ultralytics/.github/workflows/publish.yml
@@ -0,0 +1,112 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Publish pip package to PyPI https://pypi.org/project/ultralytics/ and Docs to https://docs.ultralytics.com
+
+name: Publish to PyPI and Deploy Docs
+
+on:
+ push:
+ branches: [main]
+ workflow_dispatch:
+ inputs:
+ pypi:
+ type: boolean
+ description: Publish to PyPI
+ docs:
+ type: boolean
+ description: Deploy Docs
+
+jobs:
+ publish:
+ if: github.repository == 'ultralytics/ultralytics' && github.actor == 'glenn-jocher'
+ name: Publish
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+ with:
+ fetch-depth: "0" # pulls all commits (needed correct last updated dates in Docs)
+ - name: Set up Python environment
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.10'
+ cache: 'pip' # caching pip dependencies
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip wheel build twine
+ pip install -e ".[dev]" --extra-index-url https://download.pytorch.org/whl/cpu
+ - name: Check PyPI version
+ shell: python
+ run: |
+ import os
+ import ultralytics
+ from ultralytics.utils.checks import check_latest_pypi_version
+
+ v_local = tuple(map(int, ultralytics.__version__.split('.')))
+ v_pypi = tuple(map(int, check_latest_pypi_version().split('.')))
+ print(f'Local version is {v_local}')
+ print(f'PyPI version is {v_pypi}')
+ d = [a - b for a, b in zip(v_local, v_pypi)] # diff
+ increment = (d[0] == d[1] == 0) and (0 < d[2] < 3) # only publish if patch version increments by 1 or 2
+ os.system(f'echo "increment={increment}" >> $GITHUB_OUTPUT')
+ os.system(f'echo "version={ultralytics.__version__}" >> $GITHUB_OUTPUT')
+ if increment:
+ print('Local version is higher than PyPI version. Publishing new version to PyPI โ .')
+ id: check_pypi
+ - name: Publish to PyPI
+ continue-on-error: true
+ if: (github.event_name == 'push' || github.event.inputs.pypi == 'true') && steps.check_pypi.outputs.increment == 'True'
+ env:
+ PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+ run: |
+ python -m build
+ python -m twine upload dist/* -u __token__ -p $PYPI_TOKEN
+ - name: Deploy Docs
+ continue-on-error: true
+ if: (github.event_name == 'push' || github.event.inputs.docs == 'true') && github.repository == 'ultralytics/ultralytics' && github.actor == 'glenn-jocher'
+ env:
+ PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+ INDEXNOW_KEY: ${{ secrets.INDEXNOW_KEY_DOCS }}
+ run: |
+ python docs/build_docs.py
+ git config --global user.name "Glenn Jocher"
+ git config --global user.email "glenn.jocher@ultralytics.com"
+ git clone https://github.com/ultralytics/docs.git docs-repo
+ cd docs-repo
+ git checkout gh-pages || git checkout -b gh-pages
+ rm -rf *
+ cp -R ../site/* .
+ echo "$INDEXNOW_KEY" > "$INDEXNOW_KEY.txt"
+ git add .
+ 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://$PERSONAL_ACCESS_TOKEN@github.com/ultralytics/docs.git gh-pages
+ - name: Extract PR Details
+ run: |
+ if [ "${{ github.event_name }}" = "pull_request" ]; then
+ PR_JSON=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" https://api.github.com/repos/${{ github.repository }}/pulls/${{ github.event.pull_request.number }})
+ PR_NUMBER=${{ github.event.pull_request.number }}
+ PR_TITLE=$(echo $PR_JSON | jq -r '.title')
+ else
+ COMMIT_SHA=${{ github.event.after }}
+ PR_JSON=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" "https://api.github.com/search/issues?q=repo:${{ github.repository }}+is:pr+is:merged+sha:$COMMIT_SHA")
+ PR_NUMBER=$(echo $PR_JSON | jq -r '.items[0].number')
+ PR_TITLE=$(echo $PR_JSON | jq -r '.items[0].title')
+ fi
+ echo "PR_NUMBER=$PR_NUMBER" >> $GITHUB_ENV
+ echo "PR_TITLE=$PR_TITLE" >> $GITHUB_ENV
+ - name: Notify on Slack (Success)
+ if: success() && github.event_name == 'push' && steps.check_pypi.outputs.increment == 'True'
+ uses: slackapi/slack-github-action@v1.24.0
+ with:
+ payload: |
+ {"text": " 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 'ultralytics ${{ steps.check_pypi.outputs.version }}' pip package published ๐\n*Job Status:* ${{ job.status }}\n*Pull Request:* ${{ env.PR_TITLE }}\n"}
+ env:
+ SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
+ - name: Notify on Slack (Failure)
+ if: failure()
+ uses: slackapi/slack-github-action@v1.24.0
+ with:
+ payload: |
+ {"text": " 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:* ${{ env.PR_TITLE }}\n"}
+ env:
+ SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL_YOLO }}
diff --git a/ultralytics/.github/workflows/publish.yml:Zone.Identifier b/ultralytics/.github/workflows/publish.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/publish.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.github/workflows/stale.yml b/ultralytics/.github/workflows/stale.yml
new file mode 100755
index 0000000..cc7fde6
--- /dev/null
+++ b/ultralytics/.github/workflows/stale.yml
@@ -0,0 +1,47 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+
+name: Close stale issues
+on:
+ schedule:
+ - cron: '0 0 * * *' # Runs at 00:00 UTC every day
+
+jobs:
+ stale:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/stale@v9
+ 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
+ - **HUB**: https://hub.ultralytics.com
+ - **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
+ - **HUB**: https://hub.ultralytics.com
+ - **Community**: https://community.ultralytics.com
+
+ Thank you for your contributions to YOLO ๐ and Vision AI โญ
+
+ 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'
+ operations-per-run: 300 # The maximum number of operations per run, used to control rate limiting.
diff --git a/ultralytics/.github/workflows/stale.yml:Zone.Identifier b/ultralytics/.github/workflows/stale.yml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.github/workflows/stale.yml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.gitignore b/ultralytics/.gitignore
new file mode 100755
index 0000000..c8987d8
--- /dev/null
+++ b/ultralytics/.gitignore
@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos 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/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Profiling
+*.pclprof
+
+# pyenv
+.python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+.idea
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# VSCode project settings
+.vscode/
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+mkdocs_github_authors.yaml
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# datasets and projects
+datasets/
+runs/
+wandb/
+tests/
+.DS_Store
+
+# Neural Network weights -----------------------------------------------------------------------------------------------
+weights/
+*.weights
+*.pt
+*.pb
+*.onnx
+*.engine
+*.mlmodel
+*.mlpackage
+*.torchscript
+*.tflite
+*.h5
+*_saved_model/
+*_web_model/
+*_openvino_model/
+*_paddle_model/
+pnnx*
+
+# Autogenerated files for tests
+/ultralytics/assets/
diff --git a/ultralytics/.gitignore:Zone.Identifier b/ultralytics/.gitignore:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.gitignore:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/.pre-commit-config.yaml b/ultralytics/.pre-commit-config.yaml
new file mode 100755
index 0000000..4c47d7e
--- /dev/null
+++ b/ultralytics/.pre-commit-config.yaml
@@ -0,0 +1,92 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Pre-commit hooks. For more information see https://github.com/pre-commit/pre-commit-hooks/blob/main/README.md
+# Optionally remove from local hooks with 'rm .git/hooks/pre-commit'
+
+# Define bot property if installed via https://github.com/marketplace/pre-commit-ci
+ci:
+ autofix_prs: true
+ autoupdate_commit_msg: '[pre-commit.ci] pre-commit suggestions'
+ autoupdate_schedule: monthly
+ submodules: true
+
+# Exclude directories (optional)
+# exclude: 'docs/'
+
+# Define repos to run
+repos:
+ - repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v4.5.0
+ hooks:
+ - id: end-of-file-fixer
+ - id: trailing-whitespace
+ - id: check-case-conflict
+ # - id: check-yaml
+ - id: check-docstring-first
+ - id: double-quote-string-fixer
+ - id: detect-private-key
+
+ - repo: https://github.com/asottile/pyupgrade
+ rev: v3.15.0
+ hooks:
+ - id: pyupgrade
+ name: Upgrade code
+
+ - repo: https://github.com/PyCQA/isort
+ rev: 5.12.0
+ hooks:
+ - id: isort
+ name: Sort imports
+
+ - repo: https://github.com/google/yapf
+ rev: v0.40.2
+ hooks:
+ - id: yapf
+ name: YAPF formatting
+
+ - repo: https://github.com/executablebooks/mdformat
+ rev: 0.7.17
+ hooks:
+ - id: mdformat
+ name: MD formatting
+ additional_dependencies:
+ - mdformat-gfm
+ # - mdformat-black
+ # - mdformat-frontmatter
+ args:
+ - --wrap=no
+ exclude: 'docs/.*\.md'
+ # exclude: "README.md|README.zh-CN.md|CONTRIBUTING.md"
+
+ - repo: https://github.com/PyCQA/flake8
+ rev: 6.1.0
+ hooks:
+ - id: flake8
+ name: PEP8
+
+ - repo: https://github.com/codespell-project/codespell
+ rev: v2.2.6
+ hooks:
+ - id: codespell
+ exclude: 'docs/de|docs/fr|docs/pt|docs/es|docs/mkdocs_de.yml'
+ args:
+ - --ignore-words-list=crate,nd,strack,dota,ane,segway,fo,gool,winn
+
+ - repo: https://github.com/PyCQA/docformatter
+ rev: v1.7.5
+ hooks:
+ - id: docformatter
+
+# - repo: https://github.com/asottile/yesqa
+# rev: v1.4.0
+# hooks:
+# - id: yesqa
+
+# - repo: https://github.com/asottile/dead
+# rev: v1.5.0
+# hooks:
+# - id: dead
+
+# - repo: https://github.com/ultralytics/pre-commit
+# rev: bd60a414f80a53fb8f593d3bfed4701fc47e4b23
+# hooks:
+# - id: capitalize-comments
diff --git a/ultralytics/.pre-commit-config.yaml:Zone.Identifier b/ultralytics/.pre-commit-config.yaml:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/.pre-commit-config.yaml:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/1.png b/ultralytics/1.png
new file mode 100755
index 0000000..30eeece
Binary files /dev/null and b/ultralytics/1.png differ
diff --git a/ultralytics/1.png:Zone.Identifier b/ultralytics/1.png:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/1.png:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/2.png b/ultralytics/2.png
new file mode 100755
index 0000000..58e3bc9
Binary files /dev/null and b/ultralytics/2.png differ
diff --git a/ultralytics/2.png:Zone.Identifier b/ultralytics/2.png:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/2.png:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/CITATION.cff b/ultralytics/CITATION.cff
new file mode 100755
index 0000000..8e85b7a
--- /dev/null
+++ b/ultralytics/CITATION.cff
@@ -0,0 +1,20 @@
+cff-version: 1.2.0
+preferred-citation:
+ type: software
+ message: If you use this software, please cite it as below.
+ authors:
+ - family-names: Jocher
+ given-names: Glenn
+ orcid: "https://orcid.org/0000-0001-5950-6979"
+ - family-names: Chaurasia
+ given-names: Ayush
+ orcid: "https://orcid.org/0000-0002-7603-6750"
+ - family-names: Qiu
+ given-names: Jing
+ orcid: "https://orcid.org/0000-0003-3783-7069"
+ title: "YOLO by Ultralytics"
+ version: 8.0.0
+ # doi: 10.5281/zenodo.3908559 # TODO
+ date-released: 2023-1-10
+ license: AGPL-3.0
+ url: "https://github.com/ultralytics/ultralytics"
diff --git a/ultralytics/CITATION.cff:Zone.Identifier b/ultralytics/CITATION.cff:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/CITATION.cff:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/CONTRIBUTING.md b/ultralytics/CONTRIBUTING.md
new file mode 100755
index 0000000..615ef41
--- /dev/null
+++ b/ultralytics/CONTRIBUTING.md
@@ -0,0 +1,96 @@
+# Contributing to YOLOv8 ๐
+
+We love your input! We want to make contributing to YOLOv8 as easy and transparent as possible, whether it's:
+
+- Reporting a bug
+- Discussing the current state of the code
+- Submitting a fix
+- Proposing a new feature
+- Becoming a maintainer
+
+YOLOv8 works so well due to our combined community effort, and for every small improvement you contribute you will be helping push the frontiers of what's possible in AI ๐!
+
+## Submitting a Pull Request (PR) ๐ ๏ธ
+
+Submitting a PR is easy! This example shows how to submit a PR for updating `requirements.txt` in 4 steps:
+
+### 1. Select File to Update
+
+Select `requirements.txt` to update by clicking on it in GitHub.
+
+
+
+### 2. Click 'Edit this file'
+
+Button is in top-right corner.
+
+
+
+### 3. Make Changes
+
+Change `matplotlib` version from `3.2.2` to `3.3`.
+
+
+
+### 4. Preview Changes and Submit PR
+
+Click on the **Preview changes** tab to verify your updates. At the bottom of the screen select 'Create a **new branch** for this commit', assign your branch a descriptive name such as `fix/matplotlib_version` and click the green **Propose changes** button. All done, your PR is now submitted to YOLOv8 for review and approval ๐!
+
+
+
+### PR recommendations
+
+To allow your work to be integrated as seamlessly as possible, we advise you to:
+
+- โ Verify your PR is **up-to-date** with `ultralytics/ultralytics` `main` branch. If your PR is behind you can update your code by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
+
+
+
+- โ Verify all YOLOv8 Continuous Integration (CI) **checks are passing**.
+
+
+
+- โ Reduce changes to the absolute **minimum** required for your bug fix or feature addition. _"It is not daily increase but daily decrease, hack away the unessential. The closer to the source, the less wastage there is."_ โ Bruce Lee
+
+### Docstrings
+
+Not all functions or classes require docstrings but when they do, we follow [google-style docstrings format](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings). Here is an example:
+
+```python
+"""
+ What the function does. Performs NMS on given detection predictions.
+
+ Args:
+ arg1: The description of the 1st argument
+ arg2: The description of the 2nd argument
+
+ Returns:
+ What the function returns. Empty if nothing is returned.
+
+ Raises:
+ Exception Class: When and why this exception can be raised by the function.
+"""
+```
+
+## Submitting a Bug Report ๐
+
+If you spot a problem with YOLOv8 please submit a Bug Report!
+
+For us to start investigating a possible problem we need to be able to reproduce it ourselves first. We've created a few short guidelines below to help users provide what we need in order to get started.
+
+When asking a question, people will be better able to provide help if you provide **code** that they can easily understand and use to **reproduce** the problem. This is referred to by community members as creating a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/). Your code that reproduces the problem should be:
+
+- โ **Minimal** โ Use as little code as possible that still produces the same problem
+- โ **Complete** โ Provide **all** parts someone else needs to reproduce your problem in the question itself
+- โ **Reproducible** โ Test the code you're about to provide to make sure it reproduces the problem
+
+In addition to the above requirements, for [Ultralytics](https://ultralytics.com/) to provide assistance your code should be:
+
+- โ **Current** โ Verify that your code is up-to-date with current GitHub [main](https://github.com/ultralytics/ultralytics/tree/main) branch, and if necessary `git pull` or `git clone` a new copy to ensure your problem has not already been resolved by previous commits.
+- โ **Unmodified** โ Your problem must be reproducible without any modifications to the codebase in this repository. [Ultralytics](https://ultralytics.com/) does not provide support for custom code โ ๏ธ.
+
+If you believe your problem meets all of the above criteria, please close this issue and raise a new one using the ๐ **Bug Report** [template](https://github.com/ultralytics/ultralytics/issues/new/choose) and providing a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/) to help us better understand and diagnose your problem.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the [AGPL-3.0 license](https://choosealicense.com/licenses/agpl-3.0/)
diff --git a/ultralytics/CONTRIBUTING.md:Zone.Identifier b/ultralytics/CONTRIBUTING.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/CONTRIBUTING.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/LICENSE b/ultralytics/LICENSE
new file mode 100755
index 0000000..be3f7b2
--- /dev/null
+++ b/ultralytics/LICENSE
@@ -0,0 +1,661 @@
+ GNU AFFERO GENERAL PUBLIC LICENSE
+ Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ 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.
+
+
+ Copyright (C)
+
+ 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 .
+
+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
+.
diff --git a/ultralytics/LICENSE:Zone.Identifier b/ultralytics/LICENSE:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/LICENSE:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/MANIFEST.in b/ultralytics/MANIFEST.in
new file mode 100755
index 0000000..cd7df3e
--- /dev/null
+++ b/ultralytics/MANIFEST.in
@@ -0,0 +1,8 @@
+include *.md
+include requirements.txt
+include LICENSE
+include setup.py
+include ultralytics/assets/bus.jpg
+include ultralytics/assets/zidane.jpg
+include tests/*.py
+recursive-include ultralytics *.yaml
diff --git a/ultralytics/MANIFEST.in:Zone.Identifier b/ultralytics/MANIFEST.in:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/MANIFEST.in:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/README.md b/ultralytics/README.md
new file mode 100755
index 0000000..9e71812
--- /dev/null
+++ b/ultralytics/README.md
@@ -0,0 +1,265 @@
+
+
+
+[Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics) is a cutting-edge, state-of-the-art (SOTA) model that builds upon the success of previous YOLO versions and introduces new features and improvements to further boost performance and flexibility. YOLOv8 is designed to be fast, accurate, and easy to use, making it an excellent choice for a wide range of object detection and tracking, instance segmentation, image classification and pose estimation tasks.
+
+We hope that the resources here will help you get the most out of YOLOv8. Please browse the YOLOv8 Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!
+
+To request an Enterprise License please complete the form at [Ultralytics Licensing](https://ultralytics.com/license).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+##
Documentation
+
+See below for a quickstart installation and usage example, and see the [YOLOv8 Docs](https://docs.ultralytics.com) for full documentation on training, validation, prediction and deployment.
+
+
+Install
+
+Pip install the ultralytics package including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/).
+
+[](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/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 Git, please refer to the [Quickstart Guide](https://docs.ultralytics.com/quickstart).
+
+
+
+
+Usage
+
+#### CLI
+
+YOLOv8 may be used directly in the Command Line Interface (CLI) with a `yolo` command:
+
+```bash
+yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'
+```
+
+`yolo` can be used for a variety of tasks and modes and accepts additional arguments, i.e. `imgsz=640`. See the YOLOv8 [CLI Docs](https://docs.ultralytics.com/usage/cli) for examples.
+
+#### Python
+
+YOLOv8 may also be used directly in a Python environment, and accepts the same [arguments](https://docs.ultralytics.com/usage/cfg/) as in the CLI example above:
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolov8n.yaml") # build a new model from scratch
+model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
+
+# Use the model
+model.train(data="coco128.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
+```
+
+See YOLOv8 [Python Docs](https://docs.ultralytics.com/usage/python) for more examples.
+
+
+
+##
Models
+
+YOLOv8 [Detect](https://docs.ultralytics.com/tasks/detect), [Segment](https://docs.ultralytics.com/tasks/segment) and [Pose](https://docs.ultralytics.com/tasks/pose) models pretrained on the [COCO](https://docs.ultralytics.com/datasets/detect/coco) dataset are available here, as well as YOLOv8 [Classify](https://docs.ultralytics.com/tasks/classify) models pretrained on the [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet) dataset. [Track](https://docs.ultralytics.com/modes/track) mode is available for all Detect, Segment and Pose models.
+
+
+
+All [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+Detection (COCO)
+
+See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [COCO](https://docs.ultralytics.com/datasets/detect/coco/), which include 80 pre-trained classes.
+
+| Model | size (pixels) | mAPval 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+| ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
+| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
+| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
+| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
+| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
+
+- **mAPval** values are for single-model single-scale on [COCO val2017](http://cocodataset.org) dataset. Reproduce by `yolo val detect data=coco.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. Reproduce by `yolo val detect data=coco.yaml batch=1 device=0|cpu`
+
+
+
+Detection (Open Image V7)
+
+See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), which include 600 pre-trained classes.
+
+| Model | size (pixels) | mAPval 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
+| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
+| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
+| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
+| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
+
+- **mAPval** values are for single-model single-scale on [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/) dataset. Reproduce by `yolo val detect data=open-images-v7.yaml device=0`
+- **Speed** averaged over Open Image V7 val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. Reproduce by `yolo val detect data=open-images-v7.yaml batch=1 device=0|cpu`
+
+
+
+Segmentation (COCO)
+
+See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for usage examples with these models trained on [COCO-Seg](https://docs.ultralytics.com/datasets/segment/coco/), which include 80 pre-trained classes.
+
+| Model | size (pixels) | mAPbox 50-95 | mAPmask 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+| -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
+| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
+| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
+| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
+| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
+
+- **mAPval** values are for single-model single-scale on [COCO val2017](http://cocodataset.org) dataset. Reproduce by `yolo val segment data=coco-seg.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. Reproduce by `yolo val segment data=coco-seg.yaml batch=1 device=0|cpu`
+
+
+
+Pose (COCO)
+
+See [Pose Docs](https://docs.ultralytics.com/tasks/pose/) for usage examples with these models trained on [COCO-Pose](https://docs.ultralytics.com/datasets/pose/coco/), which include 1 pre-trained class, person.
+
+| Model | size (pixels) | mAPpose 50-95 | mAPpose 50 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+| ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
+| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
+| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
+| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
+| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
+| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
+
+- **mAPval** values are for single-model single-scale on [COCO Keypoints val2017](http://cocodataset.org) dataset. Reproduce by `yolo val pose data=coco-pose.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. Reproduce by `yolo val pose data=coco-pose.yaml batch=1 device=0|cpu`
+
+
+
+Classification (ImageNet)
+
+See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for usage examples with these models trained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), which include 1000 pretrained classes.
+
+| Model | size (pixels) | acc top1 | acc top5 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) at 640 |
+| -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------ | ----------------------------------- | ------------------ | ------------------------ |
+| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
+| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
+| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
+| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
+| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
+
+- **acc** values are model accuracies on the [ImageNet](https://www.image-net.org/) dataset validation set. Reproduce by `yolo val classify data=path/to/ImageNet device=0`
+- **Speed** averaged over ImageNet val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. Reproduce by `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
+
+
+
+##
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 [Roboflow](https://roboflow.com/?ref=ultralytics), ClearML, [Comet](https://bit.ly/yolov8-readme-comet), Neural Magic and [OpenVINO](https://docs.ultralytics.com/integrations/openvino), can optimize your AI workflow.
+
+
+
+
+
+
+
+
+
+| Roboflow | ClearML โญ NEW | Comet โญ NEW | Neural Magic โญ NEW |
+| :--------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------: |
+| Label and export your custom datasets directly to YOLOv8 for training with [Roboflow](https://roboflow.com/?ref=ultralytics) | Automatically track, visualize and even remotely train YOLOv8 using [ClearML](https://cutt.ly/yolov5-readme-clearml) (open-source!) | Free forever, [Comet](https://bit.ly/yolov8-readme-comet) lets you save YOLOv8 models, resume training, and interactively visualize and debug predictions | Run YOLOv8 inference up to 6x faster with [Neural Magic DeepSparse](https://bit.ly/yolov5-neuralmagic) |
+
+##
Ultralytics HUB
+
+Experience seamless AI with [Ultralytics HUB](https://bit.ly/ultralytics_hub) โญ, the all-in-one solution for data visualization, YOLOv5 and YOLOv8 ๐ model training and deployment, without any coding. Transform images into actionable insights and bring your AI visions to life with ease using our cutting-edge platform and user-friendly [Ultralytics App](https://ultralytics.com/app_install). Start your journey for **Free** now!
+
+
+
+
+##
Contribute
+
+We love your input! YOLOv5 and YOLOv8 would not be possible without help from our community. Please see our [Contributing Guide](https://docs.ultralytics.com/help/contributing) to get started, and fill out our [Survey](https://ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey) to send us feedback on your experience. Thank you ๐ to all our contributors!
+
+
+
+
+
+
+##
License
+
+Ultralytics offers two licensing options to accommodate diverse use cases:
+
+- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/licenses/) 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.
+- **Enterprise License**: Designed for commercial use, this license permits seamless integration of Ultralytics software and AI models into commercial goods and services, bypassing the open-source requirements of AGPL-3.0. If your scenario involves embedding our solutions into a commercial offering, reach out through [Ultralytics Licensing](https://ultralytics.com/license).
+
+##
Contact
+
+For Ultralytics bug reports and feature requests please visit [GitHub Issues](https://github.com/ultralytics/ultralytics/issues), and join our [Discord](https://ultralytics.com/discord) community for questions and discussions!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ultralytics/README.md:Zone.Identifier b/ultralytics/README.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/README.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/README.zh-CN.md b/ultralytics/README.zh-CN.md
new file mode 100755
index 0000000..7a3bf9c
--- /dev/null
+++ b/ultralytics/README.zh-CN.md
@@ -0,0 +1,265 @@
+
diff --git a/ultralytics/README.zh-CN.md:Zone.Identifier b/ultralytics/README.zh-CN.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/README.zh-CN.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/bus.jpg b/ultralytics/bus.jpg
new file mode 100755
index 0000000..b43e311
Binary files /dev/null and b/ultralytics/bus.jpg differ
diff --git a/ultralytics/bus.jpg:Zone.Identifier b/ultralytics/bus.jpg:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/bus.jpg:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docker/Dockerfile b/ultralytics/docker/Dockerfile
new file mode 100755
index 0000000..e3a32c8
--- /dev/null
+++ b/ultralytics/docker/Dockerfile
@@ -0,0 +1,82 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CUDA-optimized for YOLOv8 single/multi-GPU training and inference
+
+# Start FROM PyTorch image https://hub.docker.com/r/pytorch/pytorch or nvcr.io/nvidia/pytorch:23.03-py3
+FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime
+RUN pip install --no-cache nvidia-tensorrt --index-url https://pypi.ngc.nvidia.com
+
+# Downloads to user config dir
+ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+ && apt install --no-install-recommends -y gcc git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Security updates
+# https://security.snyk.io/vuln/SNYK-UBUNTU1804-OPENSSL-3314796
+RUN apt upgrade --no-install-recommends -y openssl tar
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt /usr/src/ultralytics/
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e ".[export]" albumentations comet pycocotools pytest-cov
+
+# Run exports to AutoInstall packages
+RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
+RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
+# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
+RUN pip install --no-cache paddlepaddle==2.4.2 x2paddle
+# Fix error: `np.bool` was a deprecated alias for the builtin `bool` segmentation error in Tests
+RUN pip install --no-cache numpy==1.23.5
+# Remove exported models
+RUN rm -rf tmp
+
+# Set environment variables
+ENV OMP_NUM_THREADS=1
+# Avoid DDP error "MKL_THREADING_LAYER=INTEL is incompatible with libgomp.so.1 library" https://github.com/pytorch/pytorch/issues/37377
+ENV MKL_THREADING_LAYER=GNU
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest && sudo docker build -f docker/Dockerfile -t $t . && sudo docker push $t
+
+# Pull and Run with access to all GPUs
+# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all $t
+
+# Pull and Run with access to GPUs 2 and 3 (inside container CUDA devices will appear as 0 and 1)
+# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus '"device=2,3"' $t
+
+# Pull and Run with local directory access
+# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/datasets:/usr/src/datasets $t
+
+# Kill all
+# sudo docker kill $(sudo docker ps -q)
+
+# Kill all image-based
+# sudo docker kill $(sudo docker ps -qa --filter ancestor=ultralytics/ultralytics:latest)
+
+# DockerHub tag update
+# t=ultralytics/ultralytics:latest tnew=ultralytics/ultralytics:v6.2 && sudo docker pull $t && sudo docker tag $t $tnew && sudo docker push $tnew
+
+# Clean up
+# sudo docker system prune -a --volumes
+
+# Update Ubuntu drivers
+# https://www.maketecheasier.com/install-nvidia-drivers-ubuntu/
+
+# DDP test
+# python -m torch.distributed.run --nproc_per_node 2 --master_port 1 train.py --epochs 3
+
+# GCP VM from Image
+# docker.io/ultralytics/ultralytics:latest
diff --git a/ultralytics/docker/Dockerfile-arm64 b/ultralytics/docker/Dockerfile-arm64
new file mode 100755
index 0000000..aedb4f2
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-arm64
@@ -0,0 +1,44 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-arm64 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is aarch64-compatible for Apple M1 and other ARM architectures i.e. Jetson Nano and Raspberry Pi
+
+# Start FROM Ubuntu image https://hub.docker.com/_/ubuntu
+FROM arm64v8/ubuntu:22.04
+
+# Downloads to user config dir
+ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+ && apt install --no-install-recommends -y python3-pip git zip curl htop gcc libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt /usr/src/ultralytics/
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e .
+
+# Creates a symbolic link to make 'python' point to 'python3'
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker build --platform linux/arm64 -f docker/Dockerfile-arm64 -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t
diff --git a/ultralytics/docker/Dockerfile-arm64:Zone.Identifier b/ultralytics/docker/Dockerfile-arm64:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-arm64:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docker/Dockerfile-conda b/ultralytics/docker/Dockerfile-conda
new file mode 100755
index 0000000..73d38d6
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-conda
@@ -0,0 +1,38 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-conda image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is optimized for Ultralytics Anaconda (https://anaconda.org/conda-forge/ultralytics) installation and usage
+
+# Start FROM miniconda3 image https://hub.docker.com/r/continuumio/miniconda3
+FROM continuumio/miniconda3:latest
+
+# Downloads to user config dir
+ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
+
+# Install linux packages
+RUN apt update \
+ && apt install --no-install-recommends -y libgl1
+
+# Copy contents
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt .
+
+# Install conda packages
+# mkl required to fix 'OSError: libmkl_intel_lp64.so.2: cannot open shared object file: No such file or directory'
+RUN conda config --set solver libmamba && \
+ conda install pytorch torchvision pytorch-cuda=11.8 -c pytorch -c nvidia && \
+ conda install -c conda-forge ultralytics mkl
+ # conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics mkl
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-conda && sudo docker build -f docker/Dockerfile-cpu -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-conda && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-conda && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-conda && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t
diff --git a/ultralytics/docker/Dockerfile-conda:Zone.Identifier b/ultralytics/docker/Dockerfile-conda:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-conda:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docker/Dockerfile-cpu b/ultralytics/docker/Dockerfile-cpu
new file mode 100755
index 0000000..42e5ec3
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-cpu
@@ -0,0 +1,55 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-cpu image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CPU-optimized for ONNX, OpenVINO and PyTorch YOLOv8 deployments
+
+# Start FROM Ubuntu image https://hub.docker.com/_/ubuntu
+FROM ubuntu:23.10
+
+# Downloads to user config dir
+ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+ && apt install --no-install-recommends -y python3-pip git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt /usr/src/ultralytics/
+
+# Remove python3.11/EXTERNALLY-MANAGED or use 'pip install --break-system-packages' avoid 'externally-managed-environment' Ubuntu nightly error
+RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e ".[export]" --extra-index-url https://download.pytorch.org/whl/cpu
+
+# Run exports to AutoInstall packages
+RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
+RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
+# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
+# RUN pip install --no-cache paddlepaddle==2.4.2 x2paddle
+# Remove exported models
+RUN rm -rf tmp
+
+# Creates a symbolic link to make 'python' point to 'python3'
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-cpu && sudo docker build -f docker/Dockerfile-cpu -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-cpu && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-cpu && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-cpu && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t
diff --git a/ultralytics/docker/Dockerfile-cpu:Zone.Identifier b/ultralytics/docker/Dockerfile-cpu:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-cpu:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docker/Dockerfile-jetson b/ultralytics/docker/Dockerfile-jetson
new file mode 100755
index 0000000..c177b8e
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-jetson
@@ -0,0 +1,48 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds ultralytics/ultralytics:jetson image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Supports JetPack for YOLOv8 on Jetson Nano, TX1/TX2, Xavier NX, AGX Xavier, AGX Orin, and Orin NX
+
+# Start FROM https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-pytorch
+FROM nvcr.io/nvidia/l4t-pytorch:r35.2.1-pth2.0-py3
+
+# Downloads to user config dir
+ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+ && apt install --no-install-recommends -y gcc git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt /usr/src/ultralytics/
+
+# Remove opencv-python from requirements.txt as it conflicts with opencv-python installed in base image
+RUN grep -v '^opencv-python' requirements.txt > tmp.txt && mv tmp.txt requirements.txt
+
+# Install pip packages manually for TensorRT compatibility https://github.com/NVIDIA/TensorRT/issues/2567
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache tqdm matplotlib pyyaml psutil pandas onnx "numpy==1.23"
+RUN pip install --no-cache -e .
+
+# Set environment variables
+ENV OMP_NUM_THREADS=1
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-jetson && sudo docker build --platform linux/arm64 -f docker/Dockerfile-jetson -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-jetson && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with NVIDIA runtime
+# t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
diff --git a/ultralytics/docker/Dockerfile-jetson:Zone.Identifier b/ultralytics/docker/Dockerfile-jetson:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-jetson:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docker/Dockerfile-python b/ultralytics/docker/Dockerfile-python
new file mode 100755
index 0000000..b227fa6
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-python
@@ -0,0 +1,52 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-cpu image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CPU-optimized for ONNX, OpenVINO and PyTorch YOLOv8 deployments
+
+# Use the official Python 3.10 slim-bookworm as base image
+FROM python:3.10-slim-bookworm
+
+# Downloads to user config dir
+ADD https://ultralytics.com/assets/Arial.ttf https://ultralytics.com/assets/Arial.Unicode.ttf /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+ && apt install --no-install-recommends -y python3-pip git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt /usr/src/ultralytics/
+
+# Remove python3.11/EXTERNALLY-MANAGED or use 'pip install --break-system-packages' avoid 'externally-managed-environment' Ubuntu nightly error
+# RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e ".[export]" --extra-index-url https://download.pytorch.org/whl/cpu
+
+# Run exports to AutoInstall packages
+RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
+RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
+# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
+RUN pip install --no-cache paddlepaddle==2.4.2 x2paddle
+# Remove exported models
+RUN rm -rf tmp
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-python && sudo docker build -f docker/Dockerfile-python -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-python && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-python && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-python && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t
diff --git a/ultralytics/docker/Dockerfile-python:Zone.Identifier b/ultralytics/docker/Dockerfile-python:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-python:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docker/Dockerfile-runner b/ultralytics/docker/Dockerfile-runner
new file mode 100755
index 0000000..c0f8659
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-runner
@@ -0,0 +1,38 @@
+# Ultralytics YOLO ๐, AGPL-3.0 license
+# Builds GitHub actions CI runner image for deployment to DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CUDA-optimized for YOLOv8 single/multi-GPU training and inference tests
+
+# Start FROM Ultralytics GPU image
+FROM ultralytics/ultralytics:latest
+
+# Set the working directory
+WORKDIR /actions-runner
+
+# Download and unpack the latest runner from https://github.com/actions/runner
+RUN FILENAME=actions-runner-linux-x64-2.309.0.tar.gz && \
+ curl -o $FILENAME -L https://github.com/actions/runner/releases/download/v2.309.0/$FILENAME && \
+ tar xzf $FILENAME && \
+ rm $FILENAME
+
+# Install runner dependencies
+ENV RUNNER_ALLOW_RUNASROOT=1
+ENV DEBIAN_FRONTEND=noninteractive
+RUN ./bin/installdependencies.sh && \
+ apt-get -y install libicu-dev
+
+# Inline ENTRYPOINT command to configure and start runner with default TOKEN and NAME
+ENTRYPOINT sh -c './config.sh --url https://github.com/ultralytics/ultralytics \
+ --token ${GITHUB_RUNNER_TOKEN:-TOKEN} \
+ --name ${GITHUB_RUNNER_NAME:-NAME} \
+ --labels gpu-latest \
+ --replace && \
+ ./run.sh'
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-runner && sudo docker build -f docker/Dockerfile-runner -t $t . && sudo docker push $t
+
+# Pull and Run in detached mode with access to GPUs 0 and 1
+# t=ultralytics/ultralytics:latest-runner && sudo docker run -d -e GITHUB_RUNNER_TOKEN=TOKEN -e GITHUB_RUNNER_NAME=NAME --ipc=host --gpus '"device=0,1"' $t
diff --git a/ultralytics/docker/Dockerfile-runner:Zone.Identifier b/ultralytics/docker/Dockerfile-runner:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docker/Dockerfile-runner:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docker/Dockerfile:Zone.Identifier b/ultralytics/docker/Dockerfile:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docker/Dockerfile:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/README.md b/ultralytics/docs/README.md
new file mode 100755
index 0000000..a5da59e
--- /dev/null
+++ b/ultralytics/docs/README.md
@@ -0,0 +1,102 @@
+# Ultralytics Docs
+
+Ultralytics Docs are deployed to [https://docs.ultralytics.com](https://docs.ultralytics.com).
+
+[](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment) [](https://github.com/ultralytics/docs/actions/workflows/links.yml)
+
+## Install Ultralytics package
+
+[](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics)
+
+To install the ultralytics package in developer mode, you will need to have Git and Python 3 installed on your system. Then, follow these steps:
+
+1. Clone the ultralytics repository to your local machine using Git:
+
+ ```bash
+ git clone https://github.com/ultralytics/ultralytics.git
+ ```
+
+2. Navigate to the root directory of the repository:
+
+ ```bash
+ cd ultralytics
+ ```
+
+3. Install the package in developer mode using pip:
+
+ ```bash
+ pip install -e '.[dev]'
+ ```
+
+This will install the ultralytics package and its dependencies in developer mode, allowing you to make changes to the package code and have them reflected immediately in your Python environment.
+
+Note that you may need to use the pip3 command instead of pip if you have multiple versions of Python installed on your system.
+
+## Building and Serving Locally
+
+The `mkdocs serve` command is used to build and serve a local version of the MkDocs documentation site. It is typically used during the development and testing phase of a documentation project.
+
+```bash
+mkdocs serve
+```
+
+Here is a breakdown of what this command does:
+
+- `mkdocs`: This is the command-line interface (CLI) for the MkDocs static site generator. It is used to build and serve MkDocs sites.
+- `serve`: This is a subcommand of the `mkdocs` CLI that tells it to build and serve the documentation site locally.
+- `-a`: This flag specifies the hostname and port number to bind the server to. The default value is `localhost:8000`.
+- `-t`: This flag specifies the theme to use for the documentation site. The default value is `mkdocs`.
+- `-s`: This flag tells the `serve` command to serve the site in silent mode, which means it will not display any log messages or progress updates. When you run the `mkdocs serve` command, it will build the documentation site using the files in the `docs/` directory and serve it at the specified hostname and port number. You can then view the site by going to the URL in your web browser.
+
+While the site is being served, you can make changes to the documentation files and see them reflected in the live site immediately. This is useful for testing and debugging your documentation before deploying it to a live server.
+
+To stop the serve command and terminate the local server, you can use the `CTRL+C` keyboard shortcut.
+
+## Building and Serving Multi-Language
+
+For multi-language MkDocs sites use the following additional steps:
+
+1. Add all new language *.md files to git commit: `git add docs/**/*.md -f`
+2. Build all languages to the `/site` directory. Verify that the top-level `/site` directory contains `CNAME`, `robots.txt` and `sitemap.xml` files, if applicable.
+
+ ```bash
+ # Remove existing /site directory
+ rm -rf site
+
+ # Loop through all *.yml files in the docs directory
+ mkdocs build -f docs/mkdocs.yml
+ for file in docs/mkdocs_*.yml; do
+ echo "Building MkDocs site with configuration file: $file"
+ mkdocs build -f "$file"
+ done
+ ```
+
+3. Preview in web browser with:
+
+ ```bash
+ cd site
+ python -m http.server
+ open http://localhost:8000 # on macOS
+ ```
+
+Note the above steps are combined into the Ultralytics [build_docs.py](https://github.com/ultralytics/ultralytics/blob/main/docs/build_docs.py) script.
+
+## Deploying Your Documentation Site
+
+To deploy your MkDocs documentation site, you will need to choose a hosting provider and a deployment method. Some popular options include GitHub Pages, GitLab Pages, and Amazon S3.
+
+Before you can deploy your site, you will need to configure your `mkdocs.yml` file to specify the remote host and any other necessary deployment settings.
+
+Once you have configured your `mkdocs.yml` file, you can use the `mkdocs deploy` command to build and deploy your site. This command will build the documentation site using the files in the `docs/` directory and the specified configuration file and theme, and then deploy the site to the specified remote host.
+
+For example, to deploy your site to GitHub Pages using the gh-deploy plugin, you can use the following command:
+
+```bash
+mkdocs gh-deploy
+```
+
+If you are using GitHub Pages, you can set a custom domain for your documentation site by going to the "Settings" page for your repository and updating the "Custom domain" field in the "GitHub Pages" section.
+
+
+
+For more information on deploying your MkDocs documentation site, see the [MkDocs documentation](https://www.mkdocs.org/user-guide/deploying-your-docs/).
diff --git a/ultralytics/docs/README.md:Zone.Identifier b/ultralytics/docs/README.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/README.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/ar/index.md b/ultralytics/docs/ar/index.md
new file mode 100755
index 0000000..ab95a6a
--- /dev/null
+++ b/ultralytics/docs/ar/index.md
@@ -0,0 +1,83 @@
+---
+comments: true
+description: ุงุณุชูุดู ุฏููู ูุงู ู ูู Ultralytics YOLOv8 ุ ูู ูุฐุฌ ูุดู ุงููุงุฆูุงุช ูุชุฌุฒุฆุฉ ุงูุตูุฑ ุฐู ุงูุณุฑุนุฉ ุงูุนุงููุฉ ูุงูุฏูุฉ ุงูุนุงููุฉ. ุชุซุจูุช ุงูู ุญุฑุฑุฉ ุ ูุงูุชูุจุค ุ ูุงูุชุฏุฑูุจ ูุงูู ุฒูุฏ.
+keywords: Ultralyticsุ YOLOv8ุ ูุดู ุงููุงุฆูุงุชุ ุชุฌุฒุฆุฉ ุงูุตูุฑุ ุงูุชุนูู ุงูุขููุ ุงูุชุนูู ุงูุนู ููุ ุงูุฑุคูุฉ ุงูุญุงุณูุจูุฉุ YOLOv8 installationุ YOLOv8 predictionุ YOLOv8 trainingุ ุชุงุฑูุฎ YOLOุ ุชุฑุงุฎูุต YOLO
+---
+
+
+
+Wir stellen [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics) vor, die neueste Version des renommierten Echtzeit-Modells zur Objekterkennung und Bildsegmentierung. YOLOv8 basiert auf den neuesten Erkenntnissen im Bereich Deep Learning und Computer Vision und bietet eine unvergleichliche Leistung hinsichtlich Geschwindigkeit und Genauigkeit. Sein optimiertes Design macht es fรผr verschiedene Anwendungen geeignet und leicht an verschiedene Hardwareplattformen anpassbar, von Edge-Gerรคten bis hin zu Cloud-APIs.
+
+Erkunden Sie die YOLOv8-Dokumentation, eine umfassende Ressource, die Ihnen helfen soll, seine Funktionen und Fรคhigkeiten zu verstehen und zu nutzen. Ob Sie ein erfahrener Machine-Learning-Praktiker sind oder neu in diesem Bereich, dieses Hub zielt darauf ab, das Potenzial von YOLOv8 in Ihren Projekten zu maximieren
+
+!!! Note "Hinweis"
+
+ ๐ง Unsere mehrsprachige Dokumentation wird derzeit entwickelt und wir arbeiten intensiv an ihrer Verbesserung. Wir danken fรผr Ihre Geduld! ๐
+
+## Wo Sie beginnen sollten
+
+- **Installieren** Sie `ultralytics` mit pip und starten Sie in wenigen Minuten [:material-clock-fast: Loslegen](quickstart.md){ .md-button }
+- **Vorhersagen** Sie neue Bilder und Videos mit YOLOv8 [:octicons-image-16: Auf Bilder vorhersagen](modes/predict.md){ .md-button }
+- **Trainieren** Sie ein neues YOLOv8-Modell mit Ihrem eigenen benutzerdefinierten Datensatz [:fontawesome-solid-brain: Ein Modell trainieren](modes/train.md){ .md-button }
+- **Erforschen** Sie YOLOv8-Aufgaben wie Segmentieren, Klassifizieren, Posenschรคtzung und Verfolgen [:material-magnify-expand: Aufgaben erkunden](tasks/index.md){ .md-button }
+
+
+
+
+
+ Ansehen: Wie Sie ein YOLOv8-Modell auf Ihrem eigenen Datensatz in Google Colab trainieren.
+
+
+## YOLO: Eine kurze Geschichte
+
+[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), ein beliebtes Modell zur Objekterkennung und Bildsegmentierung, wurde von Joseph Redmon und Ali Farhadi an der Universitรคt von Washington entwickelt. Seit seiner Einfรผhrung im Jahr 2015 erfreut es sich aufgrund seiner hohen Geschwindigkeit und Genauigkeit groรer Beliebtheit.
+
+- [YOLOv2](https://arxiv.org/abs/1612.08242), verรถffentlicht im Jahr 2016, verbesserte das Originalmodell durch die Einfรผhrung von Batch-Normalisierung, Ankerkรคsten und Dimensionsclustern.
+- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), eingefรผhrt im Jahr 2018, erhรถhte die Leistung des Modells weiter mit einem effizienteren Backbone-Netzwerk, mehreren Ankern und rรคumlichem Pyramid-Pooling.
+- [YOLOv4](https://arxiv.org/abs/2004.10934) wurde 2020 verรถffentlicht und brachte Neuerungen wie Mosaic-Datenerweiterung, einen neuen ankerfreien Erkennungskopf und eine neue Verlustfunktion.
+- [YOLOv5](https://github.com/ultralytics/yolov5) verbesserte die Leistung des Modells weiter und fรผhrte neue Funktionen ein, wie Hyperparameter-Optimierung, integriertes Experiment-Tracking und automatischen Export in beliebte Exportformate.
+- [YOLOv6](https://github.com/meituan/YOLOv6) wurde 2022 von [Meituan](https://about.meituan.com/) als Open Source zur Verfรผgung gestellt und wird in vielen autonomen Lieferrobotern des Unternehmens eingesetzt.
+- [YOLOv7](https://github.com/WongKinYiu/yolov7) fรผhrte zusรคtzliche Aufgaben ein, wie Posenschรคtzung auf dem COCO-Keypoints-Datensatz.
+- [YOLOv8](https://github.com/ultralytics/ultralytics) ist die neueste Version von YOLO von Ultralytics. Als Spitzenmodell der neuesten Generation baut YOLOv8 auf dem Erfolg vorheriger Versionen auf und fรผhrt neue Funktionen und Verbesserungen fรผr erhรถhte Leistung, Flexibilitรคt und Effizienz ein. YOLOv8 unterstรผtzt eine vollstรคndige Palette an Vision-KI-Aufgaben, einschlieรlich [Erkennung](tasks/detect.md), [Segmentierung](tasks/segment.md), [Posenschรคtzung](tasks/pose.md), [Verfolgung](modes/track.md) und [Klassifizierung](tasks/classify.md). Diese Vielseitigkeit ermรถglicht es Benutzern, die Fรคhigkeiten von YOLOv8 in verschiedenen Anwendungen und Domรคnen zu nutzen.
+
+## YOLO-Lizenzen: Wie wird Ultralytics YOLO lizenziert?
+
+Ultralytics bietet zwei Lizenzoptionen, um unterschiedliche Einsatzszenarien zu berรผcksichtigen:
+
+- **AGPL-3.0-Lizenz**: Diese [OSI-geprรผfte](https://opensource.org/licenses/) Open-Source-Lizenz ist ideal fรผr Studenten und Enthusiasten und fรถrdert offene Zusammenarbeit und Wissensaustausch. Weitere Details finden Sie in der [LIZENZ](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)-Datei.
+- **Enterprise-Lizenz**: Fรผr die kommerzielle Nutzung konzipiert, ermรถglicht diese Lizenz die problemlose Integration von Ultralytics-Software und KI-Modellen in kommerzielle Produkte und Dienstleistungen und umgeht die Open-Source-Anforderungen der AGPL-3.0. Wenn Ihr Szenario die Einbettung unserer Lรถsungen in ein kommerzielles Angebot beinhaltet, kontaktieren Sie uns รผber [Ultralytics-Lizenzierung](https://ultralytics.com/license).
+
+Unsere Lizenzstrategie ist darauf ausgerichtet sicherzustellen, dass jegliche Verbesserungen an unseren Open-Source-Projekten der Gemeinschaft zurรผckgegeben werden. Wir halten die Prinzipien von Open Source in Ehren โค๏ธ und es ist unser Anliegen, dass unsere Beitrรคge auf Weisen genutzt und erweitert werden kรถnnen, die fรผr alle vorteilhaft sind.
diff --git a/ultralytics/docs/de/index.md:Zone.Identifier b/ultralytics/docs/de/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/fast-sam.md b/ultralytics/docs/de/models/fast-sam.md
new file mode 100755
index 0000000..e726c5c
--- /dev/null
+++ b/ultralytics/docs/de/models/fast-sam.md
@@ -0,0 +1,193 @@
+---
+comments: true
+description: Erkunden Sie FastSAM, eine CNN-basierte Lรถsung zur Echtzeit-Segmentierung von Objekten in Bildern. Verbesserte Benutzerinteraktion, Recheneffizienz und anpassbar fรผr verschiedene Vision-Aufgaben.
+keywords: FastSAM, maschinelles Lernen, CNN-basierte Lรถsung, Objektsegmentierung, Echtzeillรถsung, Ultralytics, Vision-Aufgaben, Bildverarbeitung, industrielle Anwendungen, Benutzerinteraktion
+---
+
+# Fast Segment Anything Model (FastSAM)
+
+Das Fast Segment Anything Model (FastSAM) ist eine neuartige, Echtzeit-CNN-basierte Lรถsung fรผr die Segment Anything Aufgabe. Diese Aufgabe zielt darauf ab, jedes Objekt in einem Bild auf Basis verschiedener mรถglicher Benutzerinteraktionen zu segmentieren. FastSAM reduziert signifikant den Rechenbedarf, wรคhrend es eine wettbewerbsfรคhige Leistung beibehรคlt und somit fรผr eine Vielzahl von Vision-Aufgaben praktisch einsetzbar ist.
+
+
+
+## รberblick
+
+FastSAM wurde entwickelt, um die Einschrรคnkungen des [Segment Anything Model (SAM)](sam.md) zu beheben, einem schweren Transformer-Modell mit erheblichem Rechenressourcenbedarf. Das FastSAM teilt die Segment Anything Aufgabe in zwei aufeinanderfolgende Stufen auf: die Instanzsegmentierung und die promptgesteuerte Auswahl. In der ersten Stufe wird [YOLOv8-seg](../tasks/segment.md) verwendet, um die Segmentierungsmasken aller Instanzen im Bild zu erzeugen. In der zweiten Stufe gibt es den Bereich von Interesse aus, der dem Prompt entspricht.
+
+## Hauptmerkmale
+
+1. **Echtzeitlรถsung:** Durch die Nutzung der Recheneffizienz von CNNs bietet FastSAM eine Echtzeitlรถsung fรผr die Segment Anything Aufgabe und eignet sich somit fรผr industrielle Anwendungen, die schnelle Ergebnisse erfordern.
+
+2. **Effizienz und Leistung:** FastSAM bietet eine signifikante Reduzierung des Rechen- und Ressourcenbedarfs, ohne die Leistungsqualitรคt zu beeintrรคchtigen. Es erzielt eine vergleichbare Leistung wie SAM, verwendet jedoch drastisch reduzierte Rechenressourcen und ermรถglicht so eine Echtzeitanwendung.
+
+3. **Promptgesteuerte Segmentierung:** FastSAM kann jedes Objekt in einem Bild anhand verschiedener mรถglicher Benutzerinteraktionsaufforderungen segmentieren. Dies ermรถglicht Flexibilitรคt und Anpassungsfรคhigkeit in verschiedenen Szenarien.
+
+4. **Basierend auf YOLOv8-seg:** FastSAM basiert auf [YOLOv8-seg](../tasks/segment.md), einem Objektdetektor mit einem Instanzsegmentierungsmodul. Dadurch ist es in der Lage, die Segmentierungsmasken aller Instanzen in einem Bild effektiv zu erzeugen.
+
+5. **Wettbewerbsfรคhige Ergebnisse auf Benchmarks:** Bei der Objektvorschlagsaufgabe auf MS COCO erzielt FastSAM hohe Punktzahlen bei deutlich schnellerem Tempo als [SAM](sam.md) auf einer einzelnen NVIDIA RTX 3090. Dies demonstriert seine Effizienz und Leistungsfรคhigkeit.
+
+6. **Praktische Anwendungen:** Der vorgeschlagene Ansatz bietet eine neue, praktische Lรถsung fรผr eine Vielzahl von Vision-Aufgaben mit sehr hoher Geschwindigkeit, die zehn- oder hundertmal schneller ist als vorhandene Methoden.
+
+7. **Mรถglichkeit zur Modellkompression:** FastSAM zeigt, dass der Rechenaufwand erheblich reduziert werden kann, indem ein kรผnstlicher Prior in die Struktur eingefรผhrt wird. Dadurch erรถffnen sich neue Mรถglichkeiten fรผr groรe Modellarchitekturen fรผr allgemeine Vision-Aufgaben.
+
+## Verfรผgbare Modelle, unterstรผtzte Aufgaben und Betriebsmodi
+
+In dieser Tabelle werden die verfรผgbaren Modelle mit ihren spezifischen vorab trainierten Gewichten, den unterstรผtzten Aufgaben und ihrer Kompatibilitรคt mit verschiedenen Betriebsmodi wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md) angezeigt. Dabei stehen โ Emojis fรผr unterstรผtzte Modi und โ Emojis fรผr nicht unterstรผtzte Modi.
+
+| Modelltyp | Vorab trainierte Gewichte | Unterstรผtzte Aufgaben | Inferenz | Validierung | Training | Export |
+|-----------|---------------------------|---------------------------------------------|----------|-------------|----------|--------|
+| FastSAM-s | `FastSAM-s.pt` | [Instanzsegmentierung](../tasks/segment.md) | โ | โ | โ | โ |
+| FastSAM-x | `FastSAM-x.pt` | [Instanzsegmentierung](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Beispiele fรผr die Verwendung
+
+Die FastSAM-Modelle lassen sich problemlos in Ihre Python-Anwendungen integrieren. Ultralytics bietet eine benutzerfreundliche Python-API und CLI-Befehle zur Vereinfachung der Entwicklung.
+
+### Verwendung der Methode `predict`
+
+Um eine Objekterkennung auf einem Bild durchzufรผhren, verwenden Sie die Methode `predict` wie folgt:
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM
+ from ultralytics.models.fastsam import FastSAMPrompt
+
+ # Definieren Sie die Quelle fรผr die Inferenz
+ source = 'Pfad/zum/bus.jpg'
+
+ # Erstellen Sie ein FastSAM-Modell
+ model = FastSAM('FastSAM-s.pt') # oder FastSAM-x.pt
+
+ # Fรผhren Sie die Inferenz auf einem Bild durch
+ everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
+
+ # Bereiten Sie ein Prompt-Process-Objekt vor
+ prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
+
+ # Alles-Prompt
+ ann = prompt_process.everything_prompt()
+
+ # Bbox Standardform [0,0,0,0] -> [x1,y1,x2,y2]
+ ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
+
+ # Text-Prompt
+ ann = prompt_process.text_prompt(text='ein Foto von einem Hund')
+
+ # Punkt-Prompt
+ # Punkte Standard [[0,0]] [[x1,y1],[x2,y2]]
+ # Punktbezeichnung Standard [0] [1,0] 0:Hintergrund, 1:Vordergrund
+ ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
+ prompt_process.plot(annotations=ann, output='./')
+ ```
+
+ === "CLI"
+ ```bash
+ # Laden Sie ein FastSAM-Modell und segmentieren Sie alles damit
+ yolo segment predict model=FastSAM-s.pt source=Pfad/zum/bus.jpg imgsz=640
+ ```
+
+Dieser Code-Ausschnitt zeigt die Einfachheit des Ladens eines vorab trainierten Modells und das Durchfรผhren einer Vorhersage auf einem Bild.
+
+### Verwendung von `val`
+
+Die Validierung des Modells auf einem Datensatz kann wie folgt durchgefรผhrt werden:
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM
+
+ # Erstellen Sie ein FastSAM-Modell
+ model = FastSAM('FastSAM-s.pt') # oder FastSAM-x.pt
+
+ # Validieren Sie das Modell
+ results = model.val(data='coco8-seg.yaml')
+ ```
+
+ === "CLI"
+ ```bash
+ # Laden Sie ein FastSAM-Modell und validieren Sie es auf dem COCO8-Beispieldatensatz mit Bildgrรถรe 640
+ yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
+ ```
+
+Bitte beachten Sie, dass FastSAM nur die Erkennung und Segmentierung einer einzigen Objektklasse unterstรผtzt. Das bedeutet, dass es alle Objekte als dieselbe Klasse erkennt und segmentiert. Daher mรผssen Sie beim Vorbereiten des Datensatzes alle Objektkategorie-IDs in 0 umwandeln.
+
+## Offizielle Verwendung von FastSAM
+
+FastSAM ist auch direkt aus dem [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM) Repository erhรคltlich. Hier ist ein kurzer รberblick รผber die typischen Schritte, die Sie unternehmen kรถnnten, um FastSAM zu verwenden:
+
+### Installation
+
+1. Klonen Sie das FastSAM-Repository:
+ ```shell
+ git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
+ ```
+
+2. Erstellen und aktivieren Sie eine Conda-Umgebung mit Python 3.9:
+ ```shell
+ conda create -n FastSAM python=3.9
+ conda activate FastSAM
+ ```
+
+3. Navigieren Sie zum geklonten Repository und installieren Sie die erforderlichen Pakete:
+ ```shell
+ cd FastSAM
+ pip install -r requirements.txt
+ ```
+
+4. Installieren Sie das CLIP-Modell:
+ ```shell
+ pip install git+https://github.com/openai/CLIP.git
+ ```
+
+### Beispielverwendung
+
+1. Laden Sie eine [Modell-Sicherung](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing) herunter.
+
+2. Verwenden Sie FastSAM fรผr Inferenz. Beispielbefehle:
+
+ - Segmentieren Sie alles in einem Bild:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
+ ```
+
+ - Segmentieren Sie bestimmte Objekte anhand eines Textprompts:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "der gelbe Hund"
+ ```
+
+ - Segmentieren Sie Objekte innerhalb eines Begrenzungsrahmens (geben Sie die Boxkoordinaten im xywh-Format an):
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
+ ```
+
+ - Segmentieren Sie Objekte in der Nรคhe bestimmter Punkte:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
+ ```
+
+Sie kรถnnen FastSAM auch รผber eine [Colab-Demo](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) oder die [HuggingFace-Web-Demo](https://huggingface.co/spaces/An-619/FastSAM) testen, um eine visuelle Erfahrung zu machen.
+
+## Zitate und Danksagungen
+
+Wir mรถchten den Autoren von FastSAM fรผr ihre bedeutenden Beitrรคge auf dem Gebiet der Echtzeit-Instanzsegmentierung danken:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{zhao2023fast,
+ title={Fast Segment Anything},
+ author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
+ year={2023},
+ eprint={2306.12156},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+Die ursprรผngliche FastSAM-Arbeit ist auf [arXiv](https://arxiv.org/abs/2306.12156) zu finden. Die Autoren haben ihre Arbeit รถffentlich zugรคnglich gemacht, und der Code ist auf [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM) verfรผgbar. Wir schรคtzen ihre Bemรผhungen, das Fachgebiet voranzutreiben und ihre Arbeit der breiteren Gemeinschaft zugรคnglich zu machen.
diff --git a/ultralytics/docs/de/models/fast-sam.md:Zone.Identifier b/ultralytics/docs/de/models/fast-sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/fast-sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/index.md b/ultralytics/docs/de/models/index.md
new file mode 100755
index 0000000..4482ccc
--- /dev/null
+++ b/ultralytics/docs/de/models/index.md
@@ -0,0 +1,98 @@
+---
+comments: true
+description: Entdecken Sie die vielfรคltige Palette an Modellen der YOLO-Familie, SAM, MobileSAM, FastSAM, YOLO-NAS und RT-DETR, die von Ultralytics unterstรผtzt werden. Beginnen Sie mit Beispielen fรผr die CLI- und Python-Nutzung.
+keywords: Ultralytics, Dokumentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, Modelle, Architekturen, Python, CLI
+---
+
+# Von Ultralytics unterstรผtzte Modelle
+
+Willkommen bei der Modell-Dokumentation von Ultralytics! Wir bieten Unterstรผtzung fรผr eine breite Palette von Modellen, die jeweils fรผr spezifische Aufgaben wie [Objekterkennung](../tasks/detect.md), [Instanzsegmentierung](../tasks/segment.md), [Bildklassifizierung](../tasks/classify.md), [Posenschรคtzung](../tasks/pose.md) und [Multi-Objekt-Tracking](../modes/track.md) maรgeschneidert sind. Wenn Sie daran interessiert sind, Ihre Modellarchitektur bei Ultralytics beizutragen, sehen Sie sich unseren [Beitragenden-Leitfaden](../../help/contributing.md) an.
+
+!!! Note "Hinweis"
+
+ ๐ง Unsere Dokumentation in verschiedenen Sprachen ist derzeit im Aufbau und wir arbeiten hart daran, sie zu verbessern. Vielen Dank fรผr Ihre Geduld! ๐
+
+## Vorgestellte Modelle
+
+Hier sind einige der wichtigsten unterstรผtzten Modelle:
+
+1. **[YOLOv3](yolov3.md)**: Die dritte Iteration der YOLO-Modellfamilie, ursprรผnglich von Joseph Redmon, bekannt fรผr ihre effiziente Echtzeit-Objekterkennungsfรคhigkeiten.
+2. **[YOLOv4](yolov4.md)**: Ein dunkelnetz-natives Update von YOLOv3, verรถffentlicht von Alexey Bochkovskiy im Jahr 2020.
+3. **[YOLOv5](yolov5.md)**: Eine verbesserte Version der YOLO-Architektur von Ultralytics, die bessere Leistungs- und Geschwindigkeitskompromisse im Vergleich zu frรผheren Versionen bietet.
+4. **[YOLOv6](yolov6.md)**: Verรถffentlicht von [Meituan](https://about.meituan.com/) im Jahr 2022 und in vielen autonomen Lieferrobotern des Unternehmens im Einsatz.
+5. **[YOLOv7](yolov7.md)**: Aktualisierte YOLO-Modelle, die 2022 von den Autoren von YOLOv4 verรถffentlicht wurden.
+6. **[YOLOv8](yolov8.md) NEU ๐**: Die neueste Version der YOLO-Familie, mit erweiterten Fรคhigkeiten wie Instanzsegmentierung, Pose/Schlรผsselpunktschรคtzung und Klassifizierung.
+7. **[Segment Anything Model (SAM)](sam.md)**: Metas Segment Anything Model (SAM).
+8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM fรผr mobile Anwendungen, von der Kyung Hee University.
+9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: FastSAM von der Image & Video Analysis Group, Institute of Automation, Chinesische Akademie der Wissenschaften.
+10. **[YOLO-NAS](yolo-nas.md)**: YOLO Neural Architecture Search (NAS) Modelle.
+11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)**: Baidus PaddlePaddle Realtime Detection Transformer (RT-DETR) Modelle.
+
+
+
+
+
+ Anschauen: Fรผhren Sie Ultralytics YOLO-Modelle in nur wenigen Codezeilen aus.
+
+
+## Einstieg: Nutzungbeispiele
+
+Dieses Beispiel bietet einfache YOLO-Trainings- und Inferenzbeispiele. Fรผr vollstรคndige Dokumentationen รผber diese und andere [Modi](../modes/index.md) siehe die Dokumentationsseiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md).
+
+Beachten Sie, dass das folgende Beispiel fรผr YOLOv8 [Detect](../tasks/detect.md) Modelle zur Objekterkennung ist. Fรผr zusรคtzliche unterstรผtzte Aufgaben siehe die Dokumentation zu [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) und [Pose](../tasks/pose.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ Vorgefertigte PyTorch `*.pt` Modelle sowie Konfigurationsdateien `*.yaml` kรถnnen den Klassen `YOLO()`, `SAM()`, `NAS()` und `RTDETR()` รผbergeben werden, um eine Modellinstanz in Python zu erstellen:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden eines COCO-vortrainierten YOLOv8n Modells
+ model = YOLO('yolov8n.pt')
+
+ # Modellinformationen anzeigen (optional)
+ model.info()
+
+ # Model auf dem COCO8-Beispieldatensatz fรผr 100 Epochen trainieren
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Inferenz mit dem YOLOv8n Modell auf das Bild 'bus.jpg' ausfรผhren
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI-Befehle sind verfรผgbar, um die Modelle direkt auszufรผhren:
+
+ ```bash
+ # Ein COCO-vortrainiertes YOLOv8n Modell laden und auf dem COCO8-Beispieldatensatz fรผr 100 Epochen trainieren
+ yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Ein COCO-vortrainiertes YOLOv8n Modell laden und Inferenz auf das Bild 'bus.jpg' ausfรผhren
+ yolo predict model=yolov8n.pt source=path/to/bus.jpg
+ ```
+
+## Neue Modelle beitragen
+
+Sind Sie daran interessiert, Ihr Modell bei Ultralytics beizutragen? Groรartig! Wir sind immer offen dafรผr, unser Modellportfolio zu erweitern.
+
+1. **Repository forken**: Beginnen Sie mit dem Forken des [Ultralytics GitHub-Repositorys](https://github.com/ultralytics/ultralytics).
+
+2. **Ihren Fork klonen**: Klonen Sie Ihren Fork auf Ihre lokale Maschine und erstellen Sie einen neuen Branch, um daran zu arbeiten.
+
+3. **Ihr Modell implementieren**: Fรผgen Sie Ihr Modell entsprechend den in unserem [Beitragenden-Leitfaden](../../help/contributing.md) bereitgestellten Kodierungsstandards und Richtlinien hinzu.
+
+4. **Grรผndlich testen**: Stellen Sie sicher, dass Sie Ihr Modell sowohl isoliert als auch als Teil des Pipelines grรผndlich testen.
+
+5. **Eine Pull-Anfrage erstellen**: Sobald Sie mit Ihrem Modell zufrieden sind, erstellen Sie eine Pull-Anfrage zum Hauptrepository zur รberprรผfung.
+
+6. **Code-Review & Zusammenfรผhren**: Nach der รberprรผfung, wenn Ihr Modell unseren Kriterien entspricht, wird es in das Hauptrepository zusammengefรผhrt.
+
+Fรผr detaillierte Schritte konsultieren Sie unseren [Beitragenden-Leitfaden](../../help/contributing.md).
diff --git a/ultralytics/docs/de/models/index.md:Zone.Identifier b/ultralytics/docs/de/models/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/mobile-sam.md b/ultralytics/docs/de/models/mobile-sam.md
new file mode 100755
index 0000000..7f30175
--- /dev/null
+++ b/ultralytics/docs/de/models/mobile-sam.md
@@ -0,0 +1,116 @@
+---
+comments: true
+description: Erfahren Sie mehr รผber MobileSAM, dessen Implementierung, den Vergleich mit dem Original-SAM und wie Sie es im Ultralytics-Framework herunterladen und testen kรถnnen. Verbessern Sie Ihre mobilen Anwendungen heute.
+keywords: MobileSAM, Ultralytics, SAM, mobile Anwendungen, Arxiv, GPU, API, Bildencoder, Maskendekoder, Modell-Download, Testmethode
+---
+
+
+
+# Mobile Segment Anything (MobileSAM)
+
+Das MobileSAM-Paper ist jetzt auf [arXiv](https://arxiv.org/pdf/2306.14289.pdf) verfรผgbar.
+
+Eine Demonstration von MobileSAM, das auf einer CPU ausgefรผhrt wird, finden Sie unter diesem [Demo-Link](https://huggingface.co/spaces/dhkim2810/MobileSAM). Die Leistung auf einer Mac i5 CPU betrรคgt etwa 3 Sekunden. Auf der Hugging Face-Demo fรผhrt die Benutzeroberflรคche und CPUs mit niedrigerer Leistung zu einer langsameren Reaktion, aber die Funktion bleibt effektiv.
+
+MobileSAM ist in verschiedenen Projekten implementiert, darunter [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling) und [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D).
+
+MobileSAM wird mit einem einzigen GPU und einem 100K-Datensatz (1% der Originalbilder) in weniger als einem Tag trainiert. Der Code fรผr dieses Training wird in Zukunft verfรผgbar gemacht.
+
+## Verfรผgbarkeit von Modellen, unterstรผtzte Aufgaben und Betriebsarten
+
+Die folgende Tabelle zeigt die verfรผgbaren Modelle mit ihren spezifischen vortrainierten Gewichten, die unterstรผtzten Aufgaben und ihre Kompatibilitรคt mit unterschiedlichen Betriebsarten wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md). Unterstรผtzte Betriebsarten werden mit โ -Emojis und nicht unterstรผtzte Betriebsarten mit โ-Emojis angezeigt.
+
+| Modelltyp | Vortrainierte Gewichte | Unterstรผtzte Aufgaben | Inferenz | Validierung | Training | Export |
+|-----------|------------------------|---------------------------------------------|----------|-------------|----------|--------|
+| MobileSAM | `mobile_sam.pt` | [Instanzsegmentierung](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Anpassung von SAM zu MobileSAM
+
+Da MobileSAM die gleiche Pipeline wie das Original-SAM beibehรคlt, haben wir das ursprรผngliche Preprocessing, Postprocessing und alle anderen Schnittstellen eingebunden. Personen, die derzeit das ursprรผngliche SAM verwenden, kรถnnen daher mit minimalem Aufwand zu MobileSAM wechseln.
+
+MobileSAM bietet vergleichbare Leistungen wie das ursprรผngliche SAM und behรคlt dieselbe Pipeline, mit Ausnahme eines Wechsels des Bildencoders. Konkret ersetzen wir den ursprรผnglichen, leistungsstarken ViT-H-Encoder (632M) durch einen kleineren Tiny-ViT-Encoder (5M). Auf einem einzelnen GPU arbeitet MobileSAM in etwa 12 ms pro Bild: 8 ms auf dem Bildencoder und 4 ms auf dem Maskendekoder.
+
+Die folgende Tabelle bietet einen Vergleich der Bildencoder, die auf ViT basieren:
+
+| Bildencoder | Original-SAM | MobileSAM |
+|-----------------|--------------|-----------|
+| Parameter | 611M | 5M |
+| Geschwindigkeit | 452ms | 8ms |
+
+Sowohl das ursprรผngliche SAM als auch MobileSAM verwenden denselben promptgefรผhrten Maskendekoder:
+
+| Maskendekoder | Original-SAM | MobileSAM |
+|-----------------|--------------|-----------|
+| Parameter | 3.876M | 3.876M |
+| Geschwindigkeit | 4ms | 4ms |
+
+Hier ist ein Vergleich der gesamten Pipeline:
+
+| Gesamte Pipeline (Enc+Dec) | Original-SAM | MobileSAM |
+|----------------------------|--------------|-----------|
+| Parameter | 615M | 9.66M |
+| Geschwindigkeit | 456ms | 12ms |
+
+Die Leistung von MobileSAM und des ursprรผnglichen SAM werden sowohl mit einem Punkt als auch mit einem Kasten als Prompt demonstriert.
+
+
+
+
+
+Mit seiner รผberlegenen Leistung ist MobileSAM etwa 5-mal kleiner und 7-mal schneller als das aktuelle FastSAM. Weitere Details finden Sie auf der [MobileSAM-Projektseite](https://github.com/ChaoningZhang/MobileSAM).
+
+## Testen von MobileSAM in Ultralytics
+
+Wie beim ursprรผnglichen SAM bieten wir eine unkomplizierte Testmethode in Ultralytics an, einschlieรlich Modi fรผr Punkt- und Kasten-Prompts.
+
+### Modell-Download
+
+Sie kรถnnen das Modell [hier](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt) herunterladen.
+
+### Punkt-Prompt
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ from ultralytics import SAM
+
+ # Laden Sie das Modell
+ model = SAM('mobile_sam.pt')
+
+ # Vorhersage einer Segmentierung basierend auf einem Punkt-Prompt
+ model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
+ ```
+
+### Kasten-Prompt
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ from ultralytics import SAM
+
+ # Laden Sie das Modell
+ model = SAM('mobile_sam.pt')
+
+ # Vorhersage einer Segmentierung basierend auf einem Kasten-Prompt
+ model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
+ ```
+
+Wir haben `MobileSAM` und `SAM` mit derselben API implementiert. Fรผr weitere Verwendungsinformationen sehen Sie bitte die [SAM-Seite](sam.md).
+
+## Zitate und Danksagungen
+
+Wenn Sie MobileSAM in Ihrer Forschungs- oder Entwicklungsarbeit nรผtzlich finden, zitieren Sie bitte unser Paper:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{mobile_sam,
+ title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications},
+ author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon},
+ journal={arXiv preprint arXiv:2306.14289},
+ year={2023}
+ }
diff --git a/ultralytics/docs/de/models/mobile-sam.md:Zone.Identifier b/ultralytics/docs/de/models/mobile-sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/mobile-sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/rtdetr.md b/ultralytics/docs/de/models/rtdetr.md
new file mode 100755
index 0000000..dbc0b41
--- /dev/null
+++ b/ultralytics/docs/de/models/rtdetr.md
@@ -0,0 +1,93 @@
+---
+comments: true
+description: Entdecken Sie die Funktionen und Vorteile von RT-DETR, dem effizienten und anpassungsfรคhigen Echtzeitobjektdetektor von Baidu, der von Vision Transformers unterstรผtzt wird, einschlieรlich vortrainierter Modelle.
+keywords: RT-DETR, Baidu, Vision Transformers, Objekterkennung, Echtzeitleistung, CUDA, TensorRT, IoU-bewusste Query-Auswahl, Ultralytics, Python API, PaddlePaddle
+---
+
+# Baidus RT-DETR: Ein Echtzeit-Objektdetektor auf Basis von Vision Transformers
+
+## รberblick
+
+Der Real-Time Detection Transformer (RT-DETR), entwickelt von Baidu, ist ein moderner End-to-End-Objektdetektor, der Echtzeitleistung mit hoher Genauigkeit bietet. Er nutzt die Leistung von Vision Transformers (ViT), um Multiskalen-Funktionen effizient zu verarbeiten, indem intra-skaliere Interaktion und eine skalenรผbergreifende Fusion entkoppelt werden. RT-DETR ist hoch anpassungsfรคhig und unterstรผtzt flexible Anpassung der Inferenzgeschwindigkeit durch Verwendung verschiedener Decoder-Schichten ohne erneutes Training. Das Modell รผbertrifft viele andere Echtzeit-Objektdetektoren auf beschleunigten Backends wie CUDA mit TensorRT.
+
+
+**รbersicht von Baidus RT-DETR.** Die Modellarchitekturdiagramm des RT-DETR zeigt die letzten drei Stufen des Backbone {S3, S4, S5} als Eingabe fรผr den Encoder. Der effiziente Hybrid-Encoder verwandelt Multiskalen-Funktionen durch intraskalare Feature-Interaktion (AIFI) und das skalenรผbergreifende Feature-Fusion-Modul (CCFM) in eine Sequenz von Bildmerkmalen. Die IoU-bewusste Query-Auswahl wird verwendet, um eine feste Anzahl von Bildmerkmalen als anfรคngliche Objekt-Queries fรผr den Decoder auszuwรคhlen. Der Decoder optimiert iterativ Objekt-Queries, um Boxen und Vertrauenswerte zu generieren ([Quelle](https://arxiv.org/pdf/2304.08069.pdf)).
+
+### Hauptmerkmale
+
+- **Effizienter Hybrid-Encoder:** Baidus RT-DETR verwendet einen effizienten Hybrid-Encoder, der Multiskalen-Funktionen verarbeitet, indem intra-skaliere Interaktion und eine skalenรผbergreifende Fusion entkoppelt werden. Dieses einzigartige Design auf Basis von Vision Transformers reduziert die Rechenkosten und ermรถglicht die Echtzeit-Objekterkennung.
+- **IoU-bewusste Query-Auswahl:** Baidus RT-DETR verbessert die Initialisierung von Objekt-Queries, indem IoU-bewusste Query-Auswahl verwendet wird. Dadurch kann das Modell sich auf die relevantesten Objekte in der Szene konzentrieren und die Erkennungsgenauigkeit verbessern.
+- **Anpassbare Inferenzgeschwindigkeit:** Baidus RT-DETR ermรถglicht flexible Anpassungen der Inferenzgeschwindigkeit durch Verwendung unterschiedlicher Decoder-Schichten ohne erneutes Training. Diese Anpassungsfรคhigkeit erleichtert den praktischen Einsatz in verschiedenen Echtzeit-Objekterkennungsszenarien.
+
+## Vortrainierte Modelle
+
+Die Ultralytics Python API bietet vortrainierte PaddlePaddle RT-DETR-Modelle in verschiedenen Skalierungen:
+
+- RT-DETR-L: 53,0% AP auf COCO val2017, 114 FPS auf T4 GPU
+- RT-DETR-X: 54,8% AP auf COCO val2017, 74 FPS auf T4 GPU
+
+## Beispiele fรผr die Verwendung
+
+Das folgende Beispiel enthรคlt einfache Trainings- und Inferenzbeispiele fรผr RT-DETRR. Fรผr die vollstรคndige Dokumentation zu diesen und anderen [Modi](../modes/index.md) siehe die Dokumentationsseiten fรผr [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import RTDETR
+
+ # Laden Sie ein vortrainiertes RT-DETR-l Modell auf COCO
+ model = RTDETR('rtdetr-l.pt')
+
+ # Zeigen Sie Informationen รผber das Modell an (optional)
+ model.info()
+
+ # Trainieren Sie das Modell auf dem COCO8-Beispiel-Datensatz fรผr 100 Epochen
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Fรผhren Sie die Inferenz mit dem RT-DETR-l Modell auf dem Bild 'bus.jpg' aus
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Laden Sie ein vortrainiertes RT-DETR-l Modell auf COCO und trainieren Sie es auf dem COCO8-Beispiel-Datensatz fรผr 100 Epochen
+ yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Laden Sie ein vortrainiertes RT-DETR-l Modell auf COCO und fรผhren Sie die Inferenz auf dem Bild 'bus.jpg' aus
+ yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
+ ```
+
+## Unterstรผtzte Aufgaben und Modi
+
+In dieser Tabelle werden die Modelltypen, die spezifischen vortrainierten Gewichte, die von jedem Modell unterstรผtzten Aufgaben und die verschiedenen Modi ([Train](../modes/train.md), [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)), die unterstรผtzt werden, mit โ -Emoji angezeigt.
+
+| Modelltyp | Vortrainierte Gewichte | Unterstรผtzte Aufgaben | Inferenz | Validierung | Training | Exportieren |
+|--------------------|------------------------|---------------------------------------|----------|-------------|----------|-------------|
+| RT-DETR Groร | `rtdetr-l.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| RT-DETR Extra-Groร | `rtdetr-x.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+
+## Zitate und Danksagungen
+
+Wenn Sie Baidus RT-DETR in Ihrer Forschungs- oder Entwicklungsarbeit verwenden, zitieren Sie bitte das [ursprรผngliche Papier](https://arxiv.org/abs/2304.08069):
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{lv2023detrs,
+ title={DETRs Beat YOLOs on Real-time Object Detection},
+ author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu},
+ year={2023},
+ eprint={2304.08069},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+Wir mรถchten Baidu und dem [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection)-Team fรผr die Erstellung und Pflege dieser wertvollen Ressource fรผr die Computer-Vision-Community danken. Ihre Beitrag zum Gebiet der Entwicklung des Echtzeit-Objekterkenners auf Basis von Vision Transformers, RT-DETR, wird sehr geschรคtzt.
+
+*Keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, Objekterkennung in Echtzeit, objekterkennung basierend auf Vision Transformers, vortrainierte PaddlePaddle RT-DETR Modelle, Verwendung von Baidus RT-DETR, Ultralytics Python API*
diff --git a/ultralytics/docs/de/models/rtdetr.md:Zone.Identifier b/ultralytics/docs/de/models/rtdetr.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/rtdetr.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/sam.md b/ultralytics/docs/de/models/sam.md
new file mode 100755
index 0000000..9ca50b9
--- /dev/null
+++ b/ultralytics/docs/de/models/sam.md
@@ -0,0 +1,226 @@
+---
+comments: true
+description: Erkunden Sie das innovative Segment Anything Model (SAM) von Ultralytics, das Echtzeit-Bildsegmentierung ermรถglicht. Erfahren Sie mehr รผber die promptable Segmentierung, die Zero-Shot-Performance und die Anwendung.
+keywords: Ultralytics, Bildsegmentierung, Segment Anything Model, SAM, SA-1B-Datensatz, Echtzeit-Performance, Zero-Shot-Transfer, Objekterkennung, Bildanalyse, maschinelles Lernen
+---
+
+# Segment Anything Model (SAM)
+
+Willkommen an der Spitze der Bildsegmentierung mit dem Segment Anything Model (SAM). Dieses revolutionรคre Modell hat mit promptabler Bildsegmentierung und Echtzeit-Performance neue Standards in diesem Bereich gesetzt.
+
+## Einfรผhrung in SAM: Das Segment Anything Model
+
+Das Segment Anything Model (SAM) ist ein innovatives Bildsegmentierungsmodell, das promptable Segmentierung ermรถglicht und so eine beispiellose Vielseitigkeit bei der Bildanalyse bietet. SAM bildet das Herzstรผck der Segment Anything Initiative, einem bahnbrechenden Projekt, das ein neuartiges Modell, eine neue Aufgabe und einen neuen Datensatz fรผr die Bildsegmentierung einfรผhrt.
+
+Dank seiner fortschrittlichen Konstruktion kann SAM sich an neue Bildverteilungen und Aufgaben anpassen, auch ohne Vorwissen. Das wird als Zero-Shot-Transfer bezeichnet. Trainiert wurde SAM auf dem umfangreichen [SA-1B-Datensatz](https://ai.facebook.com/datasets/segment-anything/), der รผber 1 Milliarde Masken auf 11 Millionen sorgfรคltig kuratierten Bildern enthรคlt. SAM hat beeindruckende Zero-Shot-Performance gezeigt und in vielen Fรคllen frรผhere vollstรคndig รผberwachte Ergebnisse รผbertroffen.
+
+
+Beispielimagen mit รผberlagernden Masken aus unserem neu eingefรผhrten Datensatz SA-1B. SA-1B enthรคlt 11 Millionen diverse, hochauflรถsende, lizenzierte und die Privatsphรคre schรผtzende Bilder und 1,1 Milliarden qualitativ hochwertige Segmentierungsmasken. Diese wurden vollautomatisch von SAM annotiert und sind nach menschlichen Bewertungen und zahlreichen Experimenten von hoher Qualitรคt und Vielfalt. Die Bilder sind nach der Anzahl der Masken pro Bild gruppiert (im Durchschnitt sind es etwa 100 Masken pro Bild).
+
+## Hauptmerkmale des Segment Anything Model (SAM)
+
+- **Promptable Segmentierungsaufgabe:** SAM wurde mit der Ausfรผhrung einer promptable Segmentierungsaufgabe entwickelt, wodurch es valide Segmentierungsmasken aus beliebigen Prompts generieren kann, z. B. rรคumlichen oder textuellen Hinweisen zur Identifizierung eines Objekts.
+- **Fortgeschrittene Architektur:** Das Segment Anything Model verwendet einen leistungsfรคhigen Bild-Encoder, einen Prompt-Encoder und einen leichten Masken-Decoder. Diese einzigartige Architektur ermรถglicht flexibles Prompting, Echtzeitmaskenberechnung und Berรผcksichtigung von Mehrdeutigkeiten in Segmentierungsaufgaben.
+- **Der SA-1B-Datensatz:** Eingefรผhrt durch das Segment Anything Projekt, enthรคlt der SA-1B-Datensatz รผber 1 Milliarde Masken auf 11 Millionen Bildern. Als bisher grรถรter Segmentierungsdatensatz liefert er SAM eine vielfรคltige und umfangreiche Datenquelle fรผr das Training.
+- **Zero-Shot-Performance:** SAM zeigt herausragende Zero-Shot-Performance in verschiedenen Segmentierungsaufgaben und ist damit ein einsatzbereites Werkzeug fรผr vielfรคltige Anwendungen mit minimalem Bedarf an prompt engineering.
+
+Fรผr eine detaillierte Betrachtung des Segment Anything Models und des SA-1B-Datensatzes besuchen Sie bitte die [Segment Anything Website](https://segment-anything.com) und lesen Sie das Forschungspapier [Segment Anything](https://arxiv.org/abs/2304.02643).
+
+## Verfรผgbare Modelle, unterstรผtzte Aufgaben und Betriebsmodi
+
+Diese Tabelle zeigt die verfรผgbaren Modelle mit ihren spezifischen vortrainierten Gewichten, die unterstรผtzten Aufgaben und ihre Kompatibilitรคt mit verschiedenen Betriebsmodi wie [Inference](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md), wobei โ Emojis fรผr unterstรผtzte Modi und โ Emojis fรผr nicht unterstรผtzte Modi verwendet werden.
+
+| Modelltyp | Vortrainierte Gewichte | Unterstรผtzte Aufgaben | Inference | Validierung | Training | Export |
+|-----------|------------------------|---------------------------------------------|-----------|-------------|----------|--------|
+| SAM base | `sam_b.pt` | [Instanzsegmentierung](../tasks/segment.md) | โ | โ | โ | โ |
+| SAM large | `sam_l.pt` | [Instanzsegmentierung](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Wie man SAM verwendet: Vielseitigkeit und Power in der Bildsegmentierung
+
+Das Segment Anything Model kann fรผr eine Vielzahl von Aufgaben verwendet werden, die รผber die Trainingsdaten hinausgehen. Dazu gehรถren Kantenerkennung, Generierung von Objektvorschlรคgen, Instanzsegmentierung und vorlรคufige Text-to-Mask-Vorhersage. Mit prompt engineering kann SAM sich schnell an neue Aufgaben und Datenverteilungen anpassen und sich so als vielseitiges und leistungsstarkes Werkzeug fรผr alle Anforderungen der Bildsegmentierung etablieren.
+
+### Beispiel fรผr SAM-Vorhersage
+
+!!! Example "Segmentierung mit Prompts"
+
+ Bildsegmentierung mit gegebenen Prompts.
+
+ === "Python"
+
+ ```python
+ from ultralytics import SAM
+
+ # Modell laden
+ model = SAM('sam_b.pt')
+
+ # Modellinformationen anzeigen (optional)
+ model.info()
+
+ # Inferenz mit Bounding Box Prompt
+ model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
+
+ # Inferenz mit Point Prompt
+ model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
+ ```
+
+!!! Example "Alles segmentieren"
+
+ Das ganze Bild segmentieren.
+
+ === "Python"
+
+ ```python
+ from ultralytics import SAM
+
+ # Modell laden
+ model = SAM('sam_b.pt')
+
+ # Modellinformationen anzeigen (optional)
+ model.info()
+
+ # Inferenz
+ model('Pfad/zum/Bild.jpg')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Inferenz mit einem SAM-Modell
+ yolo predict model=sam_b.pt source=Pfad/zum/Bild.jpg
+ ```
+
+- Die Logik hier besteht darin, das gesamte Bild zu segmentieren, wenn keine Prompts (Bounding Box/Point/Maske) รผbergeben werden.
+
+!!! Example "Beispiel SAMPredictor"
+
+ Dadurch kรถnnen Sie das Bild einmal festlegen und mehrmals Inferenz mit Prompts ausfรผhren, ohne den Bild-Encoder mehrfach auszufรผhren.
+
+ === "Prompt-Inferenz"
+
+ ```python
+ from ultralytics.models.sam import Predictor as SAMPredictor
+
+ # SAMPredictor erstellen
+ overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
+ predictor = SAMPredictor(overrides=overrides)
+
+ # Bild festlegen
+ predictor.set_image("ultralytics/assets/zidane.jpg") # Festlegung mit Bild-Datei
+ predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # Festlegung mit np.ndarray
+ results = predictor(bboxes=[439, 437, 524, 709])
+ results = predictor(points=[900, 370], labels=[1])
+
+ # Bild zurรผcksetzen
+ predictor.reset_image()
+ ```
+
+ Alles segmentieren mit zusรคtzlichen Argumenten.
+
+ === "Alles segmentieren"
+
+ ```python
+ from ultralytics.models.sam import Predictor as SAMPredictor
+
+ # SAMPredictor erstellen
+ overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
+ predictor = SAMPredictor(overrides=overrides)
+
+ # Mit zusรคtzlichen Argumenten segmentieren
+ results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
+ ```
+
+- Weitere zusรคtzliche Argumente fรผr `Alles segmentieren` finden Sie in der [`Predictor/generate` Referenz](../../../reference/models/sam/predict.md).
+
+## Vergleich von SAM und YOLOv8
+
+Hier vergleichen wir Meta's kleinstes SAM-Modell, SAM-b, mit Ultralytics kleinstem Segmentierungsmodell, [YOLOv8n-seg](../tasks/segment.md):
+
+| Modell | Grรถรe | Parameter | Geschwindigkeit (CPU) |
+|------------------------------------------------|-------------------------------|------------------------------|----------------------------------------|
+| Meta's SAM-b | 358 MB | 94,7 M | 51096 ms/pro Bild |
+| [MobileSAM](mobile-sam.md) | 40,7 MB | 10,1 M | 46122 ms/pro Bild |
+| [FastSAM-s](fast-sam.md) mit YOLOv8-Backbone | 23,7 MB | 11,8 M | 115 ms/pro Bild |
+| Ultralytics [YOLOv8n-seg](../tasks/segment.md) | **6,7 MB** (53,4-mal kleiner) | **3,4 M** (27,9-mal kleiner) | **59 ms/pro Bild** (866-mal schneller) |
+
+Dieser Vergleich zeigt die Grรถรen- und Geschwindigkeitsunterschiede zwischen den Modellen. Wรคhrend SAM einzigartige Fรคhigkeiten fรผr die automatische Segmentierung bietet, konkurriert es nicht direkt mit YOLOv8-Segmentierungsmodellen, die kleiner, schneller und effizienter sind.
+
+Die Tests wurden auf einem Apple M2 MacBook aus dem Jahr 2023 mit 16 GB RAM durchgefรผhrt. Um diesen Test zu reproduzieren:
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM, SAM, YOLO
+
+ # SAM-b profilieren
+ model = SAM('sam_b.pt')
+ model.info()
+ model('ultralytics/assets')
+
+ # MobileSAM profilieren
+ model = SAM('mobile_sam.pt')
+ model.info()
+ model('ultralytics/assets')
+
+ # FastSAM-s profilieren
+ model = FastSAM('FastSAM-s.pt')
+ model.info()
+ model('ultralytics/assets')
+
+ # YOLOv8n-seg profilieren
+ model = YOLO('yolov8n-seg.pt')
+ model.info()
+ model('ultralytics/assets')
+ ```
+
+## Auto-Annotierung: Der schnelle Weg zu Segmentierungsdatensรคtzen
+
+Die Auto-Annotierung ist eine wichtige Funktion von SAM, mit der Benutzer mithilfe eines vortrainierten Detektionsmodells einen [Segmentierungsdatensatz](https://docs.ultralytics.com/datasets/segment) generieren kรถnnen. Diese Funktion ermรถglicht eine schnelle und genaue Annotation einer groรen Anzahl von Bildern, ohne dass zeitaufwรคndiges manuelles Labeling erforderlich ist.
+
+### Generieren Sie Ihren Segmentierungsdatensatz mit einem Detektionsmodell
+
+Um Ihren Datensatz mit dem Ultralytics-Framework automatisch zu annotieren, verwenden Sie die `auto_annotate` Funktion wie folgt:
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ from ultralytics.data.annotator import auto_annotate
+
+ auto_annotate(data="Pfad/zum/Bilderordner", det_model="yolov8x.pt", sam_model='sam_b.pt')
+ ```
+
+| Argument | Typ | Beschreibung | Standard |
+|------------|---------------------|---------------------------------------------------------------------------------------------------------------------------|--------------|
+| data | str | Pfad zu einem Ordner, der die zu annotierenden Bilder enthรคlt. | |
+| det_model | str, optional | Vortrainiertes YOLO-Detektionsmodell. Standardmรครig 'yolov8x.pt'. | 'yolov8x.pt' |
+| sam_model | str, optional | Vortrainiertes SAM-Segmentierungsmodell. Standardmรครig 'sam_b.pt'. | 'sam_b.pt' |
+| device | str, optional | Gerรคt, auf dem die Modelle ausgefรผhrt werden. Standardmรครig ein leerer String (CPU oder GPU, falls verfรผgbar). | |
+| output_dir | str, None, optional | Verzeichnis zum Speichern der annotierten Ergebnisse. Standardmรครig ein 'labels'-Ordner im selben Verzeichnis wie 'data'. | None |
+
+Die `auto_annotate` Funktion nimmt den Pfad zu Ihren Bildern entgegen, mit optionalen Argumenten fรผr das vortrainierte Detektions- und SAM-Segmentierungsmodell, das Gerรคt, auf dem die Modelle ausgefรผhrt werden sollen, und das Ausgabeverzeichnis, in dem die annotierten Ergebnisse gespeichert werden sollen.
+
+Die Auto-Annotierung mit vortrainierten Modellen kann die Zeit und den Aufwand fรผr die Erstellung hochwertiger Segmentierungsdatensรคtze erheblich reduzieren. Diese Funktion ist besonders vorteilhaft fรผr Forscher und Entwickler, die mit groรen Bildersammlungen arbeiten. Sie ermรถglicht es ihnen, sich auf die Modellentwicklung und -bewertung zu konzentrieren, anstatt auf die manuelle Annotation.
+
+## Zitate und Danksagungen
+
+Wenn Sie SAM in Ihrer Forschungs- oder Entwicklungsarbeit nรผtzlich finden, erwรคgen Sie bitte, unser Paper zu zitieren:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{kirillov2023segment,
+ title={Segment Anything},
+ author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollรกr and Ross Girshick},
+ year={2023},
+ eprint={2304.02643},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+Wir mรถchten Meta AI fรผr die Erstellung und Pflege dieser wertvollen Ressource fรผr die Computer Vision Community danken.
+
+*Stichworte: Segment Anything, Segment Anything Model, SAM, Meta SAM, Bildsegmentierung, Promptable Segmentierung, Zero-Shot-Performance, SA-1B-Datensatz, fortschrittliche Architektur, Auto-Annotierung, Ultralytics, vortrainierte Modelle, SAM Base, SAM Large, Instanzsegmentierung, Computer Vision, Kรผnstliche Intelligenz, maschinelles Lernen, Datenannotation, Segmentierungsmasken, Detektionsmodell, YOLO Detektionsmodell, Bibtex, Meta AI.*
diff --git a/ultralytics/docs/de/models/sam.md:Zone.Identifier b/ultralytics/docs/de/models/sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/yolo-nas.md b/ultralytics/docs/de/models/yolo-nas.md
new file mode 100755
index 0000000..c1d8ed7
--- /dev/null
+++ b/ultralytics/docs/de/models/yolo-nas.md
@@ -0,0 +1,121 @@
+---
+comments: true
+description: Erfahren Sie mehr รผber YOLO-NAS, ein herausragendes Modell fรผr die Objekterkennung. Erfahren Sie mehr รผber seine Funktionen, vortrainierte Modelle, Nutzung mit der Ultralytics Python API und vieles mehr.
+keywords: YOLO-NAS, Deci AI, Objekterkennung, Deep Learning, Neural Architecture Search, Ultralytics Python API, YOLO-Modell, vortrainierte Modelle, Quantisierung, Optimierung, COCO, Objects365, Roboflow 100
+---
+
+# YOLO-NAS
+
+## รbersicht
+
+Entwickelt von Deci AI, ist YOLO-NAS ein bahnbrechendes Modell fรผr die Objekterkennung. Es ist das Ergebnis fortschrittlicher Technologien zur Neural Architecture Search und wurde sorgfรคltig entworfen, um die Einschrรคnkungen frรผherer YOLO-Modelle zu รผberwinden. Mit signifikanten Verbesserungen in der Quantisierungsunterstรผtzung und Abwรคgung von Genauigkeit und Latenz stellt YOLO-NAS einen groรen Fortschritt in der Objekterkennung dar.
+
+
+**รbersicht รผber YOLO-NAS.** YOLO-NAS verwendet Quantisierungsblรถcke und selektive Quantisierung fรผr optimale Leistung. Das Modell weist bei der Konvertierung in seine quantisierte Version mit INT8 einen minimalen Prรคzisionsverlust auf, was im Vergleich zu anderen Modellen eine signifikante Verbesserung darstellt. Diese Entwicklungen fรผhren zu einer รผberlegenen Architektur mit beispiellosen Fรคhigkeiten zur Objekterkennung und herausragender Leistung.
+
+### Schlรผsselfunktionen
+
+- **Quantisierungsfreundlicher Basiselement:** YOLO-NAS fรผhrt ein neues Basiselement ein, das fรผr Quantisierung geeignet ist und eine der wesentlichen Einschrรคnkungen frรผherer YOLO-Modelle angeht.
+- **Raffiniertes Training und Quantisierung:** YOLO-NAS nutzt fortschrittliche Trainingsschemata und post-training Quantisierung zur Leistungsverbesserung.
+- **AutoNAC-Optimierung und Vortraining:** YOLO-NAS verwendet die AutoNAC-Optimierung und wird auf prominenten Datensรคtzen wie COCO, Objects365 und Roboflow 100 vortrainiert. Dieses Vortraining macht es รคuรerst geeignet fรผr die Objekterkennung in Produktionsumgebungen.
+
+## Vortrainierte Modelle
+
+Erleben Sie die Leistungsfรคhigkeit der Objekterkennung der nรคchsten Generation mit den vortrainierten YOLO-NAS-Modellen von Ultralytics. Diese Modelle sind darauf ausgelegt, sowohl bei Geschwindigkeit als auch bei Genauigkeit hervorragende Leistung zu liefern. Wรคhlen Sie aus einer Vielzahl von Optionen, die auf Ihre spezifischen Anforderungen zugeschnitten sind:
+
+| Modell | mAP | Latenz (ms) |
+|------------------|-------|-------------|
+| YOLO-NAS S | 47,5 | 3,21 |
+| YOLO-NAS M | 51,55 | 5,85 |
+| YOLO-NAS L | 52,22 | 7,87 |
+| YOLO-NAS S INT-8 | 47,03 | 2,36 |
+| YOLO-NAS M INT-8 | 51,0 | 3,78 |
+| YOLO-NAS L INT-8 | 52,1 | 4,78 |
+
+Jede Modellvariante ist darauf ausgelegt, eine Balance zwischen Mean Average Precision (mAP) und Latenz zu bieten und Ihre Objekterkennungsaufgaben fรผr Performance und Geschwindigkeit zu optimieren.
+
+## Beispiele zur Verwendung
+
+Ultralytics hat es einfach gemacht, YOLO-NAS-Modelle in Ihre Python-Anwendungen รผber unser `ultralytics` Python-Paket zu integrieren. Das Paket bietet eine benutzerfreundliche Python-API, um den Prozess zu optimieren.
+
+Die folgenden Beispiele zeigen, wie Sie YOLO-NAS-Modelle mit dem `ultralytics`-Paket fรผr Inferenz und Validierung verwenden:
+
+### Beispiele fรผr Inferenz und Validierung
+
+In diesem Beispiel validieren wir YOLO-NAS-s auf dem COCO8-Datensatz.
+
+!!! Example "Beispiel"
+
+ Dieses Beispiel bietet einfachen Code fรผr Inferenz und Validierung fรผr YOLO-NAS. Fรผr die Verarbeitung von Inferenzergebnissen siehe den [Predict](../modes/predict.md)-Modus. Fรผr die Verwendung von YOLO-NAS mit zusรคtzlichen Modi siehe [Val](../modes/val.md) und [Export](../modes/export.md). Das YOLO-NAS-Modell im `ultralytics`-Paket unterstรผtzt kein Training.
+
+ === "Python"
+
+ Vorab trainierte `*.pt`-Modelldateien von PyTorch kรถnnen der Klasse `NAS()` รผbergeben werden, um eine Modellinstanz in Python zu erstellen:
+
+ ```python
+ from ultralytics import NAS
+
+ # Laden Sie ein auf COCO vortrainiertes YOLO-NAS-s-Modell
+ model = NAS('yolo_nas_s.pt')
+
+ # Modelinformationen anzeigen (optional)
+ model.info()
+
+ # Validieren Sie das Modell am Beispiel des COCO8-Datensatzes
+ results = model.val(data='coco8.yaml')
+
+ # Fรผhren Sie Inferenz mit dem YOLO-NAS-s-Modell auf dem Bild 'bus.jpg' aus
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI-Befehle sind verfรผgbar, um die Modelle direkt auszufรผhren:
+
+ ```bash
+ # Laden Sie ein auf COCO vortrainiertes YOLO-NAS-s-Modell und validieren Sie die Leistung am Beispiel des COCO8-Datensatzes
+ yolo val model=yolo_nas_s.pt data=coco8.yaml
+
+ # Laden Sie ein auf COCO vortrainiertes YOLO-NAS-s-Modell und fรผhren Sie Inferenz auf dem Bild 'bus.jpg' aus
+ yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
+ ```
+
+## Unterstรผtzte Aufgaben und Modi
+
+Wir bieten drei Varianten der YOLO-NAS-Modelle an: Small (s), Medium (m) und Large (l). Jede Variante ist dazu gedacht, unterschiedliche Berechnungs- und Leistungsanforderungen zu erfรผllen:
+
+- **YOLO-NAS-s**: Optimiert fรผr Umgebungen mit begrenzten Rechenressourcen, bei denen Effizienz entscheidend ist.
+- **YOLO-NAS-m**: Bietet einen ausgewogenen Ansatz und ist fรผr die Objekterkennung im Allgemeinen mit hรถherer Genauigkeit geeignet.
+- **YOLO-NAS-l**: Maรgeschneidert fรผr Szenarien, bei denen hรถchste Genauigkeit gefordert ist und Rechenressourcen weniger einschrรคnkend sind.
+
+Im Folgenden finden Sie eine detaillierte รbersicht รผber jedes Modell, einschlieรlich Links zu den vortrainierten Gewichten, den unterstรผtzten Aufgaben und deren Kompatibilitรคt mit verschiedenen Betriebsmodi.
+
+| Modelltyp | Vortrainierte Gewichte | Unterstรผtzte Aufgaben | Inferenz | Validierung | Training | Export |
+|------------|-----------------------------------------------------------------------------------------------|---------------------------------------|----------|-------------|----------|--------|
+| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_s.pt) | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_m.pt) | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_l.pt) | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+
+## Zitierungen und Danksagungen
+
+Wenn Sie YOLO-NAS in Ihrer Forschungs- oder Entwicklungsarbeit verwenden, zitieren Sie bitte SuperGradients:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{supergradients,
+ doi = {10.5281/ZENODO.7789328},
+ url = {https://zenodo.org/record/7789328},
+ author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}},
+ title = {Super-Gradients},
+ publisher = {GitHub},
+ journal = {GitHub repository},
+ year = {2021},
+ }
+ ```
+
+Wir mรถchten dem [SuperGradients](https://github.com/Deci-AI/super-gradients/)-Team von Deci AI fรผr ihre Bemรผhungen bei der Erstellung und Pflege dieser wertvollen Ressource fรผr die Computer Vision Community danken. Wir sind der Meinung, dass YOLO-NAS mit seiner innovativen Architektur und seinen herausragenden Fรคhigkeiten zur Objekterkennung ein wichtiges Werkzeug fรผr Entwickler und Forscher gleichermaรen wird.
+
+*Keywords: YOLO-NAS, Deci AI, Objekterkennung, Deep Learning, Neural Architecture Search, Ultralytics Python API, YOLO-Modell, SuperGradients, vortrainierte Modelle, quantisierungsfreundliches Basiselement, fortschrittliche Trainingsschemata, post-training Quantisierung, AutoNAC-Optimierung, COCO, Objects365, Roboflow 100*
diff --git a/ultralytics/docs/de/models/yolo-nas.md:Zone.Identifier b/ultralytics/docs/de/models/yolo-nas.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/yolo-nas.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/yolov3.md b/ultralytics/docs/de/models/yolov3.md
new file mode 100755
index 0000000..de1cf46
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov3.md
@@ -0,0 +1,98 @@
+---
+comments: true
+description: Erhalten Sie eine รbersicht รผber YOLOv3, YOLOv3-Ultralytics und YOLOv3u. Erfahren Sie mehr รผber ihre wichtigsten Funktionen, Verwendung und unterstรผtzte Aufgaben fรผr die Objekterkennung.
+keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Objekterkennung, Inferenz, Training, Ultralytics
+---
+
+# YOLOv3, YOLOv3-Ultralytics und YOLOv3u
+
+## รbersicht
+
+Dieses Dokument bietet eine รbersicht รผber drei eng verwandte Modelle zur Objekterkennung, nรคmlich [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) und [YOLOv3u](https://github.com/ultralytics/ultralytics).
+
+1. **YOLOv3:** Dies ist die dritte Version des You Only Look Once (YOLO) Objekterkennungsalgorithmus. Ursprรผnglich entwickelt von Joseph Redmon, verbesserte YOLOv3 seine Vorgรคngermodelle durch die Einfรผhrung von Funktionen wie mehrskaligen Vorhersagen und drei verschiedenen Grรถรen von Erkennungskernen.
+
+2. **YOLOv3-Ultralytics:** Dies ist die Implementierung des YOLOv3-Modells von Ultralytics. Es reproduziert die ursprรผngliche YOLOv3-Architektur und bietet zusรคtzliche Funktionalitรคten, wie die Unterstรผtzung fรผr weitere vortrainierte Modelle und einfachere Anpassungsoptionen.
+
+3. **YOLOv3u:** Dies ist eine aktualisierte Version von YOLOv3-Ultralytics, die den anchor-freien, objektfreien Split Head aus den YOLOv8-Modellen einbezieht. YOLOv3u verwendet die gleiche Backbone- und Neck-Architektur wie YOLOv3, aber mit dem aktualisierten Erkennungskopf von YOLOv8.
+
+
+
+## Wichtigste Funktionen
+
+- **YOLOv3:** Einfรผhrung der Verwendung von drei unterschiedlichen Skalen fรผr die Erkennung unter Verwendung von drei verschiedenen Grรถรen von Erkennungskernen: 13x13, 26x26 und 52x52. Dadurch wurde die Erkennungsgenauigkeit fรผr Objekte unterschiedlicher Grรถรe erheblich verbessert. Darรผber hinaus fรผgte YOLOv3 Funktionen wie Mehrfachkennzeichnungen fรผr jeden Begrenzungsrahmen und ein besseres Feature-Extraktionsnetzwerk hinzu.
+
+- **YOLOv3-Ultralytics:** Ultralytics' Implementierung von YOLOv3 bietet die gleiche Leistung wie das ursprรผngliche Modell, bietet jedoch zusรคtzliche Unterstรผtzung fรผr weitere vortrainierte Modelle, zusรคtzliche Trainingsmethoden und einfachere Anpassungsoptionen. Dadurch wird es vielseitiger und benutzerfreundlicher fรผr praktische Anwendungen.
+
+- **YOLOv3u:** Dieses aktualisierte Modell enthรคlt den anchor-freien, objektfreien Split Head aus YOLOv8. Durch die Beseitigung der Notwendigkeit vordefinierter Ankerfelder und Objektheitsscores kann dieses Entwurfsmerkmal fรผr den Erkennungskopf die Fรคhigkeit des Modells verbessern, Objekte unterschiedlicher Grรถรe und Form zu erkennen. Dadurch wird YOLOv3u robuster und genauer fรผr Aufgaben der Objekterkennung.
+
+## Unterstรผtzte Aufgaben und Modi
+
+Die YOLOv3-Serie, einschlieรlich YOLOv3, YOLOv3-Ultralytics und YOLOv3u, ist speziell fรผr Aufgaben der Objekterkennung konzipiert. Diese Modelle sind bekannt fรผr ihre Effektivitรคt in verschiedenen realen Szenarien und kombinieren Genauigkeit und Geschwindigkeit. Jede Variante bietet einzigartige Funktionen und Optimierungen, die sie fรผr eine Vielzahl von Anwendungen geeignet machen.
+
+Alle drei Modelle unterstรผtzen einen umfangreichen Satz von Modi, um Vielseitigkeit in verschiedenen Phasen der Modellbereitstellung und -entwicklung zu gewรคhrleisten. Zu diesen Modi gehรถren [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md), was den Benutzern ein vollstรคndiges Toolkit fรผr eine effektive Objekterkennung bietet.
+
+| Modelltyp | Unterstรผtzte Aufgaben | Inferenz | Validierung | Training | Export |
+|--------------------|---------------------------------------|----------|-------------|----------|--------|
+| YOLOv3 | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv3-Ultralytics | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv3u | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+
+Diese Tabelle bietet einen schnellen รberblick รผber die Fรคhigkeiten jeder YOLOv3-Variante und hebt ihre Vielseitigkeit und Eignung fรผr verschiedene Aufgaben und Betriebsmodi in Workflows zur Objekterkennung hervor.
+
+## Beispiele zur Verwendung
+
+Dieses Beispiel enthรคlt einfache Trainings- und Inferenzbeispiele fรผr YOLOv3. Fรผr die vollstรคndige Dokumentation zu diesen und anderen [Modi](../modes/index.md) siehe die Seiten zur [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ Vorgefertigte PyTorch-Modelle im `*.pt`-Format sowie Konfigurationsdateien im `*.yaml`-Format kรถnnen an die `YOLO()`-Klasse รผbergeben werden, um eine Modellinstanz in Python zu erstellen:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Lade ein vortrainiertes YOLOv3n-Modell fรผr COCO
+ model = YOLO('yolov3n.pt')
+
+ # Zeige Informationen zum Modell an (optional)
+ model.info()
+
+ # Trainiere das Modell mit dem COCO8-Beispieldatensatz fรผr 100 Epochen
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Fรผhre Inferenz mit dem YOLOv3n-Modell auf dem Bild "bus.jpg" durch
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI-Befehle stehen zur Verfรผgung, um die Modelle direkt auszufรผhren:
+
+ ```bash
+ # Lade ein vortrainiertes YOLOv3n-Modell und trainiere es mit dem COCO8-Beispieldatensatz fรผr 100 Epochen
+ yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Lade ein vortrainiertes YOLOv3n-Modell und fรผhre Inferenz auf dem Bild "bus.jpg" aus
+ yolo predict model=yolov3n.pt source=path/to/bus.jpg
+ ```
+
+## Zitate und Anerkennungen
+
+Wenn Sie YOLOv3 in Ihrer Forschung verwenden, zitieren Sie bitte die ursprรผnglichen YOLO-Papiere und das Ultralytics YOLOv3-Repository:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{redmon2018yolov3,
+ title={YOLOv3: An Incremental Improvement},
+ author={Redmon, Joseph and Farhadi, Ali},
+ journal={arXiv preprint arXiv:1804.02767},
+ year={2018}
+ }
+ ```
+
+Vielen Dank an Joseph Redmon und Ali Farhadi fรผr die Entwicklung des originalen YOLOv3.
diff --git a/ultralytics/docs/de/models/yolov3.md:Zone.Identifier b/ultralytics/docs/de/models/yolov3.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov3.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/yolov4.md b/ultralytics/docs/de/models/yolov4.md
new file mode 100755
index 0000000..3d3fd2d
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov4.md
@@ -0,0 +1,71 @@
+---
+comments: true
+description: Erforschen Sie unseren detaillierten Leitfaden zu YOLOv4, einem hochmodernen Echtzeit-Objektdetektor. Erfahren Sie mehr รผber seine architektonischen Highlights, innovativen Funktionen und Anwendungsbeispiele.
+keywords: ultralytics, YOLOv4, Objekterkennung, neuronales Netzwerk, Echtzeit-Erkennung, Objektdetektor, maschinelles Lernen
+---
+
+# YOLOv4: Schnelle und prรคzise Objekterkennung
+
+Willkommen auf der Ultralytics-Dokumentationsseite fรผr YOLOv4, einem hochmodernen, Echtzeit-Objektdetektor, der 2020 von Alexey Bochkovskiy unter [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet) verรถffentlicht wurde. YOLOv4 wurde entwickelt, um das optimale Gleichgewicht zwischen Geschwindigkeit und Genauigkeit zu bieten und ist somit eine ausgezeichnete Wahl fรผr viele Anwendungen.
+
+
+**YOLOv4 Architekturdiagramm**. Zeigt das komplexe Netzwerkdesign von YOLOv4, einschlieรlich der Backbone-, Neck- und Head-Komponenten sowie ihrer verbundenen Schichten fรผr eine optimale Echtzeit-Objekterkennung.
+
+## Einleitung
+
+YOLOv4 steht fรผr You Only Look Once Version 4. Es handelt sich um ein Echtzeit-Objekterkennungsmodell, das entwickelt wurde, um die Grenzen frรผherer YOLO-Versionen wie [YOLOv3](yolov3.md) und anderer Objekterkennungsmodelle zu รผberwinden. Im Gegensatz zu anderen konvolutionellen neuronalen Netzwerken (CNN), die auf Objekterkennung basieren, ist YOLOv4 nicht nur fรผr Empfehlungssysteme geeignet, sondern auch fรผr eigenstรคndiges Prozessmanagement und Reduzierung der Benutzereingabe. Durch den Einsatz von herkรถmmlichen Grafikprozessoreinheiten (GPUs) ermรถglicht es YOLOv4 eine Massennutzung zu einem erschwinglichen Preis und ist so konzipiert, dass es in Echtzeit auf einer herkรถmmlichen GPU funktioniert, wobei nur eine solche GPU fรผr das Training erforderlich ist.
+
+## Architektur
+
+YOLOv4 nutzt mehrere innovative Funktionen, die zusammenarbeiten, um seine Leistung zu optimieren. Dazu gehรถren Weighted-Residual-Connections (WRC), Cross-Stage-Partial-connections (CSP), Cross mini-Batch Normalization (CmBN), Self-adversarial-training (SAT), Mish-Aktivierung, Mosaic-Datenaugmentation, DropBlock-Regularisierung und CIoU-Verlust. Diese Funktionen werden kombiniert, um erstklassige Ergebnisse zu erzielen.
+
+Ein typischer Objektdetektor besteht aus mehreren Teilen, darunter der Eingabe, dem Backbone, dem Neck und dem Head. Das Backbone von YOLOv4 ist auf ImageNet vorgeschult und wird zur Vorhersage von Klassen und Begrenzungsrahmen von Objekten verwendet. Das Backbone kann aus verschiedenen Modellen wie VGG, ResNet, ResNeXt oder DenseNet stammen. Der Neck-Teil des Detektors wird verwendet, um Merkmalskarten von verschiedenen Stufen zu sammeln und umfasst normalerweise mehrere Bottom-up-Pfade und mehrere Top-down-Pfade. Der Head-Teil wird schlieรlich zur Durchfรผhrung der endgรผltigen Objekterkennung und Klassifizierung verwendet.
+
+## Bag of Freebies
+
+YOLOv4 verwendet auch Methoden, die als "Bag of Freebies" bekannt sind. Dabei handelt es sich um Techniken, die die Genauigkeit des Modells wรคhrend des Trainings verbessern, ohne die Kosten der Inferenz zu erhรถhen. Datenaugmentation ist eine hรคufige Bag of Freebies-Technik, die in der Objekterkennung verwendet wird, um die Variabilitรคt der Eingabebilder zu erhรถhen und die Robustheit des Modells zu verbessern. Beispiele fรผr Datenaugmentation sind photometrische Verzerrungen (Anpassung von Helligkeit, Kontrast, Farbton, Sรคttigung und Rauschen eines Bildes) und geometrische Verzerrungen (Hinzufรผgen von zufรคlliger Skalierung, Ausschnitt, Spiegelung und Rotation). Diese Techniken helfen dem Modell, sich besser an verschiedene Arten von Bildern anzupassen.
+
+## Funktionen und Leistung
+
+YOLOv4 ist fรผr optimale Geschwindigkeit und Genauigkeit in der Objekterkennung konzipiert. Die Architektur von YOLOv4 umfasst CSPDarknet53 als Backbone, PANet als Neck und YOLOv3 als Detektionskopf. Diese Konstruktion ermรถglicht es YOLOv4, beeindruckend schnelle Objekterkennungen durchzufรผhren und ist somit fรผr Echtzeitanwendungen geeignet. YOLOv4 zeichnet sich auch durch Genauigkeit aus und erzielt erstklassige Ergebnisse in Objekterkennungs-Benchmarks.
+
+## Beispiele fรผr die Verwendung
+
+Zum Zeitpunkt der Erstellung dieser Dokumentation unterstรผtzt Ultralytics derzeit keine YOLOv4-Modelle. Daher mรผssen sich Benutzer, die YOLOv4 verwenden mรถchten, direkt an das YOLOv4 GitHub-Repository fรผr Installations- und Verwendungshinweise wenden.
+
+Hier ist ein kurzer รberblick รผber die typischen Schritte, die Sie unternehmen kรถnnten, um YOLOv4 zu verwenden:
+
+1. Besuchen Sie das YOLOv4 GitHub-Repository: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
+
+2. Befolgen Sie die in der README-Datei bereitgestellten Anweisungen zur Installation. Dies beinhaltet in der Regel das Klonen des Repositories, die Installation der erforderlichen Abhรคngigkeiten und das Einrichten der erforderlichen Umgebungsvariablen.
+
+3. Sobald die Installation abgeschlossen ist, kรถnnen Sie das Modell gemรคร den in dem Repository bereitgestellten Verwendungshinweisen trainieren und verwenden. Dies beinhaltet in der Regel die Vorbereitung des Datensatzes, die Konfiguration der Modellparameter, das Training des Modells und die anschlieรende Verwendung des trainierten Modells zur Durchfรผhrung der Objekterkennung.
+
+Bitte beachten Sie, dass die spezifischen Schritte je nach Ihrer spezifischen Anwendung und dem aktuellen Stand des YOLOv4-Repositories variieren kรถnnen. Es wird daher dringend empfohlen, sich direkt an die Anweisungen im YOLOv4-GitHub-Repository zu halten.
+
+Wir bedauern etwaige Unannehmlichkeiten und werden uns bemรผhen, dieses Dokument mit Verwendungsbeispielen fรผr Ultralytics zu aktualisieren, sobald die Unterstรผtzung fรผr YOLOv4 implementiert ist.
+
+## Fazit
+
+YOLOv4 ist ein leistungsstarkes und effizientes Modell zur Objekterkennung, das eine Balance zwischen Geschwindigkeit und Genauigkeit bietet. Durch den Einsatz einzigartiger Funktionen und Bag of Freebies-Techniken wรคhrend des Trainings erzielt es hervorragende Ergebnisse in Echtzeit-Objekterkennungsaufgaben. YOLOv4 kann von jedem mit einer herkรถmmlichen GPU trainiert und verwendet werden, was es fรผr eine Vielzahl von Anwendungen zugรคnglich und praktisch macht.
+
+## Zitate und Anerkennungen
+
+Wir mรถchten den Autoren von YOLOv4 fรผr ihren bedeutenden Beitrag auf dem Gebiet der Echtzeit-Objekterkennung danken:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{bochkovskiy2020yolov4,
+ title={YOLOv4: Optimal Speed and Accuracy of Object Detection},
+ author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao},
+ year={2020},
+ eprint={2004.10934},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+Die originale YOLOv4-Publikation finden Sie auf [arXiv](https://arxiv.org/abs/2004.10934). Die Autoren haben ihre Arbeit รถffentlich zugรคnglich gemacht und der Code kann auf [GitHub](https://github.com/AlexeyAB/darknet) abgerufen werden. Wir schรคtzen ihre Bemรผhungen, das Fachgebiet voranzubringen und ihre Arbeit der breiteren Community zugรคnglich zu machen.
diff --git a/ultralytics/docs/de/models/yolov4.md:Zone.Identifier b/ultralytics/docs/de/models/yolov4.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov4.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/yolov5.md b/ultralytics/docs/de/models/yolov5.md
new file mode 100755
index 0000000..b194f12
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov5.md
@@ -0,0 +1,113 @@
+---
+comments: true
+description: Entdecken Sie YOLOv5u, eine verbesserte Version des YOLOv5-Modells mit einem optimierten Verhรคltnis von Genauigkeit und Geschwindigkeit sowie zahlreiche vorab trainierte Modelle fรผr verschiedene Objekterkennungsaufgaben.
+keywords: YOLOv5u, Objekterkennung, vorab trainierte Modelle, Ultralytics, Inferenz, Validierung, YOLOv5, YOLOv8, Ankerfrei, Objektlos, Echtzeitanwendungen, Maschinelles Lernen
+---
+
+# YOLOv5
+
+## รbersicht
+
+YOLOv5u steht fรผr eine Weiterentwicklung der Methoden zur Objekterkennung. Basierend auf der grundlegenden Architektur des von Ultralytics entwickelten YOLOv5-Modells integriert YOLOv5u den ankerfreien, objektlosen Split-Kopf, ein Feature, das zuvor in den YOLOv8-Modellen eingefรผhrt wurde. Diese Anpassung verfeinert die Architektur des Modells und fรผhrt zu einem optimierten Verhรคltnis von Genauigkeit und Geschwindigkeit bei der Objekterkennung. Basierend auf den empirischen Ergebnissen und den abgeleiteten Features bietet YOLOv5u eine effiziente Alternative fรผr diejenigen, die robuste Lรถsungen sowohl in der Forschung als auch in praktischen Anwendungen suchen.
+
+
+
+## Hauptmerkmale
+
+- **Ankerfreier Split-Ultralytics-Kopf:** Herkรถmmliche Objekterkennungsmodelle verwenden vordefinierte Ankerboxen, um die Position von Objekten vorherzusagen. YOLOv5u modernisiert diesen Ansatz. Durch die Verwendung eines ankerfreien Split-Ultralytics-Kopfes wird ein flexiblerer und anpassungsfรคhigerer Detektionsmechanismus gewรคhrleistet, der die Leistung in verschiedenen Szenarien verbessert.
+
+- **Optimiertes Verhรคltnis von Genauigkeit und Geschwindigkeit:** Geschwindigkeit und Genauigkeit ziehen oft in entgegengesetzte Richtungen. Aber YOLOv5u stellt diese Abwรคgung in Frage. Es bietet eine ausgewogene Balance, die Echtzeitdetektionen ohne Einbuรen bei der Genauigkeit ermรถglicht. Diese Funktion ist besonders wertvoll fรผr Anwendungen, die schnelle Reaktionen erfordern, wie autonome Fahrzeuge, Robotik und Echtzeitanalyse von Videos.
+
+- **Vielfalt an vorab trainierten Modellen:** YOLOv5u bietet eine Vielzahl von vorab trainierten Modellen, da verschiedene Aufgaben unterschiedliche Werkzeuge erfordern. Ob Sie sich auf Inferenz, Validierung oder Training konzentrieren, es wartet ein maรgeschneidertes Modell auf Sie. Diese Vielfalt gewรคhrleistet, dass Sie nicht nur eine Einheitslรถsung verwenden, sondern ein speziell fรผr Ihre einzigartige Herausforderung feinabgestimmtes Modell.
+
+## Unterstรผtzte Aufgaben und Modi
+
+Die YOLOv5u-Modelle mit verschiedenen vorab trainierten Gewichten eignen sich hervorragend fรผr Aufgaben zur [Objekterkennung](../tasks/detect.md). Sie unterstรผtzen eine umfassende Palette von Modi, die sie fรผr verschiedene Anwendungen von der Entwicklung bis zur Bereitstellung geeignet machen.
+
+| Modelltyp | Vorab trainierte Gewichte | Aufgabe | Inferenz | Validierung | Training | Export |
+|-----------|-----------------------------------------------------------------------------------------------------------------------------|---------------------------------------|----------|-------------|----------|--------|
+| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+
+Diese Tabelle bietet eine detaillierte รbersicht รผber die verschiedenen Varianten des YOLOv5u-Modells und hebt ihre Anwendbarkeit in der Objekterkennung sowie die Unterstรผtzung unterschiedlicher Betriebsmodi wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md) hervor. Diese umfassende Unterstรผtzung ermรถglicht es Benutzern, die Fรคhigkeiten der YOLOv5u-Modelle in einer Vielzahl von Objekterkennungsszenarien voll auszuschรถpfen.
+
+## Leistungskennzahlen
+
+!!! Leistung
+
+ === "Erkennung"
+
+ Siehe [Erkennungsdokumentation](https://docs.ultralytics.com/tasks/detect/) fรผr Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/detect/coco/) trainiert wurden und 80 vorab trainierte Klassen enthalten.
+
+ | Modell | YAML | Grรถรe (Pixel) | mAPval 50-95 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) |
+ |---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|------------------------------------------|-----------------------------------------------|--------------------|-------------------|
+ | [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34,3 | 73,6 | 1,06 | 2,6 | 7,7 |
+ | [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43,0 | 120,7 | 1,27 | 9,1 | 24,0 |
+ | [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49,0 | 233,9 | 1,86 | 25,1 | 64,2 |
+ | [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52,2 | 408,4 | 2,50 | 53,2 | 135,0 |
+ | [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53,2 | 763,2 | 3,81 | 97,2 | 246,4 |
+ | | | | | | | | |
+ | [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 42,1 | 211,0 | 1,83 | 4,3 | 7,8 |
+ | [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 48,6 | 422,6 | 2,34 | 15,3 | 24,6 |
+ | [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 53,6 | 810,9 | 4,36 | 41,2 | 65,7 |
+ | [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 55,7 | 1.470,9 | 5,47 | 86,1 | 137,4 |
+ | [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1.280 | 56,8 | 2.436,5 | 8,98 | 155,4 | 250,7 |
+
+## Beispiele zur Verwendung
+
+Dieses Beispiel enthรคlt einfache Beispiele zur Schulung und Inferenz mit YOLOv5. Die vollstรคndige Dokumentation zu diesen und anderen [Modi](../modes/index.md) finden Sie in den Seiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ PyTorch-vortrainierte `*.pt`-Modelle sowie Konfigurationsdateien `*.yaml` kรถnnen an die `YOLO()`-Klasse รผbergeben werden, um eine Modellinstanz in Python zu erstellen:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden Sie ein vortrainiertes YOLOv5n-Modell fรผr COCO-Daten
+ modell = YOLO('yolov5n.pt')
+
+ # Informationen zum Modell anzeigen (optional)
+ model.info()
+
+ # Trainieren Sie das Modell anhand des COCO8-Beispieldatensatzes fรผr 100 Epochen
+ ergebnisse = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Fรผhren Sie die Inferenz mit dem YOLOv5n-Modell auf dem Bild 'bus.jpg' durch
+ ergebnisse = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI-Befehle sind verfรผgbar, um die Modelle direkt auszufรผhren:
+
+ ```bash
+ # Laden Sie ein vortrainiertes YOLOv5n-Modell und trainieren Sie es anhand des COCO8-Beispieldatensatzes fรผr 100 Epochen
+ yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Laden Sie ein vortrainiertes YOLOv5n-Modell und fรผhren Sie die Inferenz auf dem Bild 'bus.jpg' durch
+ yolo predict model=yolov5n.pt source=path/to/bus.jpg
+ ```
+
+## Zitate und Danksagungen
+
+Wenn Sie YOLOv5 oder YOLOv5u in Ihrer Forschung verwenden, zitieren Sie bitte das Ultralytics YOLOv5-Repository wie folgt:
+
+!!! Quote ""
+
+ === "BibTeX"
+ ```bibtex
+ @software{yolov5,
+ title = {Ultralytics YOLOv5},
+ author = {Glenn Jocher},
+ year = {2020},
+ version = {7.0},
+ license = {AGPL-3.0},
+ url = {https://github.com/ultralytics/yolov5},
+ doi = {10.5281/zenodo.3908559},
+ orcid = {0000-0001-5950-6979}
+ }
+ ```
+
+Bitte beachten Sie, dass die YOLOv5-Modelle unter den Lizenzen [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) und [Enterprise](https://ultralytics.com/license) bereitgestellt werden.
diff --git a/ultralytics/docs/de/models/yolov5.md:Zone.Identifier b/ultralytics/docs/de/models/yolov5.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov5.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/yolov6.md b/ultralytics/docs/de/models/yolov6.md
new file mode 100755
index 0000000..0246170
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov6.md
@@ -0,0 +1,107 @@
+---
+comments: true
+description: Erforschen Sie Meituan YOLOv6, ein modernes Objekterkennungsmodell, das eine ausgewogene Kombination aus Geschwindigkeit und Genauigkeit bietet. Tauchen Sie ein in Funktionen, vorab trainierte Modelle und die Verwendung von Python.
+keywords: Meituan YOLOv6, Objekterkennung, Ultralytics, YOLOv6 Dokumentation, Bi-direktionale Konkatenation, Anchor-Aided Training, vorab trainierte Modelle, Echtzeitanwendungen
+---
+
+# Meituan YOLOv6
+
+## รberblick
+
+[Meituan](https://about.meituan.com/) YOLOv6 ist ein moderner Objekterkenner, der eine bemerkenswerte Balance zwischen Geschwindigkeit und Genauigkeit bietet und somit eine beliebte Wahl fรผr Echtzeitanwendungen darstellt. Dieses Modell bietet mehrere bemerkenswerte Verbesserungen in seiner Architektur und seinem Trainingsschema, einschlieรlich der Implementierung eines Bi-direktionalen Konkatenationsmoduls (BiC), einer anchor-aided training (AAT)-Strategie und einem verbesserten Backpropagation- und Neck-Design fรผr Spitzenleistungen auf dem COCO-Datensatz.
+
+
+
+**รbersicht รผber YOLOv6.** Diagramm der Modellarchitektur, das die neu gestalteten Netzwerkkomponenten und Trainingstrategien zeigt, die zu signifikanten Leistungsverbesserungen gefรผhrt haben. (a) Der Nacken von YOLOv6 (N und S sind dargestellt). Beachten Sie, dass bei M/L RepBlocks durch CSPStackRep ersetzt wird. (b) Die Struktur eines BiC-Moduls. (c) Ein SimCSPSPPF-Block. ([Quelle](https://arxiv.org/pdf/2301.05586.pdf)).
+
+### Hauptmerkmale
+
+- **Bi-direktionales Konkatenations (BiC) Modul:** YOLOv6 fรผhrt ein BiC-Modul im Nacken des Erkenners ein, das die Lokalisierungssignale verbessert und eine Leistungssteigerung bei vernachlรคssigbarem Geschwindigkeitsabfall liefert.
+- **Anchor-aided Training (AAT) Strategie:** Dieses Modell schlรคgt AAT vor, um die Vorteile sowohl von ankerbasierten als auch von ankerfreien Paradigmen zu nutzen, ohne die Inferenzeffizienz zu beeintrรคchtigen.
+- **Verbessertes Backpropagation- und Neck-Design:** Durch Vertiefung von YOLOv6 um eine weitere Stufe im Backpropagation und Nacken erreicht dieses Modell Spitzenleistungen auf dem COCO-Datensatz bei hochauflรถsenden Eingaben.
+- **Self-Distillation Strategie:** Eine neue Self-Distillation-Strategie wird implementiert, um die Leistung von kleineren Modellen von YOLOv6 zu steigern, indem der Hilfsregressionszweig wรคhrend des Trainings verstรคrkt und bei der Inferenz entfernt wird, um einen deutlichen Geschwindigkeitsabfall zu vermeiden.
+
+## Leistungsmetriken
+
+YOLOv6 bietet verschiedene vorab trainierte Modelle mit unterschiedlichen Maรstรคben:
+
+- YOLOv6-N: 37,5% AP auf COCO val2017 bei 1187 FPS mit NVIDIA Tesla T4 GPU.
+- YOLOv6-S: 45,0% AP bei 484 FPS.
+- YOLOv6-M: 50,0% AP bei 226 FPS.
+- YOLOv6-L: 52,8% AP bei 116 FPS.
+- YOLOv6-L6: Spitzenleistung in Echtzeit.
+
+YOLOv6 bietet auch quantisierte Modelle fรผr verschiedene Genauigkeiten sowie Modelle, die fรผr mobile Plattformen optimiert sind.
+
+## Beispiele zur Verwendung
+
+In diesem Beispiel werden einfache Schulungs- und Inferenzbeispiele fรผr YOLOv6 bereitgestellt. Weitere Dokumentation zu diesen und anderen [Modi](../modes/index.md) finden Sie auf den Seiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ In Python kann PyTorch-vorab trainierte `*.pt`-Modelle sowie Konfigurations-`*.yaml`-Dateien an die `YOLO()`-Klasse รผbergeben werden, um eine Modellinstanz zu erstellen:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Erstellen Sie ein YOLOv6n-Modell von Grund auf
+ model = YOLO('yolov6n.yaml')
+
+ # Zeigen Sie Informationen zum Modell an (optional)
+ model.info()
+
+ # Trainieren Sie das Modell am Beispiel des COCO8-Datensatzes fรผr 100 Epochen
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Fรผhren Sie Inferenz mit dem YOLOv6n-Modell auf dem Bild 'bus.jpg' durch
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI-Befehle stehen zur Verfรผgung, um die Modelle direkt auszufรผhren:
+
+ ```bash
+ # Erstellen Sie ein YOLOv6n-Modell von Grund auf und trainieren Sie es am Beispiel des COCO8-Datensatzes fรผr 100 Epochen
+ yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
+
+ # Erstellen Sie ein YOLOv6n-Modell von Grund auf und fรผhren Sie Inferenz auf dem Bild 'bus.jpg' durch
+ yolo predict model=yolov6n.yaml source=path/to/bus.jpg
+ ```
+
+## Unterstรผtzte Aufgaben und Modi
+
+Die YOLOv6-Serie bietet eine Reihe von Modellen, die jeweils fรผr die Hochleistungs-[Objekterkennung](../tasks/detect.md) optimiert sind. Diese Modelle erfรผllen unterschiedliche Rechenanforderungen und Genauigkeitsanforderungen und sind daher vielseitig fรผr eine Vielzahl von Anwendungen einsetzbar.
+
+| Modelltyp | Vorab trainierte Gewichte | Unterstรผtzte Aufgaben | Inferenz | Validierung | Training | Exportieren |
+|-----------|---------------------------|---------------------------------------|----------|-------------|----------|-------------|
+| YOLOv6-N | `yolov6-n.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-S | `yolov6-s.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-M | `yolov6-m.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-L | `yolov6-l.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-L6 | `yolov6-l6.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+
+Diese Tabelle bietet einen detaillierten รberblick รผber die YOLOv6-Modellvarianten und hebt ihre Fรคhigkeiten bei der Objekterkennung sowie ihre Kompatibilitรคt mit verschiedenen Betriebsmodi wie [Inferenz](../modes/predict.md), [Validierung](../modes/val.md), [Training](../modes/train.md) und [Exportieren](../modes/export.md) hervor. Diese umfassende Unterstรผtzung ermรถglicht es den Benutzern, die Fรคhigkeiten von YOLOv6-Modellen in einer Vielzahl von Objekterkennungsszenarien vollstรคndig zu nutzen.
+
+## Zitate und Anerkennungen
+
+Wir mรถchten den Autoren fรผr ihre bedeutenden Beitrรคge auf dem Gebiet der Echtzeit-Objekterkennung danken:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{li2023yolov6,
+ title={YOLOv6 v3.0: A Full-Scale Reloading},
+ author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
+ year={2023},
+ eprint={2301.05586},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+Das ursprรผngliche YOLOv6-Papier finden Sie auf [arXiv](https://arxiv.org/abs/2301.05586). Die Autoren haben ihre Arbeit รถffentlich zugรคnglich gemacht, und der Code kann auf [GitHub](https://github.com/meituan/YOLOv6) abgerufen werden. Wir schรคtzen ihre Bemรผhungen zur Weiterentwicklung des Fachgebiets und zur Zugรคnglichmachung ihrer Arbeit fรผr die breitere Gemeinschaft.
diff --git a/ultralytics/docs/de/models/yolov6.md:Zone.Identifier b/ultralytics/docs/de/models/yolov6.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov6.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/yolov7.md b/ultralytics/docs/de/models/yolov7.md
new file mode 100755
index 0000000..4edb969
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov7.md
@@ -0,0 +1,66 @@
+---
+comments: true
+description: Erforsche den YOLOv7, einen echtzeitfรคhigen Objektdetektor. Verstehe seine รผberlegene Geschwindigkeit, beeindruckende Genauigkeit und seinen einzigartigen Fokus auf die optimierte Ausbildung mit "trainable bag-of-freebies".
+keywords: YOLOv7, echtzeitfรคhiger Objektdetektor, State-of-the-Art, Ultralytics, MS COCO Datensatz, Modellumparameterisierung, dynamische Labelzuweisung, erweiterte Skalierung, umfassende Skalierung
+---
+
+# YOLOv7: Trainable Bag-of-Freebies
+
+YOLOv7 ist ein echtzeitfรคhiger Objektdetektor der Spitzenklasse, der alle bekannten Objektdetektoren in Bezug auf Geschwindigkeit und Genauigkeit im Bereich von 5 FPS bis 160 FPS รผbertrifft. Mit einer Genauigkeit von 56,8% AP ist er der prรคziseste Echtzeit-Objektdetektor unter allen bekannten Modellen mit einer FPS von 30 oder hรถher auf der GPU V100. Darรผber hinaus รผbertrifft YOLOv7 andere Objektdetektoren wie YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 und viele andere in Bezug auf Geschwindigkeit und Genauigkeit. Das Modell wird ausschlieรlich auf dem MS COCO-Datensatz trainiert, ohne andere Datensรคtze oder vortrainierte Gewichte zu verwenden. Sourcecode fรผr YOLOv7 ist auf GitHub verfรผgbar.
+
+
+**Vergleich von Spitzen-Objektdetektoren.
+** Aus den Ergebnissen in Tabelle 2 wissen wir, dass die vorgeschlagene Methode das beste Verhรคltnis von Geschwindigkeit und Genauigkeit umfassend aufweist. Vergleichen wir YOLOv7-tiny-SiLU mit YOLOv5-N (r6.1), so ist unsere Methode 127 FPS schneller und um 10,7% genauer beim AP. Darรผber hinaus erreicht YOLOv7 bei einer Bildrate von 161 FPS einen AP von 51,4%, wรคhrend PPYOLOE-L mit demselben AP nur eine Bildrate von 78 FPS aufweist. In Bezug auf die Parameterverwendung ist YOLOv7 um 41% geringer als PPYOLOE-L. Vergleicht man YOLOv7-X mit 114 FPS Inferenzgeschwindigkeit mit YOLOv5-L (r6.1) mit 99 FPS Inferenzgeschwindigkeit, kann YOLOv7-X den AP um 3,9% verbessern. Wenn YOLOv7-X mit YOLOv5-X (r6.1) in รคhnlichem Maรstab verglichen wird, ist die Inferenzgeschwindigkeit von YOLOv7-X 31 FPS schneller. Darรผber hinaus reduziert YOLOv7-X in Bezug auf die Anzahl der Parameter und Berechnungen 22% der Parameter und 8% der Berechnungen im Vergleich zu YOLOv5-X (r6.1), verbessert jedoch den AP um 2,2% ([Source](https://arxiv.org/pdf/2207.02696.pdf)).
+
+## รbersicht
+
+Echtzeit-Objekterkennung ist eine wichtige Komponente vieler Computersysteme fรผr Bildverarbeitung, einschlieรlich Multi-Object-Tracking, autonomes Fahren, Robotik und medizinische Bildanalyse. In den letzten Jahren konzentrierte sich die Entwicklung der Echtzeit-Objekterkennung auf die Gestaltung effizienter Architekturen und die Verbesserung der Inferenzgeschwindigkeit verschiedener CPUs, GPUs und Neural Processing Units (NPUs). YOLOv7 unterstรผtzt sowohl mobile GPUs als auch GPU-Gerรคte, von der Edge bis zur Cloud.
+
+Im Gegensatz zu herkรถmmlichen, echtzeitfรคhigen Objektdetektoren, die sich auf die Architekturoptimierung konzentrieren, fรผhrt YOLOv7 eine Fokussierung auf die Optimierung des Schulungsprozesses ein. Dazu gehรถren Module und Optimierungsmethoden, die darauf abzielen, die Genauigkeit der Objekterkennung zu verbessern, ohne die Inferenzkosten zu erhรถhen - ein Konzept, das als "trainable bag-of-freebies" bekannt ist.
+
+## Hauptmerkmale
+
+YOLOv7 fรผhrt mehrere Schlรผsselfunktionen ein:
+
+1. **Modellumparameterisierung**: YOLOv7 schlรคgt ein geplantes umparameterisiertes Modell vor, das eine in verschiedenen Netzwerken anwendbare Strategie darstellt und auf dem Konzept des Gradientenpropagationspfades basiert.
+
+2. **Dynamische Labelzuweisung**: Das Training des Modells mit mehreren Ausgabeschichten stellt ein neues Problem dar: "Wie weist man dynamische Ziele fรผr die Ausgaben der verschiedenen Zweige zu?" Zur Lรถsung dieses Problems fรผhrt YOLOv7 eine neue Methode zur Labelzuweisung ein, die als coarse-to-fine lead guided label assignment bekannt ist.
+
+3. **Erweiterte und umfassende Skalierung**: YOLOv7 schlรคgt Methoden zur "erweiterten" und "umfassenden Skalierung" des echtzeitfรคhigen Objektdetektors vor, die Parameter und Berechnungen effektiv nutzen kรถnnen.
+
+4. **Effizienz**: Die von YOLOv7 vorgeschlagene Methode kann etwa 40 % der Parameter und 50 % der Berechnungen des state-of-the-art echtzeitfรคhigen Objektdetektors wirksam reduzieren und weist eine schnellere Inferenzgeschwindigkeit und eine hรถhere Detektionsgenauigkeit auf.
+
+## Beispiele zur Nutzung
+
+Zum Zeitpunkt der Erstellung dieses Textes unterstรผtzt Ultralytics derzeit keine YOLOv7-Modelle. Daher mรผssen sich alle Benutzer, die YOLOv7 verwenden mรถchten, direkt an das YOLOv7 GitHub-Repository fรผr Installations- und Nutzungshinweise wenden.
+
+Hier ist ein kurzer รberblick รผber die typischen Schritte, die Sie unternehmen kรถnnten, um YOLOv7 zu verwenden:
+
+1. Besuchen Sie das YOLOv7 GitHub-Repository: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
+
+2. Befolgen Sie die in der README-Datei bereitgestellten Anweisungen zur Installation. Dies beinhaltet in der Regel das Klonen des Repositories, die Installation der erforderlichen Abhรคngigkeiten und das Einrichten eventuell notwendiger Umgebungsvariablen.
+
+3. Sobald die Installation abgeschlossen ist, kรถnnen Sie das Modell entsprechend den im Repository bereitgestellten Anleitungen trainieren und verwenden. Dies umfasst in der Regel die Vorbereitung des Datensatzes, das Konfigurieren der Modellparameter, das Training des Modells und anschlieรend die Verwendung des trainierten Modells zur Durchfรผhrung der Objekterkennung.
+
+Bitte beachten Sie, dass die spezifischen Schritte je nach Ihrem spezifischen Anwendungsfall und dem aktuellen Stand des YOLOv7-Repositories variieren kรถnnen. Es wird daher dringend empfohlen, sich direkt an die im YOLOv7 GitHub-Repository bereitgestellten Anweisungen zu halten.
+
+Wir bedauern etwaige Unannehmlichkeiten und werden uns bemรผhen, dieses Dokument mit Anwendungsbeispielen fรผr Ultralytics zu aktualisieren, sobald die Unterstรผtzung fรผr YOLOv7 implementiert ist.
+
+## Zitationen und Danksagungen
+
+Wir mรถchten den Autoren von YOLOv7 fรผr ihre bedeutenden Beitrรคge im Bereich der echtzeitfรคhigen Objekterkennung danken:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{wang2022yolov7,
+ title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
+ author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
+ journal={arXiv preprint arXiv:2207.02696},
+ year={2022}
+ }
+ ```
+
+Die ursprรผngliche YOLOv7-Studie kann auf [arXiv](https://arxiv.org/pdf/2207.02696.pdf) gefunden werden. Die Autoren haben ihre Arbeit รถffentlich zugรคnglich gemacht, und der Code kann auf [GitHub](https://github.com/WongKinYiu/yolov7) abgerufen werden. Wir schรคtzen ihre Bemรผhungen, das Feld voranzubringen und ihre Arbeit der breiteren Gemeinschaft zugรคnglich zu machen.
diff --git a/ultralytics/docs/de/models/yolov7.md:Zone.Identifier b/ultralytics/docs/de/models/yolov7.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov7.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/models/yolov8.md b/ultralytics/docs/de/models/yolov8.md
new file mode 100755
index 0000000..e24ca96
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov8.md
@@ -0,0 +1,162 @@
+---
+comments: true
+description: Erfahren Sie mehr รผber die aufregenden Funktionen von YOLOv8, der neuesten Version unseres Echtzeit-Objekterkenners! Erfahren Sie, wie fortschrittliche Architekturen, vortrainierte Modelle und die optimale Balance zwischen Genauigkeit und Geschwindigkeit YOLOv8 zur perfekten Wahl fรผr Ihre Objekterkennungsaufgaben machen.
+keywords: YOLOv8, Ultralytics, Echtzeit-Objekterkennung, vortrainierte Modelle, Dokumentation, Objekterkennung, YOLO-Serie, fortschrittliche Architekturen, Genauigkeit, Geschwindigkeit
+---
+
+# YOLOv8
+
+## รbersicht
+
+YOLOv8 ist die neueste Version der YOLO-Serie von Echtzeit-Objekterkennern und bietet modernste Leistung in Bezug auf Genauigkeit und Geschwindigkeit. Basierend auf den Fortschritten frรผherer YOLO-Versionen bringt YOLOv8 neue Funktionen und Optimierungen mit sich, die ihn zu einer idealen Wahl fรผr verschiedene Objekterkennungsaufgaben in einer Vielzahl von Anwendungen machen.
+
+
+
+## Schlรผsselfunktionen
+
+- **Fortschrittliche Backbone- und Neck-Architekturen:** YOLOv8 verwendet modernste Backbone- und Neck-Architekturen, die zu einer verbesserten Merkmalsextraktion und Objekterkennungsleistung fรผhren.
+- **Ankerfreier Split Ultralytics Head:** YOLOv8 verwendet einen ankerfreien Split Ultralytics Head, der zu einer besseren Genauigkeit und einem effizienteren Erkennungsprozess im Vergleich zu ankerbasierten Ansรคtzen fรผhrt.
+- **Optimale Genauigkeits-Geschwindigkeits-Balance:** Mit dem Fokus auf die Aufrechterhaltung einer optimalen Balance zwischen Genauigkeit und Geschwindigkeit eignet sich YOLOv8 fรผr Echtzeit-Objekterkennungsaufgaben in verschiedenen Anwendungsbereichen.
+- **Vielfalt an vortrainierten Modellen:** YOLOv8 bietet eine Vielzahl von vortrainierten Modellen, um verschiedenen Aufgaben und Leistungsanforderungen gerecht zu werden. Dies erleichtert die Suche nach dem richtigen Modell fรผr Ihren spezifischen Anwendungsfall.
+
+## Unterstรผtzte Aufgaben und Modi
+
+Die YOLOv8-Serie bietet eine Vielzahl von Modellen, von denen jedes auf bestimmte Aufgaben in der Computer Vision spezialisiert ist. Diese Modelle sind so konzipiert, dass sie verschiedenen Anforderungen gerecht werden, von der Objekterkennung bis hin zu komplexeren Aufgaben wie Instanzsegmentierung, Pose/Keypoint-Erkennung und Klassifikation.
+
+Jede Variante der YOLOv8-Serie ist auf ihre jeweilige Aufgabe optimiert und gewรคhrleistet damit hohe Leistung und Genauigkeit. Darรผber hinaus sind diese Modelle kompatibel mit verschiedenen Betriebsmodi, einschlieรlich [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) und [Export](../modes/export.md). Dadurch wird ihre Verwendung in verschiedenen Phasen der Bereitstellung und Entwicklung erleichtert.
+
+| Modell | Dateinamen | Aufgabe | Inference | Validation | Training | Export |
+|-------------|----------------------------------------------------------------------------------------------------------------|---------------------------------------------|-----------|------------|----------|--------|
+| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Objekterkennung](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Instanzsegmentierung](../tasks/segment.md) | โ | โ | โ | โ |
+| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Keypoints](../tasks/pose.md) | โ | โ | โ | โ |
+| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Klassifikation](../tasks/classify.md) | โ | โ | โ | โ |
+
+Diese Tabelle gibt einen รberblick รผber die verschiedenen Varianten des YOLOv8-Modells und deren Anwendungsbereiche sowie deren Kompatibilitรคt mit verschiedenen Betriebsmodi wie Inference, Validation, Training und Export. Sie zeigt die Vielseitigkeit und Robustheit der YOLOv8-Serie, was sie fรผr verschiedene Anwendungen in der Computer Vision geeignet macht.
+
+## Leistungskennzahlen
+
+!!! Performance
+
+ === "Objekterkennung (COCO)"
+
+ Siehe [Objekterkennungsdokumentation](https://docs.ultralytics.com/tasks/detect/) fรผr Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/detect/coco/) trainiert wurden und 80 vortrainierte Klassen enthalten.
+
+ | Modell | Grรถรe (Pixel) | mAPval 50-95 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) |
+ | ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ---------------------------------------- | --------------------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37,3 | 80,4 | 0,99 | 3,2 | 8,7 |
+ | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44,9 | 128,4 | 1,20 | 11,2 | 28,6 |
+ | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50,2 | 234,7 | 1,83 | 25,9 | 78,9 |
+ | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52,9 | 375,2 | 2,39 | 43,7 | 165,2 |
+ | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53,9 | 479,1 | 3,53 | 68,2 | 257,8 |
+
+ === "Objekterkennung (Open Images V7)"
+
+ Siehe [Objekterkennungsdokumentation](https://docs.ultralytics.com/tasks/detect/) fรผr Beispiele zur Verwendung dieser Modelle, die auf [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/) trainiert wurden und 600 vortrainierte Klassen enthalten.
+
+ | Modell | Grรถรe (Pixel) | mAPval 50-95 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) |
+ | ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ---------------------------------------- | --------------------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-oiv7.pt) | 640 | 18,4 | 142,4 | 1,21 | 3,5 | 10,5 |
+ | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27,7 | 183,1 | 1,40 | 11,4 | 29,7 |
+ | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33,6 | 408,5 | 2,26 | 26,2 | 80,6 |
+ | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34,9 | 596,9 | 2,43 | 44,1 | 167,4 |
+ | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36,3 | 860,6 | 3,56 | 68,7 | 260,6 |
+
+ === "Segmentierung (COCO)"
+
+ Siehe [Segmentierungsdokumentation](https://docs.ultralytics.com/tasks/segment/) fรผr Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/segment/coco/) trainiert wurden und 80 vortrainierte Klassen enthalten.
+
+ | Modell | Grรถรe (Pixel) | mAPbox 50-95 | mAPmask 50-95 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) |
+ | -------------------------------------------------------------------------------------------- | --------------------- | --------------------- | --------------------- | ---------------------------------------- | --------------------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36,7 | 30,5 | 96,1 | 1,21 | 3,4 | 12,6 |
+ | [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44,6 | 36,8 | 155,7 | 1,47 | 11,8 | 42,6 |
+ | [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49,9 | 40,8 | 317,0 | 2,18 | 27,3 | 110,2 |
+ | [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52,3 | 42,6 | 572,4 | 2,79 | 46,0 | 220,5 |
+ | [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53,4 | 43,4 | 712,1 | 4,02 | 71,8 | 344,1 |
+
+ === "Klassifikation (ImageNet)"
+
+ Siehe [Klassifikationsdokumentation](https://docs.ultralytics.com/tasks/classify/) fรผr Beispiele zur Verwendung dieser Modelle, die auf [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/) trainiert wurden und 1000 vortrainierte Klassen enthalten.
+
+ | Modell | Grรถรe (Pixel) | acc top1 | acc top5 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) bei 640 |
+ | -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ---------------------------------------- | --------------------------------------------- | ------------------ | ------------------------ |
+ | [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66,6 | 87,0 | 12,9 | 0,31 | 2,7 | 4,3 |
+ | [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72,3 | 91,1 | 23,4 | 0,35 | 6,4 | 13,5 |
+ | [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76,4 | 93,2 | 85,4 | 0,62 | 17,0 | 42,7 |
+ | [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78,0 | 94,1 | 163,0 | 0,87 | 37,5 | 99,7 |
+ | [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78,4 | 94,3 | 232,0 | 1,01 | 57,4 | 154,8 |
+
+ === "Pose (COCO)"
+
+ Siehe [Pose Estimation Docs](https://docs.ultralytics.com/tasks/segment/) fรผr Beispiele zur Verwendung dieser Modelle, die auf [COCO](https://docs.ultralytics.com/datasets/pose/coco/) trainiert wurden und 1 vortrainierte Klasse, 'person', enthalten.
+
+ | Modell | Grรถรe (Pixel) | mAPpose 50-95 | mAPpose 50 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) |
+ | ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ---------------------------------------- | --------------------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50,4 | 80,1 | 131,8 | 1,18 | 3,3 | 9,2 |
+ | [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60,0 | 86,2 | 233,2 | 1,42 | 11,6 | 30,2 |
+ | [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65,0 | 88,8 | 456,3 | 2,00 | 26,4 | 81,0 |
+ | [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67,6 | 90,0 | 784,5 | 2,59 | 44,4 | 168,6 |
+ | [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69,2 | 90,2 | 1607,1 | 3,73 | 69,4 | 263,2 |
+ | [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71,6 | 91,2 | 4088,7 | 10,04 | 99,1 | 1066,4 |
+
+## Beispiele zur Verwendung
+
+Dieses Beispiel liefert einfache Trainings- und Inferenzbeispiele fรผr YOLOv8. Fรผr die vollstรคndige Dokumentation zu diesen und anderen [Modi](../modes/index.md) siehe die Seiten [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) und [Export](../modes/export.md).
+
+Beachten Sie, dass das folgende Beispiel fรผr YOLOv8 [Detect](../tasks/detect.md) Modelle fรผr die Objekterkennung verwendet. Fรผr zusรคtzliche unterstรผtzte Aufgaben siehe die Dokumentation zur [Segmentation](../tasks/segment.md), [Classification](../tasks/classify.md) und [Pose](../tasks/pose.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ Vortrainierte PyTorch-`*.pt`-Modelle sowie Konfigurations-`*.yaml`-Dateien kรถnnen der Klasse `YOLO()` in Python รผbergeben werden, um eine Modellinstanz zu erstellen:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden Sie ein vortrainiertes YOLOv8n-Modell fรผr COCO
+ model = YOLO('yolov8n.pt')
+
+ # Zeigen Sie Informationen zum Modell an (optional)
+ model.info()
+
+ # Trainieren Sie das Modell mit dem COCO8-Beispieldatensatz fรผr 100 Epochen
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Fรผhren Sie eine Inferenz mit dem YOLOv8n-Modell auf dem Bild 'bus.jpg' aus
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI-Befehle stehen zur direkten Ausfรผhrung der Modelle zur Verfรผgung:
+
+ ```bash
+ # Laden Sie ein vortrainiertes YOLOv8n-Modell fรผr COCO und trainieren Sie es mit dem COCO8-Beispieldatensatz fรผr 100 Epochen
+ yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Laden Sie ein vortrainiertes YOLOv8n-Modell fรผr COCO und fรผhren Sie eine Inferenz auf dem Bild 'bus.jpg' aus
+ yolo predict model=yolov8n.pt source=path/to/bus.jpg
+ ```
+
+## Zitate und Danksagungen
+
+Wenn Sie das YOLOv8-Modell oder eine andere Software aus diesem Repository in Ihrer Arbeit verwenden, zitieren Sie es bitte in folgendem Format:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @software{yolov8_ultralytics,
+ author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu},
+ title = {Ultralytics YOLOv8},
+ version = {8.0.0},
+ year = {2023},
+ url = {https://github.com/ultralytics/ultralytics},
+ orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069},
+ license = {AGPL-3.0}
+ }
+ ```
+
+Bitte beachten Sie, dass dieDOI aussteht und der Zitation hinzugefรผgt wird, sobald sie verfรผgbar ist. YOLOv8-Modelle werden unter den Lizenzen [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) und [Enterprise](https://ultralytics.com/license) bereitgestellt.
diff --git a/ultralytics/docs/de/models/yolov8.md:Zone.Identifier b/ultralytics/docs/de/models/yolov8.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/models/yolov8.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/modes/benchmark.md b/ultralytics/docs/de/modes/benchmark.md
new file mode 100755
index 0000000..93908a1
--- /dev/null
+++ b/ultralytics/docs/de/modes/benchmark.md
@@ -0,0 +1,94 @@
+---
+comments: true
+description: Lernen Sie, wie Sie die Geschwindigkeit und Genauigkeit von YOLOv8 รผber verschiedene Exportformate hinweg profilieren kรถnnen; erhalten Sie Einblicke in mAP50-95, Genauigkeit_top5 Kennzahlen und mehr.
+keywords: Ultralytics, YOLOv8, Benchmarking, Geschwindigkeitsprofilierung, Genauigkeitsprofilierung, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, YOLO-Exportformate
+---
+
+# Modell-Benchmarking mit Ultralytics YOLO
+
+
+
+## Einfรผhrung
+
+Nachdem Ihr Modell trainiert und validiert wurde, ist der nรคchste logische Schritt, seine Leistung in verschiedenen realen Szenarien zu bewerten. Der Benchmark-Modus in Ultralytics YOLOv8 dient diesem Zweck, indem er einen robusten Rahmen fรผr die Beurteilung von Geschwindigkeit und Genauigkeit Ihres Modells รผber eine Reihe von Exportformaten hinweg bietet.
+
+## Warum ist Benchmarking entscheidend?
+
+- **Informierte Entscheidungen:** Erhalten Sie Einblicke in die Kompromisse zwischen Geschwindigkeit und Genauigkeit.
+- **Ressourcenzuweisung:** Verstehen Sie, wie sich verschiedene Exportformate auf unterschiedlicher Hardware verhalten.
+- **Optimierung:** Erfahren Sie, welches Exportformat die beste Leistung fรผr Ihren spezifischen Anwendungsfall bietet.
+- **Kosteneffizienz:** Nutzen Sie Hardware-Ressourcen basierend auf den Benchmark-Ergebnissen effizienter.
+
+### Schlรผsselmetriken im Benchmark-Modus
+
+- **mAP50-95:** Fรผr Objekterkennung, Segmentierung und Posenschรคtzung.
+- **accuracy_top5:** Fรผr die Bildklassifizierung.
+- **Inferenzzeit:** Zeit, die fรผr jedes Bild in Millisekunden benรถtigt wird.
+
+### Unterstรผtzte Exportformate
+
+- **ONNX:** Fรผr optimale CPU-Leistung
+- **TensorRT:** Fรผr maximale GPU-Effizienz
+- **OpenVINO:** Fรผr die Optimierung von Intel-Hardware
+- **CoreML, TensorFlow SavedModel, und mehr:** Fรผr vielfรคltige Deployment-Anforderungen.
+
+!!! Tip "Tipp"
+
+ * Exportieren Sie in ONNX oder OpenVINO fรผr bis zu 3x CPU-Beschleunigung.
+ * Exportieren Sie in TensorRT fรผr bis zu 5x GPU-Beschleunigung.
+
+## Anwendungsbeispiele
+
+Fรผhren Sie YOLOv8n-Benchmarks auf allen unterstรผtzten Exportformaten einschlieรlich ONNX, TensorRT usw. durch. Siehe den Abschnitt Argumente unten fรผr eine vollstรคndige Liste der Exportargumente.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics.utils.benchmarks import benchmark
+
+ # Benchmark auf GPU
+ benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
+ ```
+ === "CLI"
+
+ ```bash
+ yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
+ ```
+
+## Argumente
+
+Argumente wie `model`, `data`, `imgsz`, `half`, `device` und `verbose` bieten Benutzern die Flexibilitรคt, die Benchmarks auf ihre spezifischen Bedรผrfnisse abzustimmen und die Leistung verschiedener Exportformate mรผhelos zu vergleichen.
+
+| Schlรผssel | Wert | Beschreibung |
+|-----------|---------|--------------------------------------------------------------------------------------|
+| `model` | `None` | Pfad zur Modelldatei, z. B. yolov8n.pt, yolov8n.yaml |
+| `data` | `None` | Pfad zur YAML, die das Benchmarking-Dataset referenziert (unter `val`-Kennzeichnung) |
+| `imgsz` | `640` | Bildgrรถรe als Skalar oder Liste (h, w), z. B. (640, 480) |
+| `half` | `False` | FP16-Quantisierung |
+| `int8` | `False` | INT8-Quantisierung |
+| `device` | `None` | Gerรคt zum Ausfรผhren, z. B. CUDA device=0 oder device=0,1,2,3 oder device=cpu |
+| `verbose` | `False` | bei Fehlern nicht fortsetzen (bool), oder Wertebereichsschwelle (float) |
+
+## Exportformate
+
+Benchmarks werden automatisch auf allen mรถglichen Exportformaten unten ausgefรผhrt.
+
+| Format | `format`-Argument | Modell | Metadaten | Argumente |
+|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
+
+Vollstรคndige Details zum `export` finden Sie auf der [Export](https://docs.ultralytics.com/modes/export/)-Seite.
diff --git a/ultralytics/docs/de/modes/benchmark.md:Zone.Identifier b/ultralytics/docs/de/modes/benchmark.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/modes/benchmark.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/modes/export.md b/ultralytics/docs/de/modes/export.md
new file mode 100755
index 0000000..c62a1d6
--- /dev/null
+++ b/ultralytics/docs/de/modes/export.md
@@ -0,0 +1,108 @@
+---
+comments: true
+description: Schritt-fรผr-Schritt-Anleitung zum Exportieren Ihrer YOLOv8-Modelle in verschiedene Formate wie ONNX, TensorRT, CoreML und mehr fรผr den Einsatz.
+keywords: YOLO, YOLOv8, Ultralytics, Modell-Export, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, Modell exportieren
+---
+
+# Modell-Export mit Ultralytics YOLO
+
+
+
+## Einfรผhrung
+
+Das ultimative Ziel des Trainierens eines Modells besteht darin, es fรผr reale Anwendungen einzusetzen. Der Exportmodus in Ultralytics YOLOv8 bietet eine vielseitige Palette von Optionen fรผr den Export Ihres trainierten Modells in verschiedene Formate, sodass es auf verschiedenen Plattformen und Gerรคten eingesetzt werden kann. Dieser umfassende Leitfaden soll Sie durch die Nuancen des Modell-Exports fรผhren und zeigen, wie Sie maximale Kompatibilitรคt und Leistung erzielen kรถnnen.
+
+
+
+
+
+ Ansehen: Wie man ein benutzerdefiniertes trainiertes Ultralytics YOLOv8-Modell exportiert und Live-Inferenz auf der Webcam ausfรผhrt.
+
+
+## Warum den Exportmodus von YOLOv8 wรคhlen?
+
+- **Vielseitigkeit:** Export in verschiedene Formate einschlieรlich ONNX, TensorRT, CoreML und mehr.
+- **Leistung:** Bis zu 5-fache GPU-Beschleunigung mit TensorRT und 3-fache CPU-Beschleunigung mit ONNX oder OpenVINO.
+- **Kompatibilitรคt:** Machen Sie Ihr Modell universell einsetzbar in zahlreichen Hardware- und Softwareumgebungen.
+- **Benutzerfreundlichkeit:** Einfache CLI- und Python-API fรผr schnellen und unkomplizierten Modell-Export.
+
+### Schlรผsselfunktionen des Exportmodus
+
+Hier sind einige der herausragenden Funktionen:
+
+- **Ein-Klick-Export:** Einfache Befehle fรผr den Export in verschiedene Formate.
+- **Batch-Export:** Export von Modellen, die Batch-Inferenz unterstรผtzen.
+- **Optimiertes Inferenzverhalten:** Exportierte Modelle sind fรผr schnellere Inferenzzeiten optimiert.
+- **Tutorial-Videos:** Ausfรผhrliche Anleitungen und Tutorials fรผr ein reibungsloses Exporterlebnis.
+
+!!! Tip "Tipp"
+
+ * Exportieren Sie nach ONNX oder OpenVINO fรผr bis zu 3-fache CPU-Beschleunigung.
+ * Exportieren Sie nach TensorRT fรผr bis zu 5-fache GPU-Beschleunigung.
+
+## Nutzungsbeispiele
+
+Exportieren Sie ein YOLOv8n-Modell in ein anderes Format wie ONNX oder TensorRT. Weitere Informationen zu den Exportargumenten finden Sie im Abschnitt โArgumenteโ unten.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden eines Modells
+ model = YOLO('yolov8n.pt') # offizielles Modell laden
+ model = YOLO('path/to/best.pt') # benutzerdefiniertes trainiertes Modell laden
+
+ # Exportieren des Modells
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n.pt format=onnx # offizielles Modell exportieren
+ yolo export model=path/to/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren
+ ```
+
+## Argumente
+
+Exporteinstellungen fรผr YOLO-Modelle beziehen sich auf verschiedene Konfigurationen und Optionen, die verwendet werden, um das Modell zu speichern oder fรผr den Einsatz in anderen Umgebungen oder Plattformen zu exportieren. Diese Einstellungen kรถnnen die Leistung, Grรถรe und Kompatibilitรคt des Modells mit verschiedenen Systemen beeinflussen. Zu den gรคngigen Exporteinstellungen von YOLO gehรถren das Format der exportierten Modelldatei (z. B. ONNX, TensorFlow SavedModel), das Gerรคt, auf dem das Modell ausgefรผhrt wird (z. B. CPU, GPU) und das Vorhandensein zusรคtzlicher Funktionen wie Masken oder mehrere Labels pro Box. Andere Faktoren, die den Exportprozess beeinflussen kรถnnen, sind die spezifische Aufgabe, fรผr die das Modell verwendet wird, und die Anforderungen oder Einschrรคnkungen der Zielumgebung oder -plattform. Es ist wichtig, diese Einstellungen sorgfรคltig zu berรผcksichtigen und zu konfigurieren, um sicherzustellen, dass das exportierte Modell fรผr den beabsichtigten Einsatzzweck optimiert ist und in der Zielumgebung effektiv eingesetzt werden kann.
+
+| Schlรผssel | Wert | Beschreibung |
+|-------------|-----------------|----------------------------------------------------------|
+| `format` | `'torchscript'` | Format fรผr den Export |
+| `imgsz` | `640` | Bildgrรถรe als Skalar oder (h, w)-Liste, z.B. (640, 480) |
+| `keras` | `False` | Verwendung von Keras fรผr TensorFlow SavedModel-Export |
+| `optimize` | `False` | TorchScript: Optimierung fรผr mobile Gerรคte |
+| `half` | `False` | FP16-Quantisierung |
+| `int8` | `False` | INT8-Quantisierung |
+| `dynamic` | `False` | ONNX/TensorRT: dynamische Achsen |
+| `simplify` | `False` | ONNX/TensorRT: Vereinfachung des Modells |
+| `opset` | `None` | ONNX: Opset-Version (optional, Standardwert ist neueste) |
+| `workspace` | `4` | TensorRT: Arbeitsbereichgrรถรe (GB) |
+| `nms` | `False` | CoreML: Hinzufรผgen von NMS |
+
+## Exportformate
+
+Verfรผgbare YOLOv8-Exportformate finden Sie in der Tabelle unten. Sie kรถnnen in jedes Format exportieren, indem Sie das `format`-Argument verwenden, z. B. `format='onnx'` oder `format='engine'`.
+
+| Format | `format`-Argument | Modell | Metadaten | Argumente |
+|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
diff --git a/ultralytics/docs/de/modes/export.md:Zone.Identifier b/ultralytics/docs/de/modes/export.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/modes/export.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/modes/index.md b/ultralytics/docs/de/modes/index.md
new file mode 100755
index 0000000..c73b488
--- /dev/null
+++ b/ultralytics/docs/de/modes/index.md
@@ -0,0 +1,74 @@
+---
+comments: true
+description: Vom Training bis zum Tracking - Nutzen Sie YOLOv8 von Ultralytics optimal. Erhalten Sie Einblicke und Beispiele fรผr jeden unterstรผtzten Modus, einschlieรlich Validierung, Export und Benchmarking.
+keywords: Ultralytics, YOLOv8, Maschinelles Lernen, Objekterkennung, Training, Validierung, Vorhersage, Export, Tracking, Benchmarking
+---
+
+# Ultralytics YOLOv8 Modi
+
+
+
+## Einfรผhrung
+
+Ultralytics YOLOv8 ist nicht nur ein weiteres Objekterkennungsmodell; es ist ein vielseitiges Framework, das den gesamten Lebenszyklus von Machine-Learning-Modellen abdeckt - von der Dateneingabe und dem Modelltraining รผber die Validierung und Bereitstellung bis hin zum Tracking in der realen Welt. Jeder Modus dient einem bestimmten Zweck und ist darauf ausgelegt, Ihnen die Flexibilitรคt und Effizienz zu bieten, die fรผr verschiedene Aufgaben und Anwendungsfรคlle erforderlich ist.
+
+
+
+### Modi im รberblick
+
+Das Verstรคndnis der verschiedenen **Modi**, die Ultralytics YOLOv8 unterstรผtzt, ist entscheidend, um das Beste aus Ihren Modellen herauszuholen:
+
+- **Train**-Modus: Verfeinern Sie Ihr Modell mit angepassten oder vorgeladenen Datensรคtzen.
+- **Val**-Modus: Eine Nachtrainingsprรผfung zur Validierung der Modellleistung.
+- **Predict**-Modus: Entfesseln Sie die Vorhersagekraft Ihres Modells mit realen Daten.
+- **Export**-Modus: Machen Sie Ihr Modell in verschiedenen Formaten einsatzbereit.
+- **Track**-Modus: Erweitern Sie Ihr Objekterkennungsmodell um Echtzeit-Tracking-Anwendungen.
+- **Benchmark**-Modus: Analysieren Sie die Geschwindigkeit und Genauigkeit Ihres Modells in verschiedenen Einsatzumgebungen.
+
+Dieser umfassende Leitfaden soll Ihnen einen รberblick und praktische Einblicke in jeden Modus geben, um Ihnen zu helfen, das volle Potenzial von YOLOv8 zu nutzen.
+
+## [Trainieren](train.md)
+
+Der Trainingsmodus wird verwendet, um ein YOLOv8-Modell mit einem angepassten Datensatz zu trainieren. In diesem Modus wird das Modell mit dem angegebenen Datensatz und den Hyperparametern trainiert. Der Trainingsprozess beinhaltet die Optimierung der Modellparameter, damit es die Klassen und Standorte von Objekten in einem Bild genau vorhersagen kann.
+
+[Trainingsbeispiele](train.md){ .md-button }
+
+## [Validieren](val.md)
+
+Der Validierungsmodus wird genutzt, um ein YOLOv8-Modell nach dem Training zu bewerten. In diesem Modus wird das Modell auf einem Validierungsset getestet, um seine Genauigkeit und Generalisierungsleistung zu messen. Dieser Modus kann verwendet werden, um die Hyperparameter des Modells fรผr eine bessere Leistung zu optimieren.
+
+[Validierungsbeispiele](val.md){ .md-button }
+
+## [Vorhersagen](predict.md)
+
+Der Vorhersagemodus wird verwendet, um mit einem trainierten YOLOv8-Modell Vorhersagen fรผr neue Bilder oder Videos zu treffen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Benutzer kann Bilder oder Videos zur Inferenz bereitstellen. Das Modell sagt die Klassen und Standorte von Objekten in den Eingabebildern oder -videos voraus.
+
+[Vorhersagebeispiele](predict.md){ .md-button }
+
+## [Exportieren](export.md)
+
+Der Exportmodus wird verwendet, um ein YOLOv8-Modell in ein Format zu exportieren, das fรผr die Bereitstellung verwendet werden kann. In diesem Modus wird das Modell in ein Format konvertiert, das von anderen Softwareanwendungen oder Hardwaregerรคten verwendet werden kann. Dieser Modus ist nรผtzlich, wenn das Modell in Produktionsumgebungen eingesetzt wird.
+
+[Exportbeispiele](export.md){ .md-button }
+
+## [Verfolgen](track.md)
+
+Der Trackingmodus wird zur Echtzeitverfolgung von Objekten mit einem YOLOv8-Modell verwendet. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Benutzer kann einen Live-Videostream fรผr das Echtzeitobjekttracking bereitstellen. Dieser Modus ist nรผtzlich fรผr Anwendungen wie รberwachungssysteme oder selbstfahrende Autos.
+
+[Trackingbeispiele](track.md){ .md-button }
+
+## [Benchmarking](benchmark.md)
+
+Der Benchmark-Modus wird verwendet, um die Geschwindigkeit und Genauigkeit verschiedener Exportformate fรผr YOLOv8 zu profilieren. Die Benchmarks liefern Informationen รผber die Grรถรe des exportierten Formats, seine `mAP50-95`-Metriken (fรผr Objekterkennung, Segmentierung und Pose)
+oder `accuracy_top5`-Metriken (fรผr Klassifizierung) und die Inferenzzeit in Millisekunden pro Bild fรผr verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und andere. Diese Informationen kรถnnen den Benutzern dabei helfen, das optimale Exportformat fรผr ihren spezifischen Anwendungsfall basierend auf ihren Anforderungen an Geschwindigkeit und Genauigkeit auszuwรคhlen.
+
+[Benchmarkbeispiele](benchmark.md){ .md-button }
diff --git a/ultralytics/docs/de/modes/index.md:Zone.Identifier b/ultralytics/docs/de/modes/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/modes/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/modes/predict.md b/ultralytics/docs/de/modes/predict.md
new file mode 100755
index 0000000..feb64f0
--- /dev/null
+++ b/ultralytics/docs/de/modes/predict.md
@@ -0,0 +1,226 @@
+---
+comments: true
+description: Erkunden Sie, wie der YOLOv8-Prognosemodus fรผr verschiedene Aufgaben verwendet werden kann. Erfahren Sie mehr รผber verschiedene Inferenzquellen wie Bilder, Videos und Datenformate.
+keywords: Ultralytics, YOLOv8, Vorhersagemodus, Inferenzquellen, Vorhersageaufgaben, Streaming-Modus, Bildverarbeitung, Videoverarbeitung, maschinelles Lernen, KI
+---
+
+# Modellvorhersage mit Ultralytics YOLO
+
+
+
+## Einfรผhrung
+
+Im Bereich des maschinellen Lernens und der Computer Vision wird der Prozess des Verstehens visueller Daten als 'Inferenz' oder 'Vorhersage' bezeichnet. Ultralytics YOLOv8 bietet eine leistungsstarke Funktion, die als **Prognosemodus** bekannt ist und fรผr eine hochleistungsfรคhige, echtzeitfรคhige Inferenz auf einer breiten Palette von Datenquellen zugeschnitten ist.
+
+
+
+
+
+ Anschauen: Wie man die Ausgaben vom Ultralytics YOLOv8 Modell fรผr individuelle Projekte extrahiert.
+
+
+## Anwendungen in der realen Welt
+
+| Herstellung | Sport | Sicherheit |
+|:---------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|
+|  |  |  |
+| Erkennung von Fahrzeugersatzteilen | Erkennung von Fuรballspielern | Erkennung von stรผrzenden Personen |
+
+## Warum Ultralytics YOLO fรผr Inferenz nutzen?
+
+Hier sind Grรผnde, warum Sie den Prognosemodus von YOLOv8 fรผr Ihre verschiedenen Inferenzanforderungen in Betracht ziehen sollten:
+
+- **Vielseitigkeit:** Fรคhig, Inferenzen auf Bilder, Videos und sogar Live-Streams zu machen.
+- **Leistung:** Entwickelt fรผr Echtzeit-Hochgeschwindigkeitsverarbeitung ohne Genauigkeitsverlust.
+- **Einfache Bedienung:** Intuitive Python- und CLI-Schnittstellen fรผr schnelle Einsatzbereitschaft und Tests.
+- **Hohe Anpassbarkeit:** Verschiedene Einstellungen und Parameter, um das Verhalten der Modellinferenz entsprechend Ihren spezifischen Anforderungen zu optimieren.
+
+### Schlรผsselfunktionen des Prognosemodus
+
+Der Prognosemodus von YOLOv8 ist robust und vielseitig konzipiert und verfรผgt รผber:
+
+- **Kompatibilitรคt mit mehreren Datenquellen:** Ganz gleich, ob Ihre Daten in Form von Einzelbildern, einer Bildersammlung, Videodateien oder Echtzeit-Videostreams vorliegen, der Prognosemodus deckt alles ab.
+- **Streaming-Modus:** Nutzen Sie die Streaming-Funktion, um einen speichereffizienten Generator von `Results`-Objekten zu erzeugen. Aktivieren Sie dies, indem Sie `stream=True` in der Aufrufmethode des Predictors einstellen.
+- **Batchverarbeitung:** Die Mรถglichkeit, mehrere Bilder oder Videoframes in einem einzigen Batch zu verarbeiten, wodurch die Inferenzzeit weiter verkรผrzt wird.
+- **Integrationsfreundlich:** Dank der flexiblen API leicht in bestehende Datenpipelines und andere Softwarekomponenten zu integrieren.
+
+Ultralytics YOLO-Modelle geben entweder eine Python-Liste von `Results`-Objekten zurรผck, oder einen speichereffizienten Python-Generator von `Results`-Objekten, wenn `stream=True` beim Inferenzvorgang an das Modell รผbergeben wird:
+
+!!! Example "Predict"
+
+ === "Gibt eine Liste mit `stream=False` zurรผck"
+ ```python
+ from ultralytics import YOLO
+
+ # Ein Modell laden
+ model = YOLO('yolov8n.pt') # vortrainiertes YOLOv8n Modell
+
+ # Batch-Inferenz auf einer Liste von Bildern ausfรผhren
+ results = model(['im1.jpg', 'im2.jpg']) # gibt eine Liste von Results-Objekten zurรผck
+
+ # Ergebnisliste verarbeiten
+ for result in results:
+ boxes = result.boxes # Boxes-Objekt fรผr Bbox-Ausgaben
+ masks = result.masks # Masks-Objekt fรผr Segmentierungsmasken-Ausgaben
+ keypoints = result.keypoints # Keypoints-Objekt fรผr Pose-Ausgaben
+ probs = result.probs # Probs-Objekt fรผr Klassifizierungs-Ausgaben
+ ```
+
+ === "Gibt einen Generator mit `stream=True` zurรผck"
+ ```python
+ from ultralytics import YOLO
+
+ # Ein Modell laden
+ model = YOLO('yolov8n.pt') # vortrainiertes YOLOv8n Modell
+
+ # Batch-Inferenz auf einer Liste von Bildern ausfรผhren
+ results = model(['im1.jpg', 'im2.jpg'], stream=True) # gibt einen Generator von Results-Objekten zurรผck
+
+ # Generator von Ergebnissen verarbeiten
+ for result in results:
+ boxes = result.boxes # Boxes-Objekt fรผr Bbox-Ausgaben
+ masks = result.masks # Masks-Objekt fรผr Segmentierungsmasken-Ausgaben
+ keypoints = result.keypoints # Keypoints-Objekt fรผr Pose-Ausgaben
+ probs = result.probs # Probs-Objekt fรผr Klassifizierungs-Ausgaben
+ ```
+
+## Inferenzquellen
+
+YOLOv8 kann verschiedene Arten von Eingabequellen fรผr die Inferenz verarbeiten, wie in der folgenden Tabelle gezeigt. Die Quellen umfassen statische Bilder, Videostreams und verschiedene Datenformate. Die Tabelle gibt ebenfalls an, ob jede Quelle im Streaming-Modus mit dem Argument `stream=True` โ verwendet werden kann. Der Streaming-Modus ist vorteilhaft fรผr die Verarbeitung von Videos oder Live-Streams, da er einen Generator von Ergebnissen statt das Laden aller Frames in den Speicher erzeugt.
+
+!!! Tip "Tipp"
+
+ Verwenden Sie `stream=True` fรผr die Verarbeitung langer Videos oder groรer Datensรคtze, um den Speicher effizient zu verwalten. Bei `stream=False` werden die Ergebnisse fรผr alle Frames oder Datenpunkte im Speicher gehalten, was bei groรen Eingaben schnell zu Speicherรผberlรคufen fรผhren kann. Im Gegensatz dazu verwendet `stream=True` einen Generator, der nur die Ergebnisse des aktuellen Frames oder Datenpunkts im Speicher behรคlt, was den Speicherverbrauch erheblich reduziert und Speicherรผberlaufprobleme verhindert.
+
+| Quelle | Argument | Typ | Hinweise |
+|--------------------|--------------------------------------------|-------------------|------------------------------------------------------------------------------------------------|
+| Bild | `'image.jpg'` | `str` oder `Path` | Einzelbilddatei. |
+| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL zu einem Bild. |
+| Bildschirmaufnahme | `'screen'` | `str` | Eine Bildschirmaufnahme erstellen. |
+| PIL | `Image.open('im.jpg')` | `PIL.Image` | HWC-Format mit RGB-Kanรคlen. |
+| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | HWC-Format mit BGR-Kanรคlen `uint8 (0-255)`. |
+| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | HWC-Format mit BGR-Kanรคlen `uint8 (0-255)`. |
+| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | BCHW-Format mit RGB-Kanรคlen `float32 (0.0-1.0)`. |
+| CSV | `'sources.csv'` | `str` oder `Path` | CSV-Datei mit Pfaden zu Bildern, Videos oder Verzeichnissen. |
+| video โ | `'video.mp4'` | `str` oder `Path` | Videodatei in Formaten wie MP4, AVI, usw. |
+| Verzeichnis โ | `'path/'` | `str` oder `Path` | Pfad zu einem Verzeichnis mit Bildern oder Videos. |
+| glob โ | `'path/*.jpg'` | `str` | Glob-Muster, um mehrere Dateien zu finden. Verwenden Sie das `*` Zeichen als Platzhalter. |
+| YouTube โ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL zu einem YouTube-Video. |
+| stream โ | `'rtsp://example.com/media.mp4'` | `str` | URL fรผr Streaming-Protokolle wie RTSP, RTMP, TCP oder eine IP-Adresse. |
+| Multi-Stream โ | `'list.streams'` | `str` oder `Path` | `*.streams` Textdatei mit einer Stream-URL pro Zeile, z.B. 8 Streams laufen bei Batch-Grรถรe 8. |
+
+Untenstehend finden Sie Codebeispiele fรผr die Verwendung jedes Quelltyps:
+
+!!! Example "Vorhersagequellen"
+
+ === "Bild"
+ Fรผhren Sie die Inferenz auf einer Bilddatei aus.
+ ```python
+ from ultralytics import YOLO
+
+ # Ein vortrainiertes YOLOv8n Modell laden
+ model = YOLO('yolov8n.pt')
+
+ # Pfad zur Bilddatei definieren
+ quell = 'Pfad/zum/Bild.jpg'
+
+ # Inferenz auf der Quelle ausfรผhren
+ ergebnisse = model(quell) # Liste von Results-Objekten
+ ```
+
+ === "Bildschirmaufnahme"
+ Fรผhren Sie die Inferenz auf dem aktuellen Bildschirminhalt als Screenshot aus.
+ ```python
+ from ultralytics import YOLO
+
+ # Ein vortrainiertes YOLOv8n Modell laden
+ model = YOLO('yolov8n.pt')
+
+ # Aktuellen Screenshot als Quelle definieren
+ quell = 'Bildschirm'
+
+ # Inferenz auf der Quelle ausfรผhren
+ ergebnisse = model(quell) # Liste von Results-Objekten
+ ```
+
+ === "URL"
+ Fรผhren Sie die Inferenz auf einem Bild oder Video aus, das รผber eine URL remote gehostet wird.
+ ```python
+ from ultralytics import YOLO
+
+ # Ein vortrainiertes YOLOv8n Modell laden
+ model = YOLO('yolov8n.pt')
+
+ # Remote-Bild- oder Video-URL definieren
+ quell = 'https://ultralytics.com/images/bus.jpg'
+
+ # Inferenz auf der Quelle ausfรผhren
+ ergebnisse = model(quell) # Liste von Results-Objekten
+ ```
+
+ === "PIL"
+ Fรผhren Sie die Inferenz auf einem Bild aus, das mit der Python Imaging Library (PIL) geรถffnet wurde.
+ ```python
+ from PIL import Image
+ from ultralytics import YOLO
+
+ # Ein vortrainiertes YOLOv8n Modell laden
+ model = YOLO('yolov8n.pt')
+
+ # Ein Bild mit PIL รถffnen
+ quell = Image.open('Pfad/zum/Bild.jpg')
+
+ # Inferenz auf der Quelle ausfรผhren
+ ergebnisse = model(quell) # Liste von Results-Objekten
+ ```
+
+ === "OpenCV"
+ Fรผhren Sie die Inferenz auf einem Bild aus, das mit OpenCV gelesen wurde.
+ ```python
+ import cv2
+ from ultralytics import YOLO
+
+ # Ein vortrainiertes YOLOv8n Modell laden
+ model = YOLO('yolov8n.pt')
+
+ # Ein Bild mit OpenCV lesen
+ quell = cv2.imread('Pfad/zum/Bild.jpg')
+
+ # Inferenz auf der Quelle ausfรผhren
+ ergebnisse = model(quell) # Liste von Results-Objekten
+ ```
+
+ === "numpy"
+ Fรผhren Sie die Inferenz auf einem Bild aus, das als numpy-Array dargestellt wird.
+ ```python
+ import numpy as np
+ from ultralytics import YOLO
+
+ # Ein vortrainiertes YOLOv8n Modell laden
+ model = YOLO('yolov8n.pt')
+
+ # Ein zufรคlliges numpy-Array der HWC-Form (640, 640, 3) mit Werten im Bereich [0, 255] und Typ uint8 erstellen
+ quell = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')
+
+ # Inferenz auf der Quelle ausfรผhren
+ ergebnisse = model(quell) # Liste von Results-Objekten
+ ```
+
+ === "torch"
+ Fรผhren Sie die Inferenz auf einem Bild aus, das als PyTorch-Tensor dargestellt wird.
+ ```python
+ import torch
+ from ultralytics import YOLO
+
+ # Ein vortrainiertes YOLOv8n Modell laden
+ model = YOLO('yolov8n.pt')
+
+ # Ein zufรคlliger torch-Tensor der BCHW-Form (1, 3, 640, 640) mit Werten im Bereich [0, 1] und Typ float32 erstellen
+ quell = torch.rand(1, 3, 640, 640, dtype=torch.float32)
+
+ # Inferenz auf der Quelle ausfรผhren
+ ergebnisse = model(quell) # Liste von Results-Objekten
diff --git a/ultralytics/docs/de/modes/predict.md:Zone.Identifier b/ultralytics/docs/de/modes/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/modes/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/modes/track.md b/ultralytics/docs/de/modes/track.md
new file mode 100755
index 0000000..f29dae9
--- /dev/null
+++ b/ultralytics/docs/de/modes/track.md
@@ -0,0 +1,200 @@
+---
+comments: true
+description: Erfahren Sie, wie Sie Ultralytics YOLO fรผr Objektverfolgung in Videostreams verwenden. Anleitungen zum Einsatz verschiedener Tracker und zur Anpassung von Tracker-Konfigurationen.
+keywords: Ultralytics, YOLO, Objektverfolgung, Videostreams, BoT-SORT, ByteTrack, Python-Anleitung, CLI-Anleitung
+---
+
+# Multi-Objektverfolgung mit Ultralytics YOLO
+
+
+
+Objektverfolgung im Bereich der Videoanalytik ist eine essentielle Aufgabe, die nicht nur den Standort und die Klasse von Objekten innerhalb des Frames identifiziert, sondern auch eine eindeutige ID fรผr jedes erkannte Objekt, wรคhrend das Video fortschreitet, erhรคlt. Die Anwendungsmรถglichkeiten sind grenzenlos โ von รberwachung und Sicherheit bis hin zur Echtzeitsportanalytik.
+
+## Warum Ultralytics YOLO fรผr Objektverfolgung wรคhlen?
+
+Die Ausgabe von Ultralytics Trackern ist konsistent mit der standardmรครigen Objekterkennung, bietet aber zusรคtzlich Objekt-IDs. Dies erleichtert das Verfolgen von Objekten in Videostreams und das Durchfรผhren nachfolgender Analysen. Hier sind einige Grรผnde, warum Sie Ultralytics YOLO fรผr Ihre Objektverfolgungsaufgaben in Betracht ziehen sollten:
+
+- **Effizienz:** Verarbeitung von Videostreams in Echtzeit ohne Einbuรen bei der Genauigkeit.
+- **Flexibilitรคt:** Unterstรผtzt mehrere Tracking-Algorithmen und -Konfigurationen.
+- **Benutzerfreundlichkeit:** Einfache Python-API und CLI-Optionen fรผr schnelle Integration und Bereitstellung.
+- **Anpassbarkeit:** Einfache Verwendung mit individuell trainierten YOLO-Modellen, ermรถglicht Integration in branchenspezifische Anwendungen.
+
+
+
+
+
+ Ansehen: Objekterkennung und -verfolgung mit Ultralytics YOLOv8.
+
+
+## Anwendungen in der realen Welt
+
+| Transportwesen | Einzelhandel | Aquakultur |
+|:------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------:|
+|  |  |  |
+| Fahrzeugverfolgung | Personenverfolgung | Fischverfolgung |
+
+## Eigenschaften auf einen Blick
+
+Ultralytics YOLO erweitert seine Objekterkennungsfunktionen, um eine robuste und vielseitige Objektverfolgung bereitzustellen:
+
+- **Echtzeitverfolgung:** Nahtloses Verfolgen von Objekten in Videos mit hoher Bildfrequenz.
+- **Unterstรผtzung mehrerer Tracker:** Auswahl aus einer Vielzahl etablierter Tracking-Algorithmen.
+- **Anpassbare Tracker-Konfigurationen:** Anpassen des Tracking-Algorithmus an spezifische Anforderungen durch Einstellung verschiedener Parameter.
+
+## Verfรผgbare Tracker
+
+Ultralytics YOLO unterstรผtzt die folgenden Tracking-Algorithmen. Sie kรถnnen aktiviert werden, indem Sie die entsprechende YAML-Konfigurationsdatei wie `tracker=tracker_type.yaml` รผbergeben:
+
+* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Verwenden Sie `botsort.yaml`, um diesen Tracker zu aktivieren.
+* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Verwenden Sie `bytetrack.yaml`, um diesen Tracker zu aktivieren.
+
+Der Standardtracker ist BoT-SORT.
+
+## Verfolgung
+
+Um den Tracker auf Videostreams auszufรผhren, verwenden Sie ein trainiertes Erkennungs-, Segmentierungs- oder Posierungsmodell wie YOLOv8n, YOLOv8n-seg und YOLOv8n-pose.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden Sie ein offizielles oder individuelles Modell
+ model = YOLO('yolov8n.pt') # Laden Sie ein offizielles Erkennungsmodell
+ model = YOLO('yolov8n-seg.pt') # Laden Sie ein offizielles Segmentierungsmodell
+ model = YOLO('yolov8n-pose.pt') # Laden Sie ein offizielles Posierungsmodell
+ model = YOLO('path/to/best.pt') # Laden Sie ein individuell trainiertes Modell
+
+ # Fรผhren Sie die Verfolgung mit dem Modell durch
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Verfolgung mit Standardtracker
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Verfolgung mit ByteTrack-Tracker
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Fรผhren Sie die Verfolgung mit verschiedenen Modellen รผber die Befehlszeilenschnittstelle durch
+ yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Erkennungsmodell
+ yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Segmentierungsmodell
+ yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Posierungsmodell
+ yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Individuell trainiertes Modell
+
+ # Verfolgung mit ByteTrack-Tracker
+ yolo track model=path/to/best.pt tracker="bytetrack.yaml"
+ ```
+
+Wie in der obigen Nutzung zu sehen ist, ist die Verfolgung fรผr alle Detect-, Segment- und Pose-Modelle verfรผgbar, die auf Videos oder Streaming-Quellen ausgefรผhrt werden.
+
+## Konfiguration
+
+### Tracking-Argumente
+
+Die Tracking-Konfiguration teilt Eigenschaften mit dem Predict-Modus, wie `conf`, `iou` und `show`. Fรผr weitere Konfigurationen siehe die Seite des [Predict](https://docs.ultralytics.com/modes/predict/)-Modells.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Konfigurieren Sie die Tracking-Parameter und fรผhren Sie den Tracker aus
+ model = YOLO('yolov8n.pt')
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Konfigurieren Sie die Tracking-Parameter und fรผhren Sie den Tracker รผber die Befehlszeilenschnittstelle aus
+ yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
+ ```
+
+### Tracker-Auswahl
+
+Ultralytics ermรถglicht es Ihnen auch, eine modifizierte Tracker-Konfigurationsdatei zu verwenden. Hierfรผr kopieren Sie einfach eine Tracker-Konfigurationsdatei (zum Beispiel `custom_tracker.yaml`) von [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) und รคndern jede Konfiguration (auรer dem `tracker_type`), wie es Ihren Bedรผrfnissen entspricht.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden Sie das Modell und fรผhren Sie den Tracker mit einer individuellen Konfigurationsdatei aus
+ model = YOLO('yolov8n.pt')
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Laden Sie das Modell und fรผhren Sie den Tracker mit einer individuellen Konfigurationsdatei รผber die Befehlszeilenschnittstelle aus
+ yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
+ ```
+
+Fรผr eine umfassende Liste der Tracking-Argumente siehe die Seite [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
+
+## Python-Beispiele
+
+### Persistierende Tracks-Schleife
+
+Hier ist ein Python-Skript, das OpenCV (`cv2`) und YOLOv8 verwendet, um Objektverfolgung in Videoframes durchzufรผhren. Dieses Skript setzt voraus, dass Sie die notwendigen Pakete (`opencv-python` und `ultralytics`) bereits installiert haben. Das Argument `persist=True` teilt dem Tracker mit, dass das aktuelle Bild oder Frame das nรคchste in einer Sequenz ist und Tracks aus dem vorherigen Bild im aktuellen Bild erwartet werden.
+
+!!! Example "Streaming-For-Schleife mit Tracking"
+
+ ```python
+ import cv2
+ from ultralytics import YOLO
+
+ # Laden Sie das YOLOv8-Modell
+ model = YOLO('yolov8n.pt')
+
+ # รffnen Sie die Videodatei
+ video_path = "path/to/video.mp4"
+ cap = cv2.VideoCapture(video_path)
+
+ # Schleife durch die Videoframes
+ while cap.isOpened():
+ # Einen Frame aus dem Video lesen
+ success, frame = cap.read()
+
+ if success:
+ # Fรผhren Sie YOLOv8-Tracking im Frame aus, wobei Tracks zwischen Frames beibehalten werden
+ results = model.track(frame, persist=True)
+
+ # Visualisieren Sie die Ergebnisse im Frame
+ annotated_frame = results[0].plot()
+
+ # Zeigen Sie den kommentierten Frame an
+ cv2.imshow("YOLOv8-Tracking", annotated_frame)
+
+ # Beenden Sie die Schleife, wenn 'q' gedrรผckt wird
+ if cv2.waitKey(1) & 0xFF == ord("q"):
+ break
+ else:
+ # Beenden Sie die Schleife, wenn das Ende des Videos erreicht ist
+ break
+
+ # Geben Sie das Videoaufnahmeobjekt frei und schlieรen Sie das Anzeigefenster
+ cap.release()
+ cv2.destroyAllWindows()
+ ```
+
+Bitte beachten Sie die รnderung von `model(frame)` zu `model.track(frame)`, welche die Objektverfolgung anstelle der einfachen Erkennung aktiviert. Dieses modifizierte Skript fรผhrt den Tracker auf jedem Frame des Videos aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drรผcken von 'q' beendet werden.
+
+## Neue Tracker beisteuern
+
+Sind Sie versiert in der Multi-Objektverfolgung und haben erfolgreich einen Tracking-Algorithmus mit Ultralytics YOLO implementiert oder angepasst? Wir laden Sie ein, zu unserem Trackers-Bereich in [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) beizutragen! Ihre realen Anwendungen und Lรถsungen kรถnnten fรผr Benutzer, die an Tracking-Aufgaben arbeiten, von unschรคtzbarem Wert sein.
+
+Indem Sie zu diesem Bereich beitragen, helfen Sie, das Spektrum verfรผgbarer Tracking-Lรถsungen innerhalb des Ultralytics YOLO-Frameworks zu erweitern und fรผgen eine weitere Funktionsschicht fรผr die Gemeinschaft hinzu.
+
+Um Ihren Beitrag einzuleiten, sehen Sie bitte in unserem [Contributing Guide](https://docs.ultralytics.com/help/contributing) fรผr umfassende Anweisungen zur Einreichung eines Pull Requests (PR) ๐ ๏ธ. Wir sind gespannt darauf, was Sie beitragen!
+
+Gemeinsam verbessern wir die Tracking-Fรคhigkeiten des Ultralytics YOLO-รkosystems ๐!
diff --git a/ultralytics/docs/de/modes/track.md:Zone.Identifier b/ultralytics/docs/de/modes/track.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/modes/track.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/modes/train.md b/ultralytics/docs/de/modes/train.md
new file mode 100755
index 0000000..b7ee65e
--- /dev/null
+++ b/ultralytics/docs/de/modes/train.md
@@ -0,0 +1,206 @@
+---
+comments: true
+description: Schritt-fรผr-Schritt-Leitfaden zum Trainieren von YOLOv8-Modellen mit Ultralytics YOLO, einschlieรlich Beispielen fรผr Single-GPU- und Multi-GPU-Training
+keywords: Ultralytics, YOLOv8, YOLO, Objekterkennung, Trainingsmodus, benutzerdefinierter Datensatz, GPU-Training, Multi-GPU, Hyperparameter, CLI-Beispiele, Python-Beispiele
+---
+
+# Modelltraining mit Ultralytics YOLO
+
+
+
+## Einleitung
+
+Das Training eines Deep-Learning-Modells beinhaltet das Einspeisen von Daten und die Anpassung seiner Parameter, so dass es genaue Vorhersagen treffen kann. Der Trainingsmodus in Ultralytics YOLOv8 ist fรผr das effektive und effiziente Training von Objekterkennungsmodellen konzipiert und nutzt dabei die Fรคhigkeiten moderner Hardware voll aus. Dieser Leitfaden zielt darauf ab, alle Details zu vermitteln, die Sie benรถtigen, um mit dem Training Ihrer eigenen Modelle unter Verwendung des robusten Funktionssatzes von YOLOv8 zu beginnen.
+
+
+
+
+
+ Video anschauen: Wie man ein YOLOv8-Modell auf Ihrem benutzerdefinierten Datensatz in Google Colab trainiert.
+
+
+## Warum Ultralytics YOLO fรผr das Training wรคhlen?
+
+Hier einige รผberzeugende Grรผnde, sich fรผr den Trainingsmodus von YOLOv8 zu entscheiden:
+
+- **Effizienz:** Machen Sie das Beste aus Ihrer Hardware, egal ob Sie auf einem Single-GPU-Setup sind oder รผber mehrere GPUs skalieren.
+- **Vielseitigkeit:** Training auf benutzerdefinierten Datensรคtzen zusรคtzlich zu den bereits verfรผgbaren Datensรคtzen wie COCO, VOC und ImageNet.
+- **Benutzerfreundlich:** Einfache, aber leistungsstarke CLI- und Python-Schnittstellen fรผr ein unkompliziertes Trainingserlebnis.
+- **Flexibilitรคt der Hyperparameter:** Eine breite Palette von anpassbaren Hyperparametern, um die Modellleistung zu optimieren.
+
+### Schlรผsselfunktionen des Trainingsmodus
+
+Die folgenden sind einige bemerkenswerte Funktionen von YOLOv8s Trainingsmodus:
+
+- **Automatischer Datensatz-Download:** Standarddatensรคtze wie COCO, VOC und ImageNet werden bei der ersten Verwendung automatisch heruntergeladen.
+- **Multi-GPU-Unterstรผtzung:** Skalieren Sie Ihr Training nahtlos รผber mehrere GPUs, um den Prozess zu beschleunigen.
+- **Konfiguration der Hyperparameter:** Die Mรถglichkeit zur Modifikation der Hyperparameter รผber YAML-Konfigurationsdateien oder CLI-Argumente.
+- **Visualisierung und รberwachung:** Echtzeit-Tracking von Trainingsmetriken und Visualisierung des Lernprozesses fรผr bessere Einsichten.
+
+!!! Tip "Tipp"
+
+ * YOLOv8-Datensรคtze wie COCO, VOC, ImageNet und viele andere werden automatisch bei der ersten Verwendung heruntergeladen, d.h. `yolo train data=coco.yaml`
+
+## Nutzungsbeispiele
+
+Trainieren Sie YOLOv8n auf dem COCO128-Datensatz fรผr 100 Epochen bei einer Bildgrรถรe von 640. Das Trainingsgerรคt kann mit dem Argument `device` spezifiziert werden. Wenn kein Argument รผbergeben wird, wird GPU `device=0` verwendet, wenn verfรผgbar, sonst wird `device=cpu` verwendet. Siehe den Abschnitt Argumente unten fรผr eine vollstรคndige Liste der Trainingsargumente.
+
+!!! Example "Beispiel fรผr Single-GPU- und CPU-Training"
+
+ Das Gerรคt wird automatisch ermittelt. Wenn eine GPU verfรผgbar ist, dann wird diese verwendet, sonst beginnt das Training auf der CPU.
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden Sie ein Modell
+ model = YOLO('yolov8n.yaml') # bauen Sie ein neues Modell aus YAML
+ model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen fรผr das Training)
+ model = YOLO('yolov8n.yaml').load('yolov8n.pt') # bauen Sie aus YAML und รผbertragen Sie Gewichte
+
+ # Trainieren Sie das Modell
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Bauen Sie ein neues Modell aus YAML und beginnen Sie das Training von Grund auf
+ yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
+
+ # Beginnen Sie das Training von einem vortrainierten *.pt Modell
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
+
+ # Bauen Sie ein neues Modell aus YAML, รผbertragen Sie vortrainierte Gewichte darauf und beginnen Sie das Training
+ yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+### Multi-GPU-Training
+
+Multi-GPU-Training ermรถglicht eine effizientere Nutzung von verfรผgbaren Hardware-Ressourcen, indem die Trainingslast รผber mehrere GPUs verteilt wird. Diese Funktion ist รผber sowohl die Python-API als auch die Befehlszeilenschnittstelle verfรผgbar. Um das Multi-GPU-Training zu aktivieren, geben Sie die GPU-Gerรคte-IDs an, die Sie verwenden mรถchten.
+
+!!! Example "Beispiel fรผr Multi-GPU-Training"
+
+ Um mit 2 GPUs zu trainieren, verwenden Sie die folgenden Befehle fรผr CUDA-Gerรคte 0 und 1. Erweitern Sie dies bei Bedarf auf zusรคtzliche GPUs.
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden Sie ein Modell
+ model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen fรผr das Training)
+
+ # Trainieren Sie das Modell mit 2 GPUs
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Beginnen Sie das Training von einem vortrainierten *.pt Modell unter Verwendung der GPUs 0 und 1
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
+ ```
+
+### Apple M1- und M2-MPS-Training
+
+Mit der Unterstรผtzung fรผr Apple M1- und M2-Chips, die in den Ultralytics YOLO-Modellen integriert ist, ist es jetzt mรถglich, Ihre Modelle auf Gerรคten zu trainieren, die das leistungsstarke Metal Performance Shaders (MPS)-Framework nutzen. MPS bietet eine leistungsstarke Methode zur Ausfรผhrung von Berechnungs- und Bildverarbeitungsaufgaben auf Apples benutzerdefinierten Siliziumchips.
+
+Um das Training auf Apple M1- und M2-Chips zu ermรถglichen, sollten Sie 'mps' als Ihr Gerรคt angeben, wenn Sie den Trainingsprozess starten. Unten ist ein Beispiel, wie Sie dies in Python und รผber die Befehlszeile tun kรถnnten:
+
+!!! Example "MPS-Training Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Laden Sie ein Modell
+ model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen fรผr das Training)
+
+ # Trainieren Sie das Modell mit 2 GPUs
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Beginnen Sie das Training von einem vortrainierten *.pt Modell unter Verwendung der GPUs 0 und 1
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
+ ```
+
+Indem sie die Rechenleistung der M1/M2-Chips nutzen, ermรถglicht dies eine effizientere Verarbeitung der Trainingsaufgaben. Fรผr detailliertere Anleitungen und fortgeschrittene Konfigurationsoptionen beziehen Sie sich bitte auf die [PyTorch MPS-Dokumentation](https://pytorch.org/docs/stable/notes/mps.html).
+
+## Protokollierung
+
+Beim Training eines YOLOv8-Modells kann es wertvoll sein, die Leistung des Modells im Laufe der Zeit zu verfolgen. Hier kommt die Protokollierung ins Spiel. Ultralytics' YOLO unterstรผtzt drei Typen von Loggern - Comet, ClearML und TensorBoard.
+
+Um einen Logger zu verwenden, wรคhlen Sie ihn aus dem Dropdown-Menรผ im obigen Codeausschnitt aus und fรผhren ihn aus. Der ausgewรคhlte Logger wird installiert und initialisiert.
+
+### Comet
+
+[Comet](https://www.comet.ml/site/) ist eine Plattform, die Datenwissenschaftlern und Entwicklern erlaubt, Experimente und Modelle zu verfolgen, zu vergleichen, zu erklรคren und zu optimieren. Es bietet Funktionen wie Echtzeitmetriken, Code-Diffs und das Verfolgen von Hyperparametern.
+
+Um Comet zu verwenden:
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ # pip installieren comet_ml
+ import comet_ml
+
+ comet_ml.init()
+ ```
+
+Vergessen Sie nicht, sich auf der Comet-Website anzumelden und Ihren API-Schlรผssel zu erhalten. Sie mรผssen diesen zu Ihren Umgebungsvariablen oder Ihrem Skript hinzufรผgen, um Ihre Experimente zu protokollieren.
+
+### ClearML
+
+[ClearML](https://www.clear.ml/) ist eine Open-Source-Plattform, die das Verfolgen von Experimenten automatisiert und hilft, Ressourcen effizient zu teilen. Sie ist darauf ausgelegt, Teams bei der Verwaltung, Ausfรผhrung und Reproduktion ihrer ML-Arbeiten effizienter zu unterstรผtzen.
+
+Um ClearML zu verwenden:
+
+!!! Example "Beispiel"
+
+ === "Python"
+ ```python
+ # pip installieren clearml
+ import clearml
+
+ clearml.browser_login()
+ ```
+
+Nach dem Ausfรผhren dieses Skripts mรผssen Sie sich auf dem Browser bei Ihrem ClearML-Konto anmelden und Ihre Sitzung authentifizieren.
+
+### TensorBoard
+
+[TensorBoard](https://www.tensorflow.org/tensorboard) ist ein Visualisierungstoolset fรผr TensorFlow. Es ermรถglicht Ihnen, Ihren TensorFlow-Graphen zu visualisieren, quantitative Metriken รผber die Ausfรผhrung Ihres Graphen zu plotten und zusรคtzliche Daten wie Bilder zu zeigen, die durch ihn hindurchgehen.
+
+Um TensorBoard in [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb) zu verwenden:
+
+!!! Example "Beispiel"
+
+ === "CLI"
+ ```bash
+ load_ext tensorboard
+ tensorboard --logdir ultralytics/runs # ersetzen Sie mit Ihrem 'runs' Verzeichnis
+ ```
+
+Um TensorBoard lokal auszufรผhren, fรผhren Sie den folgenden Befehl aus und betrachten Sie die Ergebnisse unter http://localhost:6006/.
+
+!!! Example "Beispiel"
+
+ === "CLI"
+ ```bash
+ tensorboard --logdir ultralytics/runs # ersetzen Sie mit Ihrem 'runs' Verzeichnis
+ ```
+
+Dies lรคdt TensorBoard und weist es an, das Verzeichnis zu verwenden, in dem Ihre Trainingsprotokolle gespeichert sind.
+
+Nachdem Sie Ihren Logger eingerichtet haben, kรถnnen Sie mit Ihrem Modelltraining fortfahren. Alle Trainingsmetriken werden automatisch in Ihrer gewรคhlten Plattform protokolliert, und Sie kรถnnen auf diese Protokolle zugreifen, um die Leistung Ihres Modells im Laufe der Zeit zu รผberwachen, verschiedene Modelle zu vergleichen und Bereiche fรผr Verbesserungen zu identifizieren.
diff --git a/ultralytics/docs/de/modes/train.md:Zone.Identifier b/ultralytics/docs/de/modes/train.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/modes/train.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/modes/val.md b/ultralytics/docs/de/modes/val.md
new file mode 100755
index 0000000..3f0c188
--- /dev/null
+++ b/ultralytics/docs/de/modes/val.md
@@ -0,0 +1,86 @@
+---
+comments: true
+description: Anleitung zur Validierung von YOLOv8-Modellen. Erfahren Sie, wie Sie die Leistung Ihrer YOLO-Modelle mit Validierungseinstellungen und Metriken in Python und CLI-Beispielen bewerten kรถnnen.
+keywords: Ultralytics, YOLO-Dokumente, YOLOv8, Validierung, Modellbewertung, Hyperparameter, Genauigkeit, Metriken, Python, CLI
+---
+
+# Modellvalidierung mit Ultralytics YOLO
+
+
+
+## Einfรผhrung
+
+Die Validierung ist ein kritischer Schritt im Machine-Learning-Prozess, der es Ihnen ermรถglicht, die Qualitรคt Ihrer trainierten Modelle zu bewerten. Der Val-Modus in Ultralytics YOLOv8 bietet eine robuste Suite von Tools und Metriken zur Bewertung der Leistung Ihrer Objekterkennungsmodelle. Dieser Leitfaden dient als umfassende Ressource, um zu verstehen, wie Sie den Val-Modus effektiv nutzen kรถnnen, um sicherzustellen, dass Ihre Modelle sowohl genau als auch zuverlรคssig sind.
+
+## Warum mit Ultralytics YOLO validieren?
+
+Hier sind die Vorteile der Verwendung des Val-Modus von YOLOv8:
+
+- **Prรคzision:** Erhalten Sie genaue Metriken wie mAP50, mAP75 und mAP50-95, um Ihr Modell umfassend zu bewerten.
+- **Bequemlichkeit:** Nutzen Sie integrierte Funktionen, die Trainingseinstellungen speichern und so den Validierungsprozess vereinfachen.
+- **Flexibilitรคt:** Validieren Sie Ihr Modell mit den gleichen oder verschiedenen Datensรคtzen und Bildgrรถรen.
+- **Hyperparameter-Tuning:** Verwenden Sie Validierungsmetriken, um Ihr Modell fรผr eine bessere Leistung zu optimieren.
+
+### Schlรผsselfunktionen des Val-Modus
+
+Dies sind die bemerkenswerten Funktionen, die der Val-Modus von YOLOv8 bietet:
+
+- **Automatisierte Einstellungen:** Modelle erinnern sich an ihre Trainingskonfigurationen fรผr eine unkomplizierte Validierung.
+- **Unterstรผtzung mehrerer Metriken:** Bewerten Sie Ihr Modell anhand einer Reihe von Genauigkeitsmetriken.
+- **CLI- und Python-API:** Wรคhlen Sie zwischen Befehlszeilenschnittstelle oder Python-API basierend auf Ihrer Prรคferenz fรผr die Validierung.
+- **Datenkompatibilitรคt:** Funktioniert nahtlos mit Datensรคtzen, die wรคhrend der Trainingsphase sowie mit benutzerdefinierten Datensรคtzen verwendet wurden.
+
+!!! Tip "Tipp"
+
+ * YOLOv8-Modelle speichern automatisch ihre Trainingseinstellungen, sodass Sie ein Modell mit der gleichen Bildgrรถรe und dem ursprรผnglichen Datensatz leicht validieren kรถnnen, indem Sie einfach `yolo val model=yolov8n.pt` oder `model('yolov8n.pt').val()` ausfรผhren
+
+## Beispielverwendung
+
+Validieren Sie die Genauigkeit des trainierten YOLOv8n-Modells auf dem COCO128-Datensatz. Es muss kein Argument รผbergeben werden, da das `model` seine Trainings-`data` und Argumente als Modellattribute speichert. Siehe Abschnitt โArgumenteโ unten fรผr eine vollstรคndige Liste der Exportargumente.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n.pt') # ein offizielles Modell laden
+ model = YOLO('path/to/best.pt') # ein benutzerdefiniertes Modell laden
+
+ # Modell validieren
+ metrics = model.val() # keine Argumente benรถtigt, Datensatz und Einstellungen gespeichert
+ metrics.box.map # map50-95
+ metrics.box.map50 # map50
+ metrics.box.map75 # map75
+ metrics.box.maps # eine Liste enthรคlt map50-95 jeder Kategorie
+ ```
+ === "CLI"
+
+ ```bash
+ yolo detect val model=yolov8n.pt # offizielles Modell validieren
+ yolo detect val model=path/to/best.pt # benutzerdefiniertes Modell validieren
+ ```
+
+## Argumente
+
+Validierungseinstellungen fรผr YOLO-Modelle beziehen sich auf verschiedene Hyperparameter und Konfigurationen, die verwendet werden, um die Leistung des Modells an einem Validierungsdatensatz zu bewerten. Diese Einstellungen kรถnnen die Leistung, Geschwindigkeit und Genauigkeit des Modells beeinflussen. Einige gรคngige YOLO-Validierungseinstellungen umfassen die Batch-Grรถรe, die Hรคufigkeit der Validierung wรคhrend des Trainings und die Metriken zur Bewertung der Modellleistung. Andere Faktoren, die den Validierungsprozess beeinflussen kรถnnen, sind die Grรถรe und Zusammensetzung des Validierungsdatensatzes und die spezifische Aufgabe, fรผr die das Modell verwendet wird. Es ist wichtig, diese Einstellungen sorgfรคltig abzustimmen und zu experimentieren, um sicherzustellen, dass das Modell auf dem Validierungsdatensatz gut funktioniert sowie รberanpassung zu erkennen und zu verhindern.
+
+| Key | Value | Beschreibung |
+|---------------|---------|---------------------------------------------------------------------------------|
+| `data` | `None` | Pfad zur Datendatei, z.B. coco128.yaml |
+| `imgsz` | `640` | Grรถรe der Eingabebilder als ganzzahlige Zahl |
+| `batch` | `16` | Anzahl der Bilder pro Batch (-1 fรผr AutoBatch) |
+| `save_json` | `False` | Ergebnisse in JSON-Datei speichern |
+| `save_hybrid` | `False` | hybride Version der Labels speichern (Labels + zusรคtzliche Vorhersagen) |
+| `conf` | `0.001` | Objekterkennungsschwelle fรผr Zuversichtlichkeit |
+| `iou` | `0.6` | Schwellenwert fรผr IoU (Intersection over Union) fรผr NMS |
+| `max_det` | `300` | maximale Anzahl an Vorhersagen pro Bild |
+| `half` | `True` | Halbprรคzision verwenden (FP16) |
+| `device` | `None` | Gerรคt zur Ausfรผhrung, z.B. CUDA device=0/1/2/3 oder device=cpu |
+| `dnn` | `False` | OpenCV DNN fรผr ONNX-Inf erenz nutzen |
+| `plots` | `False` | Diagramme wรคhrend des Trainings anzeigen |
+| `rect` | `False` | rechteckige Validierung mit jeder Batch-Charge fรผr minimale Polsterung |
+| `split` | `val` | Zu verwendende Daten-Teilmenge fรผr Validierung, z.B. 'val', 'test' oder 'train' |
+|
diff --git a/ultralytics/docs/de/modes/val.md:Zone.Identifier b/ultralytics/docs/de/modes/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/modes/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/quickstart.md b/ultralytics/docs/de/quickstart.md
new file mode 100755
index 0000000..1bfbaf7
--- /dev/null
+++ b/ultralytics/docs/de/quickstart.md
@@ -0,0 +1,198 @@
+---
+comments: true
+description: Entdecken Sie verschiedene Methoden zur Installation von Ultralytics mit Pip, Conda, Git und Docker. Erfahren Sie, wie Sie Ultralytics รผber die Befehlszeilenschnittstelle oder innerhalb Ihrer Python-Projekte verwenden kรถnnen.
+keywords: Ultralytics-Installation, pip installieren Ultralytics, Docker installieren Ultralytics, Ultralytics-Befehlszeilenschnittstelle, Ultralytics Python-Schnittstelle
+---
+
+## Ultralytics installieren
+
+Ultralytics bietet verschiedene Installationsmethoden, darunter Pip, Conda und Docker. Installiere YOLOv8 รผber das `ultralytics` Pip-Paket fรผr die neueste stabile Verรถffentlichung oder indem du das [Ultralytics GitHub-Repository](https://github.com/ultralytics/ultralytics) klonst fรผr die aktuellste Version. Docker kann verwendet werden, um das Paket in einem isolierten Container auszufรผhren, ohne eine lokale Installation vornehmen zu mรผssen.
+
+!!! Example "Installieren"
+
+ === "Pip-Installation (empfohlen)"
+ Installieren Sie das `ultralytics` Paket mit Pip oder aktualisieren Sie eine bestehende Installation, indem Sie `pip install -U ultralytics` ausfรผhren. Besuchen Sie den Python Package Index (PyPI) fรผr weitere Details zum `ultralytics` Paket: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
+
+ [](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics)
+
+ ```bash
+ # Installiere das ultralytics Paket von PyPI
+ pip install ultralytics
+ ```
+
+ Sie kรถnnen auch das `ultralytics` Paket direkt vom GitHub [Repository](https://github.com/ultralytics/ultralytics) installieren. Dies kรถnnte nรผtzlich sein, wenn Sie die neueste Entwicklerversion mรถchten. Stellen Sie sicher, dass das Git-Kommandozeilen-Tool auf Ihrem System installiert ist. Der Befehl `@main` installiert den `main` Branch und kann zu einem anderen Branch geรคndert werden, z. B. `@my-branch`, oder ganz entfernt werden, um auf den `main` Branch standardmรครig zurรผckzugreifen.
+
+ ```bash
+ # Installiere das ultralytics Paket von GitHub
+ pip install git+https://github.com/ultralytics/ultralytics.git@main
+ ```
+
+
+ === "Conda-Installation"
+ Conda ist ein alternativer Paketmanager zu Pip, der ebenfalls fรผr die Installation verwendet werden kann. Besuche Anaconda fรผr weitere Details unter [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Ultralytics Feedstock Repository fรผr die Aktualisierung des Conda-Pakets befindet sich unter [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
+
+
+ [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics)
+
+ ```bash
+ # Installiere das ultralytics Paket mit Conda
+ conda install -c conda-forge ultralytics
+ ```
+
+ !!! Note "Hinweis"
+
+ Wenn Sie in einer CUDA-Umgebung installieren, ist es am besten, `ultralytics`, `pytorch` und `pytorch-cuda` im selben Befehl zu installieren, um dem Conda-Paketmanager zu ermรถglichen, Konflikte zu lรถsen, oder `pytorch-cuda` als letztes zu installieren, damit es das CPU-spezifische `pytorch` Paket bei Bedarf รผberschreiben kann.
+ ```bash
+ # Installiere alle Pakete zusammen mit Conda
+ conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
+ ```
+
+ ### Conda Docker-Image
+
+ Ultralytics Conda Docker-Images sind ebenfalls von [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics) verfรผgbar. Diese Bilder basieren auf [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) und bieten eine einfache Mรถglichkeit, `ultralytics` in einer Conda-Umgebung zu nutzen.
+
+ ```bash
+ # Setze Image-Name als Variable
+ t=ultralytics/ultralytics:latest-conda
+
+ # Ziehe das neuste ultralytics Image von Docker Hub
+ sudo docker pull $t
+
+ # Fรผhre das ultralytics Image in einem Container mit GPU-Unterstรผtzung aus
+ sudo docker run -it --ipc=host --gpus all $t # alle GPUs
+ sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # spezifische GPUs angeben
+ ```
+
+ === "Git klonen"
+ Klonen Sie das `ultralytics` Repository, wenn Sie einen Beitrag zur Entwicklung leisten mรถchten oder mit dem neuesten Quellcode experimentieren wollen. Nach dem Klonen navigieren Sie in das Verzeichnis und installieren das Paket im editierbaren Modus `-e` mit Pip.
+ ```bash
+ # Klonen Sie das ultralytics Repository
+ git clone https://github.com/ultralytics/ultralytics
+
+ # Navigiere zum geklonten Verzeichnis
+ cd ultralytics
+
+ # Installiere das Paket im editierbaren Modus fรผr die Entwicklung
+ pip install -e .
+ ```
+
+Siehe die `ultralytics` [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) Datei fรผr eine Liste der Abhรคngigkeiten. Beachten Sie, dass alle oben genannten Beispiele alle erforderlichen Abhรคngigkeiten installieren.
+
+
+
+!!! Tip "Tipp"
+
+ PyTorch-Anforderungen variieren je nach Betriebssystem und CUDA-Anforderungen, daher wird empfohlen, PyTorch zuerst gemรคร den Anweisungen unter [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally) zu installieren.
+
+
+
+
+
+## Ultralytics mit CLI verwenden
+
+Die Befehlszeilenschnittstelle (CLI) von Ultralytics ermรถglicht einfache Einzeilige Befehle ohne die Notwendigkeit einer Python-Umgebung. CLI erfordert keine Anpassung oder Python-Code. Sie kรถnnen alle Aufgaben einfach vom Terminal aus mit dem `yolo` Befehl ausfรผhren. Schauen Sie sich den [CLI-Leitfaden](/../usage/cli.md) an, um mehr รผber die Verwendung von YOLOv8 รผber die Befehlszeile zu erfahren.
+
+!!! Example "Beispiel"
+
+ === "Syntax"
+
+ Ultralytics `yolo` Befehle verwenden die folgende Syntax:
+ ```bash
+ yolo TASK MODE ARGS
+
+ Wo TASK (optional) einer von [detect, segment, classify] ist
+ MODE (erforderlich) einer von [train, val, predict, export, track] ist
+ ARGS (optional) eine beliebige Anzahl von benutzerdefinierten 'arg=value' Paaren wie 'imgsz=320', die Vorgaben รผberschreiben.
+ ```
+ Sehen Sie alle ARGS im vollstรคndigen [Konfigurationsleitfaden](/../usage/cfg.md) oder mit `yolo cfg`
+
+ === "Trainieren"
+
+ Trainieren Sie ein Erkennungsmodell fรผr 10 Epochen mit einer Anfangslernerate von 0.01
+ ```bash
+ yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+ ```
+
+ === "Vorhersagen"
+
+ Vorhersagen eines YouTube-Videos mit einem vortrainierten Segmentierungsmodell bei einer Bildgrรถรe von 320:
+ ```bash
+ yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+ ```
+
+ === "Val"
+
+ Val ein vortrainiertes Erkennungsmodell bei Batch-Grรถรe 1 und Bildgrรถรe 640:
+ ```bash
+ yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+ ```
+
+ === "Exportieren"
+
+ Exportieren Sie ein YOLOv8n-Klassifikationsmodell im ONNX-Format bei einer Bildgrรถรe von 224 mal 128 (kein TASK erforderlich)
+ ```bash
+ yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+ ```
+
+ === "Speziell"
+
+ Fรผhren Sie spezielle Befehle aus, um Version, Einstellungen zu sehen, Checks auszufรผhren und mehr:
+ ```bash
+ yolo help
+ yolo checks
+ yolo version
+ yolo settings
+ yolo copy-cfg
+ yolo cfg
+ ```
+
+!!! Warning "Warnung"
+
+ Argumente mรผssen als `arg=val` Paare รผbergeben werden, getrennt durch ein Gleichheitszeichen `=` und durch Leerzeichen ` ` zwischen den Paaren. Verwenden Sie keine `--` Argumentprรคfixe oder Kommata `,` zwischen den Argumenten.
+
+ - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` โ
+ - `yolo predict model yolov8n.pt imgsz 640 conf 0.25` โ
+ - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` โ
+
+[CLI-Leitfaden](/../usage/cli.md){ .md-button }
+
+## Ultralytics mit Python verwenden
+
+Die Python-Schnittstelle von YOLOv8 ermรถglicht eine nahtlose Integration in Ihre Python-Projekte und erleichtert das Laden, Ausfรผhren und Verarbeiten der Modellausgabe. Konzipiert fรผr Einfachheit und Benutzerfreundlichkeit, ermรถglicht die Python-Schnittstelle Benutzern, Objekterkennung, Segmentierung und Klassifizierung schnell in ihren Projekten zu implementieren. Dies macht die Python-Schnittstelle von YOLOv8 zu einem unschรคtzbaren Werkzeug fรผr jeden, der diese Funktionalitรคten in seine Python-Projekte integrieren mรถchte.
+
+Benutzer kรถnnen beispielsweise ein Modell laden, es trainieren, seine Leistung an einem Validierungsset auswerten und sogar in das ONNX-Format exportieren, und das alles mit nur wenigen Codezeilen. Schauen Sie sich den [Python-Leitfaden](/../usage/python.md) an, um mehr รผber die Verwendung von YOLOv8 in Ihren_python_pro_jek_ten zu erfahren.
+
+!!! Example "Beispiel"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Erstellen Sie ein neues YOLO Modell von Grund auf
+ model = YOLO('yolov8n.yaml')
+
+ # Laden Sie ein vortrainiertes YOLO Modell (empfohlen fรผr das Training)
+ model = YOLO('yolov8n.pt')
+
+ # Trainieren Sie das Modell mit dem Datensatz 'coco128.yaml' fรผr 3 Epochen
+ results = model.train(data='coco128.yaml', epochs=3)
+
+ # Bewerten Sie die Leistung des Modells am Validierungssatz
+ results = model.val()
+
+ # Fรผhren Sie eine Objekterkennung an einem Bild mit dem Modell durch
+ results = model('https://ultralytics.com/images/bus.jpg')
+
+ # Exportieren Sie das Modell ins ONNX-Format
+ success = model.export(format='onnx')
+ ```
+
+[Python-Leitfaden](/../usage/python.md){.md-button .md-button--primary}
diff --git a/ultralytics/docs/de/quickstart.md:Zone.Identifier b/ultralytics/docs/de/quickstart.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/quickstart.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/tasks/classify.md b/ultralytics/docs/de/tasks/classify.md
new file mode 100755
index 0000000..09622a0
--- /dev/null
+++ b/ultralytics/docs/de/tasks/classify.md
@@ -0,0 +1,172 @@
+---
+comments: true
+description: Erfahren Sie mehr รผber YOLOv8 Classify-Modelle zur Bildklassifizierung. Erhalten Sie detaillierte Informationen รผber die Liste vortrainierter Modelle und wie man Modelle trainiert, validiert, vorhersagt und exportiert.
+keywords: Ultralytics, YOLOv8, Bildklassifizierung, Vortrainierte Modelle, YOLOv8n-cls, Training, Validierung, Vorhersage, Modellexport
+---
+
+# Bildklassifizierung
+
+
+
+Bildklassifizierung ist die einfachste der drei Aufgaben und besteht darin, ein ganzes Bild in eine von einem Satz vordefinierter Klassen zu klassifizieren.
+
+Die Ausgabe eines Bildklassifizierers ist ein einzelnes Klassenlabel und eine Vertrauenspunktzahl. Bildklassifizierung ist nรผtzlich, wenn Sie nur wissen mรผssen, zu welcher Klasse ein Bild gehรถrt, und nicht wissen mรผssen, wo sich Objekte dieser Klasse befinden oder wie ihre genaue Form ist.
+
+!!! Tip "Tipp"
+
+ YOLOv8 Classify-Modelle verwenden den Suffix `-cls`, z.B. `yolov8n-cls.pt` und sind auf [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) vortrainiert.
+
+## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+Hier werden vortrainierte YOLOv8 Classify-Modelle gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, wรคhrend Classify-Modelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind.
+
+[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch vom neuesten Ultralytics-[Release](https://github.com/ultralytics/assets/releases) beim ersten Gebrauch heruntergeladen.
+
+| Modell | Grรถรe (Pixel) | Genauigkeit top1 | Genauigkeit top5 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) bei 640 |
+|----------------------------------------------------------------------------------------------|-----------------------|--------------------------|--------------------------|------------------------------------------|-----------------------------------------------|-----------------------|---------------------------|
+| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
+| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
+| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
+| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
+| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
+
+- **Genauigkeit**-Werte sind Modellgenauigkeiten auf dem [ImageNet](https://www.image-net.org/)-Datensatz Validierungsset.
+ Zur Reproduktion `yolo val classify data=pfad/zu/ImageNet device=0 verwenden`
+- **Geschwindigkeit** Durchschnitt รผber ImageNet-Validierungsbilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/de/ec2/instance-types/p4/)-Instanz.
+ Zur Reproduktion `yolo val classify data=pfad/zu/ImageNet batch=1 device=0|cpu verwenden`
+
+## Trainieren
+
+Trainieren Sie das YOLOv8n-cls-Modell auf dem MNIST160-Datensatz fรผr 100 Epochen bei Bildgrรถรe 64. Eine vollstรคndige Liste der verfรผgbaren Argumente finden Sie auf der Seite [Konfiguration](/../usage/cfg.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Ein Modell laden
+ model = YOLO('yolov8n-cls.yaml') # ein neues Modell aus YAML erstellen
+ model = YOLO('yolov8n-cls.pt') # ein vortrainiertes Modell laden (empfohlen fรผr das Training)
+ model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # aus YAML erstellen und Gewichte รผbertragen
+
+ # Das Modell trainieren
+ results = model.train(data='mnist160', epochs=100, imgsz=64)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Ein neues Modell aus YAML erstellen und das Training von Grund auf starten
+ yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
+
+ # Das Training von einem vortrainierten *.pt Modell starten
+ yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
+
+ # Ein neues Modell aus YAML erstellen, vortrainierte Gewichte รผbertragen und das Training starten
+ yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
+ ```
+
+### Datenformat
+
+Das Datenformat fรผr YOLO-Klassifizierungsdatensรคtze finden Sie im Detail im [Datenleitfaden](../../../datasets/classify/index.md).
+
+## Validieren
+
+Validieren Sie die Genauigkeit des trainierten YOLOv8n-cls-Modells auf dem MNIST160-Datensatz. Kein Argument muss รผbergeben werden, da das `modell` seine Trainings`daten` und Argumente als Modellattribute behรคlt.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Ein Modell laden
+ model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
+
+ # Das Modell validieren
+ metrics = model.val() # keine Argumente benรถtigt, Datensatz und Einstellungen gespeichert
+ metrics.top1 # top1 Genauigkeit
+ metrics.top5 # top5 Genauigkeit
+ ```
+ === "CLI"
+
+ ```bash
+ yolo classify val model=yolov8n-cls.pt # ein offizielles Modell validieren
+ yolo classify val model=pfad/zu/best.pt # ein benutzerdefiniertes Modell validieren
+ ```
+
+## Vorhersagen
+
+Verwenden Sie ein trainiertes YOLOv8n-cls-Modell, um Vorhersagen auf Bildern durchzufรผhren.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Ein Modell laden
+ model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
+
+ # Mit dem Modell vorhersagen
+ results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild
+ ```
+ === "CLI"
+
+ ```bash
+ yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # mit offiziellem Modell vorhersagen
+ yolo classify predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # mit benutzerdefiniertem Modell vorhersagen
+ ```
+
+Vollstรคndige Details zum `predict`-Modus finden Sie auf der Seite [Vorhersage](https://docs.ultralytics.com/modes/predict/).
+
+## Exportieren
+
+Exportieren Sie ein YOLOv8n-cls-Modell in ein anderes Format wie ONNX, CoreML usw.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Ein Modell laden
+ model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes trainiertes Modell laden
+
+ # Das Modell exportieren
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n-cls.pt format=onnx # offizielles Modell exportieren
+ yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren
+ ```
+
+Verfรผgbare YOLOv8-cls Exportformate stehen in der folgenden Tabelle. Sie kรถnnen direkt auf exportierten Modellen vorhersagen oder validieren, d.h. `yolo predict model=yolov8n-cls.onnx`. Nutzungsexempel werden fรผr Ihr Modell nach Abschluss des Exports angezeigt.
+
+| Format | `format`-Argument | Modell | Metadaten | Argumente |
+|--------------------------------------------------------------------|-------------------|-------------------------------|-----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | โ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | โ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | โ | `imgsz`, `half` |
+
+Vollstรคndige Details zum `export` finden Sie auf der Seite [Export](https://docs.ultralytics.com/modes/export/).
diff --git a/ultralytics/docs/de/tasks/classify.md:Zone.Identifier b/ultralytics/docs/de/tasks/classify.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/tasks/classify.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/tasks/detect.md b/ultralytics/docs/de/tasks/detect.md
new file mode 100755
index 0000000..ab2848c
--- /dev/null
+++ b/ultralytics/docs/de/tasks/detect.md
@@ -0,0 +1,184 @@
+---
+comments: true
+description: Offizielle Dokumentation fรผr YOLOv8 von Ultralytics. Erfahren Sie, wie Sie Modelle trainieren, validieren, vorhersagen und in verschiedenen Formaten exportieren. Einschlieรlich detaillierter Leistungsstatistiken.
+keywords: YOLOv8, Ultralytics, Objekterkennung, vortrainierte Modelle, Training, Validierung, Vorhersage, Modell-Export, COCO, ImageNet, PyTorch, ONNX, CoreML
+---
+
+# Objekterkennung
+
+
+
+Objekterkennung ist eine Aufgabe, die das Identifizieren der Position und Klasse von Objekten in einem Bild oder Videostream umfasst.
+
+Die Ausgabe eines Objekterkenners ist eine Menge von Begrenzungsrahmen, die die Objekte im Bild umschlieรen, zusammen mit Klassenbezeichnungen und Vertrauenswerten fรผr jedes Feld. Objekterkennung ist eine gute Wahl, wenn Sie Objekte von Interesse in einer Szene identifizieren mรผssen, aber nicht genau wissen mรผssen, wo das Objekt ist oder wie seine genaue Form ist.
+
+
+
+!!! Tip "Tipp"
+
+ YOLOv8 Detect Modelle sind die Standard YOLOv8 Modelle, zum Beispiel `yolov8n.pt`, und sind vortrainiert auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz.
+
+## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+Hier werden die vortrainierten YOLOv8 Detect Modelle gezeigt. Detect, Segment und Pose Modelle sind vortrainiert auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz, wรคhrend die Classify Modelle vortrainiert sind auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz.
+
+[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch von der neuesten Ultralytics [Verรถffentlichung](https://github.com/ultralytics/assets/releases) bei Erstbenutzung heruntergeladen.
+
+| Modell | Grรถรe (Pixel) | mAPval 50-95 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | params (M) | FLOPs (B) |
+|--------------------------------------------------------------------------------------|-----------------------|----------------------|------------------------------------------|-----------------------------------------------|--------------------|-------------------|
+| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
+| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
+| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
+| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
+| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
+
+- **mAPval** Werte sind fรผr Single-Modell Single-Scale auf dem [COCO val2017](http://cocodataset.org) Datensatz.
+ Reproduzieren mit `yolo val detect data=coco.yaml device=0`
+- **Geschwindigkeit** gemittelt รผber COCO Val Bilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)-Instanz.
+ Reproduzieren mit `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
+
+## Training
+
+YOLOv8n auf dem COCO128-Datensatz fรผr 100 Epochen bei Bildgrรถรe 640 trainieren. Fรผr eine vollstรคndige Liste verfรผgbarer Argumente siehe die [Konfigurationsseite](/../usage/cfg.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n.yaml') # ein neues Modell aus YAML aufbauen
+ model = YOLO('yolov8n.pt') # ein vortrainiertes Modell laden (empfohlen fรผr Training)
+ model = YOLO('yolov8n.yaml').load('yolov8n.pt') # aus YAML aufbauen und Gewichte รผbertragen
+
+ # Das Modell trainieren
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
+ ```
+ === "CLI"
+
+ ```bash
+ # Ein neues Modell aus YAML aufbauen und Training von Grund auf starten
+ yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
+
+ # Training von einem vortrainierten *.pt Modell starten
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
+
+ # Ein neues Modell aus YAML aufbauen, vortrainierte Gewichte รผbertragen und Training starten
+ yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+### Datenformat
+
+Das Datenformat fรผr YOLO-Erkennungsdatensรคtze finden Sie detailliert im [Dataset Guide](../../../datasets/detect/index.md). Um Ihren vorhandenen Datensatz von anderen Formaten (wie COCO etc.) in das YOLO-Format zu konvertieren, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics.
+
+## Validierung
+
+Genauigkeit des trainierten YOLOv8n-Modells auf dem COCO128-Datensatz validieren. Es mรผssen keine Argumente รผbergeben werden, da das `modell` seine Trainingsdaten und Argumente als Modellattribute beibehรคlt.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniertes Modell laden
+
+ # Das Modell validieren
+ metrics = model.val() # keine Argumente nรถtig, Datensatz und Einstellungen erinnert
+ metrics.box.map # map50-95
+ metrics.box.map50 # map50
+ metrics.box.map75 # map75
+ metrics.box.maps # eine Liste enthรคlt map50-95 jeder Kategorie
+ ```
+ === "CLI"
+
+ ```bash
+ yolo detect val model=yolov8n.pt # offizielles Modell validieren
+ yolo detect val model=pfad/zum/besten.pt # benutzerdefiniertes Modell validieren
+ ```
+
+## Vorhersage
+
+Ein trainiertes YOLOv8n-Modell verwenden, um Vorhersagen auf Bildern durchzufรผhren.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniertes Modell laden
+
+ # Mit dem Modell vorhersagen
+ results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild
+ ```
+ === "CLI"
+
+ ```bash
+ yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit offiziellem Modell
+ yolo detect predict model=pfad/zum/besten.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit benutzerdefiniertem Modell
+ ```
+
+Volle Details รผber den `predict`-Modus finden Sie auf der [Predict-Seite](https://docs.ultralytics.com/modes/predict/).
+
+## Export
+
+Ein YOLOv8n-Modell in ein anderes Format wie ONNX, CoreML usw. exportieren.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniert trainiertes Modell laden
+
+ # Das Modell exportieren
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n.pt format=onnx # offizielles Modell exportieren
+ yolo export model=pfad/zum/besten.pt format=onnx # benutzerdefiniert trainiertes Modell exportieren
+ ```
+
+Verfรผgbare YOLOv8 Exportformate sind in der untenstehenden Tabelle aufgefรผhrt. Sie kรถnnen direkt auf den exportierten Modellen Vorhersagen treffen oder diese validieren, zum Beispiel `yolo predict model=yolov8n.onnx`. Verwendungsbeispiele werden fรผr Ihr Modell nach Abschluss des Exports angezeigt.
+
+| Format | `format`-Argument | Modell | Metadaten | Argumente |
+|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
+
+Volle Details zum `export` finden Sie auf der [Export-Seite](https://docs.ultralytics.com/modes/export/).
diff --git a/ultralytics/docs/de/tasks/detect.md:Zone.Identifier b/ultralytics/docs/de/tasks/detect.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/tasks/detect.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/tasks/index.md b/ultralytics/docs/de/tasks/index.md
new file mode 100755
index 0000000..4077c5e
--- /dev/null
+++ b/ultralytics/docs/de/tasks/index.md
@@ -0,0 +1,55 @@
+---
+comments: true
+description: Erfahren Sie, welche grundlegenden Aufgaben im Bereich der Computer Vision YOLOv8 durchfรผhren kann, einschlieรlich Erkennung, Segmentierung, Klassifizierung und Haltungsschรคtzung, und wie sie in Ihren KI-Projekten verwendet werden kรถnnen.
+keywords: Ultralytics, YOLOv8, Erkennung, Segmentierung, Klassifizierung, Pose-Schรคtzung, KI-Framework, Computer Vision-Aufgaben
+---
+
+# Ultralytics YOLOv8 Aufgaben
+
+
+
+
+YOLOv8 ist ein KI-Framework, das mehrere Aufgaben im Bereich der Computer Vision **unterstรผtzt**. Das Framework kann fรผr die [Erkennung](detect.md), [Segmentierung](segment.md), [Klassifizierung](classify.md) und die [Pose](pose.md)-Schรคtzung verwendet werden. Jede dieser Aufgaben hat ein unterschiedliches Ziel und Anwendungsgebiete.
+
+!!! Note "Hinweis"
+
+ ๐ง Unsere mehrsprachigen Dokumentation befindet sich derzeit im Aufbau und wir arbeiten hart daran, sie zu verbessern. Danke fรผr Ihre Geduld! ๐
+
+
+
+
+
+ Schauen Sie zu: Entdecken Sie Ultralytics YOLO Aufgaben: Objekterkennung, Segmentierung, Verfolgung und Pose-Schรคtzung.
+
+
+## [Erkennung](detect.md)
+
+Erkennung ist die primรคre von YOLOv8 unterstรผtzte Aufgabe. Sie beinhaltet das Erkennen von Objekten in einem Bild oder Videobild und das Zeichnen von Rahmen um sie herum. Die erkannten Objekte werden anhand ihrer Merkmale in verschiedene Kategorien klassifiziert. YOLOv8 kann mehrere Objekte in einem einzelnen Bild oder Videobild mit hoher Genauigkeit und Geschwindigkeit erkennen.
+
+[Beispiele fรผr Erkennung](detect.md){ .md-button }
+
+## [Segmentierung](segment.md)
+
+Segmentierung ist eine Aufgabe, die das Aufteilen eines Bildes in unterschiedliche Regionen anhand des Bildinhalts beinhaltet. Jeder Region wird basierend auf ihrem Inhalt eine Markierung zugewiesen. Diese Aufgabe ist nรผtzlich in Anwendungen wie der Bildsegmentierung und medizinischen Bildgebung. YOLOv8 verwendet eine Variante der U-Net-Architektur, um die Segmentierung durchzufรผhren.
+
+[Beispiele fรผr Segmentierung](segment.md){ .md-button }
+
+## [Klassifizierung](classify.md)
+
+Klassifizierung ist eine Aufgabe, die das Einordnen eines Bildes in verschiedene Kategorien umfasst. YOLOv8 kann genutzt werden, um Bilder anhand ihres Inhalts zu klassifizieren. Es verwendet eine Variante der EfficientNet-Architektur, um die Klassifizierung durchzufรผhren.
+
+[Beispiele fรผr Klassifizierung](classify.md){ .md-button }
+
+## [Pose](pose.md)
+
+Die Pose-/Keypoint-Erkennung ist eine Aufgabe, die das Erkennen von spezifischen Punkten in einem Bild oder Videobild beinhaltet. Diese Punkte werden als Keypoints bezeichnet und werden zur Bewegungsverfolgung oder Pose-Schรคtzung verwendet. YOLOv8 kann Keypoints in einem Bild oder Videobild mit hoher Genauigkeit und Geschwindigkeit erkennen.
+
+[Beispiele fรผr Posen](pose.md){ .md-button }
+
+## Fazit
+
+YOLOv8 unterstรผtzt mehrere Aufgaben, einschlieรlich Erkennung, Segmentierung, Klassifizierung und Keypoint-Erkennung. Jede dieser Aufgaben hat unterschiedliche Ziele und Anwendungsgebiete. Durch das Verstรคndnis der Unterschiede zwischen diesen Aufgaben kรถnnen Sie die geeignete Aufgabe fรผr Ihre Anwendung im Bereich der Computer Vision auswรคhlen.
diff --git a/ultralytics/docs/de/tasks/index.md:Zone.Identifier b/ultralytics/docs/de/tasks/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/tasks/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/tasks/pose.md b/ultralytics/docs/de/tasks/pose.md
new file mode 100755
index 0000000..14d0f25
--- /dev/null
+++ b/ultralytics/docs/de/tasks/pose.md
@@ -0,0 +1,185 @@
+---
+comments: true
+description: Erfahren Sie, wie Sie Ultralytics YOLOv8 fรผr Aufgaben der Pose-Schรคtzung verwenden kรถnnen. Finden Sie vortrainierte Modelle, lernen Sie, wie man eigene trainiert, validiert, vorhersagt und exportiert.
+keywords: Ultralytics, YOLO, YOLOv8, Pose-Schรคtzung, Erkennung von Schlรผsselpunkten, Objekterkennung, vortrainierte Modelle, maschinelles Lernen, kรผnstliche Intelligenz
+---
+
+# Pose-Schรคtzung
+
+
+
+Die Pose-Schรคtzung ist eine Aufgabe, die das Identifizieren der Lage spezifischer Punkte in einem Bild beinhaltet, die normalerweise als Schlรผsselpunkte bezeichnet werden. Die Schlรผsselpunkte kรถnnen verschiedene Teile des Objekts wie Gelenke, Landmarken oder andere charakteristische Merkmale reprรคsentieren. Die Positionen der Schlรผsselpunkte sind รผblicherweise als eine Gruppe von 2D `[x, y]` oder 3D `[x, y, sichtbar]` Koordinaten dargestellt.
+
+Das Ergebnis eines Pose-Schรคtzungsmodells ist eine Gruppe von Punkten, die die Schlรผsselpunkte auf einem Objekt im Bild darstellen, normalerweise zusammen mit den Konfidenzwerten fรผr jeden Punkt. Die Pose-Schรคtzung eignet sich gut, wenn Sie spezifische Teile eines Objekts in einer Szene identifizieren mรผssen und deren Lage zueinander.
+
+
+
+
+
+ Ansehen: Pose-Schรคtzung mit Ultralytics YOLOv8.
+
+
+!!! Tip "Tipp"
+
+ YOLOv8 _pose_-Modelle verwenden den Suffix `-pose`, z. B. `yolov8n-pose.pt`. Diese Modelle sind auf dem [COCO-Schlรผsselpunkte](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml)-Datensatz trainiert und fรผr eine Vielzahl von Pose-Schรคtzungsaufgaben geeignet.
+
+## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+Hier werden vortrainierte YOLOv8 Pose-Modelle gezeigt. Erkennungs-, Segmentierungs- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, wรคhrend Klassifizierungsmodelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind.
+
+[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch aus der neuesten Ultralytics-[Verรถffentlichung](https://github.com/ultralytics/assets/releases) bei erstmaliger Verwendung heruntergeladen.
+
+| Modell | Grรถรe (Pixel) | mAPpose 50-95 | mAPpose 50 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) |
+|------------------------------------------------------------------------------------------------------|-----------------------|-----------------------|--------------------|------------------------------------------|-----------------------------------------------|-----------------------|-------------------|
+| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50,4 | 80,1 | 131,8 | 1,18 | 3,3 | 9,2 |
+| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60,0 | 86,2 | 233,2 | 1,42 | 11,6 | 30,2 |
+| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65,0 | 88,8 | 456,3 | 2,00 | 26,4 | 81,0 |
+| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67,6 | 90,0 | 784,5 | 2,59 | 44,4 | 168,6 |
+| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69,2 | 90,2 | 1607,1 | 3,73 | 69,4 | 263,2 |
+| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71,6 | 91,2 | 4088,7 | 10,04 | 99,1 | 1066,4 |
+
+- **mAPval** Werte gelten fรผr ein einzelnes Modell mit einfacher Skala auf dem [COCO Keypoints val2017](http://cocodataset.org)-Datensatz.
+ Zu reproduzieren mit `yolo val pose data=coco-pose.yaml device=0`.
+- **Geschwindigkeit** gemittelt รผber COCO-Validierungsbilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/de/ec2/instance-types/p4/)-Instanz.
+ Zu reproduzieren mit `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`.
+
+## Trainieren
+
+Trainieren Sie ein YOLOv8-Pose-Modell auf dem COCO128-Pose-Datensatz.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-pose.yaml') # ein neues Modell aus YAML bauen
+ model = YOLO('yolov8n-pose.pt') # ein vortrainiertes Modell laden (empfohlen fรผr das Training)
+ model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # aus YAML bauen und Gewichte รผbertragen
+
+ # Modell trainieren
+ results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
+ ```
+ === "CLI"
+
+ ```bash
+ # Ein neues Modell aus YAML bauen und das Training von Grund auf starten
+ yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
+
+ # Training von einem vortrainierten *.pt Modell starten
+ yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
+
+ # Ein neues Modell aus YAML bauen, vortrainierte Gewichte รผbertragen und das Training starten
+ yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
+ ```
+
+### Datensatzformat
+
+Das YOLO-Pose-Datensatzformat finden Sie detailliert im [Datensatz-Leitfaden](../../../datasets/pose/index.md). Um Ihren bestehenden Datensatz aus anderen Formaten (wie COCO usw.) in das YOLO-Format zu konvertieren, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics.
+
+## Validieren
+
+Die Genauigkeit des trainierten YOLOv8n-Pose-Modells auf dem COCO128-Pose-Datensatz validieren. Es mรผssen keine Argumente รผbergeben werden, da das `Modell` seine Trainings`daten` und Argumente als Modellattribute beibehรคlt.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
+
+ # Modell validieren
+ metrics = model.val() # keine Argumente nรถtig, Datensatz und Einstellungen sind gespeichert
+ metrics.box.map # map50-95
+ metrics.box.map50 # map50
+ metrics.box.map75 # map75
+ metrics.box.maps # Liste enthรคlt map50-95 jeder Kategorie
+ ```
+ === "CLI"
+
+ ```bash
+ yolo pose val model=yolov8n-pose.pt # offizielles Modell validieren
+ yolo pose val model=pfad/zu/best.pt # benutzerdefiniertes Modell validieren
+ ```
+
+## Vorhersagen
+
+Ein trainiertes YOLOv8n-Pose-Modell verwenden, um Vorhersagen auf Bildern zu machen.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
+
+ # Mit dem Modell Vorhersagen machen
+ results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild machen
+ ```
+ === "CLI"
+
+ ```bash
+ yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit dem offiziellen Modell machen
+ yolo pose predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit dem benutzerdefinierten Modell machen
+ ```
+
+Vollstรคndige `predict`-Modusdetails finden Sie auf der [Vorhersage](https://docs.ultralytics.com/modes/predict/)-Seite.
+
+## Exportieren
+
+Ein YOLOv8n-Pose-Modell in ein anderes Format wie ONNX, CoreML usw. exportieren.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden
+
+ # Modell exportieren
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n-pose.pt format=onnx # offizielles Modell exportieren
+ yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes Modell exportieren
+ ```
+
+Verfรผgbare YOLOv8-Pose-Exportformate sind in der folgenden Tabelle aufgefรผhrt. Sie kรถnnen direkt auf exportierten Modellen vorhersagen oder validieren, z. B. `yolo predict model=yolov8n-pose.onnx`. Verwendungsbeispiele werden fรผr Ihr Modell nach Abschluss des Exports angezeigt.
+
+| Format | `format` Argument | Modell | Metadaten | Argumente |
+|--------------------------------------------------------------------|-------------------|--------------------------------|-----------|-----------------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | โ | `imgsz`, `optimieren` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | โ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | โ | `imgsz`, `halb` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | โ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | โ | `imgsz`, `halb`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | โ | `imgsz`, `halb`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | โ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | โ | `imgsz`, `halb` |
+
+Vollstรคndige `export`-Details finden Sie auf der [Export](https://docs.ultralytics.com/modes/export/)-Seite.
diff --git a/ultralytics/docs/de/tasks/pose.md:Zone.Identifier b/ultralytics/docs/de/tasks/pose.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/tasks/pose.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/de/tasks/segment.md b/ultralytics/docs/de/tasks/segment.md
new file mode 100755
index 0000000..a70909f
--- /dev/null
+++ b/ultralytics/docs/de/tasks/segment.md
@@ -0,0 +1,188 @@
+---
+comments: true
+description: Erfahren Sie, wie Sie Instanzsegmentierungsmodelle mit Ultralytics YOLO verwenden. Anleitungen zum Training, zur Validierung, zur Bildvorhersage und zum Export von Modellen.
+Schlagworte: yolov8, Instanzsegmentierung, Ultralytics, COCO-Datensatz, Bildsegmentierung, Objekterkennung, Modelltraining, Modellvalidierung, Bildvorhersage, Modellexport
+---
+
+# Instanzsegmentierung
+
+
+
+Instanzsegmentierung geht einen Schritt weiter als die Objekterkennung und beinhaltet die Identifizierung einzelner Objekte in einem Bild und deren Abtrennung vom Rest des Bildes.
+
+Das Ergebnis eines Instanzsegmentierungsmodells ist eine Reihe von Masken oder Konturen, die jedes Objekt im Bild umreiรen, zusammen mit Klassenbezeichnungen und Vertrauensscores fรผr jedes Objekt. Instanzsegmentierung ist nรผtzlich, wenn man nicht nur wissen muss, wo sich Objekte in einem Bild befinden, sondern auch, welche genaue Form sie haben.
+
+
+
+
+
+ Schauen Sie: Fรผhren Sie Segmentierung mit dem vortrainierten Ultralytics YOLOv8 Modell in Python aus.
+
+
+!!! Tip "Tipp"
+
+ YOLOv8 Segment-Modelle verwenden das Suffix `-seg`, d.h. `yolov8n-seg.pt` und sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert.
+
+## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+Hier werden vortrainierte YOLOv8 Segment-Modelle gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, wรคhrend Classify-Modelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind.
+
+[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) laden sich automatisch von der neuesten Ultralytics [Verรถffentlichung](https://github.com/ultralytics/assets/releases) beim ersten Gebrauch herunter.
+
+| Modell | Grรถรe (Pixel) | mAPKasten 50-95 | mAPMasken 50-95 | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit A100 TensorRT (ms) | Parameter (M) | FLOPs (B) |
+|----------------------------------------------------------------------------------------------|-----------------------|-------------------------|-------------------------|------------------------------------------|-----------------------------------------------|-----------------------|-------------------|
+| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
+| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
+| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
+| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
+| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
+
+- Die **mAPval**-Werte sind fรผr ein einzelnes Modell, einzelne Skala auf dem [COCO val2017](http://cocodataset.org)-Datensatz.
+ Zum Reproduzieren nutzen Sie `yolo val segment data=coco.yaml device=0`
+- Die **Geschwindigkeit** ist รผber die COCO-Validierungsbilder gemittelt und verwendet eine [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)-Instanz.
+ Zum Reproduzieren `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
+
+## Training
+
+Trainieren Sie YOLOv8n-seg auf dem COCO128-seg-Datensatz fรผr 100 Epochen mit einer Bildgrรถรe von 640. Eine vollstรคndige Liste der verfรผgbaren Argumente finden Sie auf der Seite [Konfiguration](/../usage/cfg.md).
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-seg.yaml') # ein neues Modell aus YAML erstellen
+ model = YOLO('yolov8n-seg.pt') # ein vortrainiertes Modell laden (empfohlen fรผr das Training)
+ model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # aus YAML erstellen und Gewichte รผbertragen
+
+ # Das Modell trainieren
+ results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
+ ```
+ === "CLI"
+
+ ```bash
+ # Ein neues Modell aus YAML erstellen und das Training von vorne beginnen
+ yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
+
+ # Das Training von einem vortrainierten *.pt Modell aus starten
+ yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
+
+ # Ein neues Modell aus YAML erstellen, vortrainierte Gewichte darauf รผbertragen und das Training beginnen
+ yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
+ ```
+
+### Datenformat
+
+Das YOLO Segmentierungsdatenformat finden Sie detailliert im [Dataset Guide](../../../datasets/segment/index.md). Um Ihre vorhandenen Daten aus anderen Formaten (wie COCO usw.) in das YOLO-Format umzuwandeln, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics.
+
+## Val
+
+Validieren Sie die Genauigkeit des trainierten YOLOv8n-seg-Modells auf dem COCO128-seg-Datensatz. Es mรผssen keine Argumente รผbergeben werden, da das `Modell` seine Trainingsdaten und -argumente als Modellattribute behรคlt.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-seg.pt') # offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes Modell laden
+
+ # Das Modell validieren
+ metrics = model.val() # Keine Argumente erforderlich, Datensatz und Einstellungen werden behalten
+ metrics.box.map # mAP50-95(B)
+ metrics.box.map50 # mAP50(B)
+ metrics.box.map75 # mAP75(B)
+ metrics.box.maps # eine Liste enthรคlt mAP50-95(B) fรผr jede Kategorie
+ metrics.seg.map # mAP50-95(M)
+ metrics.seg.map50 # mAP50(M)
+ metrics.seg.map75 # mAP75(M)
+ metrics.seg.maps # eine Liste enthรคlt mAP50-95(M) fรผr jede Kategorie
+ ```
+ === "CLI"
+
+ ```bash
+ yolo segment val model=yolov8n-seg.pt # offizielles Modell validieren
+ yolo segment val model=pfad/zu/best.pt # benutzerdefiniertes Modell validieren
+ ```
+
+## Predict
+
+Verwenden Sie ein trainiertes YOLOv8n-seg-Modell fรผr Vorhersagen auf Bildern.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-seg.pt') # offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes Modell laden
+
+ # Mit dem Modell Vorhersagen treffen
+ results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild
+ ```
+ === "CLI"
+
+ ```bash
+ yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit offiziellem Modell treffen
+ yolo segment predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit benutzerdefiniertem Modell treffen
+ ```
+
+Die vollstรคndigen Details zum `predict`-Modus finden Sie auf der Seite [Predict](https://docs.ultralytics.com/modes/predict/).
+
+## Export
+
+Exportieren Sie ein YOLOv8n-seg-Modell in ein anderes Format wie ONNX, CoreML usw.
+
+!!! Example "Beispiel"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Modell laden
+ model = YOLO('yolov8n-seg.pt') # offizielles Modell laden
+ model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes trainiertes Modell laden
+
+ # Das Modell exportieren
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n-seg.pt format=onnx # offizielles Modell exportieren
+ yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren
+ ```
+
+Die verfรผgbaren YOLOv8-seg-Exportformate sind in der folgenden Tabelle aufgefรผhrt. Sie kรถnnen direkt auf exportierten Modellen Vorhersagen treffen oder sie validieren, z.B. `yolo predict model=yolov8n-seg.onnx`. Verwendungsbeispiele werden fรผr Ihr Modell nach dem Export angezeigt.
+
+| Format | `format`-Argument | Modell | Metadaten | Argumente |
+|--------------------------------------------------------------------|-------------------|-------------------------------|-----------|-----------------------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | โ | `imgsz`, `optimieren` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | โ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | โ | `imgsz`, `halb` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | โ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `Arbeitsspeicher` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | โ | `imgsz`, `halb`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | โ | `imgsz`, `halb`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | โ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | โ | `imgsz`, `halb` |
+
+Die vollstรคndigen Details zum `export` finden Sie auf der Seite [Export](https://docs.ultralytics.com/modes/export/).
diff --git a/ultralytics/docs/de/tasks/segment.md:Zone.Identifier b/ultralytics/docs/de/tasks/segment.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/de/tasks/segment.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/CNAME b/ultralytics/docs/en/CNAME
new file mode 100755
index 0000000..339382a
--- /dev/null
+++ b/ultralytics/docs/en/CNAME
@@ -0,0 +1 @@
+docs.ultralytics.com
diff --git a/ultralytics/docs/en/CNAME:Zone.Identifier b/ultralytics/docs/en/CNAME:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/CNAME:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/azureml-quickstart.md b/ultralytics/docs/en/guides/azureml-quickstart.md
new file mode 100755
index 0000000..56b1cea
--- /dev/null
+++ b/ultralytics/docs/en/guides/azureml-quickstart.md
@@ -0,0 +1,152 @@
+---
+comments: true
+description: Step-by-step Quickstart Guide to Running YOLOv8 Object Detection Models on AzureML for Fast Prototyping and Testing
+keywords: Ultralytics, YOLOv8, Object Detection, Azure Machine Learning, Quickstart Guide, Prototype, Compute Instance, Terminal, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# YOLOv8 ๐ on AzureML
+
+## What is Azure?
+
+[Azure](https://azure.microsoft.com/) is Microsoft's 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, 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 YOLOv8 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.
+
+
+
+
+
+## Quickstart from Terminal
+
+Start your compute and open a Terminal:
+
+
+
+
+
+### Create virtualenv
+
+Create your conda virtualenv and install pip in it:
+
+```bash
+conda create --name yolov8env -y
+conda activate yolov8env
+conda install pip -y
+```
+
+Install the required dependencies:
+
+```bash
+cd ultralytics
+pip install -r requirements.txt
+pip install ultralytics
+pip install onnx>=1.12.0
+```
+
+### Perform YOLOv8 tasks
+
+Predict:
+
+```bash
+yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'
+```
+
+Train a detection model for 10 epochs with an initial learning_rate of 0.01:
+
+```bash
+yolo train data=coco128.yaml model=yolov8n.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.
+
+
+
+
+
+From your compute terminal, you need to create a new ipykernel that will be used by your notebook to manage your dependencies:
+
+```bash
+conda create --name yolov8env -y
+conda activate yolov8env
+conda install pip -y
+conda install ipykernel -y
+python -m ipykernel install --user --name yolov8env --display-name "yolov8env"
+```
+
+Close your terminal and create a new notebook. From your Notebook, you can select the new kernel.
+
+Then you can open a Notebook cell and install the required dependencies:
+
+```bash
+%%bash
+source activate yolov8env
+cd ultralytics
+pip install -r requirements.txt
+pip install ultralytics
+pip install onnx>=1.12.0
+```
+
+Note that we need to use the `source activate yolov8env` for all the %%bash cells, to make sure that the %%bash cell uses environment we want.
+
+Run some predictions using the [Ultralytics CLI](../quickstart.md#use-ultralytics-with-cli):
+
+```bash
+%%bash
+source activate yolov8env
+yolo predict model=yolov8n.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("yolov8n.pt") # load an official YOLOv8n model
+
+# Use the model
+model.train(data="coco128.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 YOLOv8 tasks, as described in the terminal section above.
+
+By following these steps, you should be able to get YOLOv8 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 YOLOv8 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 YOLOv8 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 YOLOv8 models.
+- [Train YOLOv8 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 YOLOv8 models on AzureML.
diff --git a/ultralytics/docs/en/guides/azureml-quickstart.md:Zone.Identifier b/ultralytics/docs/en/guides/azureml-quickstart.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/azureml-quickstart.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/conda-quickstart.md b/ultralytics/docs/en/guides/conda-quickstart.md
new file mode 100755
index 0000000..21f3b89
--- /dev/null
+++ b/ultralytics/docs/en/guides/conda-quickstart.md
@@ -0,0 +1,132 @@
+---
+comments: true
+description: Comprehensive guide to setting up and using Ultralytics YOLO models in a Conda environment. Learn how to install the package, manage dependencies, and get started with object detection projects.
+keywords: Ultralytics, YOLO, Conda, environment setup, object detection, package installation, deep learning, machine learning, guide
+---
+
+# Conda Quickstart Guide for Ultralytics
+
+
+
+
+
+This guide provides a comprehensive introduction to setting up a Conda environment for your Ultralytics projects. Conda is an open-source package and environment management system that offers an excellent alternative to pip for installing packages and dependencies. Its isolated environments make it particularly well-suited for data science and machine learning endeavors. For more details, visit the Ultralytics Conda package on [Anaconda](https://anaconda.org/conda-forge/ultralytics) and check out the Ultralytics feedstock repository for package updates on [GitHub](https://github.com/conda-forge/ultralytics-feedstock/).
+
+[](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics)
+
+## What You Will Learn
+
+- Setting up a Conda environment
+- Installing Ultralytics via Conda
+- Initializing Ultralytics in your environment
+- Using Ultralytics Docker images with Conda
+
+---
+
+## Prerequisites
+
+- You should have Anaconda or Miniconda installed on your system. If not, download and install it from [Anaconda](https://www.anaconda.com/) or [Miniconda](https://docs.conda.io/projects/miniconda/en/latest/).
+
+---
+
+## Setting up a Conda Environment
+
+First, let's create a new Conda environment. Open your terminal and run the following command:
+
+```bash
+conda create --name ultralytics-env python=3.8 -y
+```
+
+Activate the new environment:
+
+```bash
+conda activate ultralytics-env
+```
+
+---
+
+## Installing Ultralytics
+
+You can install the Ultralytics package from the conda-forge channel. Execute the following command:
+
+```bash
+conda install -c conda-forge ultralytics
+```
+
+### Note on CUDA Environment
+
+If you're working in a CUDA-enabled environment, it's a good practice to install `ultralytics`, `pytorch`, and `pytorch-cuda` together to resolve any conflicts:
+
+```bash
+conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
+```
+
+---
+
+## Using Ultralytics
+
+With Ultralytics installed, you can now start using its robust features for object detection, instance segmentation, and more. For example, to predict an image, you can run:
+
+```python
+from ultralytics import YOLO
+
+model = YOLO('yolov8n.pt') # initialize model
+results = model('path/to/image.jpg') # perform inference
+results.show() # display results
+```
+
+---
+
+## Ultralytics Conda Docker Image
+
+If you prefer using Docker, Ultralytics offers Docker images with a Conda environment included. You can pull these images from [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics).
+
+Pull the latest Ultralytics image:
+
+```bash
+# Set image name as a variable
+t=ultralytics/ultralytics:latest-conda
+
+# Pull the latest Ultralytics image from Docker Hub
+sudo docker pull $t
+```
+
+Run the image:
+
+```bash
+# Run the Ultralytics image in a container with GPU support
+sudo docker run -it --ipc=host --gpus all $t # all GPUs
+sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
+```
+
+---
+
+Certainly, you can include the following section in your Conda guide to inform users about speeding up installation using `libmamba`:
+
+---
+
+## Speeding Up Installation with Libmamba
+
+If you're looking to [speed up the package installation](https://www.anaconda.com/blog/a-faster-conda-for-a-growing-community) process in Conda, you can opt to use `libmamba`, a fast, cross-platform, and dependency-aware package manager that serves as an alternative solver to Conda's default.
+
+### How to Enable Libmamba
+
+To enable `libmamba` as the solver for Conda, you can perform the following steps:
+
+1. First, install the `conda-libmamba-solver` package. This can be skipped if your Conda version is 4.11 or above, as `libmamba` is included by default.
+
+ ```bash
+ conda install conda-libmamba-solver
+ ```
+
+2. Next, configure Conda to use `libmamba` as the solver:
+
+ ```bash
+ conda config --set solver libmamba
+ ```
+
+And that's it! Your Conda installation will now use `libmamba` as the solver, which should result in a faster package installation process.
+
+---
+
+Congratulations! You have successfully set up a Conda environment, installed the Ultralytics package, and are now ready to explore its rich functionalities. Feel free to dive deeper into the [Ultralytics documentation](../index.md) for more advanced tutorials and examples.
diff --git a/ultralytics/docs/en/guides/conda-quickstart.md:Zone.Identifier b/ultralytics/docs/en/guides/conda-quickstart.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/conda-quickstart.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/docker-quickstart.md b/ultralytics/docs/en/guides/docker-quickstart.md
new file mode 100755
index 0000000..6c45268
--- /dev/null
+++ b/ultralytics/docs/en/guides/docker-quickstart.md
@@ -0,0 +1,119 @@
+---
+comments: true
+description: Complete guide to setting up and using Ultralytics YOLO models with Docker. Learn how to install Docker, manage GPU support, and run YOLO models in isolated containers.
+keywords: Ultralytics, YOLO, Docker, GPU, containerization, object detection, package installation, deep learning, machine learning, guide
+---
+
+# Docker Quickstart Guide for Ultralytics
+
+
+
+
+
+This guide serves as a comprehensive introduction to setting up a Docker environment for your Ultralytics projects. [Docker](https://docker.com/) is a platform for developing, shipping, and running applications in containers. It is particularly beneficial for ensuring that the software will always run the same, regardless of where it's deployed. For more details, visit the Ultralytics Docker repository on [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics).
+
+[](https://hub.docker.com/r/ultralytics/ultralytics)
+
+## What You Will Learn
+
+- Setting up Docker with NVIDIA support
+- Installing Ultralytics Docker images
+- Running Ultralytics in a Docker container
+- Mounting local directories into the container
+
+---
+
+## Prerequisites
+
+- Make sure Docker is installed on your system. If not, you can download and install it from [Docker's website](https://www.docker.com/products/docker-desktop).
+- Ensure that your system has an NVIDIA GPU and NVIDIA drivers are installed.
+
+---
+
+## Setting up Docker with NVIDIA Support
+
+First, verify that the NVIDIA drivers are properly installed by running:
+
+```bash
+nvidia-smi
+```
+
+### Installing NVIDIA Docker Runtime
+
+Now, let's install the NVIDIA Docker runtime to enable GPU support in Docker containers:
+
+```bash
+# Add NVIDIA package repositories
+curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
+distribution=$(lsb_release -cs)
+curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+
+# Install NVIDIA Docker runtime
+sudo apt-get update
+sudo apt-get install -y nvidia-docker2
+
+# Restart Docker service to apply changes
+sudo systemctl restart docker
+```
+
+### Verify NVIDIA Runtime with Docker
+
+Run `docker info | grep -i runtime` to ensure that `nvidia` appears in the list of runtimes:
+
+```bash
+docker info | grep -i runtime
+```
+
+---
+
+## Installing Ultralytics Docker Images
+
+Ultralytics offers several Docker images optimized for various platforms and use-cases:
+
+- **Dockerfile:** GPU image, ideal for training.
+- **Dockerfile-arm64:** For ARM64 architecture, suitable for devices like [Raspberry Pi](raspberry-pi.md).
+- **Dockerfile-cpu:** CPU-only version for inference and non-GPU environments.
+- **Dockerfile-jetson:** Optimized for NVIDIA Jetson devices.
+- **Dockerfile-python:** Minimal Python environment for lightweight applications.
+- **Dockerfile-conda:** Includes [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) and Ultralytics package installed via Conda.
+
+To pull the latest image:
+
+```bash
+# Set image name as a variable
+t=ultralytics/ultralytics:latest
+
+# Pull the latest Ultralytics image from Docker Hub
+sudo docker pull $t
+```
+
+---
+
+## Running Ultralytics in Docker Container
+
+Here's how to execute the Ultralytics Docker container:
+
+```bash
+# Run with all GPUs
+sudo docker run -it --ipc=host --gpus all $t
+
+# Run specifying which GPUs to use
+sudo docker run -it --ipc=host --gpus '"device=2,3"' $t
+```
+
+The `-it` flag assigns a pseudo-TTY and keeps stdin open, allowing you to interact with the container. The `--ipc=host` flag enables sharing of host's IPC namespace, essential for sharing memory between processes. The `--gpus` flag allows the container to access the host's GPUs.
+
+### Note on File Accessibility
+
+To work with files on your local machine within the container, you can use Docker volumes:
+
+```bash
+# Mount a local directory into the container
+sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
+```
+
+Replace `/path/on/host` with the directory path on your local machine and `/path/in/container` with the desired path inside the Docker container.
+
+---
+
+Congratulations! You're now set up to use Ultralytics with Docker and ready to take advantage of its powerful capabilities. For alternate installation methods, feel free to explore the [Ultralytics quickstart documentation](../quickstart.md).
diff --git a/ultralytics/docs/en/guides/docker-quickstart.md:Zone.Identifier b/ultralytics/docs/en/guides/docker-quickstart.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/docker-quickstart.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/heatmaps.md b/ultralytics/docs/en/guides/heatmaps.md
new file mode 100755
index 0000000..a1c3a69
--- /dev/null
+++ b/ultralytics/docs/en/guides/heatmaps.md
@@ -0,0 +1,296 @@
+---
+comments: true
+description: Advanced Data Visualization with Ultralytics YOLOv8 Heatmaps
+keywords: Ultralytics, YOLOv8, Advanced Data Visualization, Heatmap Technology, Object Detection and Tracking, Jupyter Notebook, Python SDK, Command Line Interface
+---
+
+# Advanced Data Visualization: Heatmaps using Ultralytics YOLOv8 ๐
+
+## Introduction to Heatmaps
+
+A heatmap generated with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) transforms complex data into a vibrant, color-coded matrix. This visual tool employs a spectrum of colors to represent varying data values, where warmer hues indicate higher intensities and cooler tones signify lower values. Heatmaps excel in visualizing intricate data patterns, correlations, and anomalies, offering an accessible and engaging approach to data interpretation across diverse domains.
+
+
+
+
+
+ Watch: Heatmaps using Ultralytics YOLOv8
+
+
+## Why Choose Heatmaps for Data Analysis?
+
+- **Intuitive Data Distribution Visualization:** Heatmaps simplify the comprehension of data concentration and distribution, converting complex datasets into easy-to-understand visual formats.
+- **Efficient Pattern Detection:** By visualizing data in heatmap format, it becomes easier to spot trends, clusters, and outliers, facilitating quicker analysis and insights.
+- **Enhanced Spatial Analysis and Decision Making:** Heatmaps are instrumental in illustrating spatial relationships, aiding in decision-making processes in sectors such as business intelligence, environmental studies, and urban planning.
+
+## Real World Applications
+
+| Transportation | Retail |
+|:-----------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|
+|  |  |
+| Ultralytics YOLOv8 Transportation Heatmap | Ultralytics YOLOv8 Retail Heatmap |
+
+???+ tip "heatmap_alpha"
+
+ heatmap_alpha value should be in range (0.0 - 1.0)
+
+???+ tip "decay_factor"
+
+ Used for removal of heatmap after object removed from frame, value should be in range (0.0 - 1.0)
+
+
+!!! Example "Heatmaps using Ultralytics YOLOv8 Example"
+
+ === "Heatmap"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import heatmap
+ import cv2
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ # Video writer
+ video_writer = cv2.VideoWriter("heatmap_output.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ # Init heatmap
+ heatmap_obj = heatmap.Heatmap()
+ heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
+ imw=cap.get(4), # should same as cap height
+ imh=cap.get(3), # should same as cap width
+ view_img=True,
+ shape="circle")
+
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ tracks = model.track(im0, persist=True, show=False)
+
+ im0 = heatmap_obj.generate_heatmap(im0, tracks)
+ video_writer.write(im0)
+
+ cap.release()
+ video_writer.release()
+ cv2.destroyAllWindows()
+
+ ```
+
+ === "Line Counting"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import heatmap
+ import cv2
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ # Video writer
+ video_writer = cv2.VideoWriter("heatmap_output.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ line_points = [(256, 409), (694, 532)] # line for object counting
+
+ # Init heatmap
+ heatmap_obj = heatmap.Heatmap()
+ heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
+ imw=cap.get(4), # should same as cap height
+ imh=cap.get(3), # should same as cap width
+ view_img=True,
+ shape="circle",
+ count_reg_pts=line_points)
+
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ tracks = model.track(im0, persist=True, show=False)
+
+ im0 = heatmap_obj.generate_heatmap(im0, tracks)
+ video_writer.write(im0)
+
+ cap.release()
+ video_writer.release()
+ cv2.destroyAllWindows()
+ ```
+
+ === "Region Counting"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import heatmap
+ import cv2
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ # Video writer
+ video_writer = cv2.VideoWriter("heatmap_output.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ # Define region points
+ region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
+
+ # Init heatmap
+ heatmap_obj = heatmap.Heatmap()
+ heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
+ imw=cap.get(4), # should same as cap height
+ imh=cap.get(3), # should same as cap width
+ view_img=True,
+ shape="circle",
+ count_reg_pts=region_points)
+
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ tracks = model.track(im0, persist=True, show=False)
+
+ im0 = heatmap_obj.generate_heatmap(im0, tracks)
+ video_writer.write(im0)
+
+ cap.release()
+ video_writer.release()
+ cv2.destroyAllWindows()
+ ```
+
+ === "Im0"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import heatmap
+ import cv2
+
+ model = YOLO("yolov8s.pt") # YOLOv8 custom/pretrained model
+
+ im0 = cv2.imread("path/to/image.png") # path to image file
+
+ # Heatmap Init
+ heatmap_obj = heatmap.Heatmap()
+ heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
+ imw=cap.get(4), # should same as cap height
+ imh=cap.get(3), # should same as cap width
+ view_img=True,
+ shape="circle")
+
+
+ results = model.track(im0, persist=True)
+ im0 = heatmap_obj.generate_heatmap(im0, tracks=results)
+ cv2.imwrite("ultralytics_output.png", im0)
+ ```
+
+ === "Specific Classes"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import heatmap
+ import cv2
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ # Video writer
+ video_writer = cv2.VideoWriter("heatmap_output.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ classes_for_heatmap = [0, 2] # classes for heatmap
+
+ # Init heatmap
+ heatmap_obj = heatmap.Heatmap()
+ heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA ,
+ imw=cap.get(4), # should same as cap height
+ imh=cap.get(3), # should same as cap width
+ view_img=True,
+ shape="circle")
+
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ tracks = model.track(im0, persist=True, show=False,
+ classes=classes_for_heatmap)
+
+ im0 = heatmap_obj.generate_heatmap(im0, tracks)
+ video_writer.write(im0)
+
+ cap.release()
+ video_writer.release()
+ cv2.destroyAllWindows()
+ ```
+
+### Arguments `set_args`
+
+| Name | Type | Default | Description |
+|---------------------|----------------|-------------------|-----------------------------------------------------------|
+| view_img | `bool` | `False` | Display the frame with heatmap |
+| colormap | `cv2.COLORMAP` | `None` | cv2.COLORMAP for heatmap |
+| imw | `int` | `None` | Width of Heatmap |
+| imh | `int` | `None` | Height of Heatmap |
+| heatmap_alpha | `float` | `0.5` | Heatmap alpha value |
+| count_reg_pts | `list` | `None` | Object counting region points |
+| count_txt_thickness | `int` | `2` | Count values text size |
+| count_txt_color | `RGB Color` | `(0, 0, 0)` | Foreground color for Object counts text |
+| count_color | `RGB Color` | `(255, 255, 255)` | Background color for Object counts text |
+| count_reg_color | `RGB Color` | `(255, 0, 255)` | Counting region color |
+| region_thickness | `int` | `5` | Counting region thickness value |
+| decay_factor | `float` | `0.99` | Decay factor for heatmap area removal after specific time |
+| shape | `str` | `circle` | Heatmap shape for display "rect" or "circle" supported |
+| line_dist_thresh | `int` | `15` | Euclidean Distance threshold for line counter |
+
+### Arguments `model.track`
+
+| Name | Type | Default | Description |
+|-----------|---------|----------------|-------------------------------------------------------------|
+| `source` | `im0` | `None` | source directory for images or videos |
+| `persist` | `bool` | `False` | persisting tracks between frames |
+| `tracker` | `str` | `botsort.yaml` | Tracking method 'bytetrack' or 'botsort' |
+| `conf` | `float` | `0.3` | Confidence Threshold |
+| `iou` | `float` | `0.5` | IOU Threshold |
+| `classes` | `list` | `None` | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+
+### Heatmap COLORMAPs
+
+| Colormap Name | Description |
+|---------------------------------|----------------------------------------|
+| `cv::COLORMAP_AUTUMN` | Autumn color map |
+| `cv::COLORMAP_BONE` | Bone color map |
+| `cv::COLORMAP_JET` | Jet color map |
+| `cv::COLORMAP_WINTER` | Winter color map |
+| `cv::COLORMAP_RAINBOW` | Rainbow color map |
+| `cv::COLORMAP_OCEAN` | Ocean color map |
+| `cv::COLORMAP_SUMMER` | Summer color map |
+| `cv::COLORMAP_SPRING` | Spring color map |
+| `cv::COLORMAP_COOL` | Cool color map |
+| `cv::COLORMAP_HSV` | HSV (Hue, Saturation, Value) color map |
+| `cv::COLORMAP_PINK` | Pink color map |
+| `cv::COLORMAP_HOT` | Hot color map |
+| `cv::COLORMAP_PARULA` | Parula color map |
+| `cv::COLORMAP_MAGMA` | Magma color map |
+| `cv::COLORMAP_INFERNO` | Inferno color map |
+| `cv::COLORMAP_PLASMA` | Plasma color map |
+| `cv::COLORMAP_VIRIDIS` | Viridis color map |
+| `cv::COLORMAP_CIVIDIS` | Cividis color map |
+| `cv::COLORMAP_TWILIGHT` | Twilight color map |
+| `cv::COLORMAP_TWILIGHT_SHIFTED` | Shifted Twilight color map |
+| `cv::COLORMAP_TURBO` | Turbo color map |
+| `cv::COLORMAP_DEEPGREEN` | Deep Green color map |
+
+These colormaps are commonly used for visualizing data with different color representations.
diff --git a/ultralytics/docs/en/guides/heatmaps.md:Zone.Identifier b/ultralytics/docs/en/guides/heatmaps.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/heatmaps.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/hyperparameter-tuning.md b/ultralytics/docs/en/guides/hyperparameter-tuning.md
new file mode 100755
index 0000000..f7d2b56
--- /dev/null
+++ b/ultralytics/docs/en/guides/hyperparameter-tuning.md
@@ -0,0 +1,206 @@
+---
+comments: true
+description: Dive into hyperparameter tuning in Ultralytics YOLO models. Learn how to optimize performance using the Tuner class and genetic evolution.
+keywords: Ultralytics, YOLO, Hyperparameter Tuning, Tuner Class, Genetic Evolution, Optimization
+---
+
+# Ultralytics YOLO Hyperparameter Tuning Guide
+
+## Introduction
+
+Hyperparameter tuning is not just a one-time set-up but an iterative process aimed at optimizing the machine learning model's performance metrics, such as accuracy, precision, and recall. In the context of Ultralytics YOLO, these hyperparameters could range from learning rate to architectural details, such as the number of layers or types of activation functions used.
+
+### What are Hyperparameters?
+
+Hyperparameters are high-level, structural settings for the algorithm. They are set prior to the training phase and remain constant during it. Here are some commonly tuned hyperparameters in Ultralytics YOLO:
+
+- **Learning Rate** `lr0`: Determines the step size at each iteration while moving towards a minimum in the loss function.
+- **Batch Size** `batch`: Number of images processed simultaneously in a forward pass.
+- **Number of Epochs** `epochs`: An epoch is one complete forward and backward pass of all the training examples.
+- **Architecture Specifics**: Such as channel counts, number of layers, types of activation functions, etc.
+
+
+
+
+
+For a full list of augmentation hyperparameters used in YOLOv8 please refer to the [configurations page](../usage/cfg.md#augmentation).
+
+### Genetic Evolution and Mutation
+
+Ultralytics YOLO uses genetic algorithms to optimize hyperparameters. Genetic algorithms are inspired by the mechanism of natural selection and genetics.
+
+- **Mutation**: In the context of Ultralytics YOLO, mutation helps in locally searching the hyperparameter space by applying small, random changes to existing hyperparameters, producing new candidates for evaluation.
+- **Crossover**: Although crossover is a popular genetic algorithm technique, it is not currently used in Ultralytics YOLO for hyperparameter tuning. The focus is mainly on mutation for generating new hyperparameter sets.
+
+## Preparing for Hyperparameter Tuning
+
+Before you begin the tuning process, it's important to:
+
+1. **Identify the Metrics**: Determine the metrics you will use to evaluate the model's performance. This could be AP50, F1-score, or others.
+2. **Set the Tuning Budget**: Define how much computational resources you're willing to allocate. Hyperparameter tuning can be computationally intensive.
+
+## Steps Involved
+
+### Initialize Hyperparameters
+
+Start with a reasonable set of initial hyperparameters. This could either be the default hyperparameters set by Ultralytics YOLO or something based on your domain knowledge or previous experiments.
+
+### Mutate Hyperparameters
+
+Use the `_mutate` method to produce a new set of hyperparameters based on the existing set.
+
+### Train Model
+
+Training is performed using the mutated set of hyperparameters. The training performance is then assessed.
+
+### Evaluate Model
+
+Use metrics like AP50, F1-score, or custom metrics to evaluate the model's performance.
+
+### Log Results
+
+It's crucial to log both the performance metrics and the corresponding hyperparameters for future reference.
+
+### Repeat
+
+The process is repeated until either the set number of iterations is reached or the performance metric is satisfactory.
+
+## Usage Example
+
+Here's how to use the `model.tune()` method to utilize the `Tuner` class for hyperparameter tuning of YOLOv8n on COCO8 for 30 epochs with an AdamW optimizer and skipping plotting, checkpointing and validation other than on final epoch for faster Tuning.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Initialize the YOLO model
+ model = YOLO('yolov8n.pt')
+
+ # Tune hyperparameters on COCO8 for 30 epochs
+ model.tune(data='coco8.yaml', epochs=30, iterations=300, optimizer='AdamW', plots=False, save=False, val=False)
+ ```
+
+## Results
+
+After you've successfully completed the hyperparameter tuning process, you will obtain several files and directories that encapsulate the results of the tuning. The following describes each:
+
+### File Structure
+
+Here's what the directory structure of the results will look like. Training directories like `train1/` contain individual tuning iterations, i.e. one model trained with one set of hyperparameters. The `tune/` directory contains tuning results from all the individual model trainings:
+
+```plaintext
+runs/
+โโโ detect/
+ โโโ train1/
+ โโโ train2/
+ โโโ ...
+ โโโ tune/
+ โโโ best_hyperparameters.yaml
+ โโโ best_fitness.png
+ โโโ tune_results.csv
+ โโโ tune_scatter_plots.png
+ โโโ weights/
+ โโโ last.pt
+ โโโ best.pt
+```
+
+### File Descriptions
+
+#### best_hyperparameters.yaml
+
+This YAML file contains the best-performing hyperparameters found during the tuning process. You can use this file to initialize future trainings with these optimized settings.
+
+- **Format**: YAML
+- **Usage**: Hyperparameter results
+- **Example**:
+ ```yaml
+ # 558/900 iterations complete โ (45536.81s)
+ # Results saved to /usr/src/ultralytics/runs/detect/tune
+ # Best fitness=0.64297 observed at iteration 498
+ # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
+ # Best fitness model is /usr/src/ultralytics/runs/detect/train498
+ # Best fitness hyperparameters are printed below.
+
+ lr0: 0.00269
+ lrf: 0.00288
+ momentum: 0.73375
+ weight_decay: 0.00015
+ warmup_epochs: 1.22935
+ warmup_momentum: 0.1525
+ box: 18.27875
+ cls: 1.32899
+ dfl: 0.56016
+ hsv_h: 0.01148
+ hsv_s: 0.53554
+ hsv_v: 0.13636
+ degrees: 0.0
+ translate: 0.12431
+ scale: 0.07643
+ shear: 0.0
+ perspective: 0.0
+ flipud: 0.0
+ fliplr: 0.08631
+ mosaic: 0.42551
+ mixup: 0.0
+ copy_paste: 0.0
+ ```
+
+#### best_fitness.png
+
+This is a plot displaying fitness (typically a performance metric like AP50) against the number of iterations. It helps you visualize how well the genetic algorithm performed over time.
+
+- **Format**: PNG
+- **Usage**: Performance visualization
+
+
+
+
+
+#### tune_results.csv
+
+A CSV file containing detailed results of each iteration during the tuning. Each row in the file represents one iteration, and it includes metrics like fitness score, precision, recall, as well as the hyperparameters used.
+
+- **Format**: CSV
+- **Usage**: Per-iteration results tracking.
+- **Example**:
+ ```csv
+ fitness,lr0,lrf,momentum,weight_decay,warmup_epochs,warmup_momentum,box,cls,dfl,hsv_h,hsv_s,hsv_v,degrees,translate,scale,shear,perspective,flipud,fliplr,mosaic,mixup,copy_paste
+ 0.05021,0.01,0.01,0.937,0.0005,3.0,0.8,7.5,0.5,1.5,0.015,0.7,0.4,0.0,0.1,0.5,0.0,0.0,0.0,0.5,1.0,0.0,0.0
+ 0.07217,0.01003,0.00967,0.93897,0.00049,2.79757,0.81075,7.5,0.50746,1.44826,0.01503,0.72948,0.40658,0.0,0.0987,0.4922,0.0,0.0,0.0,0.49729,1.0,0.0,0.0
+ 0.06584,0.01003,0.00855,0.91009,0.00073,3.42176,0.95,8.64301,0.54594,1.72261,0.01503,0.59179,0.40658,0.0,0.0987,0.46955,0.0,0.0,0.0,0.49729,0.80187,0.0,0.0
+ ```
+
+#### tune_scatter_plots.png
+
+This file contains scatter plots generated from `tune_results.csv`, helping you visualize relationships between different hyperparameters and performance metrics. Note that hyperparameters initialized to 0 will not be tuned, such as `degrees` and `shear` below.
+
+- **Format**: PNG
+- **Usage**: Exploratory data analysis
+
+
+
+
+
+#### weights/
+
+This directory contains the saved PyTorch models for the last and the best iterations during the hyperparameter tuning process.
+
+- **`last.pt`**: The last.pt are the weights from the last epoch of training.
+- **`best.pt`**: The best.pt weights for the iteration that achieved the best fitness score.
+
+Using these results, you can make more informed decisions for your future model trainings and analyses. Feel free to consult these artifacts to understand how well your model performed and how you might improve it further.
+
+## Conclusion
+
+The hyperparameter tuning process in Ultralytics YOLO is simplified yet powerful, thanks to its genetic algorithm-based approach focused on mutation. Following the steps outlined in this guide will assist you in systematically tuning your model to achieve better performance.
+
+### Further Reading
+
+1. [Hyperparameter Optimization in Wikipedia](https://en.wikipedia.org/wiki/Hyperparameter_optimization)
+2. [YOLOv5 Hyperparameter Evolution Guide](../yolov5/tutorials/hyperparameter_evolution.md)
+3. [Efficient Hyperparameter Tuning with Ray Tune and YOLOv8](../integrations/ray-tune.md)
+
+For deeper insights, you can explore the `Tuner` class source code and accompanying documentation. Should you have any questions, feature requests, or need further assistance, feel free to reach out to us on [GitHub](https://github.com/ultralytics/ultralytics/issues/new/choose) or [Discord](https://ultralytics.com/discord).
diff --git a/ultralytics/docs/en/guides/hyperparameter-tuning.md:Zone.Identifier b/ultralytics/docs/en/guides/hyperparameter-tuning.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/hyperparameter-tuning.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/index.md b/ultralytics/docs/en/guides/index.md
new file mode 100755
index 0000000..e4efcea
--- /dev/null
+++ b/ultralytics/docs/en/guides/index.md
@@ -0,0 +1,47 @@
+---
+comments: true
+description: In-depth exploration of Ultralytics' YOLO. Learn about the YOLO object detection model, how to train it on custom data, multi-GPU training, exporting, predicting, deploying, and more.
+keywords: Ultralytics, YOLO, Deep Learning, Object detection, PyTorch, Tutorial, Multi-GPU training, Custom data training, SAHI, Tiled Inference
+---
+
+# Comprehensive Tutorials to Ultralytics YOLO
+
+Welcome to the Ultralytics' YOLO ๐ Guides! Our comprehensive tutorials cover various aspects of the YOLO object detection model, ranging from training and prediction to deployment. Built on PyTorch, YOLO stands out for its exceptional speed and accuracy in real-time object detection tasks.
+
+Whether you're a beginner or an expert in deep learning, our tutorials offer valuable insights into the implementation and optimization of YOLO for your computer vision projects. Let's dive in!
+
+## Guides
+
+Here's a compilation of in-depth guides to help you master different aspects of Ultralytics YOLO.
+
+* [YOLO Common Issues](yolo-common-issues.md) โญ RECOMMENDED: Practical solutions and troubleshooting tips to the most frequently encountered issues when working with Ultralytics YOLO models.
+* [YOLO Performance Metrics](yolo-performance-metrics.md) โญ ESSENTIAL: Understand the key metrics like mAP, IoU, and F1 score used to evaluate the performance of your YOLO models. Includes practical examples and tips on how to improve detection accuracy and speed.
+* [Model Deployment Options](model-deployment-options.md): Overview of YOLO model deployment formats like ONNX, OpenVINO, and TensorRT, with pros and cons for each to inform your deployment strategy.
+* [K-Fold Cross Validation](kfold-cross-validation.md) ๐ NEW: Learn how to improve model generalization using K-Fold cross-validation technique.
+* [Hyperparameter Tuning](hyperparameter-tuning.md) ๐ NEW: Discover how to optimize your YOLO models by fine-tuning hyperparameters using the Tuner class and genetic evolution algorithms.
+* [SAHI Tiled Inference](sahi-tiled-inference.md) ๐ NEW: Comprehensive guide on leveraging SAHI's sliced inference capabilities with YOLOv8 for object detection in high-resolution images.
+* [AzureML Quickstart](azureml-quickstart.md) ๐ NEW: Get up and running with Ultralytics YOLO models on Microsoft's Azure Machine Learning platform. Learn how to train, deploy, and scale your object detection projects in the cloud.
+* [Conda Quickstart](conda-quickstart.md) ๐ NEW: Step-by-step guide to setting up a [Conda](https://anaconda.org/conda-forge/ultralytics) environment for Ultralytics. Learn how to install and start using the Ultralytics package efficiently with Conda.
+* [Docker Quickstart](docker-quickstart.md) ๐ NEW: Complete guide to setting up and using Ultralytics YOLO models with [Docker](https://hub.docker.com/r/ultralytics/ultralytics). Learn how to install Docker, manage GPU support, and run YOLO models in isolated containers for consistent development and deployment.
+* [Raspberry Pi](raspberry-pi.md) ๐ NEW: Quickstart tutorial to run YOLO models to the latest Raspberry Pi hardware.
+* [Triton Inference Server Integration](triton-inference-server.md) ๐ NEW: Dive into the integration of Ultralytics YOLOv8 with NVIDIA's Triton Inference Server for scalable and efficient deep learning inference deployments.
+* [YOLO Thread-Safe Inference](yolo-thread-safe-inference.md) ๐ NEW: Guidelines for performing inference with YOLO models in a thread-safe manner. Learn the importance of thread safety and best practices to prevent race conditions and ensure consistent predictions.
+* [Isolating Segmentation Objects](isolating-segmentation-objects.md) ๐ NEW: Step-by-step recipe and explanation on how to extract and/or isolate objects from images using Ultralytics Segmentation.
+
+## Real-World Projects
+
+* [Object Counting](object-counting.md) ๐ NEW: Explore the process of real-time object counting with Ultralytics YOLOv8 and acquire the knowledge to effectively count objects in a live video stream.
+* [Workouts Monitoring](workouts-monitoring.md) ๐ NEW: Discover the comprehensive approach to monitoring workouts with Ultralytics YOLOv8. Acquire the skills and insights necessary to effectively use YOLOv8 for tracking and analyzing various aspects of fitness routines in real time.
+* [Objects Counting in Regions](region-counting.md) ๐ NEW: Explore counting objects in specific regions with Ultralytics YOLOv8 for precise and efficient object detection in varied areas.
+* [Security Alarm System](security-alarm-system.md) ๐ NEW: Discover the process of creating a security alarm system with Ultralytics YOLOv8. This system triggers alerts upon detecting new objects in the frame. Subsequently, you can customize the code to align with your specific use case.
+* [Heatmaps](heatmaps.md) ๐ NEW: Elevate your understanding of data with our Detection Heatmaps! These intuitive visual tools use vibrant color gradients to vividly illustrate the intensity of data values across a matrix. Essential in computer vision, heatmaps are skillfully designed to highlight areas of interest, providing an immediate, impactful way to interpret spatial information.
+* [Instance Segmentation with Object Tracking](instance-segmentation-and-tracking.md) ๐ NEW: Explore our feature on Object Segmentation in Bounding Boxes Shape, providing a visual representation of precise object boundaries for enhanced understanding and analysis.
+* [VisionEye View Objects Mapping](vision-eye.md) ๐ NEW: This feature aim computers to discern and focus on specific objects, much like the way the human eye observes details from a particular viewpoint.
+
+## Contribute to Our Guides
+
+We welcome contributions from the community! If you've mastered a particular aspect of Ultralytics YOLO that's not yet covered in our guides, we encourage you to share your expertise. Writing a guide is a great way to give back to the community and help us make our documentation more comprehensive and user-friendly.
+
+To get started, please read our [Contributing Guide](../help/contributing.md) for guidelines on how to open up a Pull Request (PR) ๐ ๏ธ. We look forward to your contributions!
+
+Let's work together to make the Ultralytics YOLO ecosystem more robust and versatile ๐!
diff --git a/ultralytics/docs/en/guides/index.md:Zone.Identifier b/ultralytics/docs/en/guides/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/instance-segmentation-and-tracking.md b/ultralytics/docs/en/guides/instance-segmentation-and-tracking.md
new file mode 100755
index 0000000..c08b75c
--- /dev/null
+++ b/ultralytics/docs/en/guides/instance-segmentation-and-tracking.md
@@ -0,0 +1,127 @@
+---
+comments: true
+description: Instance Segmentation with Object Tracking using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Instance Segmentation, Object Detection, Object Tracking, Segbbox, Computer Vision, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Instance Segmentation and Tracking using Ultralytics YOLOv8 ๐
+
+## What is Instance Segmentation?
+
+[Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) instance segmentation involves identifying and outlining individual objects in an image, providing a detailed understanding of spatial distribution. Unlike semantic segmentation, it uniquely labels and precisely delineates each object, crucial for tasks like object detection and medical imaging.
+
+There are two types of instance segmentation tracking available in the Ultralytics package:
+
+- **Instance Segmentation with Class Objects:** Each class object is assigned a unique color for clear visual separation.
+
+- **Instance Segmentation with Object Tracks:** Every track is represented by a distinct color, facilitating easy identification and tracking.
+
+## Samples
+
+| Instance Segmentation | Instance Segmentation + Object Tracking |
+|:---------------------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+|  |  |
+| Ultralytics Instance Segmentation ๐ | Ultralytics Instance Segmentation with Object Tracking ๐ฅ |
+
+!!! Example "Instance Segmentation and Tracking"
+
+ === "Instance Segmentation"
+ ```python
+ import cv2
+ from ultralytics import YOLO
+ from ultralytics.utils.plotting import Annotator, colors
+
+ model = YOLO("yolov8n-seg.pt")
+ names = model.model.names
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+
+ out = cv2.VideoWriter('instance-segmentation.avi',
+ cv2.VideoWriter_fourcc(*'MJPG'),
+ 30, (int(cap.get(3)), int(cap.get(4))))
+
+ while True:
+ ret, im0 = cap.read()
+ if not ret:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+
+ results = model.predict(im0)
+ clss = results[0].boxes.cls.cpu().tolist()
+ masks = results[0].masks.xy
+
+ annotator = Annotator(im0, line_width=2)
+
+ for mask, cls in zip(masks, clss):
+ annotator.seg_bbox(mask=mask,
+ mask_color=colors(int(cls), True),
+ det_label=names[int(cls)])
+
+ out.write(im0)
+ cv2.imshow("instance-segmentation", im0)
+
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+
+ out.release()
+ cap.release()
+ cv2.destroyAllWindows()
+
+ ```
+
+ === "Instance Segmentation with Object Tracking"
+ ```python
+ import cv2
+ from ultralytics import YOLO
+ from ultralytics.utils.plotting import Annotator, colors
+
+ from collections import defaultdict
+
+ track_history = defaultdict(lambda: [])
+
+ model = YOLO("yolov8n-seg.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+
+ out = cv2.VideoWriter('instance-segmentation-object-tracking.avi',
+ cv2.VideoWriter_fourcc(*'MJPG'),
+ 30, (int(cap.get(3)), int(cap.get(4))))
+
+ while True:
+ ret, im0 = cap.read()
+ if not ret:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+
+ results = model.track(im0, persist=True)
+ masks = results[0].masks.xy
+ track_ids = results[0].boxes.id.int().cpu().tolist()
+
+ annotator = Annotator(im0, line_width=2)
+
+ for mask, track_id in zip(masks, track_ids):
+ annotator.seg_bbox(mask=mask,
+ mask_color=colors(track_id, True),
+ track_label=str(track_id))
+
+ out.write(im0)
+ cv2.imshow("instance-segmentation-object-tracking", im0)
+
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+
+ out.release()
+ cap.release()
+ cv2.destroyAllWindows()
+ ```
+
+### `seg_bbox` Arguments
+
+| Name | Type | Default | Description |
+|---------------|---------|-----------------|----------------------------------------|
+| `mask` | `array` | `None` | Segmentation mask coordinates |
+| `mask_color` | `tuple` | `(255, 0, 255)` | Mask color for every segmented box |
+| `det_label` | `str` | `None` | Label for segmented object |
+| `track_label` | `str` | `None` | Label for segmented and tracked object |
+
+## Note
+
+For any inquiries, feel free to post your questions in the [Ultralytics Issue Section](https://github.com/ultralytics/ultralytics/issues/new/choose) or the discussion section mentioned below.
diff --git a/ultralytics/docs/en/guides/instance-segmentation-and-tracking.md:Zone.Identifier b/ultralytics/docs/en/guides/instance-segmentation-and-tracking.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/instance-segmentation-and-tracking.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/isolating-segmentation-objects.md b/ultralytics/docs/en/guides/isolating-segmentation-objects.md
new file mode 100755
index 0000000..a0436f4
--- /dev/null
+++ b/ultralytics/docs/en/guides/isolating-segmentation-objects.md
@@ -0,0 +1,325 @@
+---
+comments: true
+description: A concise guide on isolating segmented objects using Ultralytics.
+keywords: Ultralytics, YOLO, segmentation, Python, object detection, inference, dataset, prediction, instance segmentation, contours, binary mask, object mask, image processing
+---
+
+# Isolating Segmentation Objects
+
+After performing the [Segment Task](../tasks/segment.md), it's sometimes desirable to extract the isolated objects from the inference results. This guide provides a generic recipe on how to accomplish this using the Ultralytics [Predict Mode](../modes/predict.md).
+
+
+
+
+
+## Recipe Walk Through
+
+1. Begin with the necessary imports
+
+ ```py
+ from pathlib import Path
+
+ import cv2 as cv
+ import numpy as np
+ from ultralytics import YOLO
+ ```
+
+ ???+ tip "Ultralytics Install"
+
+ See the Ultralytics [Quickstart](../quickstart.md/#install-ultralytics) Installation section for a quick walkthrough on installing the required libraries.
+
+ ---
+
+2. Load a model and run `predict()` method on a source.
+
+ ```py
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-seg.pt')
+
+ # Run inference
+ result = model.predict()
+ ```
+
+ ??? question "No Prediction Arguments?"
+
+ Without specifying a source, the example images from the library will be used:
+
+ ```
+ 'ultralytics/assets/bus.jpg'
+ 'ultralytics/assets/zidane.jpg'
+ ```
+
+ This is helpful for rapid testing with the `predict()` method.
+
+ For additional information about Segmentation Models, visit the [Segment Task](../tasks/segment.md#models) page. To learn more about `predict()` method, see [Predict Mode](../modes/predict.md) section of the Documentation.
+
+ ---
+
+3. Now iterate over the results and the contours. For workflows that want to save an image to file, the source image `base-name` and the detection `class-label` are retrieved for later use (optional).
+
+ ``` { .py .annotate }
+ # (2) Iterate detection results (helpful for multiple images)
+ for r in res:
+ img = np.copy(r.orig_img)
+ img_name = Path(r.path).stem # source image base-name
+
+ # Iterate each object contour (multiple detections)
+ for ci,c in enumerate(r):
+ # (1) Get detection class name
+ label = c.names[c.boxes.cls.tolist().pop()]
+
+ ```
+
+ 1. To learn more about working with detection results, see [Boxes Section for Predict Mode](../modes/predict.md#boxes).
+ 2. To learn more about `predict()` results see [Working with Results for Predict Mode](../modes/predict.md#working-with-results)
+
+ ??? info "For-Loop"
+
+ A single image will only iterate the first loop once. A single image with only a single detection will iterate each loop _only_ once.
+
+ ---
+
+4. Start with generating a binary mask from the source image and then draw a filled contour onto the mask. This will allow the object to be isolated from the other parts of the image. An example from `bus.jpg` for one of the detected `person` class objects is shown on the right.
+
+ { width="240", align="right" }
+
+ ``` { .py .annotate }
+ # Create binary mask
+ b_mask = np.zeros(img.shape[:2], np.uint8)
+
+ # (1) Extract contour result
+ contour = c.masks.xy.pop()
+ # (2) Changing the type
+ contour = contour.astype(np.int32)
+ # (3) Reshaping
+ contour = contour.reshape(-1, 1, 2)
+
+
+ # Draw contour onto mask
+ _ = cv.drawContours(b_mask,
+ [contour],
+ -1,
+ (255, 255, 255),
+ cv.FILLED)
+
+ ```
+
+ 1. For more info on `c.masks.xy` see [Masks Section from Predict Mode](../modes/predict.md#masks).
+
+ 2. Here, the values are cast into `np.int32` for compatibility with `drawContours()` function from OpenCV.
+
+ 3. The OpenCV `drawContours()` function expects contours to have a shape of `[N, 1, 2]` expand section below for more details.
+
+
+ Expand to understand what is happening when defining the contour variable.
+
+
+ - `c.masks.xy` :: Provides the coordinates of the mask contour points in the format `(x, y)`. For more details, refer to the [Masks Section from Predict Mode](../modes/predict.md#masks).
+
+ - `.pop()` :: As `masks.xy` is a list containing a single element, this element is extracted using the `pop()` method.
+
+ - `.astype(np.int32)` :: Using `masks.xy` will return with a data type of `float32`, but this won't be compatible with the OpenCV `drawContours()` function, so this will change the data type to `int32` for compatibility.
+
+ - `.reshape(-1, 1, 2)` :: Reformats the data into the required shape of `[N, 1, 2]` where `N` is the number of contour points, with each point represented by a single entry `1`, and the entry is composed of `2` values. The `-1` denotes that the number of values along this dimension is flexible.
+
+
+
+
+ Expand for an explanation of the drawContours() configuration.
+
+
+ - Encapsulating the `contour` variable within square brackets, `[contour]`, was found to effectively generate the desired contour mask during testing.
+
+ - The value `-1` specified for the `drawContours()` parameter instructs the function to draw all contours present in the image.
+
+ - The `tuple` `(255, 255, 255)` represents the color white, which is the desired color for drawing the contour in this binary mask.
+
+ - The addition of `cv.FILLED` will color all pixels enclosed by the contour boundary the same, in this case, all enclosed pixels will be white.
+
+ - See [OpenCV Documentation on `drawContours()`](https://docs.opencv.org/4.8.0/d6/d6e/group__imgproc__draw.html#ga746c0625f1781f1ffc9056259103edbc) for more information.
+
+
+
+
+ ---
+
+5. Next the there are 2 options for how to move forward with the image from this point and a subsequent option for each.
+
+ ### Object Isolation Options
+
+ !!! example ""
+
+ === "Black Background Pixels"
+
+ ```py
+ # Create 3-channel mask
+ mask3ch = cv.cvtColor(b_mask, cv.COLOR_GRAY2BGR)
+
+ # Isolate object with binary mask
+ isolated = cv.bitwise_and(mask3ch, img)
+
+ ```
+
+ ??? question "How does this work?"
+
+ - First, the binary mask is first converted from a single-channel image to a three-channel image. This conversion is necessary for the subsequent step where the mask and the original image are combined. Both images must have the same number of channels to be compatible with the blending operation.
+
+ - The original image and the three-channel binary mask are merged using the OpenCV function `bitwise_and()`. This operation retains only pixel values that are greater than zero `(> 0)` from both images. Since the mask pixels are greater than zero `(> 0)` only within the contour region, the pixels remaining from the original image are those that overlap with the contour.
+
+ ### Isolate with Black Pixels: Sub-options
+
+ ??? info "Full-size Image"
+
+ There are no additional steps required if keeping full size image.
+
+
+ { width=240 }
+ Example full-size output
+
+
+ ??? info "Cropped object Image"
+
+ Additional steps required to crop image to only include object region.
+
+ { align="right" }
+ ``` { .py .annotate }
+ # (1) Bounding box coordinates
+ x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
+ # Crop image to object region
+ iso_crop = isolated[y1:y2, x1:x2]
+
+ ```
+
+ 1. For more information on bounding box results, see [Boxes Section from Predict Mode](../modes/predict.md/#boxes)
+
+ ??? question "What does this code do?"
+
+ - The `c.boxes.xyxy.cpu().numpy()` call retrieves the bounding boxes as a NumPy array in the `xyxy` format, where `xmin`, `ymin`, `xmax`, and `ymax` represent the coordinates of the bounding box rectangle. See [Boxes Section from Predict Mode](../modes/predict.md/#boxes) for more details.
+
+ - The `squeeze()` operation removes any unnecessary dimensions from the NumPy array, ensuring it has the expected shape.
+
+ - Converting the coordinate values using `.astype(np.int32)` changes the box coordinates data type from `float32` to `int32`, making them compatible for image cropping using index slices.
+
+ - Finally, the bounding box region is cropped from the image using index slicing. The bounds are defined by the `[ymin:ymax, xmin:xmax]` coordinates of the detection bounding box.
+
+ === "Transparent Background Pixels"
+
+ ```py
+ # Isolate object with transparent background (when saved as PNG)
+ isolated = np.dstack([img, b_mask])
+
+ ```
+
+ ??? question "How does this work?"
+
+ - Using the NumPy `dstack()` function (array stacking along depth-axis) in conjunction with the binary mask generated, will create an image with four channels. This allows for all pixels outside of the object contour to be transparent when saving as a `PNG` file.
+
+ ### Isolate with Transparent Pixels: Sub-options
+
+ ??? info "Full-size Image"
+
+ There are no additional steps required if keeping full size image.
+
+
+ { width=240 }
+ Example full-size output + transparent background
+
+
+ ??? info "Cropped object Image"
+
+ Additional steps required to crop image to only include object region.
+
+ { align="right" }
+ ``` { .py .annotate }
+ # (1) Bounding box coordinates
+ x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
+ # Crop image to object region
+ iso_crop = isolated[y1:y2, x1:x2]
+
+ ```
+
+ 1. For more information on bounding box results, see [Boxes Section from Predict Mode](../modes/predict.md/#boxes)
+
+ ??? question "What does this code do?"
+
+ - When using `c.boxes.xyxy.cpu().numpy()`, the bounding boxes are returned as a NumPy array, using the `xyxy` box coordinates format, which correspond to the points `xmin, ymin, xmax, ymax` for the bounding box (rectangle), see [Boxes Section from Predict Mode](../modes/predict.md/#boxes) for more information.
+
+ - Adding `squeeze()` ensures that any extraneous dimensions are removed from the NumPy array.
+
+ - Converting the coordinate values using `.astype(np.int32)` changes the box coordinates data type from `float32` to `int32` which will be compatible when cropping the image using index slices.
+
+ - Finally the image region for the bounding box is cropped using index slicing, where the bounds are set using the `[ymin:ymax, xmin:xmax]` coordinates of the detection bounding box.
+
+ ??? question "What if I want the cropped object **including** the background?"
+
+ This is a built in feature for the Ultralytics library. See the `save_crop` argument for [Predict Mode Inference Arguments](../modes/predict.md/#inference-arguments) for details.
+
+ ---
+
+6. What to do next is entirely left to you as the developer. A basic example of one possible next step (saving the image to file for future use) is shown.
+
+ - **NOTE:** this step is optional and can be skipped if not required for your specific use case.
+
+ ??? example "Example Final Step"
+
+ ```py
+ # Save isolated object to file
+ _ = cv.imwrite(f'{img_name}_{label}-{ci}.png', iso_crop)
+ ```
+
+ - In this example, the `img_name` is the base-name of the source image file, `label` is the detected class-name, and `ci` is the index of the object detection (in case of multiple instances with the same class name).
+
+## Full Example code
+
+Here, all steps from the previous section are combined into a single block of code. For repeated use, it would be optimal to define a function to do some or all commands contained in the `for`-loops, but that is an exercise left to the reader.
+
+``` { .py .annotate }
+from pathlib import Path
+
+import cv2 as cv
+import numpy as np
+from ultralytics import YOLO
+
+m = YOLO('yolov8n-seg.pt')#(4)!
+res = m.predict()#(3)!
+
+# iterate detection results (5)
+for r in res:
+ img = np.copy(r.orig_img)
+ img_name = Path(r.path).stem
+
+ # iterate each object contour (6)
+ for ci,c in enumerate(r):
+ label = c.names[c.boxes.cls.tolist().pop()]
+
+ b_mask = np.zeros(img.shape[:2], np.uint8)
+
+ # Create contour mask (1)
+ contour = c.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2)
+ _ = cv.drawContours(b_mask, [contour], -1, (255, 255, 255), cv.FILLED)
+
+ # Choose one:
+
+ # OPTION-1: Isolate object with black background
+ mask3ch = cv.cvtColor(b_mask, cv.COLOR_GRAY2BGR)
+ isolated = cv.bitwise_and(mask3ch, img)
+
+ # OPTION-2: Isolate object with transparent background (when saved as PNG)
+ isolated = np.dstack([img, b_mask])
+
+ # OPTIONAL: detection crop (from either OPT1 or OPT2)
+ x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
+ iso_crop = isolated[y1:y2, x1:x2]
+
+ # TODO your actions go here (2)
+
+```
+
+1. The line populating `contour` is combined into a single line here, where it was split to multiple above.
+2. {==What goes here is up to you!==}
+3. See [Predict Mode](../modes/predict.md) for additional information.
+4. See [Segment Task](../tasks/segment.md#models) for more information.
+5. Learn more about [Working with Results](../modes/predict.md#working-with-results)
+6. Learn more about [Segmentation Mask Results](../modes/predict.md#masks)
diff --git a/ultralytics/docs/en/guides/isolating-segmentation-objects.md:Zone.Identifier b/ultralytics/docs/en/guides/isolating-segmentation-objects.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/isolating-segmentation-objects.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/kfold-cross-validation.md b/ultralytics/docs/en/guides/kfold-cross-validation.md
new file mode 100755
index 0000000..9eb53a1
--- /dev/null
+++ b/ultralytics/docs/en/guides/kfold-cross-validation.md
@@ -0,0 +1,278 @@
+---
+comments: true
+description: An in-depth guide demonstrating the implementation of K-Fold Cross Validation with the Ultralytics ecosystem for object detection datasets, leveraging Python, YOLO, and sklearn.
+keywords: K-Fold cross validation, Ultralytics, YOLO detection format, Python, sklearn, object detection
+---
+
+# K-Fold Cross Validation with Ultralytics
+
+## Introduction
+
+This comprehensive guide illustrates the implementation of K-Fold Cross Validation for object detection datasets within the Ultralytics ecosystem. We'll leverage the YOLO detection format and key Python libraries such as sklearn, pandas, and PyYaml to guide you through the necessary setup, the process of generating feature vectors, and the execution of a K-Fold dataset split.
+
+
+
+
+
+Whether your project involves the Fruit Detection dataset or a custom data source, this tutorial aims to help you comprehend and apply K-Fold Cross Validation to bolster the reliability and robustness of your machine learning models. While we're applying `k=5` folds for this tutorial, keep in mind that the optimal number of folds can vary depending on your dataset and the specifics of your project.
+
+Without further ado, let's dive in!
+
+## Setup
+
+- Your annotations should be in the [YOLO detection format](../datasets/detect/index.md).
+
+- This guide assumes that annotation files are locally available.
+
+- For our demonstration, we use the [Fruit Detection](https://www.kaggle.com/datasets/lakshaytyagi01/fruit-detection/code) dataset.
+ - This dataset contains a total of 8479 images.
+ - It includes 6 class labels, each with its total instance counts listed below.
+
+| Class Label | Instance Count |
+|:------------|:--------------:|
+| Apple | 7049 |
+| Grapes | 7202 |
+| Pineapple | 1613 |
+| Orange | 15549 |
+| Banana | 3536 |
+| Watermelon | 1976 |
+
+- Necessary Python packages include:
+
+ - `ultralytics`
+ - `sklearn`
+ - `pandas`
+ - `pyyaml`
+
+- This tutorial operates with `k=5` folds. However, you should determine the best number of folds for your specific dataset.
+
+1. Initiate a new Python virtual environment (`venv`) for your project and activate it. Use `pip` (or your preferred package manager) to install:
+
+ - The Ultralytics library: `pip install -U ultralytics`. Alternatively, you can clone the official [repo](https://github.com/ultralytics/ultralytics).
+ - Scikit-learn, pandas, and PyYAML: `pip install -U scikit-learn pandas pyyaml`.
+
+2. Verify that your annotations are in the [YOLO detection format](../datasets/detect/index.md).
+
+ - For this tutorial, all annotation files are found in the `Fruit-Detection/labels` directory.
+
+## Generating Feature Vectors for Object Detection Dataset
+
+1. Start by creating a new Python file and import the required libraries.
+
+ ```python
+ import datetime
+ import shutil
+ from pathlib import Path
+ from collections import Counter
+
+ import yaml
+ import numpy as np
+ import pandas as pd
+ from ultralytics import YOLO
+ from sklearn.model_selection import KFold
+ ```
+
+2. Proceed to retrieve all label files for your dataset.
+
+ ```python
+ dataset_path = Path('./Fruit-detection') # replace with 'path/to/dataset' for your custom data
+ labels = sorted(dataset_path.rglob("*labels/*.txt")) # all data in 'labels'
+ ```
+
+3. Now, read the contents of the dataset YAML file and extract the indices of the class labels.
+
+ ```python
+ yaml_file = 'path/to/data.yaml' # your data YAML with data directories and names dictionary
+ with open(yaml_file, 'r', encoding="utf8") as y:
+ classes = yaml.safe_load(y)['names']
+ cls_idx = sorted(classes.keys())
+ ```
+
+4. Initialize an empty `pandas` DataFrame.
+
+ ```python
+ indx = [l.stem for l in labels] # uses base filename as ID (no extension)
+ labels_df = pd.DataFrame([], columns=cls_idx, index=indx)
+ ```
+
+5. Count the instances of each class-label present in the annotation files.
+
+ ```python
+ for label in labels:
+ lbl_counter = Counter()
+
+ with open(label,'r') as lf:
+ lines = lf.readlines()
+
+ for l in lines:
+ # classes for YOLO label uses integer at first position of each line
+ lbl_counter[int(l.split(' ')[0])] += 1
+
+ labels_df.loc[label.stem] = lbl_counter
+
+ labels_df = labels_df.fillna(0.0) # replace `nan` values with `0.0`
+ ```
+
+6. The following is a sample view of the populated DataFrame:
+
+ ```pandas
+ 0 1 2 3 4 5
+ '0000a16e4b057580_jpg.rf.00ab48988370f64f5ca8ea4...' 0.0 0.0 0.0 0.0 0.0 7.0
+ '0000a16e4b057580_jpg.rf.7e6dce029fb67f01eb19aa7...' 0.0 0.0 0.0 0.0 0.0 7.0
+ '0000a16e4b057580_jpg.rf.bc4d31cdcbe229dd022957a...' 0.0 0.0 0.0 0.0 0.0 7.0
+ '00020ebf74c4881c_jpg.rf.508192a0a97aa6c4a3b6882...' 0.0 0.0 0.0 1.0 0.0 0.0
+ '00020ebf74c4881c_jpg.rf.5af192a2254c8ecc4188a25...' 0.0 0.0 0.0 1.0 0.0 0.0
+ ... ... ... ... ... ... ...
+ 'ff4cd45896de38be_jpg.rf.c4b5e967ca10c7ced3b9e97...' 0.0 0.0 0.0 0.0 0.0 2.0
+ 'ff4cd45896de38be_jpg.rf.ea4c1d37d2884b3e3cbce08...' 0.0 0.0 0.0 0.0 0.0 2.0
+ 'ff5fd9c3c624b7dc_jpg.rf.bb519feaa36fc4bf630a033...' 1.0 0.0 0.0 0.0 0.0 0.0
+ 'ff5fd9c3c624b7dc_jpg.rf.f0751c9c3aa4519ea3c9d6a...' 1.0 0.0 0.0 0.0 0.0 0.0
+ 'fffe28b31f2a70d4_jpg.rf.7ea16bd637ba0711c53b540...' 0.0 6.0 0.0 0.0 0.0 0.0
+ ```
+
+The rows index the label files, each corresponding to an image in your dataset, and the columns correspond to your class-label indices. Each row represents a pseudo feature-vector, with the count of each class-label present in your dataset. This data structure enables the application of K-Fold Cross Validation to an object detection dataset.
+
+## K-Fold Dataset Split
+
+1. Now we will use the `KFold` class from `sklearn.model_selection` to generate `k` splits of the dataset.
+
+ - Important:
+ - Setting `shuffle=True` ensures a randomized distribution of classes in your splits.
+ - By setting `random_state=M` where `M` is a chosen integer, you can obtain repeatable results.
+
+ ```python
+ ksplit = 5
+ kf = KFold(n_splits=ksplit, shuffle=True, random_state=20) # setting random_state for repeatable results
+
+ kfolds = list(kf.split(labels_df))
+ ```
+
+2. The dataset has now been split into `k` folds, each having a list of `train` and `val` indices. We will construct a DataFrame to display these results more clearly.
+
+ ```python
+ folds = [f'split_{n}' for n in range(1, ksplit + 1)]
+ folds_df = pd.DataFrame(index=indx, columns=folds)
+
+ for idx, (train, val) in enumerate(kfolds, start=1):
+ folds_df[f'split_{idx}'].loc[labels_df.iloc[train].index] = 'train'
+ folds_df[f'split_{idx}'].loc[labels_df.iloc[val].index] = 'val'
+ ```
+
+3. Now we will calculate the distribution of class labels for each fold as a ratio of the classes present in `val` to those present in `train`.
+
+ ```python
+ fold_lbl_distrb = pd.DataFrame(index=folds, columns=cls_idx)
+
+ for n, (train_indices, val_indices) in enumerate(kfolds, start=1):
+ train_totals = labels_df.iloc[train_indices].sum()
+ val_totals = labels_df.iloc[val_indices].sum()
+
+ # To avoid division by zero, we add a small value (1E-7) to the denominator
+ ratio = val_totals / (train_totals + 1E-7)
+ fold_lbl_distrb.loc[f'split_{n}'] = ratio
+ ```
+
+ The ideal scenario is for all class ratios to be reasonably similar for each split and across classes. This, however, will be subject to the specifics of your dataset.
+
+4. Next, we create the directories and dataset YAML files for each split.
+
+ ```python
+ supported_extensions = ['.jpg', '.jpeg', '.png']
+
+ # Initialize an empty list to store image file paths
+ images = []
+
+ # Loop through supported extensions and gather image files
+ for ext in supported_extensions:
+ images.extend(sorted((dataset_path / 'images').rglob(f"*{ext}")))
+
+ # Create the necessary directories and dataset YAML files (unchanged)
+ save_path = Path(dataset_path / f'{datetime.date.today().isoformat()}_{ksplit}-Fold_Cross-val')
+ save_path.mkdir(parents=True, exist_ok=True)
+ ds_yamls = []
+
+ for split in folds_df.columns:
+ # Create directories
+ split_dir = save_path / split
+ split_dir.mkdir(parents=True, exist_ok=True)
+ (split_dir / 'train' / 'images').mkdir(parents=True, exist_ok=True)
+ (split_dir / 'train' / 'labels').mkdir(parents=True, exist_ok=True)
+ (split_dir / 'val' / 'images').mkdir(parents=True, exist_ok=True)
+ (split_dir / 'val' / 'labels').mkdir(parents=True, exist_ok=True)
+
+ # Create dataset YAML files
+ dataset_yaml = split_dir / f'{split}_dataset.yaml'
+ ds_yamls.append(dataset_yaml)
+
+ with open(dataset_yaml, 'w') as ds_y:
+ yaml.safe_dump({
+ 'path': split_dir.as_posix(),
+ 'train': 'train',
+ 'val': 'val',
+ 'names': classes
+ }, ds_y)
+ ```
+
+5. Lastly, copy images and labels into the respective directory ('train' or 'val') for each split.
+
+ - __NOTE:__ The time required for this portion of the code will vary based on the size of your dataset and your system hardware.
+
+ ```python
+ for image, label in zip(images, labels):
+ for split, k_split in folds_df.loc[image.stem].items():
+ # Destination directory
+ img_to_path = save_path / split / k_split / 'images'
+ lbl_to_path = save_path / split / k_split / 'labels'
+
+ # Copy image and label files to new directory (SamefileError if file already exists)
+ shutil.copy(image, img_to_path / image.name)
+ shutil.copy(label, lbl_to_path / label.name)
+ ```
+
+## Save Records (Optional)
+
+Optionally, you can save the records of the K-Fold split and label distribution DataFrames as CSV files for future reference.
+
+```python
+folds_df.to_csv(save_path / "kfold_datasplit.csv")
+fold_lbl_distrb.to_csv(save_path / "kfold_label_distribution.csv")
+```
+
+## Train YOLO using K-Fold Data Splits
+
+1. First, load the YOLO model.
+
+ ```python
+ weights_path = 'path/to/weights.pt'
+ model = YOLO(weights_path, task='detect')
+ ```
+
+2. Next, iterate over the dataset YAML files to run training. The results will be saved to a directory specified by the `project` and `name` arguments. By default, this directory is 'exp/runs#' where # is an integer index.
+
+ ```python
+ results = {}
+
+ # Define your additional arguments here
+ batch = 16
+ project = 'kfold_demo'
+ epochs = 100
+
+ for k in range(ksplit):
+ dataset_yaml = ds_yamls[k]
+ model.train(data=dataset_yaml,epochs=epochs, batch=batch, project=project) # include any train arguments
+ results[k] = model.metrics # save output metrics for further analysis
+ ```
+
+## Conclusion
+
+In this guide, we have explored the process of using K-Fold cross-validation for training the YOLO object detection model. We learned how to split our dataset into K partitions, ensuring a balanced class distribution across the different folds.
+
+We also explored the procedure for creating report DataFrames to visualize the data splits and label distributions across these splits, providing us a clear insight into the structure of our training and validation sets.
+
+Optionally, we saved our records for future reference, which could be particularly useful in large-scale projects or when troubleshooting model performance.
+
+Finally, we implemented the actual model training using each split in a loop, saving our training results for further analysis and comparison.
+
+This technique of K-Fold cross-validation is a robust way of making the most out of your available data, and it helps to ensure that your model performance is reliable and consistent across different data subsets. This results in a more generalizable and reliable model that is less likely to overfit to specific data patterns.
+
+Remember that although we used YOLO in this guide, these steps are mostly transferable to other machine learning models. Understanding these steps allows you to apply cross-validation effectively in your own machine learning projects. Happy coding!
diff --git a/ultralytics/docs/en/guides/kfold-cross-validation.md:Zone.Identifier b/ultralytics/docs/en/guides/kfold-cross-validation.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/kfold-cross-validation.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/model-deployment-options.md b/ultralytics/docs/en/guides/model-deployment-options.md
new file mode 100755
index 0000000..6a4adba
--- /dev/null
+++ b/ultralytics/docs/en/guides/model-deployment-options.md
@@ -0,0 +1,305 @@
+---
+comments: true
+description: A guide to help determine which deployment option to choose for your YOLOv8 model, including essential considerations.
+keywords: YOLOv8, Deployment, PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, CoreML, TensorFlow, Export
+---
+
+# Understanding YOLOv8โs Deployment Options
+
+## Introduction
+
+*Setting the Scene:* You've come a long way on your journey with YOLOv8. You've diligently collected data, meticulously annotated it, and put in the hours to train and rigorously evaluate your custom YOLOv8 model. Now, itโs time to put your model to work for your specific application, use case, or project. But there's a critical decision that stands before you: how to export and deploy your model effectively.
+
+This guide walks you through YOLOv8โs deployment options and the essential factors to consider to choose the right option for your project.
+
+## How to Select the Right Deployment Option for Your YOLOv8 Model
+
+When it's time to deploy your YOLOv8 model, selecting a suitable export format is very important. As outlined in the [Ultralytics YOLOv8 Modes documentation](../modes/export.md#usage-examples), the model.export() function allows for converting your trained model into a variety of formats tailored to diverse environments and performance requirements.
+
+The ideal format depends on your model's intended operational context, balancing speed, hardware constraints, and ease of integration. In the following section, we'll take a closer look at each export option, understanding when to choose each one.
+
+### YOLOv8โs Deployment Options
+
+Letโs walk through the different YOLOv8 deployment options. For a detailed walkthrough of the export process, visit the [Ultralytics documentation page on exporting](../modes/export.md).
+
+#### PyTorch
+
+PyTorch is an open-source machine learning library widely used for applications in deep learning and artificial intelligence. It provides a high level of flexibility and speed, which has made it a favorite among researchers and developers.
+
+- **Performance Benchmarks**: PyTorch is known for its ease of use and flexibility, which may result in a slight trade-off in raw performance when compared to other frameworks that are more specialized and optimized.
+
+- **Compatibility and Integration**: Offers excellent compatibility with various data science and machine learning libraries in Python.
+
+- **Community Support and Ecosystem**: One of the most vibrant communities, with extensive resources for learning and troubleshooting.
+
+- **Case Studies**: Commonly used in research prototypes, many academic papers reference models deployed in PyTorch.
+
+- **Maintenance and Updates**: Regular updates with active development and support for new features.
+
+- **Security Considerations**: Regular patches for security issues, but security is largely dependent on the overall environment itโs deployed in.
+
+- **Hardware Acceleration**: Supports CUDA for GPU acceleration, essential for speeding up model training and inference.
+
+#### TorchScript
+
+TorchScript extends PyTorchโs capabilities by allowing the exportation of models to be run in a C++ runtime environment. This makes it suitable for production environments where Python is unavailable.
+
+- **Performance Benchmarks**: Can offer improved performance over native PyTorch, especially in production environments.
+
+- **Compatibility and Integration**: Designed for seamless transition from PyTorch to C++ production environments, though some advanced features might not translate perfectly.
+
+- **Community Support and Ecosystem**: Benefits from PyTorchโs large community but has a narrower scope of specialized developers.
+
+- **Case Studies**: Widely used in industry settings where Pythonโs performance overhead is a bottleneck.
+
+- **Maintenance and Updates**: Maintained alongside PyTorch with consistent updates.
+
+- **Security Considerations**: Offers improved security by enabling the running of models in environments without full Python installations.
+
+- **Hardware Acceleration**: Inherits PyTorchโs CUDA support, ensuring efficient GPU utilization.
+
+#### ONNX
+
+The Open Neural Network Exchange (ONNX) is a format that allows for model interoperability across different frameworks, which can be critical when deploying to various platforms.
+
+- **Performance Benchmarks**: ONNX models may experience a variable performance depending on the specific runtime they are deployed on.
+
+- **Compatibility and Integration**: High interoperability across multiple platforms and hardware due to its framework-agnostic nature.
+
+- **Community Support and Ecosystem**: Supported by many organizations, leading to a broad ecosystem and a variety of tools for optimization.
+
+- **Case Studies**: Frequently used to move models between different machine learning frameworks, demonstrating its flexibility.
+
+- **Maintenance and Updates**: As an open standard, ONNX is regularly updated to support new operations and models.
+
+- **Security Considerations**: As with any cross-platform tool, it's essential to ensure secure practices in the conversion and deployment pipeline.
+
+- **Hardware Acceleration**: With ONNX Runtime, models can leverage various hardware optimizations.
+
+#### OpenVINO
+
+OpenVINO is an Intel toolkit designed to facilitate the deployment of deep learning models across Intel hardware, enhancing performance and speed.
+
+- **Performance Benchmarks**: Specifically optimized for Intel CPUs, GPUs, and VPUs, offering significant performance boosts on compatible hardware.
+
+- **Compatibility and Integration**: Works best within the Intel ecosystem but also supports a range of other platforms.
+
+- **Community Support and Ecosystem**: Backed by Intel, with a solid user base especially in the computer vision domain.
+
+- **Case Studies**: Often utilized in IoT and edge computing scenarios where Intel hardware is prevalent.
+
+- **Maintenance and Updates**: Intel regularly updates OpenVINO to support the latest deep learning models and Intel hardware.
+
+- **Security Considerations**: Provides robust security features suitable for deployment in sensitive applications.
+
+- **Hardware Acceleration**: Tailored for acceleration on Intel hardware, leveraging dedicated instruction sets and hardware features.
+
+For more details on deployment using OpenVINO, refer to the Ultralytics Integration documentation: [Intel OpenVINO Export](../integrations/openvino.md).
+
+#### TensorRT
+
+TensorRT is a high-performance deep learning inference optimizer and runtime from NVIDIA, ideal for applications needing speed and efficiency.
+
+- **Performance Benchmarks**: Delivers top-tier performance on NVIDIA GPUs with support for high-speed inference.
+
+- **Compatibility and Integration**: Best suited for NVIDIA hardware, with limited support outside this environment.
+
+- **Community Support and Ecosystem**: Strong support network through NVIDIAโs developer forums and documentation.
+
+- **Case Studies**: Widely adopted in industries requiring real-time inference on video and image data.
+
+- **Maintenance and Updates**: NVIDIA maintains TensorRT with frequent updates to enhance performance and support new GPU architectures.
+
+- **Security Considerations**: Like many NVIDIA products, it has a strong emphasis on security, but specifics depend on the deployment environment.
+
+- **Hardware Acceleration**: Exclusively designed for NVIDIA GPUs, providing deep optimization and acceleration.
+
+#### CoreML
+
+CoreML is Appleโs machine learning framework, optimized for on-device performance in the Apple ecosystem, including iOS, macOS, watchOS, and tvOS.
+
+- **Performance Benchmarks**: Optimized for on-device performance on Apple hardware with minimal battery usage.
+
+- **Compatibility and Integration**: Exclusively for Apple's ecosystem, providing a streamlined workflow for iOS and macOS applications.
+
+- **Community Support and Ecosystem**: Strong support from Apple and a dedicated developer community, with extensive documentation and tools.
+
+- **Case Studies**: Commonly used in applications that require on-device machine learning capabilities on Apple products.
+
+- **Maintenance and Updates**: Regularly updated by Apple to support the latest machine learning advancements and Apple hardware.
+
+- **Security Considerations**: Benefits from Apple's focus on user privacy and data security.
+
+- **Hardware Acceleration**: Takes full advantage of Apple's neural engine and GPU for accelerated machine learning tasks.
+
+#### TF SavedModel
+
+TF SavedModel is TensorFlowโs format for saving and serving machine learning models, particularly suited for scalable server environments.
+
+- **Performance Benchmarks**: Offers scalable performance in server environments, especially when used with TensorFlow Serving.
+
+- **Compatibility and Integration**: Wide compatibility across TensorFlow's ecosystem, including cloud and enterprise server deployments.
+
+- **Community Support and Ecosystem**: Large community support due to TensorFlow's popularity, with a vast array of tools for deployment and optimization.
+
+- **Case Studies**: Extensively used in production environments for serving deep learning models at scale.
+
+- **Maintenance and Updates**: Supported by Google and the TensorFlow community, ensuring regular updates and new features.
+
+- **Security Considerations**: Deployment using TensorFlow Serving includes robust security features for enterprise-grade applications.
+
+- **Hardware Acceleration**: Supports various hardware accelerations through TensorFlow's backends.
+
+#### TF GraphDef
+
+TF GraphDef is a TensorFlow format that represents the model as a graph, which is beneficial for environments where a static computation graph is required.
+
+- **Performance Benchmarks**: Provides stable performance for static computation graphs, with a focus on consistency and reliability.
+
+- **Compatibility and Integration**: Easily integrates within TensorFlow's infrastructure but less flexible compared to SavedModel.
+
+- **Community Support and Ecosystem**: Good support from TensorFlow's ecosystem, with many resources available for optimizing static graphs.
+
+- **Case Studies**: Useful in scenarios where a static graph is necessary, such as in certain embedded systems.
+
+- **Maintenance and Updates**: Regular updates alongside TensorFlow's core updates.
+
+- **Security Considerations**: Ensures safe deployment with TensorFlow's established security practices.
+
+- **Hardware Acceleration**: Can utilize TensorFlow's hardware acceleration options, though not as flexible as SavedModel.
+
+#### TF Lite
+
+TF Lite is TensorFlowโs solution for mobile and embedded device machine learning, providing a lightweight library for on-device inference.
+
+- **Performance Benchmarks**: Designed for speed and efficiency on mobile and embedded devices.
+
+- **Compatibility and Integration**: Can be used on a wide range of devices due to its lightweight nature.
+
+- **Community Support and Ecosystem**: Backed by Google, it has a robust community and a growing number of resources for developers.
+
+- **Case Studies**: Popular in mobile applications that require on-device inference with minimal footprint.
+
+- **Maintenance and Updates**: Regularly updated to include the latest features and optimizations for mobile devices.
+
+- **Security Considerations**: Provides a secure environment for running models on end-user devices.
+
+- **Hardware Acceleration**: Supports a variety of hardware acceleration options, including GPU and DSP.
+
+#### TF Edge TPU
+
+TF Edge TPU is designed for high-speed, efficient computing on Google's Edge TPU hardware, perfect for IoT devices requiring real-time processing.
+
+- **Performance Benchmarks**: Specifically optimized for high-speed, efficient computing on Google's Edge TPU hardware.
+
+- **Compatibility and Integration**: Works exclusively with TensorFlow Lite models on Edge TPU devices.
+
+- **Community Support and Ecosystem**: Growing support with resources provided by Google and third-party developers.
+
+- **Case Studies**: Used in IoT devices and applications that require real-time processing with low latency.
+
+- **Maintenance and Updates**: Continually improved upon to leverage the capabilities of new Edge TPU hardware releases.
+
+- **Security Considerations**: Integrates with Google's robust security for IoT and edge devices.
+
+- **Hardware Acceleration**: Custom-designed to take full advantage of Google Coral devices.
+
+#### TF.js
+
+TensorFlow.js (TF.js) is a library that brings machine learning capabilities directly to the browser, offering a new realm of possibilities for web developers and users alike. It allows for the integration of machine learning models in web applications without the need for back-end infrastructure.
+
+- **Performance Benchmarks**: Enables machine learning directly in the browser with reasonable performance, depending on the client device.
+
+- **Compatibility and Integration**: High compatibility with web technologies, allowing for easy integration into web applications.
+
+- **Community Support and Ecosystem**: Support from a community of web and Node.js developers, with a variety of tools for deploying ML models in browsers.
+
+- **Case Studies**: Ideal for interactive web applications that benefit from client-side machine learning without the need for server-side processing.
+
+- **Maintenance and Updates**: Maintained by the TensorFlow team with contributions from the open-source community.
+
+- **Security Considerations**: Runs within the browser's secure context, utilizing the security model of the web platform.
+
+- **Hardware Acceleration**: Performance can be enhanced with web-based APIs that access hardware acceleration like WebGL.
+
+#### PaddlePaddle
+
+PaddlePaddle is an open-source deep learning framework developed by Baidu. It is designed to be both efficient for researchers and easy to use for developers. It's particularly popular in China and offers specialized support for Chinese language processing.
+
+- **Performance Benchmarks**: Offers competitive performance with a focus on ease of use and scalability.
+
+- **Compatibility and Integration**: Well-integrated within Baidu's ecosystem and supports a wide range of applications.
+
+- **Community Support and Ecosystem**: While the community is smaller globally, it's rapidly growing, especially in China.
+
+- **Case Studies**: Commonly used in Chinese markets and by developers looking for alternatives to other major frameworks.
+
+- **Maintenance and Updates**: Regularly updated with a focus on serving Chinese language AI applications and services.
+
+- **Security Considerations**: Emphasizes data privacy and security, catering to Chinese data governance standards.
+
+- **Hardware Acceleration**: Supports various hardware accelerations, including Baidu's own Kunlun chips.
+
+#### ncnn
+
+ncnn is a high-performance neural network inference framework optimized for the mobile platform. It stands out for its lightweight nature and efficiency, making it particularly well-suited for mobile and embedded devices where resources are limited.
+
+- **Performance Benchmarks**: Highly optimized for mobile platforms, offering efficient inference on ARM-based devices.
+
+- **Compatibility and Integration**: Suitable for applications on mobile phones and embedded systems with ARM architecture.
+
+- **Community Support and Ecosystem**: Supported by a niche but active community focused on mobile and embedded ML applications.
+
+- **Case Studies**: Favoured for mobile applications where efficiency and speed are critical on Android and other ARM-based systems.
+
+- **Maintenance and Updates**: Continuously improved to maintain high performance on a range of ARM devices.
+
+- **Security Considerations**: Focuses on running locally on the device, leveraging the inherent security of on-device processing.
+
+- **Hardware Acceleration**: Tailored for ARM CPUs and GPUs, with specific optimizations for these architectures.
+
+## Comparative Analysis of YOLOv8 Deployment Options
+
+The following table provides a snapshot of the various deployment options available for YOLOv8 models, helping you to assess which may best fit your project needs based on several critical criteria. For an in-depth look at each deployment option's format, please see the [Ultralytics documentation page on export formats](../modes/export.md#export-formats).
+
+| Deployment Option | Performance Benchmarks | Compatibility and Integration | Community Support and Ecosystem | Case Studies | Maintenance and Updates | Security Considerations | Hardware Acceleration |
+|-------------------|-------------------------------------------------|------------------------------------------------|-----------------------------------------------|--------------------------------------------|---------------------------------------------|---------------------------------------------------|------------------------------------|
+| PyTorch | Good flexibility; may trade off raw performance | Excellent with Python libraries | Extensive resources and community | Research and prototypes | Regular, active development | Dependent on deployment environment | CUDA support for GPU acceleration |
+| TorchScript | Better for production than PyTorch | Smooth transition from PyTorch to C++ | Specialized but narrower than PyTorch | Industry where Python is a bottleneck | Consistent updates with PyTorch | Improved security without full Python | Inherits CUDA support from PyTorch |
+| ONNX | Variable depending on runtime | High across different frameworks | Broad ecosystem, supported by many orgs | Flexibility across ML frameworks | Regular updates for new operations | Ensure secure conversion and deployment practices | Various hardware optimizations |
+| OpenVINO | Optimized for Intel hardware | Best within Intel ecosystem | Solid in computer vision domain | IoT and edge with Intel hardware | Regular updates for Intel hardware | Robust features for sensitive applications | Tailored for Intel hardware |
+| TensorRT | Top-tier on NVIDIA GPUs | Best for NVIDIA hardware | Strong network through NVIDIA | Real-time video and image inference | Frequent updates for new GPUs | Emphasis on security | Designed for NVIDIA GPUs |
+| CoreML | Optimized for on-device Apple hardware | Exclusive to Apple ecosystem | Strong Apple and developer support | On-device ML on Apple products | Regular Apple updates | Focus on privacy and security | Apple neural engine and GPU |
+| TF SavedModel | Scalable in server environments | Wide compatibility in TensorFlow ecosystem | Large support due to TensorFlow popularity | Serving models at scale | Regular updates by Google and community | Robust features for enterprise | Various hardware accelerations |
+| TF GraphDef | Stable for static computation graphs | Integrates well with TensorFlow infrastructure | Resources for optimizing static graphs | Scenarios requiring static graphs | Updates alongside TensorFlow core | Established TensorFlow security practices | TensorFlow acceleration options |
+| TF Lite | Speed and efficiency on mobile/embedded | Wide range of device support | Robust community, Google backed | Mobile applications with minimal footprint | Latest features for mobile | Secure environment on end-user devices | GPU and DSP among others |
+| TF Edge TPU | Optimized for Google's Edge TPU hardware | Exclusive to Edge TPU devices | Growing with Google and third-party resources | IoT devices requiring real-time processing | Improvements for new Edge TPU hardware | Google's robust IoT security | Custom-designed for Google Coral |
+| TF.js | Reasonable in-browser performance | High with web technologies | Web and Node.js developers support | Interactive web applications | TensorFlow team and community contributions | Web platform security model | Enhanced with WebGL and other APIs |
+| PaddlePaddle | Competitive, easy to use and scalable | Baidu ecosystem, wide application support | Rapidly growing, especially in China | Chinese market and language processing | Focus on Chinese AI applications | Emphasizes data privacy and security | Including Baidu's Kunlun chips |
+| ncnn | Optimized for mobile ARM-based devices | Mobile and embedded ARM systems | Niche but active mobile/embedded ML community | Android and ARM systems efficiency | High performance maintenance on ARM | On-device security advantages | ARM CPUs and GPUs optimizations |
+
+This comparative analysis gives you a high-level overview. For deployment, it's essential to consider the specific requirements and constraints of your project, and consult the detailed documentation and resources available for each option.
+
+## Community and Support
+
+When you're getting started with YOLOv8, having a helpful community and support can make a significant impact. Here's how to connect with others who share your interests and get the assistance you need.
+
+### Engage with the Broader Community
+
+- **GitHub Discussions:** The YOLOv8 repository on GitHub has a "Discussions" section where you can ask questions, report issues, and suggest improvements.
+
+- **Ultralytics Discord Server:** Ultralytics has a [Discord server](https://ultralytics.com/discord/) where you can interact with other users and developers.
+
+### Official Documentation and Resources
+
+- **Ultralytics YOLOv8 Docs:** The [official documentation](../index.md) provides a comprehensive overview of YOLOv8, along with guides on installation, usage, and troubleshooting.
+
+These resources will help you tackle challenges and stay updated on the latest trends and best practices in the YOLOv8 community.
+
+## Conclusion
+
+In this guide, we've explored the different deployment options for YOLOv8. We've also discussed the important factors to consider when making your choice. These options allow you to customize your model for various environments and performance requirements, making it suitable for real-world applications.
+
+Don't forget that the YOLOv8 and Ultralytics community is a valuable source of help. Connect with other developers and experts to learn unique tips and solutions you might not find in regular documentation. Keep seeking knowledge, exploring new ideas, and sharing your experiences.
+
+Happy deploying!
diff --git a/ultralytics/docs/en/guides/model-deployment-options.md:Zone.Identifier b/ultralytics/docs/en/guides/model-deployment-options.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/model-deployment-options.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/object-counting.md b/ultralytics/docs/en/guides/object-counting.md
new file mode 100755
index 0000000..dcc4756
--- /dev/null
+++ b/ultralytics/docs/en/guides/object-counting.md
@@ -0,0 +1,197 @@
+---
+comments: true
+description: Object Counting Using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Object Counting, Object Tracking, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Object Counting using Ultralytics YOLOv8 ๐
+
+## What is Object Counting?
+
+Object counting with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves accurate identification and counting of specific objects in videos and camera streams. YOLOv8 excels in real-time applications, providing efficient and precise object counting for various scenarios like crowd analysis and surveillance, thanks to its state-of-the-art algorithms and deep learning capabilities.
+
+
+
+## Advantages of Object Counting?
+
+- **Resource Optimization:** Object counting facilitates efficient resource management by providing accurate counts, and optimizing resource allocation in applications like inventory management.
+- **Enhanced Security:** Object counting enhances security and surveillance by accurately tracking and counting entities, aiding in proactive threat detection.
+- **Informed Decision-Making:** Object counting offers valuable insights for decision-making, optimizing processes in retail, traffic management, and various other domains.
+
+## Real World Applications
+
+| Logistics | Aquaculture |
+|:-------------------------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------:|
+|  |  |
+| Conveyor Belt Packets Counting Using Ultralytics YOLOv8 | Fish Counting in Sea using Ultralytics YOLOv8 |
+
+!!! Example "Object Counting using YOLOv8 Example"
+
+ === "Region"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import object_counter
+ import cv2
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ # Define region points
+ region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
+
+ # Video writer
+ video_writer = cv2.VideoWriter("object_counting_output.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ # Init Object Counter
+ counter = object_counter.ObjectCounter()
+ counter.set_args(view_img=True,
+ reg_pts=region_points,
+ classes_names=model.names,
+ draw_tracks=True)
+
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ tracks = model.track(im0, persist=True, show=False)
+
+ im0 = counter.start_counting(im0, tracks)
+ video_writer.write(im0)
+
+ cap.release()
+ video_writer.release()
+ cv2.destroyAllWindows()
+
+ ```
+
+ === "Line"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import object_counter
+ import cv2
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ # Define line points
+ line_points = [(20, 400), (1080, 400)]
+
+ # Video writer
+ video_writer = cv2.VideoWriter("object_counting_output.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ # Init Object Counter
+ counter = object_counter.ObjectCounter()
+ counter.set_args(view_img=True,
+ reg_pts=line_points,
+ classes_names=model.names,
+ draw_tracks=True)
+
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ tracks = model.track(im0, persist=True, show=False)
+
+ im0 = counter.start_counting(im0, tracks)
+ video_writer.write(im0)
+
+ cap.release()
+ video_writer.release()
+ cv2.destroyAllWindows()
+ ```
+
+ === "Specific Classes"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import object_counter
+ import cv2
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ line_points = [(20, 400), (1080, 400)] # line or region points
+ classes_to_count = [0, 2] # person and car classes for count
+
+ # Video writer
+ video_writer = cv2.VideoWriter("object_counting_output.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ # Init Object Counter
+ counter = object_counter.ObjectCounter()
+ counter.set_args(view_img=True,
+ reg_pts=line_points,
+ classes_names=model.names,
+ draw_tracks=True)
+
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ tracks = model.track(im0, persist=True, show=False,
+ classes=classes_to_count)
+
+ im0 = counter.start_counting(im0, tracks)
+ video_writer.write(im0)
+
+ cap.release()
+ video_writer.release()
+ cv2.destroyAllWindows()
+ ```
+
+???+ tip "Region is Movable"
+
+ You can move the region anywhere in the frame by clicking on its edges
+
+### Optional Arguments `set_args`
+
+
+| Name | Type | Default | Description |
+|---------------------|-------------|----------------------------|-----------------------------------------------|
+| view_img | `bool` | `False` | Display frames with counts |
+| line_thickness | `int` | `2` | Increase bounding boxes thickness |
+| reg_pts | `list` | `[(20, 400), (1260, 400)]` | Points defining the Region Area |
+| classes_names | `dict` | `model.model.names` | Dictionary of Class Names |
+| region_color | `RGB Color` | `(255, 0, 255)` | Color of the Object counting Region or Line |
+| track_thickness | `int` | `2` | Thickness of Tracking Lines |
+| draw_tracks | `bool` | `False` | Enable drawing Track lines |
+| track_color | `RGB Color` | `(0, 255, 0)` | Color for each track line |
+| line_dist_thresh | `int` | `15` | Euclidean Distance threshold for line counter |
+| count_txt_thickness | `int` | `2` | Thickness of Object counts text |
+| count_txt_color | `RGB Color` | `(0, 0, 0)` | Foreground color for Object counts text |
+| count_color | `RGB Color` | `(255, 255, 255)` | Background color for Object counts text |
+| region_thickness | `int` | `5` | Thickness for object counter region or line |
+
+### Arguments `model.track`
+
+| Name | Type | Default | Description |
+|-----------|---------|----------------|-------------------------------------------------------------|
+| `source` | `im0` | `None` | source directory for images or videos |
+| `persist` | `bool` | `False` | persisting tracks between frames |
+| `tracker` | `str` | `botsort.yaml` | Tracking method 'bytetrack' or 'botsort' |
+| `conf` | `float` | `0.3` | Confidence Threshold |
+| `iou` | `float` | `0.5` | IOU Threshold |
+| `classes` | `list` | `None` | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+| `verbose` | `bool` | `True` | Display the object tracking results |
diff --git a/ultralytics/docs/en/guides/object-counting.md:Zone.Identifier b/ultralytics/docs/en/guides/object-counting.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/object-counting.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/raspberry-pi.md b/ultralytics/docs/en/guides/raspberry-pi.md
new file mode 100755
index 0000000..389db0d
--- /dev/null
+++ b/ultralytics/docs/en/guides/raspberry-pi.md
@@ -0,0 +1,196 @@
+---
+comments: true
+description: Quick start guide to setting up YOLO on a Raspberry Pi with a Pi Camera using the libcamera stack. Detailed comparison between Raspberry Pi 3, 4 and 5 models.
+keywords: Ultralytics, YOLO, Raspberry Pi, Pi Camera, libcamera, quick start guide, Raspberry Pi 4 vs Raspberry Pi 5, YOLO on Raspberry Pi, hardware setup, machine learning, AI
+---
+
+# Quick Start Guide: Raspberry Pi and Pi Camera with YOLOv5 and YOLOv8
+
+This comprehensive guide aims to expedite your journey with YOLO object detection models on a [Raspberry Pi](https://www.raspberrypi.com/) using a [Pi Camera](https://www.raspberrypi.com/products/camera-module-v2/). Whether you're a student, hobbyist, or a professional, this guide is designed to get you up and running in less than 30 minutes. The instructions here are rigorously tested to minimize setup issues, allowing you to focus on utilizing YOLO for your specific projects.
+
+
+
+
+
+ Watch: Raspberry Pi 5 updates and improvements.
+
+
+## Prerequisites
+
+- Raspberry Pi 3, 4 or 5
+- Pi Camera
+- 64-bit Raspberry Pi Operating System
+
+Connect the Pi Camera to your Raspberry Pi via a CSI cable and install the 64-bit Raspberry Pi Operating System. Verify your camera with the following command:
+
+```bash
+libcamera-hello
+```
+
+You should see a video feed from your camera.
+
+## Choose Your YOLO Version: YOLOv5 or YOLOv8
+
+This guide offers you the flexibility to start with either [YOLOv5](https://github.com/ultralytics/yolov5) or [YOLOv8](https://github.com/ultralytics/ultralytics). Both versions have their unique advantages and use-cases. The choice is yours, but remember, the guide's aim is not just quick setup but also a robust foundation for your future work in object detection.
+
+## Hardware Specifics: At a Glance
+
+To assist you in making an informed hardware decision, we've summarized the key hardware specifics of Raspberry Pi 3, 4, and 5 in the table below:
+
+| Feature | Raspberry Pi 3 | Raspberry Pi 4 | Raspberry Pi 5 |
+|----------------------------|------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+| **CPU** | 1.2GHz Quad-Core ARM Cortex-A53 | 1.5GHz Quad-core 64-bit ARM Cortex-A72 | 2.4GHz Quad-core 64-bit Arm Cortex-A76 |
+| **RAM** | 1GB LPDDR2 | 2GB, 4GB or 8GB LPDDR4 | *Details not yet available* |
+| **USB Ports** | 4 x USB 2.0 | 2 x USB 2.0, 2 x USB 3.0 | 2 x USB 3.0, 2 x USB 2.0 |
+| **Network** | Ethernet & Wi-Fi 802.11n | Gigabit Ethernet & Wi-Fi 802.11ac | Gigabit Ethernet with PoE+ support, Dual-band 802.11ac Wi-Fiยฎ |
+| **Performance** | Slower, may require lighter YOLO models | Faster, can run complex YOLO models | *Details not yet available* |
+| **Power Requirement** | 2.5A power supply | 3.0A USB-C power supply | *Details not yet available* |
+| **Official Documentation** | [Link](https://www.raspberrypi.org/documentation/hardware/raspberrypi/bcm2837/README.md) | [Link](https://www.raspberrypi.org/documentation/hardware/raspberrypi/bcm2711/README.md) | [Link](https://www.raspberrypi.com/news/introducing-raspberry-pi-5/) |
+
+Please make sure to follow the instructions specific to your Raspberry Pi model to ensure a smooth setup process.
+
+## Quick Start with YOLOv5
+
+This section outlines how to set up YOLOv5 on a Raspberry Pi with a Pi Camera. These steps are designed to be compatible with the libcamera camera stack introduced in Raspberry Pi OS Bullseye.
+
+### Install Necessary Packages
+
+1. Update the Raspberry Pi:
+
+ ```bash
+ sudo apt-get update
+ sudo apt-get upgrade -y
+ sudo apt-get autoremove -y
+ ```
+
+2. Clone the YOLOv5 repository:
+
+ ```bash
+ cd ~
+ git clone https://github.com/Ultralytics/yolov5.git
+ ```
+
+3. Install the required dependencies:
+
+ ```bash
+ cd ~/yolov5
+ pip3 install -r requirements.txt
+ ```
+
+4. For Raspberry Pi 3, install compatible versions of PyTorch and Torchvision (skip for Raspberry Pi 4):
+
+ ```bash
+ pip3 uninstall torch torchvision
+ pip3 install torch==1.11.0 torchvision==0.12.0
+ ```
+
+### Modify `detect.py`
+
+To enable TCP streams via SSH or the CLI, minor modifications are needed in `detect.py`.
+
+1. Open `detect.py`:
+
+ ```bash
+ sudo nano ~/yolov5/detect.py
+ ```
+
+2. Find and modify the `is_url` line to accept TCP streams:
+
+ ```python
+ is_url = source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://', 'tcp://'))
+ ```
+
+3. Comment out the `view_img` line:
+
+ ```python
+ # view_img = check_imshow(warn=True)
+ ```
+
+4. Save and exit:
+
+ ```bash
+ CTRL + O -> ENTER -> CTRL + X
+ ```
+
+### Initiate TCP Stream with Libcamera
+
+1. Start the TCP stream:
+
+ ```bash
+ libcamera-vid -n -t 0 --width 1280 --height 960 --framerate 1 --inline --listen -o tcp://127.0.0.1:8888
+ ```
+
+Keep this terminal session running for the next steps.
+
+### Perform YOLOv5 Inference
+
+1. Run the YOLOv5 detection:
+
+ ```bash
+ cd ~/yolov5
+ python3 detect.py --source=tcp://127.0.0.1:8888
+ ```
+
+## Quick Start with YOLOv8
+
+Follow this section if you are interested in setting up YOLOv8 instead. The steps are quite similar but are tailored for YOLOv8's specific needs.
+
+### Install Necessary Packages
+
+1. Update the Raspberry Pi:
+
+ ```bash
+ sudo apt-get update
+ sudo apt-get upgrade -y
+ sudo apt-get autoremove -y
+ ```
+
+2. Install the `ultralytics` Python package:
+
+ ```bash
+ pip3 install ultralytics
+ ```
+
+3. Reboot:
+
+ ```bash
+ sudo reboot
+ ```
+
+### Initiate TCP Stream with Libcamera
+
+1. Start the TCP stream:
+
+ ```bash
+ libcamera-vid -n -t 0 --width 1280 --height 960 --framerate 1 --inline --listen -o tcp://127.0.0.1:8888
+ ```
+
+### Perform YOLOv8 Inference
+
+To perform inference with YOLOv8, you can use the following Python code snippet:
+
+```python
+from ultralytics import YOLO
+
+model = YOLO('yolov8n.pt')
+results = model('tcp://127.0.0.1:8888', stream=True)
+
+while True:
+ for result in results:
+ boxes = result.boxes
+ probs = result.probs
+```
+
+## Next Steps
+
+Congratulations on successfully setting up YOLO on your Raspberry Pi! For further learning and support, visit [Ultralytics](https://ultralytics.com/) and [Kashmir World Foundation](https://www.kashmirworldfoundation.org/).
+
+## Acknowledgements and Citations
+
+This guide was initially created by Daan Eeltink for Kashmir World Foundation, an organization dedicated to the use of YOLO for the conservation of endangered species. We acknowledge their pioneering work and educational focus in the realm of object detection technologies.
+
+For more information about Kashmir World Foundation's activities, you can visit their [website](https://www.kashmirworldfoundation.org/).
diff --git a/ultralytics/docs/en/guides/raspberry-pi.md:Zone.Identifier b/ultralytics/docs/en/guides/raspberry-pi.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/raspberry-pi.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/region-counting.md b/ultralytics/docs/en/guides/region-counting.md
new file mode 100755
index 0000000..5e8b828
--- /dev/null
+++ b/ultralytics/docs/en/guides/region-counting.md
@@ -0,0 +1,86 @@
+---
+comments: true
+description: Object Counting in Different Region using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Object Counting, Object Tracking, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Object Counting in Different Regions using Ultralytics YOLOv8 ๐
+
+## What is Object Counting in Regions?
+
+Object counting in regions with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves precisely determining the number of objects within specified areas using advanced computer vision. This approach is valuable for optimizing processes, enhancing security, and improving efficiency in various applications.
+
+
+
+
+
+ Watch: Ultralytics YOLOv8 Object Counting in Multiple & Movable Regions
+
+
+## Advantages of Object Counting in Regions?
+
+- **Precision and Accuracy:** Object counting in regions with advanced computer vision ensures precise and accurate counts, minimizing errors often associated with manual counting.
+- **Efficiency Improvement:** Automated object counting enhances operational efficiency, providing real-time results and streamlining processes across different applications.
+- **Versatility and Application:** The versatility of object counting in regions makes it applicable across various domains, from manufacturing and surveillance to traffic monitoring, contributing to its widespread utility and effectiveness.
+
+## Real World Applications
+
+| Retail | Market Streets |
+|:------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+|  |  |
+| People Counting in Different Region using Ultralytics YOLOv8 | Crowd Counting in Different Region using Ultralytics YOLOv8 |
+
+## Steps to Run
+
+### Step 1: Install Required Libraries
+
+Begin by cloning the Ultralytics repository, installing dependencies, and navigating to the local directory using the provided commands in Step 2.
+
+```bash
+# Clone Ultralytics repo
+git clone https://github.com/ultralytics/ultralytics
+
+# Navigate to the local directory
+cd ultralytics/examples/YOLOv8-Region-Counter
+```
+
+### Step 2: Run Region Counting Using Ultralytics YOLOv8
+
+Execute the following basic commands for inference.
+
+???+ tip "Region is Movable"
+
+ During video playback, you can interactively move the region within the video by clicking and dragging using the left mouse button.
+
+```bash
+# Save results
+python yolov8_region_counter.py --source "path/to/video.mp4" --save-img
+
+# Run model on CPU
+python yolov8_region_counter.py --source "path/to/video.mp4" --device cpu
+
+# Change model file
+python yolov8_region_counter.py --source "path/to/video.mp4" --weights "path/to/model.pt"
+
+# Detect specific classes (e.g., first and third classes)
+python yolov8_region_counter.py --source "path/to/video.mp4" --classes 0 2
+
+# View results without saving
+python yolov8_region_counter.py --source "path/to/video.mp4" --view-img
+```
+
+### Optional Arguments
+
+| Name | Type | Default | Description |
+|----------------------|--------|--------------|--------------------------------------------|
+| `--source` | `str` | `None` | Path to video file, for webcam 0 |
+| `--line_thickness` | `int` | `2` | Bounding Box thickness |
+| `--save-img` | `bool` | `False` | Save the predicted video/image |
+| `--weights` | `str` | `yolov8n.pt` | Weights file path |
+| `--classes` | `list` | `None` | Detect specific classes i.e. --classes 0 2 |
+| `--region-thickness` | `int` | `2` | Region Box thickness |
+| `--track-thickness` | `int` | `2` | Tracking line thickness |
diff --git a/ultralytics/docs/en/guides/region-counting.md:Zone.Identifier b/ultralytics/docs/en/guides/region-counting.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/region-counting.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/sahi-tiled-inference.md b/ultralytics/docs/en/guides/sahi-tiled-inference.md
new file mode 100755
index 0000000..9728703
--- /dev/null
+++ b/ultralytics/docs/en/guides/sahi-tiled-inference.md
@@ -0,0 +1,185 @@
+---
+comments: true
+description: A comprehensive guide on how to use YOLOv8 with SAHI for standard and sliced inference in object detection tasks.
+keywords: YOLOv8, SAHI, Sliced Inference, Object Detection, Ultralytics, Large Scale Image Analysis, High-Resolution Imagery
+---
+
+# Ultralytics Docs: Using YOLOv8 with SAHI for Sliced Inference
+
+Welcome to the Ultralytics documentation on how to use YOLOv8 with [SAHI](https://github.com/obss/sahi) (Slicing Aided Hyper Inference). This comprehensive guide aims to furnish you with all the essential knowledge you'll need to implement SAHI alongside YOLOv8. We'll deep-dive into what SAHI is, why sliced inference is critical for large-scale applications, and how to integrate these functionalities with YOLOv8 for enhanced object detection performance.
+
+
+
+
+
+## Introduction to SAHI
+
+SAHI (Slicing Aided Hyper Inference) is an innovative library designed to optimize object detection algorithms for large-scale and high-resolution imagery. Its core functionality lies in partitioning images into manageable slices, running object detection on each slice, and then stitching the results back together. SAHI is compatible with a range of object detection models, including the YOLO series, thereby offering flexibility while ensuring optimized use of computational resources.
+
+### Key Features of SAHI
+
+- **Seamless Integration**: SAHI integrates effortlessly with YOLO models, meaning you can start slicing and detecting without a lot of code modification.
+- **Resource Efficiency**: By breaking down large images into smaller parts, SAHI optimizes the memory usage, allowing you to run high-quality detection on hardware with limited resources.
+- **High Accuracy**: SAHI maintains the detection accuracy by employing smart algorithms to merge overlapping detection boxes during the stitching process.
+
+## What is Sliced Inference?
+
+Sliced Inference refers to the practice of subdividing a large or high-resolution image into smaller segments (slices), conducting object detection on these slices, and then recompiling the slices to reconstruct the object locations on the original image. This technique is invaluable in scenarios where computational resources are limited or when working with extremely high-resolution images that could otherwise lead to memory issues.
+
+### Benefits of Sliced Inference
+
+- **Reduced Computational Burden**: Smaller image slices are faster to process, and they consume less memory, enabling smoother operation on lower-end hardware.
+
+- **Preserved Detection Quality**: Since each slice is treated independently, there is no reduction in the quality of object detection, provided the slices are large enough to capture the objects of interest.
+
+- **Enhanced Scalability**: The technique allows for object detection to be more easily scaled across different sizes and resolutions of images, making it ideal for a wide range of applications from satellite imagery to medical diagnostics.
+
+
+
+
YOLOv8 without SAHI
+
YOLOv8 with SAHI
+
+
+
+
+
+
+
+## Installation and Preparation
+
+### Installation
+
+To get started, install the latest versions of SAHI and Ultralytics:
+
+```bash
+pip install -U ultralytics sahi
+```
+
+### Import Modules and Download Resources
+
+Here's how to import the necessary modules and download a YOLOv8 model and some test images:
+
+```python
+from sahi.utils.yolov8 import download_yolov8s_model
+from sahi import AutoDetectionModel
+from sahi.utils.cv import read_image
+from sahi.utils.file import download_from_url
+from sahi.predict import get_prediction, get_sliced_prediction, predict
+from pathlib import Path
+from IPython.display import Image
+
+# Download YOLOv8 model
+yolov8_model_path = "models/yolov8s.pt"
+download_yolov8s_model(yolov8_model_path)
+
+# Download test images
+download_from_url('https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/small-vehicles1.jpeg', 'demo_data/small-vehicles1.jpeg')
+download_from_url('https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/terrain2.png', 'demo_data/terrain2.png')
+```
+
+## Standard Inference with YOLOv8
+
+### Instantiate the Model
+
+You can instantiate a YOLOv8 model for object detection like this:
+
+```python
+detection_model = AutoDetectionModel.from_pretrained(
+ model_type='yolov8',
+ model_path=yolov8_model_path,
+ confidence_threshold=0.3,
+ device="cpu", # or 'cuda:0'
+)
+```
+
+### Perform Standard Prediction
+
+Perform standard inference using an image path or a numpy image.
+
+```python
+# With an image path
+result = get_prediction("demo_data/small-vehicles1.jpeg", detection_model)
+
+# With a numpy image
+result = get_prediction(read_image("demo_data/small-vehicles1.jpeg"), detection_model)
+```
+
+### Visualize Results
+
+Export and visualize the predicted bounding boxes and masks:
+
+```python
+result.export_visuals(export_dir="demo_data/")
+Image("demo_data/prediction_visual.png")
+```
+
+## Sliced Inference with YOLOv8
+
+Perform sliced inference by specifying the slice dimensions and overlap ratios:
+
+```python
+result = get_sliced_prediction(
+ "demo_data/small-vehicles1.jpeg",
+ detection_model,
+ slice_height=256,
+ slice_width=256,
+ overlap_height_ratio=0.2,
+ overlap_width_ratio=0.2
+)
+```
+
+## Handling Prediction Results
+
+SAHI provides a `PredictionResult` object, which can be converted into various annotation formats:
+
+```python
+# Access the object prediction list
+object_prediction_list = result.object_prediction_list
+
+# Convert to COCO annotation, COCO prediction, imantics, and fiftyone formats
+result.to_coco_annotations()[:3]
+result.to_coco_predictions(image_id=1)[:3]
+result.to_imantics_annotations()[:3]
+result.to_fiftyone_detections()[:3]
+```
+
+## Batch Prediction
+
+For batch prediction on a directory of images:
+
+```python
+predict(
+ model_type="yolov8",
+ model_path="path/to/yolov8n.pt",
+ model_device="cpu", # or 'cuda:0'
+ model_confidence_threshold=0.4,
+ source="path/to/dir",
+ slice_height=256,
+ slice_width=256,
+ overlap_height_ratio=0.2,
+ overlap_width_ratio=0.2,
+)
+```
+
+That's it! Now you're equipped to use YOLOv8 with SAHI for both standard and sliced inference.
+
+## Citations and Acknowledgments
+
+If you use SAHI in your research or development work, please cite the original SAHI paper and acknowledge the authors:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{akyon2022sahi,
+ title={Slicing Aided Hyper Inference and Fine-tuning for Small Object Detection},
+ author={Akyon, Fatih Cagatay and Altinuc, Sinan Onur and Temizel, Alptekin},
+ journal={2022 IEEE International Conference on Image Processing (ICIP)},
+ doi={10.1109/ICIP46576.2022.9897990},
+ pages={966-970},
+ year={2022}
+ }
+ ```
+
+We extend our thanks to the SAHI research group for creating and maintaining this invaluable resource for the computer vision community. For more information about SAHI and its creators, visit the [SAHI GitHub repository](https://github.com/obss/sahi).
diff --git a/ultralytics/docs/en/guides/sahi-tiled-inference.md:Zone.Identifier b/ultralytics/docs/en/guides/sahi-tiled-inference.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/sahi-tiled-inference.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/security-alarm-system.md b/ultralytics/docs/en/guides/security-alarm-system.md
new file mode 100755
index 0000000..d61221a
--- /dev/null
+++ b/ultralytics/docs/en/guides/security-alarm-system.md
@@ -0,0 +1,166 @@
+---
+comments: true
+description: Security Alarm System Project Using Ultralytics YOLOv8. Learn How to implement a Security Alarm System Using ultralytics YOLOv8
+keywords: Object Detection, Security Alarm, Object Tracking, YOLOv8, Computer Vision Projects
+---
+
+# Security Alarm System Project Using Ultralytics YOLOv8
+
+
+
+The Security Alarm System Project utilizing Ultralytics YOLOv8 integrates advanced computer vision capabilities to enhance security measures. YOLOv8, developed by Ultralytics, provides real-time object detection, allowing the system to identify and respond to potential security threats promptly. This project offers several advantages:
+
+- **Real-time Detection:** YOLOv8's efficiency enables the Security Alarm System to detect and respond to security incidents in real-time, minimizing response time.
+- **Accuracy:** YOLOv8 is known for its accuracy in object detection, reducing false positives and enhancing the reliability of the security alarm system.
+- **Integration Capabilities:** The project can be seamlessly integrated with existing security infrastructure, providing an upgraded layer of intelligent surveillance.
+
+
+
+
+
+ Watch: Security Alarm System Project with Ultralytics YOLOv8 Object Detection
+
+
+### Code
+
+#### Import Libraries
+
+```python
+import torch
+import numpy as np
+import cv2
+from time import time
+from ultralytics import YOLO
+from ultralytics.utils.plotting import Annotator, colors
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+```
+
+#### Set up the parameters of the message
+
+???+ tip "Note"
+
+ App Password Generation is necessary
+
+- Navigate to [App Password Generator](https://myaccount.google.com/apppasswords), designate an app name such as "security project," and obtain a 16-digit password. Copy this password and paste it into the designated password field as instructed.
+
+```python
+password = ""
+from_email = "" # must match the email used to generate the password
+to_email = "" # receiver email
+```
+
+#### Server creation and authentication
+
+```python
+server = smtplib.SMTP('smtp.gmail.com: 587')
+server.starttls()
+server.login(from_email, password)
+```
+
+#### Email Send Function
+
+```python
+def send_email(to_email, from_email, object_detected=1):
+ message = MIMEMultipart()
+ message['From'] = from_email
+ message['To'] = to_email
+ message['Subject'] = "Security Alert"
+ # Add in the message body
+ message_body = f'ALERT - {object_detected} objects has been detected!!'
+
+ message.attach(MIMEText(message_body, 'plain'))
+ server.sendmail(from_email, to_email, message.as_string())
+```
+
+#### Object Detection and Alert Sender
+
+```python
+class ObjectDetection:
+ def __init__(self, capture_index):
+ # default parameters
+ self.capture_index = capture_index
+ self.email_sent = False
+
+ # model information
+ self.model = YOLO("yolov8n.pt")
+
+ # visual information
+ self.annotator = None
+ self.start_time = 0
+ self.end_time = 0
+
+ # device information
+ self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+ def predict(self, im0):
+ results = self.model(im0)
+ return results
+
+ def display_fps(self, im0):
+ self.end_time = time()
+ fps = 1 / np.round(self.end_time - self.start_time, 2)
+ text = f'FPS: {int(fps)}'
+ text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 1.0, 2)[0]
+ gap = 10
+ cv2.rectangle(im0, (20 - gap, 70 - text_size[1] - gap), (20 + text_size[0] + gap, 70 + gap), (255, 255, 255), -1)
+ cv2.putText(im0, text, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2)
+
+ def plot_bboxes(self, results, im0):
+ class_ids = []
+ self.annotator = Annotator(im0, 3, results[0].names)
+ boxes = results[0].boxes.xyxy.cpu()
+ clss = results[0].boxes.cls.cpu().tolist()
+ names = results[0].names
+ for box, cls in zip(boxes, clss):
+ class_ids.append(cls)
+ self.annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
+ return im0, class_ids
+
+ def __call__(self):
+ cap = cv2.VideoCapture(self.capture_index)
+ assert cap.isOpened()
+ cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
+ cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+ frame_count = 0
+ while True:
+ self.start_time = time()
+ ret, im0 = cap.read()
+ assert ret
+ results = self.predict(im0)
+ im0, class_ids = self.plot_bboxes(results, im0)
+
+ if len(class_ids) > 0: # Only send email If not sent before
+ if not self.email_sent:
+ send_email(to_email, from_email, len(class_ids))
+ self.email_sent = True
+ else:
+ self.email_sent = False
+
+ self.display_fps(im0)
+ cv2.imshow('YOLOv8 Detection', im0)
+ frame_count += 1
+ if cv2.waitKey(5) & 0xFF == 27:
+ break
+ cap.release()
+ cv2.destroyAllWindows()
+ server.quit()
+```
+
+#### Call the Object Detection class and Run the Inference
+
+```python
+detector = ObjectDetection(capture_index=0)
+detector()
+```
+
+That's it! When you execute the code, you'll receive a single notification on your email if any object is detected. The notification is sent immediately, not repeatedly. However, feel free to customize the code to suit your project requirements.
+
+#### Email Received Sample
+
+
diff --git a/ultralytics/docs/en/guides/security-alarm-system.md:Zone.Identifier b/ultralytics/docs/en/guides/security-alarm-system.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/security-alarm-system.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/triton-inference-server.md b/ultralytics/docs/en/guides/triton-inference-server.md
new file mode 100755
index 0000000..fc90fde
--- /dev/null
+++ b/ultralytics/docs/en/guides/triton-inference-server.md
@@ -0,0 +1,137 @@
+---
+comments: true
+description: A step-by-step guide on integrating Ultralytics YOLOv8 with Triton Inference Server for scalable and high-performance deep learning inference deployments.
+keywords: YOLOv8, Triton Inference Server, ONNX, Deep Learning Deployment, Scalable Inference, Ultralytics, NVIDIA, Object Detection, Cloud Inference
+---
+
+# Triton Inference Server with Ultralytics YOLOv8
+
+The [Triton Inference Server](https://developer.nvidia.com/nvidia-triton-inference-server) (formerly known as TensorRT Inference Server) is an open-source software solution developed by NVIDIA. It provides a cloud inference solution optimized for NVIDIA GPUs. Triton simplifies the deployment of AI models at scale in production. Integrating Ultralytics YOLOv8 with Triton Inference Server allows you to deploy scalable, high-performance deep learning inference workloads. This guide provides steps to set up and test the integration.
+
+
+
+
+
+ Watch: Getting Started with NVIDIA Triton Inference Server.
+
+
+## What is Triton Inference Server?
+
+Triton Inference Server is designed to deploy a variety of AI models in production. It supports a wide range of deep learning and machine learning frameworks, including TensorFlow, PyTorch, ONNX Runtime, and many others. Its primary use cases are:
+
+- Serving multiple models from a single server instance.
+- Dynamic model loading and unloading without server restart.
+- Ensemble inference, allowing multiple models to be used together to achieve results.
+- Model versioning for A/B testing and rolling updates.
+
+## Prerequisites
+
+Ensure you have the following prerequisites before proceeding:
+
+- Docker installed on your machine.
+- Install `tritonclient`:
+ ```bash
+ pip install tritonclient[all]
+ ```
+
+## Exporting YOLOv8 to ONNX Format
+
+Before deploying the model on Triton, it must be exported to the ONNX format. ONNX (Open Neural Network Exchange) is a format that allows models to be transferred between different deep learning frameworks. Use the `export` function from the `YOLO` class:
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO('yolov8n.pt') # load an official model
+
+# Export the model
+onnx_file = model.export(format='onnx', dynamic=True)
+```
+
+## Setting Up Triton Model Repository
+
+The Triton Model Repository is a storage location where Triton can access and load models.
+
+1. Create the necessary directory structure:
+
+ ```python
+ from pathlib import Path
+
+ # Define paths
+ triton_repo_path = Path('tmp') / 'triton_repo'
+ triton_model_path = triton_repo_path / 'yolo'
+
+ # Create directories
+ (triton_model_path / '1').mkdir(parents=True, exist_ok=True)
+ ```
+
+2. Move the exported ONNX model to the Triton repository:
+
+ ```python
+ from pathlib import Path
+
+ # Move ONNX model to Triton Model path
+ Path(onnx_file).rename(triton_model_path / '1' / 'model.onnx')
+
+ # Create config file
+ (triton_model_path / 'config.pbtxt').touch()
+ ```
+
+## Running Triton Inference Server
+
+Run the Triton Inference Server using Docker:
+
+```python
+import subprocess
+import time
+
+from tritonclient.http import InferenceServerClient
+
+# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
+tag = 'nvcr.io/nvidia/tritonserver:23.09-py3' # 6.4 GB
+
+# Pull the image
+subprocess.call(f'docker pull {tag}', shell=True)
+
+# Run the Triton server and capture the container ID
+container_id = subprocess.check_output(
+ f'docker run -d --rm -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models',
+ shell=True).decode('utf-8').strip()
+
+# Wait for the Triton server to start
+triton_client = InferenceServerClient(url='localhost:8000', verbose=False, ssl=False)
+
+# Wait until model is ready
+for _ in range(10):
+ with contextlib.suppress(Exception):
+ assert triton_client.is_model_ready(model_name)
+ break
+ time.sleep(1)
+```
+
+Then run inference using the Triton Server model:
+
+```python
+from ultralytics import YOLO
+
+# Load the Triton Server model
+model = YOLO(f'http://localhost:8000/yolo', task='detect')
+
+# Run inference on the server
+results = model('path/to/image.jpg')
+```
+
+Cleanup the container:
+
+```python
+# Kill and remove the container at the end of the test
+subprocess.call(f'docker kill {container_id}', shell=True)
+```
+
+---
+
+By following the above steps, you can deploy and run Ultralytics YOLOv8 models efficiently on Triton Inference Server, providing a scalable and high-performance solution for deep learning inference tasks. If you face any issues or have further queries, refer to the [official Triton documentation](https://docs.nvidia.com/deeplearning/triton-inference-server/user-guide/docs/index.html) or reach out to the Ultralytics community for support.
diff --git a/ultralytics/docs/en/guides/triton-inference-server.md:Zone.Identifier b/ultralytics/docs/en/guides/triton-inference-server.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/triton-inference-server.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/vision-eye.md b/ultralytics/docs/en/guides/vision-eye.md
new file mode 100755
index 0000000..530d2eb
--- /dev/null
+++ b/ultralytics/docs/en/guides/vision-eye.md
@@ -0,0 +1,116 @@
+---
+comments: true
+description: VisionEye View Object Mapping using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Object Tracking, IDetection, VisionEye, Computer Vision, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# VisionEye View Object Mapping using Ultralytics YOLOv8 ๐
+
+## What is VisionEye Object Mapping?
+
+[Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) VisionEye offers the capability for computers to identify and pinpoint objects, simulating the observational precision of the human eye. This functionality enables computers to discern and focus on specific objects, much like the way the human eye observes details from a particular viewpoint.
+
+## Samples
+
+| VisionEye View | VisionEye View With Object Tracking |
+|:------------------------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+|  |  |
+| VisionEye View Object Mapping using Ultralytics YOLOv8 | VisionEye View Object Mapping with Object Tracking using Ultralytics YOLOv8 |
+
+!!! Example "VisionEye Object Mapping using YOLOv8"
+
+ === "VisionEye Object Mapping"
+ ```python
+ import cv2
+ from ultralytics import YOLO
+ from ultralytics.utils.plotting import colors, Annotator
+
+ model = YOLO("yolov8n.pt")
+ names = model.model.names
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+
+ out = cv2.VideoWriter('visioneye-pinpoint.avi', cv2.VideoWriter_fourcc(*'MJPG'),
+ 30, (int(cap.get(3)), int(cap.get(4))))
+
+ center_point = (-10, int(cap.get(4)))
+
+ while True:
+ ret, im0 = cap.read()
+ if not ret:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+
+ results = model.predict(im0)
+ boxes = results[0].boxes.xyxy.cpu()
+ clss = results[0].boxes.cls.cpu().tolist()
+
+ annotator = Annotator(im0, line_width=2)
+
+ for box, cls in zip(boxes, clss):
+ annotator.box_label(box, label=names[int(cls)], color=colors(int(cls)))
+ annotator.visioneye(box, center_point)
+
+ out.write(im0)
+ cv2.imshow("visioneye-pinpoint", im0)
+
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+
+ out.release()
+ cap.release()
+ cv2.destroyAllWindows()
+ ```
+
+ === "VisionEye Object Mapping with Object Tracking"
+ ```python
+ import cv2
+ from ultralytics import YOLO
+ from ultralytics.utils.plotting import colors, Annotator
+
+ model = YOLO("yolov8n.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+
+ out = cv2.VideoWriter('visioneye-pinpoint.avi', cv2.VideoWriter_fourcc(*'MJPG'),
+ 30, (int(cap.get(3)), int(cap.get(4))))
+
+ center_point = (-10, int(cap.get(4)))
+
+ while True:
+ ret, im0 = cap.read()
+ if not ret:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+
+ results = model.track(im0, persist=True)
+ boxes = results[0].boxes.xyxy.cpu()
+ track_ids = results[0].boxes.id.int().cpu().tolist()
+
+ annotator = Annotator(im0, line_width=2)
+
+ for box, track_id in zip(boxes, track_ids):
+ annotator.box_label(box, label=str(track_id), color=colors(int(track_id)))
+ annotator.visioneye(box, center_point)
+
+ out.write(im0)
+ cv2.imshow("visioneye-pinpoint", im0)
+
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+
+ out.release()
+ cap.release()
+ cv2.destroyAllWindows()
+ ```
+
+### `visioneye` Arguments
+
+| Name | Type | Default | Description |
+|---------------|---------|------------------|--------------------------------------------------|
+| `color` | `tuple` | `(235, 219, 11)` | Line and object centroid color |
+| `pin_color` | `tuple` | `(255, 0, 255)` | VisionEye pinpoint color |
+| `thickness` | `int` | `2` | pinpoint to object line thickness |
+| `pins_radius` | `int` | `10` | Pinpoint and object centroid point circle radius |
+
+## Note
+
+For any inquiries, feel free to post your questions in the [Ultralytics Issue Section](https://github.com/ultralytics/ultralytics/issues/new/choose) or the discussion section mentioned below.
diff --git a/ultralytics/docs/en/guides/vision-eye.md:Zone.Identifier b/ultralytics/docs/en/guides/vision-eye.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/vision-eye.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/workouts-monitoring.md b/ultralytics/docs/en/guides/workouts-monitoring.md
new file mode 100755
index 0000000..02e8209
--- /dev/null
+++ b/ultralytics/docs/en/guides/workouts-monitoring.md
@@ -0,0 +1,130 @@
+---
+comments: true
+description: Workouts Monitoring Using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Pose Estimation, PushUps, PullUps, Ab workouts, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Workouts Monitoring using Ultralytics YOLOv8 ๐
+
+Monitoring workouts through pose estimation with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) enhances exercise assessment by accurately tracking key body landmarks and joints in real-time. This technology provides instant feedback on exercise form, tracks workout routines, and measures performance metrics, optimizing training sessions for users and trainers alike.
+
+## Advantages of Workouts Monitoring?
+
+- **Optimized Performance:** Tailoring workouts based on monitoring data for better results.
+- **Goal Achievement:** Track and adjust fitness goals for measurable progress.
+- **Personalization:** Customized workout plans based on individual data for effectiveness.
+- **Health Awareness:** Early detection of patterns indicating health issues or overtraining.
+- **Informed Decisions:** Data-driven decisions for adjusting routines and setting realistic goals.
+
+## Real World Applications
+
+| Workouts Monitoring | Workouts Monitoring |
+|:----------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------:|
+|  |  |
+| PushUps Counting | PullUps Counting |
+
+!!! Example "Workouts Monitoring Example"
+
+ === "Workouts Monitoring"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import ai_gym
+ import cv2
+
+ model = YOLO("yolov8n-pose.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ gym_object = ai_gym.AIGym() # init AI GYM module
+ gym_object.set_args(line_thickness=2,
+ view_img=True,
+ pose_type="pushup",
+ kpts_to_check=[6, 8, 10])
+
+ frame_count = 0
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ frame_count += 1
+ results = model.predict(im0, verbose=False)
+ im0 = gym_object.start_counting(im0, results, frame_count)
+
+ cv2.destroyAllWindows()
+ ```
+
+ === "Workouts Monitoring with Save Output"
+ ```python
+ from ultralytics import YOLO
+ from ultralytics.solutions import ai_gym
+ import cv2
+
+ model = YOLO("yolov8n-pose.pt")
+ cap = cv2.VideoCapture("path/to/video/file.mp4")
+ assert cap.isOpened(), "Error reading video file"
+
+ video_writer = cv2.VideoWriter("workouts.avi",
+ cv2.VideoWriter_fourcc(*'mp4v'),
+ int(cap.get(5)),
+ (int(cap.get(3)), int(cap.get(4))))
+
+ gym_object = ai_gym.AIGym() # init AI GYM module
+ gym_object.set_args(line_thickness=2,
+ view_img=True,
+ pose_type="pushup",
+ kpts_to_check=[6, 8, 10])
+
+ frame_count = 0
+ while cap.isOpened():
+ success, im0 = cap.read()
+ if not success:
+ print("Video frame is empty or video processing has been successfully completed.")
+ break
+ frame_count += 1
+ results = model.predict(im0, verbose=False)
+ im0 = gym_object.start_counting(im0, results, frame_count)
+ video_writer.write(im0)
+
+ cv2.destroyAllWindows()
+ video_writer.release()
+ ```
+
+???+ tip "Support"
+
+ "pushup", "pullup" and "abworkout" supported
+
+### KeyPoints Map
+
+
+
+### Arguments `set_args`
+
+| Name | Type | Default | Description |
+|-----------------|--------|----------|----------------------------------------------------------------------------------------|
+| kpts_to_check | `list` | `None` | List of three keypoints index, for counting specific workout, followed by keypoint Map |
+| view_img | `bool` | `False` | Display the frame with counts |
+| line_thickness | `int` | `2` | Increase the thickness of count value |
+| pose_type | `str` | `pushup` | Pose that need to be monitored, "pullup" and "abworkout" also supported |
+| pose_up_angle | `int` | `145` | Pose Up Angle value |
+| pose_down_angle | `int` | `90` | Pose Down Angle value |
+
+### Arguments `model.predict`
+
+| Name | Type | Default | Description |
+|-----------------|----------------|------------------------|----------------------------------------------------------------------------|
+| `source` | `str` | `'ultralytics/assets'` | source directory for images or videos |
+| `conf` | `float` | `0.25` | object confidence threshold for detection |
+| `iou` | `float` | `0.7` | intersection over union (IoU) threshold for NMS |
+| `imgsz` | `int or tuple` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `half` | `bool` | `False` | use half precision (FP16) |
+| `device` | `None or str` | `None` | device to run on, i.e. cuda device=0/1/2/3 or device=cpu |
+| `max_det` | `int` | `300` | maximum number of detections per image |
+| `vid_stride` | `bool` | `False` | video frame-rate stride |
+| `stream_buffer` | `bool` | `False` | buffer all streaming frames (True) or return the most recent frame (False) |
+| `visualize` | `bool` | `False` | visualize model features |
+| `augment` | `bool` | `False` | apply image augmentation to prediction sources |
+| `agnostic_nms` | `bool` | `False` | class-agnostic NMS |
+| `classes` | `list[int]` | `None` | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+| `retina_masks` | `bool` | `False` | use high-resolution segmentation masks |
+| `embed` | `list[int]` | `None` | return feature vectors/embeddings from given layers |
diff --git a/ultralytics/docs/en/guides/workouts-monitoring.md:Zone.Identifier b/ultralytics/docs/en/guides/workouts-monitoring.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/workouts-monitoring.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/yolo-common-issues.md b/ultralytics/docs/en/guides/yolo-common-issues.md
new file mode 100755
index 0000000..71083cf
--- /dev/null
+++ b/ultralytics/docs/en/guides/yolo-common-issues.md
@@ -0,0 +1,276 @@
+---
+comments: true
+description: A comprehensive guide to troubleshooting common issues encountered while working with YOLOv8 in the Ultralytics ecosystem.
+keywords: Troubleshooting, Ultralytics, YOLOv8, Installation Errors, Training Data, Model Performance, Hyperparameter Tuning, Deployment
+---
+
+# Troubleshooting Common YOLO Issues
+
+
+
+
+
+## Introduction
+
+This guide serves as a comprehensive aid for troubleshooting common issues encountered while working with YOLOv8 on your Ultralytics projects. Navigating through these issues can be a breeze with the right guidance, ensuring your projects remain on track without unnecessary delays.
+
+## Common Issues
+
+### Installation Errors
+
+Installation errors can arise due to various reasons, such as incompatible versions, missing dependencies, or incorrect environment setups. First, check to make sure you are doing the following:
+
+- You're using Python 3.8 or later as recommended.
+
+- Ensure that you have the correct version of PyTorch (1.8 or later) installed.
+
+- Consider using virtual environments to avoid conflicts.
+
+- Follow the [official installation guide](../quickstart.md) step by step.
+
+Additionally, here are some common installation issues users have encountered, along with their respective solutions:
+
+- Import Errors or Dependency Issues - If you're getting errors during the import of YOLOv8, or you're having issues related to dependencies, consider the following troubleshooting steps:
+
+ - **Fresh Installation**: Sometimes, starting with a fresh installation can resolve unexpected issues. Especially with libraries like Ultralytics, where updates might introduce changes to the file tree structure or functionalities.
+
+ - **Update Regularly**: Ensure you're using the latest version of the library. Older versions might not be compatible with recent updates, leading to potential conflicts or issues.
+
+ - **Check Dependencies**: Verify that all required dependencies are correctly installed and are of the compatible versions.
+
+ - **Review Changes**: If you initially cloned or installed an older version, be aware that significant updates might affect the library's structure or functionalities. Always refer to the official documentation or changelogs to understand any major changes.
+
+ - Remember, keeping your libraries and dependencies up-to-date is crucial for a smooth and error-free experience.
+
+- Running YOLOv8 on GPU - If you're having trouble running YOLOv8 on GPU, consider the following troubleshooting steps:
+
+ - **Verify CUDA Compatibility and Installation**: Ensure your GPU is CUDA compatible and that CUDA is correctly installed. Use the `nvidia-smi` command to check the status of your NVIDIA GPU and CUDA version.
+
+ - **Check PyTorch and CUDA Integration**: Ensure PyTorch can utilize CUDA by running `import torch; print(torch.cuda.is_available())` in a Python terminal. If it returns 'True', PyTorch is set up to use CUDA.
+
+ - **Environment Activation**: Ensure you're in the correct environment where all necessary packages are installed.
+
+ - **Update Your Packages**: Outdated packages might not be compatible with your GPU. Keep them updated.
+
+ - **Program Configuration**: Check if the program or code specifies GPU usage. In YOLOv8, this might be in the settings or configuration.
+
+### Model Training Issues
+
+This section will address common issues faced while training and their respective explanations and solutions.
+
+#### Verification of Configuration Settings
+
+**Issue**: You are unsure whether the configuration settings in the `.yaml` file are being applied correctly during model training.
+
+**Solution**: The configuration settings in the `.yaml` file should be applied when using the `model.train()` function. To ensure that these settings are correctly applied, follow these steps:
+
+- Confirm that the path to your `.yaml` configuration file is correct.
+- Make sure you pass the path to your `.yaml` file as the `data` argument when calling `model.train()`, as shown below:
+
+```python
+model.train(data='/path/to/your/data.yaml', batch=4)
+```
+
+#### Accelerating Training with Multiple GPUs
+
+**Issue**: Training is slow on a single GPU, and you want to speed up the process using multiple GPUs.
+
+**Solution**: Increasing the batch size can accelerate training, but it's essential to consider GPU memory capacity. To speed up training with multiple GPUs, follow these steps:
+
+- Ensure that you have multiple GPUs available.
+
+- Modify your .yaml configuration file to specify the number of GPUs to use, e.g., gpus: 4.
+
+- Increase the batch size accordingly to fully utilize the multiple GPUs without exceeding memory limits.
+
+- Modify your training command to utilize multiple GPUs:
+
+```python
+# Adjust the batch size and other settings as needed to optimize training speed
+model.train(data='/path/to/your/data.yaml', batch=32, multi_scale=True)
+```
+
+#### Continuous Monitoring Parameters
+
+**Issue**: You want to know which parameters should be continuously monitored during training, apart from loss.
+
+**Solution**: While loss is a crucial metric to monitor, it's also essential to track other metrics for model performance optimization. Some key metrics to monitor during training include:
+
+- Precision
+- Recall
+- Mean Average Precision (mAP)
+
+You can access these metrics from the training logs or by using tools like TensorBoard or wandb for visualization. Implementing early stopping based on these metrics can help you achieve better results.
+
+#### Tools for Tracking Training Progress
+
+**Issue**: You are looking for recommendations on tools to track training progress.
+
+**Solution**: To track and visualize training progress, you can consider using the following tools:
+
+- [TensorBoard](https://www.tensorflow.org/tensorboard): TensorBoard is a popular choice for visualizing training metrics, including loss, accuracy, and more. You can integrate it with your YOLOv8 training process.
+- [Comet](https://bit.ly/yolov8-readme-comet): Comet provides an extensive toolkit for experiment tracking and comparison. It allows you to track metrics, hyperparameters, and even model weights. Integration with YOLO models is also straightforward, providing you with a complete overview of your experiment cycle.
+- [Ultralytics HUB](https://hub.ultralytics.com): Ultralytics HUB offers a specialized environment for tracking YOLO models, giving you a one-stop platform to manage metrics, datasets, and even collaborate with your team. Given its tailored focus on YOLO, it offers more customized tracking options.
+
+Each of these tools offers its own set of advantages, so you may want to consider the specific needs of your project when making a choice.
+
+#### How to Check if Training is Happening on the GPU
+
+**Issue**: The 'device' value in the training logs is 'null,' and you're unsure if training is happening on the GPU.
+
+**Solution**: The 'device' value being 'null' typically means that the training process is set to automatically use an available GPU, which is the default behavior. To ensure training occurs on a specific GPU, you can manually set the 'device' value to the GPU index (e.g., '0' for the first GPU) in your .yaml configuration file:
+
+```yaml
+device: 0
+```
+
+This will explicitly assign the training process to the specified GPU. If you wish to train on the CPU, set 'device' to 'cpu'.
+
+Keep an eye on the 'runs' folder for logs and metrics to monitor training progress effectively.
+
+#### Key Considerations for Effective Model Training
+
+Here are some things to keep in mind, if you are facing issues related to model training.
+
+**Dataset Format and Labels**
+
+- Importance: The foundation of any machine learning model lies in the quality and format of the data it is trained on.
+
+- Recommendation: Ensure that your custom dataset and its associated labels adhere to the expected format. It's crucial to verify that annotations are accurate and of high quality. Incorrect or subpar annotations can derail the model's learning process, leading to unpredictable outcomes.
+
+**Model Convergence**
+
+- Importance: Achieving model convergence ensures that the model has sufficiently learned from the training data.
+
+- Recommendation: When training a model 'from scratch', it's vital to ensure that the model reaches a satisfactory level of convergence. This might necessitate a longer training duration, with more epochs, compared to when you're fine-tuning an existing model.
+
+**Learning Rate and Batch Size**
+
+- Importance: These hyperparameters play a pivotal role in determining how the model updates its weights during training.
+
+- Recommendation: Regularly evaluate if the chosen learning rate and batch size are optimal for your specific dataset. Parameters that are not in harmony with the dataset's characteristics can hinder the model's performance.
+
+**Class Distribution**
+
+- Importance: The distribution of classes in your dataset can influence the model's prediction tendencies.
+
+- Recommendation: Regularly assess the distribution of classes within your dataset. If there's a class imbalance, there's a risk that the model will develop a bias towards the more prevalent class. This bias can be evident in the confusion matrix, where the model might predominantly predict the majority class.
+
+**Cross-Check with Pretrained Weights**
+
+- Importance: Leveraging pretrained weights can provide a solid starting point for model training, especially when data is limited.
+
+- Recommendation: As a diagnostic step, consider training your model using the same data but initializing it with pretrained weights. If this approach yields a well-formed confusion matrix, it could suggest that the 'from scratch' model might require further training or adjustments.
+
+### Issues Related to Model Predictions
+
+This section will address common issues faced during model prediction.
+
+#### Getting Bounding Box Predictions With Your YOLOv8 Custom Model
+
+**Issue**: When running predictions with a custom YOLOv8 model, there are challenges with the format and visualization of the bounding box coordinates.
+
+**Solution**:
+
+- Coordinate Format: YOLOv8 provides bounding box coordinates in absolute pixel values. To convert these to relative coordinates (ranging from 0 to 1), you need to divide by the image dimensions. For example, letโs say your image size is 640x640. Then you would do the following:
+
+```python
+# Convert absolute coordinates to relative coordinates
+x1 = x1 / 640 # Divide x-coordinates by image width
+x2 = x2 / 640
+y1 = y1 / 640 # Divide y-coordinates by image height
+y2 = y2 / 640
+```
+
+- File Name: To obtain the file name of the image you're predicting on, access the image file path directly from the result object within your prediction loop.
+
+#### Filtering Objects in YOLOv8 Predictions
+
+**Issue**: Facing issues with how to filter and display only specific objects in the prediction results when running YOLOv8 using the Ultralytics library.
+
+**Solution**: To detect specific classes use the classes argument to specify the classes you want to include in the output. For instance, to detect only cars (assuming 'cars' have class index 2):
+
+```shell
+yolo task=detect mode=segment model=yolov8n-seg.pt source='path/to/car.mp4' show=True classes=2
+```
+
+#### Understanding Precision Metrics in YOLOv8
+
+**Issue**: Confusion regarding the difference between box precision, mask precision, and confusion matrix precision in YOLOv8.
+
+**Solution**: Box precision measures the accuracy of predicted bounding boxes compared to the actual ground truth boxes using IoU (Intersection over Union) as the metric. Mask precision assesses the agreement between predicted segmentation masks and ground truth masks in pixel-wise object classification. Confusion matrix precision, on the other hand, focuses on overall classification accuracy across all classes and does not consider the geometric accuracy of predictions. It's important to note that a bounding box can be geometrically accurate (true positive) even if the class prediction is wrong, leading to differences between box precision and confusion matrix precision. These metrics evaluate distinct aspects of a model's performance, reflecting the need for different evaluation metrics in various tasks.
+
+#### Extracting Object Dimensions in YOLOv8
+
+**Issue**: Difficulty in retrieving the length and height of detected objects in YOLOv8, especially when multiple objects are detected in an image.
+
+**Solution**: To retrieve the bounding box dimensions, first use the Ultralytics YOLOv8 model to predict objects in an image. Then, extract the width and height information of bounding boxes from the prediction results.
+
+```python
+from ultralytics import YOLO
+
+# Load a pre-trained YOLOv8 model
+model = YOLO('yolov8n.pt')
+
+# Specify the source image
+source = 'https://ultralytics.com/images/bus.jpg'
+
+# Make predictions
+results = model.predict(source, save=True, imgsz=320, conf=0.5)
+
+# Extract bounding box dimensions
+boxes = results[0].boxes.xywh.cpu()
+for box in boxes:
+ x, y, w, h = box
+ print(f"Width of Box: {w}, Height of Box: {h}")
+```
+
+### Deployment Challenges
+
+#### GPU Deployment Issues
+
+**Issue:** Deploying models in a multi-GPU environment can sometimes lead to unexpected behaviors like unexpected memory usage, inconsistent results across GPUs, etc.
+
+**Solution:** Check for default GPU initialization. Some frameworks, like PyTorch, might initialize CUDA operations on a default GPU before transitioning to the designated GPUs. To bypass unexpected default initializations, specify the GPU directly during deployment and prediction. Then, use tools to monitor GPU utilization and memory usage to identify any anomalies in real-time. Also, ensure you're using the latest version of the framework or library.
+
+#### Model Conversion/Exporting Issues
+
+**Issue:** During the process of converting or exporting machine learning models to different formats or platforms, users might encounter errors or unexpected behaviors.
+
+**Solution:**
+
+- Compatibility Check: Ensure that you are using versions of libraries and frameworks that are compatible with each other. Mismatched versions can lead to unexpected errors during conversion.
+
+- Environment Reset: If you're using an interactive environment like Jupyter or Colab, consider restarting your environment after making significant changes or installations. A fresh start can sometimes resolve underlying issues.
+
+- Official Documentation: Always refer to the official documentation of the tool or library you are using for conversion. It often contains specific guidelines and best practices for model exporting.
+
+- Community Support: Check the library or framework's official repository for similar issues reported by other users. The maintainers or community might have provided solutions or workarounds in discussion threads.
+
+- Update Regularly: Ensure that you are using the latest version of the tool or library. Developers frequently release updates that fix known bugs or improve functionality.
+
+- Test Incrementally: Before performing a full conversion, test the process with a smaller model or dataset to identify potential issues early on.
+
+## Community and Support
+
+Engaging with a community of like-minded individuals can significantly enhance your experience and success in working with YOLOv8. Below are some channels and resources you may find helpful.
+
+### Forums and Channels for Getting Help
+
+**GitHub Issues:** The YOLOv8 repository on GitHub has an [Issues tab](https://github.com/ultralytics/ultralytics/issues) where you can ask questions, report bugs, and suggest new features. The community and maintainers are active here, and itโs a great place to get help with specific problems.
+
+**Ultralytics Discord Server:** Ultralytics has a [Discord server](https://ultralytics.com/discord/) where you can interact with other users and the developers.
+
+### Official Documentation and Resources
+
+**Ultralytics YOLOv8 Docs**: The [official documentation](../index.md) provides a comprehensive overview of YOLOv8, along with guides on installation, usage, and troubleshooting.
+
+These resources should provide a solid foundation for troubleshooting and improving your YOLOv8 projects, as well as connecting with others in the YOLOv8 community.
+
+## Conclusion
+
+Troubleshooting is an integral part of any development process, and being equipped with the right knowledge can significantly reduce the time and effort spent in resolving issues. This guide aimed to address the most common challenges faced by users of the YOLOv8 model within the Ultralytics ecosystem. By understanding and addressing these common issues, you can ensure smoother project progress and achieve better results with your computer vision tasks.
+
+Remember, the Ultralytics community is a valuable resource. Engaging with fellow developers and experts can provide additional insights and solutions that might not be covered in standard documentation. Always keep learning, experimenting, and sharing your experiences to contribute to the collective knowledge of the community.
+
+Happy troubleshooting!
diff --git a/ultralytics/docs/en/guides/yolo-common-issues.md:Zone.Identifier b/ultralytics/docs/en/guides/yolo-common-issues.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/yolo-common-issues.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/yolo-performance-metrics.md b/ultralytics/docs/en/guides/yolo-performance-metrics.md
new file mode 100755
index 0000000..6a7a5e6
--- /dev/null
+++ b/ultralytics/docs/en/guides/yolo-performance-metrics.md
@@ -0,0 +1,165 @@
+---
+comments: true
+description: A comprehensive guide on various performance metrics related to YOLOv8, their significance, and how to interpret them.
+keywords: YOLOv8, Performance metrics, Object detection, Intersection over Union (IoU), Average Precision (AP), Mean Average Precision (mAP), Precision, Recall, Validation mode, Ultralytics
+---
+
+# Performance Metrics Deep Dive
+
+## Introduction
+
+Performance metrics are key tools to evaluate the accuracy and efficiency of object detection models. They shed light on how effectively a model can identify and localize objects within images. Additionally, they help in understanding the model's handling of false positives and false negatives. These insights are crucial for evaluating and enhancing the model's performance. In this guide, we will explore various performance metrics associated with YOLOv8, their significance, and how to interpret them.
+
+## Object Detection Metrics
+
+Letโs start by discussing some metrics that are not only important to YOLOv8 but are broadly applicable across different object detection models.
+
+- **Intersection over Union (IoU):** IoU is a measure that quantifies the overlap between a predicted bounding box and a ground truth bounding box. It plays a fundamental role in evaluating the accuracy of object localization.
+
+- **Average Precision (AP):** AP computes the area under the precision-recall curve, providing a single value that encapsulates the model's precision and recall performance.
+
+- **Mean Average Precision (mAP):** mAP extends the concept of AP by calculating the average AP values across multiple object classes. This is useful in multi-class object detection scenarios to provide a comprehensive evaluation of the model's performance.
+
+- **Precision and Recall:** Precision quantifies the proportion of true positives among all positive predictions, assessing the model's capability to avoid false positives. On the other hand, Recall calculates the proportion of true positives among all actual positives, measuring the model's ability to detect all instances of a class.
+
+- **F1 Score:** The F1 Score is the harmonic mean of precision and recall, providing a balanced assessment of a model's performance while considering both false positives and false negatives.
+
+## How to Calculate Metrics for YOLOv8 Model
+
+Now, we can explore [YOLOv8's Validation mode](../modes/val.md) that can be used to compute the above discussed evaluation metrics.
+
+Using the validation mode is simple. Once you have a trained model, you can invoke the model.val() function. This function will then process the validation dataset and return a variety of performance metrics. But what do these metrics mean? And how should you interpret them?
+
+### Interpreting the Output
+
+Let's break down the output of the model.val() function and understand each segment of the output.
+
+#### Class-wise Metrics
+
+One of the sections of the output is the class-wise breakdown of performance metrics. This granular information is useful when you are trying to understand how well the model is doing for each specific class, especially in datasets with a diverse range of object categories. For each class in the dataset the following is provided:
+
+- **Class**: This denotes the name of the object class, such as "person", "car", or "dog".
+
+- **Images**: This metric tells you the number of images in the validation set that contain the object class.
+
+- **Instances**: This provides the count of how many times the class appears across all images in the validation set.
+
+- **Box(P, R, mAP50, mAP50-95)**: This metric provides insights into the model's performance in detecting objects:
+
+ - **P (Precision)**: The accuracy of the detected objects, indicating how many detections were correct.
+
+ - **R (Recall)**: The ability of the model to identify all instances of objects in the images.
+
+ - **mAP50**: Mean average precision calculated at an intersection over union (IoU) threshold of 0.50. It's a measure of the model's accuracy considering only the "easy" detections.
+
+ - **mAP50-95**: The average of the mean average precision calculated at varying IoU thresholds, ranging from 0.50 to 0.95. It gives a comprehensive view of the model's performance across different levels of detection difficulty.
+
+#### Speed Metrics
+
+The speed of inference can be as critical as accuracy, especially in real-time object detection scenarios. This section breaks down the time taken for various stages of the validation process, from preprocessing to post-processing.
+
+#### COCO Metrics Evaluation
+
+For users validating on the COCO dataset, additional metrics are calculated using the COCO evaluation script. These metrics give insights into precision and recall at different IoU thresholds and for objects of different sizes.
+
+#### Visual Outputs
+
+The model.val() function, apart from producing numeric metrics, also yields visual outputs that can provide a more intuitive understanding of the model's performance. Here's a breakdown of the visual outputs you can expect:
+
+- **F1 Score Curve (`F1_curve.png`)**: This curve represents the F1 score across various thresholds. Interpreting this curve can offer insights into the model's balance between false positives and false negatives over different thresholds.
+
+- **Precision-Recall Curve (`PR_curve.png`)**: An integral visualization for any classification problem, this curve showcases the trade-offs between precision and recall at varied thresholds. It becomes especially significant when dealing with imbalanced classes.
+
+- **Precision Curve (`P_curve.png`)**: A graphical representation of precision values at different thresholds. This curve helps in understanding how precision varies as the threshold changes.
+
+- **Recall Curve (`R_curve.png`)**: Correspondingly, this graph illustrates how the recall values change across different thresholds.
+
+- **Confusion Matrix (`confusion_matrix.png`)**: The confusion matrix provides a detailed view of the outcomes, showcasing the counts of true positives, true negatives, false positives, and false negatives for each class.
+
+- **Normalized Confusion Matrix (`confusion_matrix_normalized.png`)**: This visualization is a normalized version of the confusion matrix. It represents the data in proportions rather than raw counts. This format makes it simpler to compare the performance across classes.
+
+- **Validation Batch Labels (`val_batchX_labels.jpg`)**: These images depict the ground truth labels for distinct batches from the validation dataset. They provide a clear picture of what the objects are and their respective locations as per the dataset.
+
+- **Validation Batch Predictions (`val_batchX_pred.jpg`)**: Contrasting the label images, these visuals display the predictions made by the YOLOv8 model for the respective batches. By comparing these to the label images, you can easily assess how well the model detects and classifies objects visually.
+
+#### Results Storage
+
+For future reference, the results are saved to a directory, typically named runs/detect/val.
+
+## Choosing the Right Metrics
+
+Choosing the right metrics to evaluate often depends on the specific application.
+
+- **mAP:** Suitable for a broad assessment of model performance.
+
+- **IoU:** Essential when precise object location is crucial.
+
+- **Precision:** Important when minimizing false detections is a priority.
+
+- **Recall:** Vital when it's important to detect every instance of an object.
+
+- **F1 Score:** Useful when a balance between precision and recall is needed.
+
+For real-time applications, speed metrics like FPS (Frames Per Second) and latency are crucial to ensure timely results.
+
+## Interpretation of Results
+
+Itโs important to understand the metrics. Here's what some of the commonly observed lower scores might suggest:
+
+- **Low mAP:** Indicates the model may need general refinements.
+
+- **Low IoU:** The model might be struggling to pinpoint objects accurately. Different bounding box methods could help.
+
+- **Low Precision:** The model may be detecting too many non-existent objects. Adjusting confidence thresholds might reduce this.
+
+- **Low Recall:** The model could be missing real objects. Improving feature extraction or using more data might help.
+
+- **Imbalanced F1 Score:** There's a disparity between precision and recall.
+
+- **Class-specific AP:** Low scores here can highlight classes the model struggles with.
+
+## Case Studies
+
+Real-world examples can help clarify how these metrics work in practice.
+
+### Case 1
+
+- **Situation:** mAP and F1 Score are suboptimal, but while Recall is good, Precision isn't.
+
+- **Interpretation & Action:** There might be too many incorrect detections. Tightening confidence thresholds could reduce these, though it might also slightly decrease recall.
+
+### Case 2
+
+- **Situation:** mAP and Recall are acceptable, but IoU is lacking.
+
+- **Interpretation & Action:** The model detects objects well but might not be localizing them precisely. Refining bounding box predictions might help.
+
+### Case 3
+
+- **Situation:** Some classes have a much lower AP than others, even with a decent overall mAP.
+
+- **Interpretation & Action:** These classes might be more challenging for the model. Using more data for these classes or adjusting class weights during training could be beneficial.
+
+## Connect and Collaborate
+
+Tapping into a community of enthusiasts and experts can amplify your journey with YOLOv8. Here are some avenues that can facilitate learning, troubleshooting, and networking.
+
+### Engage with the Broader Community
+
+- **GitHub Issues:** The YOLOv8 repository on GitHub has an [Issues tab](https://github.com/ultralytics/ultralytics/issues) where you can ask questions, report bugs, and suggest new features. The community and maintainers are active here, and itโs a great place to get help with specific problems.
+
+- **Ultralytics Discord Server:** Ultralytics has a [Discord server](https://ultralytics.com/discord/) where you can interact with other users and the developers.
+
+### Official Documentation and Resources:
+
+- **Ultralytics YOLOv8 Docs:** The [official documentation](../index.md) provides a comprehensive overview of YOLOv8, along with guides on installation, usage, and troubleshooting.
+
+Using these resources will not only guide you through any challenges but also keep you updated with the latest trends and best practices in the YOLOv8 community.
+
+## Conclusion
+
+In this guide, we've taken a close look at the essential performance metrics for YOLOv8. These metrics are key to understanding how well a model is performing and are vital for anyone aiming to fine-tune their models. They offer the necessary insights for improvements and to make sure the model works effectively in real-life situations.
+
+Remember, the YOLOv8 and Ultralytics community is an invaluable asset. Engaging with fellow developers and experts can open doors to insights and solutions not found in standard documentation. As you journey through object detection, keep the spirit of learning alive, experiment with new strategies, and share your findings. By doing so, you contribute to the community's collective wisdom and ensure its growth.
+
+Happy object detecting!
diff --git a/ultralytics/docs/en/guides/yolo-performance-metrics.md:Zone.Identifier b/ultralytics/docs/en/guides/yolo-performance-metrics.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/yolo-performance-metrics.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/guides/yolo-thread-safe-inference.md b/ultralytics/docs/en/guides/yolo-thread-safe-inference.md
new file mode 100755
index 0000000..abf7a36
--- /dev/null
+++ b/ultralytics/docs/en/guides/yolo-thread-safe-inference.md
@@ -0,0 +1,108 @@
+---
+comments: true
+description: This guide provides best practices for performing thread-safe inference with YOLO models, ensuring reliable and concurrent predictions in multi-threaded applications.
+keywords: thread-safe, YOLO inference, multi-threading, concurrent predictions, YOLO models, Ultralytics, Python threading, safe YOLO usage, AI concurrency
+---
+
+# Thread-Safe Inference with YOLO Models
+
+Running YOLO models in a multi-threaded environment requires careful consideration to ensure thread safety. Python's `threading` module allows you to run several threads concurrently, but when it comes to using YOLO models across these threads, there are important safety issues to be aware of. This page will guide you through creating thread-safe YOLO model inference.
+
+## Understanding Python Threading
+
+Python threads are a form of parallelism that allow your program to run multiple operations at once. However, Python's Global Interpreter Lock (GIL) means that only one thread can execute Python bytecode at a time.
+
+
+
+
+
+While this sounds like a limitation, threads can still provide concurrency, especially for I/O-bound operations or when using operations that release the GIL, like those performed by YOLO's underlying C libraries.
+
+## The Danger of Shared Model Instances
+
+Instantiating a YOLO model outside your threads and sharing this instance across multiple threads can lead to race conditions, where the internal state of the model is inconsistently modified due to concurrent accesses. This is particularly problematic when the model or its components hold state that is not designed to be thread-safe.
+
+### Non-Thread-Safe Example: Single Model Instance
+
+When using threads in Python, it's important to recognize patterns that can lead to concurrency issues. Here is what you should avoid: sharing a single YOLO model instance across multiple threads.
+
+```python
+# Unsafe: Sharing a single model instance across threads
+from ultralytics import YOLO
+from threading import Thread
+
+# Instantiate the model outside the thread
+shared_model = YOLO("yolov8n.pt")
+
+
+def predict(image_path):
+ results = shared_model.predict(image_path)
+ # Process results
+
+
+# Starting threads that share the same model instance
+Thread(target=predict, args=("image1.jpg",)).start()
+Thread(target=predict, args=("image2.jpg",)).start()
+```
+
+In the example above, the `shared_model` is used by multiple threads, which can lead to unpredictable results because `predict` could be executed simultaneously by multiple threads.
+
+### Non-Thread-Safe Example: Multiple Model Instances
+
+Similarly, here is an unsafe pattern with multiple YOLO model instances:
+
+```python
+# Unsafe: Sharing multiple model instances across threads can still lead to issues
+from ultralytics import YOLO
+from threading import Thread
+
+# Instantiate multiple models outside the thread
+shared_model_1 = YOLO("yolov8n_1.pt")
+shared_model_2 = YOLO("yolov8n_2.pt")
+
+
+def predict(model, image_path):
+ results = model.predict(image_path)
+ # Process results
+
+
+# Starting threads with individual model instances
+Thread(target=predict, args=(shared_model_1, "image1.jpg")).start()
+Thread(target=predict, args=(shared_model_2, "image2.jpg")).start()
+```
+
+Even though there are two separate model instances, the risk of concurrency issues still exists. If the internal implementation of `YOLO` is not thread-safe, using separate instances might not prevent race conditions, especially if these instances share any underlying resources or states that are not thread-local.
+
+## Thread-Safe Inference
+
+To perform thread-safe inference, you should instantiate a separate YOLO model within each thread. This ensures that each thread has its own isolated model instance, eliminating the risk of race conditions.
+
+### Thread-Safe Example
+
+Here's how to instantiate a YOLO model inside each thread for safe parallel inference:
+
+```python
+# Safe: Instantiating a single model inside each thread
+from ultralytics import YOLO
+from threading import Thread
+
+
+def thread_safe_predict(image_path):
+ # Instantiate a new model inside the thread
+ local_model = YOLO("yolov8n.pt")
+ results = local_model.predict(image_path)
+ # Process results
+
+
+# Starting threads that each have their own model instance
+Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
+Thread(target=thread_safe_predict, args=("image2.jpg",)).start()
+```
+
+In this example, each thread creates its own `YOLO` instance. This prevents any thread from interfering with the model state of another, thus ensuring that each thread performs inference safely and without unexpected interactions with the other threads.
+
+## Conclusion
+
+When using YOLO models with Python's `threading`, always instantiate your models within the thread that will use them to ensure thread safety. This practice avoids race conditions and makes sure that your inference tasks run reliably.
+
+For more advanced scenarios and to further optimize your multi-threaded inference performance, consider using process-based parallelism with `multiprocessing` or leveraging a task queue with dedicated worker processes.
diff --git a/ultralytics/docs/en/guides/yolo-thread-safe-inference.md:Zone.Identifier b/ultralytics/docs/en/guides/yolo-thread-safe-inference.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/guides/yolo-thread-safe-inference.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/CI.md b/ultralytics/docs/en/help/CI.md
new file mode 100755
index 0000000..b01549c
--- /dev/null
+++ b/ultralytics/docs/en/help/CI.md
@@ -0,0 +1,61 @@
+---
+comments: true
+description: Learn how Ultralytics leverages Continuous Integration (CI) for maintaining high-quality code. Explore our CI tests and the status of these tests for our repositories.
+keywords: continuous integration, software development, CI tests, Ultralytics repositories, high-quality code, Docker Deployment, Broken Links, CodeQL, PyPi Publishing
+---
+
+# Continuous Integration (CI)
+
+Continuous Integration (CI) is an essential aspect of software development which involves integrating changes and testing them automatically. CI allows us to maintain high-quality code by catching issues early and often in the development process. At Ultralytics, we use various CI tests to ensure the quality and integrity of our codebase.
+
+## CI Actions
+
+Here's a brief description of our CI actions:
+
+- **CI:** This is our primary CI test that involves running unit tests, linting checks, and sometimes more comprehensive tests depending on the repository.
+- **Docker Deployment:** This test checks the deployment of the project using Docker to ensure the Dockerfile and related scripts are working correctly.
+- **Broken Links:** This test scans the codebase for any broken or dead links in our markdown or HTML files.
+- **CodeQL:** CodeQL is a tool from GitHub that performs semantic analysis on our code, helping to find potential security vulnerabilities and maintain high-quality code.
+- **PyPi Publishing:** This test checks if the project can be packaged and published to PyPi without any errors.
+
+### CI Results
+
+Below is the table showing the status of these CI tests for our main repositories:
+
+| Repository | CI | Docker Deployment | Broken Links | CodeQL | PyPi and Docs Publishing |
+|-----------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [yolov3](https://github.com/ultralytics/yolov3) | [](https://github.com/ultralytics/yolov3/actions/workflows/ci-testing.yml) | [](https://github.com/ultralytics/yolov3/actions/workflows/docker.yml) | [](https://github.com/ultralytics/yolov3/actions/workflows/links.yml) | [](https://github.com/ultralytics/yolov3/actions/workflows/codeql-analysis.yml) | |
+| [yolov5](https://github.com/ultralytics/yolov5) | [](https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml) | [](https://github.com/ultralytics/yolov5/actions/workflows/docker.yml) | [](https://github.com/ultralytics/yolov5/actions/workflows/links.yml) | [](https://github.com/ultralytics/yolov5/actions/workflows/codeql-analysis.yml) | |
+| [ultralytics](https://github.com/ultralytics/ultralytics) | [](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml) | [](https://github.com/ultralytics/ultralytics/actions/workflows/docker.yaml) | [](https://github.com/ultralytics/ultralytics/actions/workflows/links.yml) | [](https://github.com/ultralytics/ultralytics/actions/workflows/codeql.yaml) | [](https://github.com/ultralytics/ultralytics/actions/workflows/publish.yml) |
+| [hub](https://github.com/ultralytics/hub) | [](https://github.com/ultralytics/hub/actions/workflows/ci.yaml) | | [](https://github.com/ultralytics/hub/actions/workflows/links.yml) | | |
+| [docs](https://github.com/ultralytics/docs) | | | [](https://github.com/ultralytics/docs/actions/workflows/links.yml) | | [](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment) |
+
+Each badge shows the status of the last run of the corresponding CI test on the `main` branch of the respective repository. If a test fails, the badge will display a "failing" status, and if it passes, it will display a "passing" status.
+
+If you notice a test failing, it would be a great help if you could report it through a GitHub issue in the respective repository.
+
+Remember, a successful CI test does not mean that everything is perfect. It is always recommended to manually review the code before deployment or merging changes.
+
+## Code Coverage
+
+Code coverage is a metric that represents the percentage of your codebase that is executed when your tests run. It provides insight into how well your tests exercise your code and can be crucial in identifying untested parts of your application. A high code coverage percentage is often associated with a lower likelihood of bugs. However, it's essential to understand that code coverage does not guarantee the absence of defects. It merely indicates which parts of the code have been executed by the tests.
+
+### Integration with [codecov.io](https://codecov.io/)
+
+At Ultralytics, we have integrated our repositories with [codecov.io](https://codecov.io/), a popular online platform for measuring and visualizing code coverage. Codecov provides detailed insights, coverage comparisons between commits, and visual overlays directly on your code, indicating which lines were covered.
+
+By integrating with Codecov, we aim to maintain and improve the quality of our code by focusing on areas that might be prone to errors or need further testing.
+
+### Coverage Results
+
+To quickly get a glimpse of the code coverage status of the `ultralytics` python package, we have included a badge and sunburst visual of the `ultralytics` coverage results. These images show the percentage of code covered by our tests, offering an at-a-glance metric of our testing efforts. For full details please see https://codecov.io/github/ultralytics/ultralytics.
+
+| Repository | Code Coverage |
+|-----------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [ultralytics](https://github.com/ultralytics/ultralytics) | [](https://codecov.io/gh/ultralytics/ultralytics) |
+
+In the sunburst graphic below, the innermost circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.
+
+
+
+
diff --git a/ultralytics/docs/en/help/CI.md:Zone.Identifier b/ultralytics/docs/en/help/CI.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/CI.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/CLA.md b/ultralytics/docs/en/help/CLA.md
new file mode 100755
index 0000000..374914a
--- /dev/null
+++ b/ultralytics/docs/en/help/CLA.md
@@ -0,0 +1,30 @@
+---
+description: Understand terms governing contributions to Ultralytics projects including source code, bug fixes, documentation and more. Read our Contributor License Agreement.
+keywords: Ultralytics, Contributor License Agreement, Open Source Software, Contributions, Copyright License, Patent License, Moral Rights
+---
+
+# Ultralytics Individual Contributor License Agreement
+
+Thank you for your interest in contributing to open source software projects (โProjectsโ) made available by Ultralytics Inc. (โUltralyticsโ). This Individual Contributor License Agreement (โAgreementโ) sets out the terms governing any source code, object code, bug fixes, configuration changes, tools, specifications, documentation, data, materials, feedback, information or other works of authorship that you submit or have submitted, in any form and in any manner, to Ultralytics in respect of any Projects (collectively โContributionsโ). If you have any questions respecting this Agreement, please contact hello@ultralytics.com.
+
+You agree that the following terms apply to all of your past, present and future Contributions. Except for the licenses granted in this Agreement, you retain all of your right, title and interest in and to your Contributions.
+
+**Copyright License.** You hereby grant, and agree to grant, to Ultralytics a non-exclusive, perpetual, irrevocable, worldwide, fully-paid, royalty-free, transferable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, and distribute your Contributions and such derivative works, with the right to sublicense the foregoing rights through multiple tiers of sublicensees.
+
+**Patent License.** You hereby grant, and agree to grant, to Ultralytics a non-exclusive, perpetual, irrevocable, worldwide, fully-paid, royalty-free, transferable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer your Contributions, where such license applies only to those patent claims licensable by you that are necessarily infringed by your Contributions alone or by combination of your Contributions with the Project to which such Contributions were submitted, with the right to sublicense the foregoing rights through multiple tiers of sublicensees.
+
+**Moral Rights.** To the fullest extent permitted under applicable law, you hereby waive, and agree not to assert, all of your โmoral rightsโ in or relating to your Contributions for the benefit of Ultralytics, its assigns, and their respective direct and indirect sublicensees.
+
+**Third Party Content/Rights.** If your Contribution includes or is based on any source code, object code, bug fixes, configuration changes, tools, specifications, documentation, data, materials, feedback, information or other works of authorship that were not authored by you (โThird Party Contentโ) or if you are aware of any third party intellectual property or proprietary rights associated with your Contribution (โThird Party Rightsโ), then you agree to include with the submission of your Contribution full details respecting such Third Party Content and Third Party Rights, including, without limitation, identification of which aspects of your Contribution contain Third Party Content or are associated with Third Party Rights, the owner/author of the Third Party Content and Third Party Rights, where you obtained the Third Party Content, and any applicable third party license terms or restrictions respecting the Third Party Content and Third Party Rights. For greater certainty, the foregoing obligations respecting the identification of Third Party Content and Third Party Rights do not apply to any portion of a Project that is incorporated into your Contribution to that same Project.
+
+**Representations.** You represent that, other than the Third Party Content and Third Party Rights identified by you in accordance with this Agreement, you are the sole author of your Contributions and are legally entitled to grant the foregoing licenses and waivers in respect of your Contributions. If your Contributions were created in the course of your employment with your past or present employer(s), you represent that such employer(s) has authorized you to make your Contributions on behalf of such employer(s) or such employer
+(s) has waived all of their right, title or interest in or to your Contributions.
+
+**Disclaimer.** To the fullest extent permitted under applicable law, your Contributions are provided on an "asis"
+basis, without any warranties or conditions, express or implied, including, without limitation, any implied warranties or conditions of non-infringement, merchantability or fitness for a particular purpose. You are not required to provide support for your Contributions, except to the extent you desire to provide support.
+
+**No Obligation.** You acknowledge that Ultralytics is under no obligation to use or incorporate your Contributions into any of the Projects. The decision to use or incorporate your Contributions into any of the Projects will be made at the sole discretion of Ultralytics or its authorized delegates.
+
+**Disputes.** This Agreement shall be governed by and construed in accordance with the laws of the State of New York, United States of America, without giving effect to its principles or rules regarding conflicts of laws, other than such principles directing application of New York law. The parties hereby submit to venue in, and jurisdiction of the courts located in New York, New York for purposes relating to this Agreement. In the event that any of the provisions of this Agreement shall be held by a court or other tribunal of competent jurisdiction to be unenforceable, the remaining portions hereof shall remain in full force and effect.
+
+**Assignment.** You agree that Ultralytics may assign this Agreement, and all of its rights, obligations and licenses hereunder.
diff --git a/ultralytics/docs/en/help/CLA.md:Zone.Identifier b/ultralytics/docs/en/help/CLA.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/CLA.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/FAQ.md b/ultralytics/docs/en/help/FAQ.md
new file mode 100755
index 0000000..8e4430a
--- /dev/null
+++ b/ultralytics/docs/en/help/FAQ.md
@@ -0,0 +1,39 @@
+---
+comments: true
+description: Find solutions to your common Ultralytics YOLO related queries. Learn about hardware requirements, fine-tuning YOLO models, conversion to ONNX/TensorFlow, and more.
+keywords: Ultralytics, YOLO, FAQ, hardware requirements, ONNX, TensorFlow, real-time detection, YOLO accuracy
+---
+
+# Ultralytics YOLO Frequently Asked Questions (FAQ)
+
+This FAQ section addresses some common questions and issues users might encounter while working with Ultralytics YOLO repositories.
+
+## 1. What are the hardware requirements for running Ultralytics YOLO?
+
+Ultralytics YOLO can be run on a variety of hardware configurations, including CPUs, GPUs, and even some edge devices. However, for optimal performance and faster training and inference, we recommend using a GPU with a minimum of 8GB of memory. NVIDIA GPUs with CUDA support are ideal for this purpose.
+
+## 2. How do I fine-tune a pre-trained YOLO model on my custom dataset?
+
+To fine-tune a pre-trained YOLO model on your custom dataset, you'll need to create a dataset configuration file (YAML) that defines the dataset's properties, such as the path to the images, the number of classes, and class names. Next, you'll need to modify the model configuration file to match the number of classes in your dataset. Finally, use the `train.py` script to start the training process with your custom dataset and the pre-trained model. You can find a detailed guide on fine-tuning YOLO in the Ultralytics documentation.
+
+## 3. How do I convert a YOLO model to ONNX or TensorFlow format?
+
+Ultralytics provides built-in support for converting YOLO models to ONNX format. You can use the `export.py` script to convert a saved model to ONNX format. If you need to convert the model to TensorFlow format, you can use the ONNX model as an intermediary and then use the ONNX-TensorFlow converter to convert the ONNX model to TensorFlow format.
+
+## 4. Can I use Ultralytics YOLO for real-time object detection?
+
+Yes, Ultralytics YOLO is designed to be efficient and fast, making it suitable for real-time object detection tasks. The actual performance will depend on your hardware configuration and the complexity of the model. Using a GPU and optimizing the model for your specific use case can help achieve real-time performance.
+
+## 5. How can I improve the accuracy of my YOLO model?
+
+Improving the accuracy of a YOLO model may involve several strategies, such as:
+
+- Fine-tuning the model on more annotated data
+- Data augmentation to increase the variety of training samples
+- Using a larger or more complex model architecture
+- Adjusting the learning rate, batch size, and other hyperparameters
+- Using techniques like transfer learning or knowledge distillation
+
+Remember that there's often a trade-off between accuracy and inference speed, so finding the right balance is crucial for your specific application.
+
+If you have any more questions or need assistance, don't hesitate to consult the Ultralytics documentation or reach out to the community through GitHub Issues or the official discussion forum.
diff --git a/ultralytics/docs/en/help/FAQ.md:Zone.Identifier b/ultralytics/docs/en/help/FAQ.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/FAQ.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/code_of_conduct.md b/ultralytics/docs/en/help/code_of_conduct.md
new file mode 100755
index 0000000..f16bc16
--- /dev/null
+++ b/ultralytics/docs/en/help/code_of_conduct.md
@@ -0,0 +1,88 @@
+---
+comments: true
+description: Explore Ultralytics communityโs Code of Conduct, ensuring a supportive, inclusive environment for contributors & members at all levels. Find our guidelines on acceptable behavior & enforcement.
+keywords: Ultralytics, code of conduct, community, contribution, behavior guidelines, enforcement, open source contributions
+---
+
+# Ultralytics Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at hello@ultralytics.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
+
+[homepage]: https://www.contributor-covenant.org
diff --git a/ultralytics/docs/en/help/code_of_conduct.md:Zone.Identifier b/ultralytics/docs/en/help/code_of_conduct.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/code_of_conduct.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/contributing.md b/ultralytics/docs/en/help/contributing.md
new file mode 100755
index 0000000..18a157a
--- /dev/null
+++ b/ultralytics/docs/en/help/contributing.md
@@ -0,0 +1,96 @@
+---
+comments: true
+description: Learn how to contribute to Ultralytics YOLO projects โ guidelines for pull requests, reporting bugs, code conduct and CLA signing.
+keywords: Ultralytics, YOLO, open-source, contribute, pull request, bug report, coding guidelines, CLA, code of conduct, GitHub
+---
+
+# Contributing to Ultralytics Open-Source YOLO Repositories
+
+First of all, thank you for your interest in contributing to Ultralytics open-source YOLO repositories! Your contributions will help improve the project and benefit the community. This document provides guidelines and best practices to get you started.
+
+## Table of Contents
+
+1. [Code of Conduct](#code-of-conduct)
+2. [Contributing via Pull Requests](#contributing-via-pull-requests)
+ - [CLA Signing](#cla-signing)
+ - [Google-Style Docstrings](#google-style-docstrings)
+ - [GitHub Actions CI Tests](#github-actions-ci-tests)
+3. [Reporting Bugs](#reporting-bugs)
+4. [License](#license)
+5. [Conclusion](#conclusion)
+
+## Code of Conduct
+
+All contributors are expected to adhere to the [Code of Conduct](code_of_conduct.md) to ensure a welcoming and inclusive environment for everyone.
+
+## Contributing via Pull Requests
+
+We welcome contributions in the form of pull requests. To make the review process smoother, please follow these guidelines:
+
+1. **Fork the repository**: Fork the Ultralytics YOLO repository to your own GitHub account.
+
+2. **Create a branch**: Create a new branch in your forked repository with a descriptive name for your changes.
+
+3. **Make your changes**: Make the changes you want to contribute. Ensure that your changes follow the coding style of the project and do not introduce new errors or warnings.
+
+4. **Test your changes**: Test your changes locally to ensure that they work as expected and do not introduce new issues.
+
+5. **Commit your changes**: Commit your changes with a descriptive commit message. Make sure to include any relevant issue numbers in your commit message.
+
+6. **Create a pull request**: Create a pull request from your forked repository to the main Ultralytics YOLO repository. In the pull request description, provide a clear explanation of your changes and how they improve the project.
+
+### CLA Signing
+
+Before we can accept your pull request, you need to sign a [Contributor License Agreement (CLA)](CLA.md). This is a legal document stating that you agree to the terms of contributing to the Ultralytics YOLO repositories. The CLA ensures that your contributions are properly licensed and that the project can continue to be distributed under the AGPL-3.0 license.
+
+To sign the CLA, follow the instructions provided by the CLA bot after you submit your PR and add a comment in your PR saying:
+
+```
+I have read the CLA Document and I sign the CLA
+```
+
+### Google-Style Docstrings
+
+When adding new functions or classes, please include a [Google-style docstring](https://google.github.io/styleguide/pyguide.html) to provide clear and concise documentation for other developers. This will help ensure that your contributions are easy to understand and maintain.
+
+Example Google-style docstring:
+
+```python
+def example_function(arg1: int, arg2: int) -> bool:
+ """
+ Example function that demonstrates Google-style docstrings.
+
+ Args:
+ arg1 (int): The first argument.
+ arg2 (int): The second argument.
+
+ Returns:
+ (bool): True if successful, False otherwise.
+
+ Examples:
+ >>> result = example_function(1, 2) # returns False
+ """
+ if arg1 == arg2:
+ return True
+ return False
+```
+
+### GitHub Actions CI Tests
+
+Before your pull request can be merged, all GitHub Actions [Continuous Integration](CI.md) (CI) tests must pass. These tests include linting, unit tests, and other checks to ensure that your changes meet the quality standards of the project. Make sure to review the output of the GitHub Actions and fix any issues
+
+## Reporting Bugs
+
+We appreciate bug reports as they play a crucial role in maintaining the project's quality. When reporting bugs it is important to provide a [Minimum Reproducible Example](minimum_reproducible_example.md): a clear, concise code example that replicates the issue. This helps in quick identification and resolution of the bug.
+
+## License
+
+Ultralytics embraces the GNU Affero General Public License v3.0 (AGPL-3.0) for its repositories, promoting openness, transparency, and collaborative enhancement in software development. This strong copyleft license ensures that all users and developers retain the freedom to use, modify, and share the software. It fosters community collaboration, ensuring that any improvements remain accessible to all.
+
+Users and developers are encouraged to familiarize themselves with the terms of AGPL-3.0 to contribute effectively and ethically to the Ultralytics open-source community.
+
+## Conclusion
+
+Thank you for your interest in contributing to Ultralytics' open-source YOLO projects. Your participation is crucial in shaping the future of our software and fostering a community of innovation and collaboration. Whether you're improving code, reporting bugs, or suggesting features, your contributions make a significant impact.
+
+We're eager to see your ideas in action and appreciate your commitment to advancing object detection technology. Let's continue to grow and innovate together in this exciting open-source journey. Happy coding! ๐๐
diff --git a/ultralytics/docs/en/help/contributing.md:Zone.Identifier b/ultralytics/docs/en/help/contributing.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/contributing.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/environmental-health-safety.md b/ultralytics/docs/en/help/environmental-health-safety.md
new file mode 100755
index 0000000..9fee240
--- /dev/null
+++ b/ultralytics/docs/en/help/environmental-health-safety.md
@@ -0,0 +1,37 @@
+---
+comments: false
+description: Discover Ultralyticsโ EHS policy principles and implementation measures. Committed to safety, environment, and continuous improvement for a sustainable future.
+keywords: Ultralytics policy, EHS, environment, health and safety, compliance, prevention, continuous improvement, risk management, emergency preparedness, resource allocation, communication
+---
+
+# Ultralytics Environmental, Health and Safety (EHS) Policy
+
+At Ultralytics, we recognize that the long-term success of our company relies not only on the products and services we offer, but also the manner in which we conduct our business. We are committed to ensuring the safety and well-being of our employees, stakeholders, and the environment, and we will continuously strive to mitigate our impact on the environment while promoting health and safety.
+
+## Policy Principles
+
+1. **Compliance**: We will comply with all applicable laws, regulations, and standards related to EHS, and we will strive to exceed these standards where possible.
+
+2. **Prevention**: We will work to prevent accidents, injuries, and environmental harm by implementing risk management measures and ensuring all our operations and procedures are safe.
+
+3. **Continuous Improvement**: We will continuously improve our EHS performance by setting measurable objectives, monitoring our performance, auditing our operations, and revising our policies and procedures as needed.
+
+4. **Communication**: We will communicate openly about our EHS performance and will engage with stakeholders to understand and address their concerns and expectations.
+
+5. **Education and Training**: We will educate and train our employees and contractors in appropriate EHS procedures and practices.
+
+## Implementation Measures
+
+1. **Responsibility and Accountability**: Every employee and contractor working at or with Ultralytics is responsible for adhering to this policy. Managers and supervisors are accountable for ensuring this policy is implemented within their areas of control.
+
+2. **Risk Management**: We will identify, assess, and manage EHS risks associated with our operations and activities to prevent accidents, injuries, and environmental harm.
+
+3. **Resource Allocation**: We will allocate the necessary resources to ensure the effective implementation of our EHS policy, including the necessary equipment, personnel, and training.
+
+4. **Emergency Preparedness and Response**: We will develop, maintain, and test emergency preparedness and response plans to ensure we can respond effectively to EHS incidents.
+
+5. **Monitoring and Review**: We will monitor and review our EHS performance regularly to identify opportunities for improvement and ensure we are meeting our objectives.
+
+This policy reflects our commitment to minimizing our environmental footprint, ensuring the safety and well-being of our employees, and continuously improving our performance.
+
+Please remember that the implementation of an effective EHS policy requires the involvement and commitment of everyone working at or with Ultralytics. We encourage you to take personal responsibility for your safety and the safety of others, and to take care of the environment in which we live and work.
diff --git a/ultralytics/docs/en/help/environmental-health-safety.md:Zone.Identifier b/ultralytics/docs/en/help/environmental-health-safety.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/environmental-health-safety.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/index.md b/ultralytics/docs/en/help/index.md
new file mode 100755
index 0000000..e8f7376
--- /dev/null
+++ b/ultralytics/docs/en/help/index.md
@@ -0,0 +1,19 @@
+---
+comments: true
+description: Find comprehensive guides and documents on Ultralytics YOLO tasks. Includes FAQs, contributing guides, CI guide, CLA, MRE guide, code of conduct & more.
+keywords: Ultralytics, YOLO, guides, documents, FAQ, contributing, CI guide, CLA, MRE guide, code of conduct, EHS policy, security policy, privacy policy
+---
+
+Welcome to the Ultralytics Help page! We are dedicated to providing you with detailed resources to enhance your experience with the Ultralytics YOLO models and repositories. This page serves as your portal to guides and documentation designed to assist you with various tasks and answer questions you may encounter while engaging with our repositories.
+
+- [Frequently Asked Questions (FAQ)](FAQ.md): Find answers to common questions and issues encountered by the community of Ultralytics YOLO users and contributors.
+- [Contributing Guide](contributing.md): Discover the protocols for making contributions, including how to submit pull requests, report bugs, and more.
+- [Continuous Integration (CI) Guide](CI.md): Gain insights into the CI processes we employ, complete with status reports for each Ultralytics repository.
+- [Contributor License Agreement (CLA)](CLA.md): Review the CLA to understand the rights and responsibilities associated with contributing to Ultralytics projects.
+- [Minimum Reproducible Example (MRE) Guide](minimum_reproducible_example.md): Learn the process for creating an MRE, which is crucial for the timely and effective resolution of bug reports.
+- [Code of Conduct](code_of_conduct.md): Our community guidelines support a respectful and open atmosphere for all collaborators.
+- [Environmental, Health and Safety (EHS) Policy](environmental-health-safety.md): Delve into our commitment to sustainability and the well-being of all our stakeholders.
+- [Security Policy](security.md): Familiarize yourself with our security protocols and the procedure for reporting vulnerabilities.
+- [Privacy Policy](privacy.md): Read our privacy policy to understand how we protect your data and respect your privacy in all our services and operations.
+
+We encourage you to review these resources for a seamless and productive experience. Our aim is to foster a helpful and friendly environment for everyone in the Ultralytics community. Should you require additional support, please feel free to reach out via GitHub Issues or our official discussion forums. Happy coding!
diff --git a/ultralytics/docs/en/help/index.md:Zone.Identifier b/ultralytics/docs/en/help/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/minimum_reproducible_example.md b/ultralytics/docs/en/help/minimum_reproducible_example.md
new file mode 100755
index 0000000..47a0cdf
--- /dev/null
+++ b/ultralytics/docs/en/help/minimum_reproducible_example.md
@@ -0,0 +1,78 @@
+---
+comments: true
+description: Learn how to create minimum reproducible examples (MRE) for efficient bug reporting in Ultralytics YOLO repositories with this step-by-step guide.
+keywords: Ultralytics, YOLO, minimum reproducible example, MRE, bug reports, guide, dependencies, code, troubleshooting
+---
+
+# Creating a Minimum Reproducible Example for Bug Reports in Ultralytics YOLO Repositories
+
+When submitting a bug report for Ultralytics YOLO repositories, it's essential to provide a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/) (MRE). An MRE is a small, self-contained piece of code that demonstrates the problem you're experiencing. Providing an MRE helps maintainers and contributors understand the issue and work on a fix more efficiently. This guide explains how to create an MRE when submitting bug reports to Ultralytics YOLO repositories.
+
+## 1. Isolate the Problem
+
+The first step in creating an MRE is to isolate the problem. This means removing any unnecessary code or dependencies that are not directly related to the issue. Focus on the specific part of the code that is causing the problem and remove any irrelevant code.
+
+## 2. Use Public Models and Datasets
+
+When creating an MRE, use publicly available models and datasets to reproduce the issue. For example, use the 'yolov8n.pt' model and the 'coco8.yaml' dataset. This ensures that the maintainers and contributors can easily run your example and investigate the problem without needing access to proprietary data or custom models.
+
+## 3. Include All Necessary Dependencies
+
+Make sure to include all the necessary dependencies in your MRE. If your code relies on external libraries, specify the required packages and their versions. Ideally, provide a `requirements.txt` file or list the dependencies in your bug report.
+
+## 4. Write a Clear Description of the Issue
+
+Provide a clear and concise description of the issue you're experiencing. Explain the expected behavior and the actual behavior you're encountering. If applicable, include any relevant error messages or logs.
+
+## 5. Format Your Code Properly
+
+When submitting an MRE, format your code properly using code blocks in the issue description. This makes it easier for others to read and understand your code. In GitHub, you can create a code block by wrapping your code with triple backticks (\```) and specifying the language:
+
+
+```python
+# Your Python code goes here
+```
+
+
+## 6. Test Your MRE
+
+Before submitting your MRE, test it to ensure that it accurately reproduces the issue. Make sure that others can run your example without any issues or modifications.
+
+## Example of an MRE
+
+Here's an example of an MRE for a hypothetical bug report:
+
+**Bug description:**
+
+When running the `detect.py` script on the sample image from the 'coco8.yaml' dataset, I get an error related to the dimensions of the input tensor.
+
+**MRE:**
+
+```python
+import torch
+from ultralytics import YOLO
+
+# Load the model
+model = YOLO("yolov8n.pt")
+
+# Load a 0-channel image
+image = torch.rand(1, 0, 640, 640)
+
+# Run the model
+results = model(image)
+```
+
+**Error message:**
+
+```
+RuntimeError: Expected input[1, 0, 640, 640] to have 3 channels, but got 0 channels instead
+```
+
+**Dependencies:**
+
+- torch==2.0.0
+- ultralytics==8.0.90
+
+In this example, the MRE demonstrates the issue with a minimal amount of code, uses a public model ('yolov8n.pt'), includes all necessary dependencies, and provides a clear description of the problem along with the error message.
+
+By following these guidelines, you'll help the maintainers and contributors of Ultralytics YOLO repositories to understand and resolve your issue more efficiently.
diff --git a/ultralytics/docs/en/help/minimum_reproducible_example.md:Zone.Identifier b/ultralytics/docs/en/help/minimum_reproducible_example.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/minimum_reproducible_example.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/privacy.md b/ultralytics/docs/en/help/privacy.md
new file mode 100755
index 0000000..c9bc3a5
--- /dev/null
+++ b/ultralytics/docs/en/help/privacy.md
@@ -0,0 +1,137 @@
+---
+description: Learn about how Ultralytics collects and uses data to improve user experience, ensure software stability, and address privacy concerns, with options to opt-out.
+keywords: Ultralytics, Data Collection, User Privacy, Google Analytics, Sentry, Crash Reporting, Anonymized Data, Privacy Settings, Opt-Out
+---
+
+# Data Collection for Ultralytics Python Package
+
+## Overview
+
+[Ultralytics](https://ultralytics.com) is dedicated to the continuous enhancement of the user experience and the capabilities of our Python package, including the advanced YOLO models we develop. Our approach involves the gathering of anonymized usage statistics and crash reports, helping us identify opportunities for improvement and ensuring the reliability of our software. This transparency document outlines what data we collect, its purpose, and the choice you have regarding this data collection.
+
+## Anonymized Google Analytics
+
+[Google Analytics](https://developers.google.com/analytics) is a web analytics service offered by Google that tracks and reports website traffic. It allows us to collect data about how our Python package is used, which is crucial for making informed decisions about design and functionality.
+
+### What We Collect
+
+- **Usage Metrics**: These metrics help us understand how frequently and in what ways the package is utilized, what features are favored, and the typical command-line arguments that are used.
+- **System Information**: We collect general non-identifiable information about your computing environment to ensure our package performs well across various systems.
+- **Performance Data**: Understanding the performance of our models during training, validation, and inference helps us in identifying optimization opportunities.
+
+For more information about Google Analytics and data privacy, visit [Google Analytics Privacy](https://support.google.com/analytics/answer/6004245).
+
+### How We Use This Data
+
+- **Feature Improvement**: Insights from usage metrics guide us in enhancing user satisfaction and interface design.
+- **Optimization**: Performance data assist us in fine-tuning our models for better efficiency and speed across diverse hardware and software configurations.
+- **Trend Analysis**: By studying usage trends, we can predict and respond to the evolving needs of our community.
+
+### Privacy Considerations
+
+We take several measures to ensure the privacy and security of the data you entrust to us:
+
+- **Anonymization**: We configure Google Analytics to anonymize the data collected, which means no personally identifiable information (PII) is gathered. You can use our services with the assurance that your personal details remain private.
+- **Aggregation**: Data is analyzed only in aggregate form. This practice ensures that patterns can be observed without revealing any individual user's activity.
+- **No Image Data Collection**: Ultralytics does not collect, process, or view any training or inference images.
+
+## Sentry Crash Reporting
+
+[Sentry](https://sentry.io/) is a developer-centric error tracking software that aids in identifying, diagnosing, and resolving issues in real-time, ensuring the robustness and reliability of applications. Within our package, it plays a crucial role by providing insights through crash reporting, significantly contributing to the stability and ongoing refinement of our software.
+
+!!! Note
+
+ Crash reporting via Sentry is activated only if the `sentry-sdk` Python package is pre-installed on your system. This package isn't included in the `ultralytics` prerequisites and won't be installed automatically by Ultralytics.
+
+### What We Collect
+
+If the `sentry-sdk` Python package is pre-installed on your system a crash event may send the following information:
+
+- **Crash Logs**: Detailed reports on the application's condition at the time of a crash, which are vital for our debugging efforts.
+- **Error Messages**: We record error messages generated during the operation of our package to understand and resolve potential issues quickly.
+
+To learn more about how Sentry handles data, please visit [Sentry's Privacy Policy](https://sentry.io/privacy/).
+
+### How We Use This Data
+
+- **Debugging**: Analyzing crash logs and error messages enables us to swiftly identify and correct software bugs.
+- **Stability Metrics**: By constantly monitoring for crashes, we aim to improve the stability and reliability of our package.
+
+### Privacy Considerations
+
+- **Sensitive Information**: We ensure that crash logs are scrubbed of any personally identifiable or sensitive user data, safeguarding the confidentiality of your information.
+- **Controlled Collection**: Our crash reporting mechanism is meticulously calibrated to gather only what is essential for troubleshooting while respecting user privacy.
+
+By detailing the tools used for data collection and offering additional background information with URLs to their respective privacy pages, users are provided with a comprehensive view of our practices, emphasizing transparency and respect for user privacy.
+
+## Disabling Data Collection
+
+We believe in providing our users with full control over their data. By default, our package is configured to collect analytics and crash reports to help improve the experience for all users. However, we respect that some users may prefer to opt out of this data collection.
+
+To opt out of sending analytics and crash reports, you can simply set `sync=False` in your YOLO settings. This ensures that no data is transmitted from your machine to our analytics tools.
+
+### Inspecting Settings
+
+To gain insight into the current configuration of your settings, you can view them directly:
+
+!!! Example "View settings"
+
+ === "Python"
+ You can use Python to view your settings. Start by importing the `settings` object from the `ultralytics` module. Print and return settings using the following commands:
+ ```python
+ from ultralytics import settings
+
+ # View all settings
+ print(settings)
+
+ # Return analytics and crash reporting setting
+ value = settings['sync']
+ ```
+
+ === "CLI"
+ Alternatively, the command-line interface allows you to check your settings with a simple command:
+ ```bash
+ yolo settings
+ ```
+
+### Modifying Settings
+
+Ultralytics allows users to easily modify their settings. Changes can be performed in the following ways:
+
+!!! Example "Update settings"
+
+ === "Python"
+ Within the Python environment, call the `update` method on the `settings` object to change your settings:
+ ```python
+ from ultralytics import settings
+
+ # Disable analytics and crash reporting
+ settings.update({'sync': False})
+
+ # Reset settings to default values
+ settings.reset()
+ ```
+
+ === "CLI"
+ If you prefer using the command-line interface, the following commands will allow you to modify your settings:
+ ```bash
+ # Disable analytics and crash reporting
+ yolo settings sync=False
+
+ # Reset settings to default values
+ yolo settings reset
+ ```
+
+The `sync=False` setting will prevent any data from being sent to Google Analytics or Sentry. Your settings will be respected across all sessions using the Ultralytics package and saved to disk for future sessions.
+
+## Commitment to Privacy
+
+Ultralytics takes user privacy seriously. We design our data collection practices with the following principles:
+
+- **Transparency**: We are open about the data we collect and how it is used.
+- **Control**: We give users full control over their data.
+- **Security**: We employ industry-standard security measures to protect the data we collect.
+
+## Questions or Concerns
+
+If you have any questions or concerns about our data collection practices, please reach out to us via our [contact form](https://ultralytics.com/contact) or via [support@ultralytics.com](mailto:support@ultralytics.com). We are dedicated to ensuring our users feel informed and confident in their privacy when using our package.
diff --git a/ultralytics/docs/en/help/privacy.md:Zone.Identifier b/ultralytics/docs/en/help/privacy.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/privacy.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/help/security.md b/ultralytics/docs/en/help/security.md
new file mode 100755
index 0000000..01ea1f8
--- /dev/null
+++ b/ultralytics/docs/en/help/security.md
@@ -0,0 +1,36 @@
+---
+description: Explore Ultralytics' comprehensive security strategies safeguarding user data and systems. Learn about our diverse security tools, including Snyk, GitHub CodeQL, and Dependabot Alerts.
+keywords: Ultralytics, Comprehensive Security, user data protection, Snyk, GitHub CodeQL, Dependabot, vulnerability management, coding security practices
+---
+
+# Ultralytics Security Policy
+
+At [Ultralytics](https://ultralytics.com), the security of our users' data and systems is of utmost importance. To ensure the safety and security of our [open-source projects](https://github.com/ultralytics), we have implemented several measures to detect and prevent security vulnerabilities.
+
+## Snyk Scanning
+
+We utilize [Snyk](https://snyk.io/advisor/python/ultralytics) to conduct comprehensive security scans on Ultralytics repositories. Snyk's robust scanning capabilities extend beyond dependency checks; it also examines our code and Dockerfiles for various vulnerabilities. By identifying and addressing these issues proactively, we ensure a higher level of security and reliability for our users.
+
+[](https://snyk.io/advisor/python/ultralytics)
+
+## GitHub CodeQL Scanning
+
+Our security strategy includes GitHub's [CodeQL](https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/about-code-scanning-with-codeql) scanning. CodeQL delves deep into our codebase, identifying complex vulnerabilities like SQL injection and XSS by analyzing the code's semantic structure. This advanced level of analysis ensures early detection and resolution of potential security risks.
+
+[](https://github.com/ultralytics/ultralytics/actions/workflows/codeql.yaml)
+
+## GitHub Dependabot Alerts
+
+[Dependabot](https://docs.github.com/en/code-security/dependabot) is integrated into our workflow to monitor dependencies for known vulnerabilities. When a vulnerability is identified in one of our dependencies, Dependabot alerts us, allowing for swift and informed remediation actions.
+
+## GitHub Secret Scanning Alerts
+
+We employ GitHub [secret scanning](https://docs.github.com/en/code-security/secret-scanning/managing-alerts-from-secret-scanning) alerts to detect sensitive data, such as credentials and private keys, accidentally pushed to our repositories. This early detection mechanism helps prevent potential security breaches and data exposures.
+
+## Private Vulnerability Reporting
+
+We enable private vulnerability reporting, allowing users to discreetly report potential security issues. This approach facilitates responsible disclosure, ensuring vulnerabilities are handled securely and efficiently.
+
+If you suspect or discover a security vulnerability in any of our repositories, please let us know immediately. You can reach out to us directly via our [contact form](https://ultralytics.com/contact) or via [security@ultralytics.com](mailto:security@ultralytics.com). Our security team will investigate and respond as soon as possible.
+
+We appreciate your help in keeping all Ultralytics open-source projects secure and safe for everyone ๐.
diff --git a/ultralytics/docs/en/help/security.md:Zone.Identifier b/ultralytics/docs/en/help/security.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/help/security.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/app/android.md b/ultralytics/docs/en/hub/app/android.md
new file mode 100755
index 0000000..0bff31c
--- /dev/null
+++ b/ultralytics/docs/en/hub/app/android.md
@@ -0,0 +1,89 @@
+---
+comments: true
+description: Learn about the Ultralytics Android App, enabling real-time object detection using YOLO models. Discover in-app features, quantization methods, and delegate options for optimal performance.
+keywords: Ultralytics, Android App, real-time object detection, YOLO models, TensorFlow Lite, FP16 quantization, INT8 quantization, CPU, GPU, Hexagon, NNAPI
+---
+
+# Ultralytics Android App: Real-time Object Detection with YOLO Models
+
+
+
+
+
+
+The Ultralytics Android App is a powerful tool that allows you to run YOLO models directly on your Android device for real-time object detection. This app utilizes TensorFlow Lite for model optimization and various hardware delegates for acceleration, enabling fast and efficient object detection.
+
+## Quantization and Acceleration
+
+To achieve real-time performance on your Android device, YOLO models are quantized to either FP16 or INT8 precision. Quantization is a process that reduces the numerical precision of the model's weights and biases, thus reducing the model's size and the amount of computation required. This results in faster inference times without significantly affecting the model's accuracy.
+
+### FP16 Quantization
+
+FP16 (or half-precision) quantization converts the model's 32-bit floating-point numbers to 16-bit floating-point numbers. This reduces the model's size by half and speeds up the inference process, while maintaining a good balance between accuracy and performance.
+
+### INT8 Quantization
+
+INT8 (or 8-bit integer) quantization further reduces the model's size and computation requirements by converting its 32-bit floating-point numbers to 8-bit integers. This quantization method can result in a significant speedup, but it may lead to a slight reduction in mean average precision (mAP) due to the lower numerical precision.
+
+!!! Tip "mAP Reduction in INT8 Models"
+
+ The reduced numerical precision in INT8 models can lead to some loss of information during the quantization process, which may result in a slight decrease in mAP. However, this trade-off is often acceptable considering the substantial performance gains offered by INT8 quantization.
+
+## Delegates and Performance Variability
+
+Different delegates are available on Android devices to accelerate model inference. These delegates include CPU, [GPU](https://www.tensorflow.org/lite/android/delegates/gpu), [Hexagon](https://www.tensorflow.org/lite/android/delegates/hexagon) and [NNAPI](https://www.tensorflow.org/lite/android/delegates/nnapi). The performance of these delegates varies depending on the device's hardware vendor, product line, and specific chipsets used in the device.
+
+1. **CPU**: The default option, with reasonable performance on most devices.
+2. **GPU**: Utilizes the device's GPU for faster inference. It can provide a significant performance boost on devices with powerful GPUs.
+3. **Hexagon**: Leverages Qualcomm's Hexagon DSP for faster and more efficient processing. This option is available on devices with Qualcomm Snapdragon processors.
+4. **NNAPI**: The Android Neural Networks API (NNAPI) serves as an abstraction layer for running ML models on Android devices. NNAPI can utilize various hardware accelerators, such as CPU, GPU, and dedicated AI chips (e.g., Google's Edge TPU, or the Pixel Neural Core).
+
+Here's a table showing the primary vendors, their product lines, popular devices, and supported delegates:
+
+| Vendor | Product Lines | Popular Devices | Delegates Supported |
+|-----------------------------------------|--------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------|
+| [Qualcomm](https://www.qualcomm.com/) | [Snapdragon (e.g., 800 series)](https://www.qualcomm.com/snapdragon) | [Samsung Galaxy S21](https://www.samsung.com/global/galaxy/galaxy-s21-5g/), [OnePlus 9](https://www.oneplus.com/9), [Google Pixel 6](https://store.google.com/product/pixel_6) | CPU, GPU, Hexagon, NNAPI |
+| [Samsung](https://www.samsung.com/) | [Exynos (e.g., Exynos 2100)](https://www.samsung.com/semiconductor/minisite/exynos/) | [Samsung Galaxy S21 (Global version)](https://www.samsung.com/global/galaxy/galaxy-s21-5g/) | CPU, GPU, NNAPI |
+| [MediaTek](https://i.mediatek.com/) | [Dimensity (e.g., Dimensity 1200)](https://i.mediatek.com/dimensity-1200) | [Realme GT](https://www.realme.com/global/realme-gt), [Xiaomi Redmi Note](https://www.mi.com/en/phone/redmi/note-list) | CPU, GPU, NNAPI |
+| [HiSilicon](https://www.hisilicon.com/) | [Kirin (e.g., Kirin 990)](https://www.hisilicon.com/en/products/Kirin) | [Huawei P40 Pro](https://consumer.huawei.com/en/phones/p40-pro/), [Huawei Mate 30 Pro](https://consumer.huawei.com/en/phones/mate30-pro/) | CPU, GPU, NNAPI |
+| [NVIDIA](https://www.nvidia.com/) | [Tegra (e.g., Tegra X1)](https://developer.nvidia.com/content/tegra-x1) | [NVIDIA Shield TV](https://www.nvidia.com/en-us/shield/shield-tv/), [Nintendo Switch](https://www.nintendo.com/switch/) | CPU, GPU, NNAPI |
+
+Please note that the list of devices mentioned is not exhaustive and may vary depending on the specific chipsets and device models. Always test your models on your target devices to ensure compatibility and optimal performance.
+
+Keep in mind that the choice of delegate can affect performance and model compatibility. For example, some models may not work with certain delegates, or a delegate may not be available on a specific device. As such, it's essential to test your model and the chosen delegate on your target devices for the best results.
+
+## Getting Started with the Ultralytics Android App
+
+To get started with the Ultralytics Android App, follow these steps:
+
+1. Download the Ultralytics App from the [Google Play Store](https://play.google.com/store/apps/details?id=com.ultralytics.ultralytics_app).
+
+2. Launch the app on your Android device and sign in with your Ultralytics account. If you don't have an account yet, create one [here](https://hub.ultralytics.com/).
+
+3. Once signed in, you will see a list of your trained YOLO models. Select a model to use for object detection.
+
+4. Grant the app permission to access your device's camera.
+
+5. Point your device's camera at objects you want to detect. The app will display bounding boxes and class labels in real-time as it detects objects.
+
+6. Explore the app's settings to adjust the detection threshold, enable or disable specific object classes, and more.
+
+With the Ultralytics Android App, you now have the power of real-time object detection using YOLO models right at your fingertips. Enjoy exploring the app's features and optimizing its settings to suit your specific use cases.
diff --git a/ultralytics/docs/en/hub/app/android.md:Zone.Identifier b/ultralytics/docs/en/hub/app/android.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/app/android.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/app/index.md b/ultralytics/docs/en/hub/app/index.md
new file mode 100755
index 0000000..ef962e8
--- /dev/null
+++ b/ultralytics/docs/en/hub/app/index.md
@@ -0,0 +1,48 @@
+---
+comments: true
+description: Explore the Ultralytics HUB App, offering the ability to run YOLOv5 and YOLOv8 models on your iOS and Android devices with optimized performance.
+keywords: Ultralytics, HUB App, YOLOv5, YOLOv8, mobile AI, real-time object detection, image recognition, mobile device, hardware acceleration, Apple Neural Engine, Android GPU, NNAPI, custom model training
+---
+
+# Ultralytics HUB App
+
+
+
+
+
+
+Welcome to the Ultralytics HUB App! We are excited to introduce this powerful mobile app that allows you to run YOLOv5 and YOLOv8 models directly on your [iOS](https://apps.apple.com/xk/app/ultralytics/id1583935240) and [Android](https://play.google.com/store/apps/details?id=com.ultralytics.ultralytics_app) devices. With the HUB App, you can utilize hardware acceleration features like Apple's Neural Engine (ANE) or Android GPU and Neural Network API (NNAPI) delegates to achieve impressive performance on your mobile device.
+
+## Features
+
+- **Run YOLOv5 and YOLOv8 models**: Experience the power of YOLO models on your mobile device for real-time object detection and image recognition tasks.
+- **Hardware Acceleration**: Benefit from Apple ANE on iOS devices or Android GPU and NNAPI delegates for optimized performance.
+- **Custom Model Training**: Train custom models with the Ultralytics HUB platform and preview them live using the HUB App.
+- **Mobile Compatibility**: The HUB App supports both iOS and Android devices, bringing the power of YOLO models to a wide range of users.
+
+## App Documentation
+
+- [**iOS**](ios.md): Learn about YOLO CoreML models accelerated on Apple's Neural Engine for iPhones and iPads.
+- [**Android**](android.md): Explore TFLite acceleration on Android mobile devices.
+
+Get started today by downloading the Ultralytics HUB App on your mobile device and unlock the potential of YOLOv5 and YOLOv8 models on-the-go. Don't forget to check out our comprehensive [HUB Docs](../index.md) for more information on training, deploying, and using your custom models with the Ultralytics HUB platform.
diff --git a/ultralytics/docs/en/hub/app/index.md:Zone.Identifier b/ultralytics/docs/en/hub/app/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/app/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/app/ios.md b/ultralytics/docs/en/hub/app/ios.md
new file mode 100755
index 0000000..ac939c9
--- /dev/null
+++ b/ultralytics/docs/en/hub/app/ios.md
@@ -0,0 +1,79 @@
+---
+comments: true
+description: Execute object detection in real-time on your iOS devices utilizing YOLO models. Leverage the power of the Apple Neural Engine and Core ML for fast and efficient object detection.
+keywords: Ultralytics, iOS app, object detection, YOLO models, real time, Apple Neural Engine, Core ML, FP16, INT8, quantization
+---
+
+# Ultralytics iOS App: Real-time Object Detection with YOLO Models
+
+
+
+
+
+
+The Ultralytics iOS App is a powerful tool that allows you to run YOLO models directly on your iPhone or iPad for real-time object detection. This app utilizes the Apple Neural Engine and Core ML for model optimization and acceleration, enabling fast and efficient object detection.
+
+## Quantization and Acceleration
+
+To achieve real-time performance on your iOS device, YOLO models are quantized to either FP16 or INT8 precision. Quantization is a process that reduces the numerical precision of the model's weights and biases, thus reducing the model's size and the amount of computation required. This results in faster inference times without significantly affecting the model's accuracy.
+
+### FP16 Quantization
+
+FP16 (or half-precision) quantization converts the model's 32-bit floating-point numbers to 16-bit floating-point numbers. This reduces the model's size by half and speeds up the inference process, while maintaining a good balance between accuracy and performance.
+
+### INT8 Quantization
+
+INT8 (or 8-bit integer) quantization further reduces the model's size and computation requirements by converting its 32-bit floating-point numbers to 8-bit integers. This quantization method can result in a significant speedup, but it may lead to a slight reduction in accuracy.
+
+## Apple Neural Engine
+
+The Apple Neural Engine (ANE) is a dedicated hardware component integrated into Apple's A-series and M-series chips. It's designed to accelerate machine learning tasks, particularly for neural networks, allowing for faster and more efficient execution of your YOLO models.
+
+By combining quantized YOLO models with the Apple Neural Engine, the Ultralytics iOS App achieves real-time object detection on your iOS device without compromising on accuracy or performance.
+
+| Release Year | iPhone Name | Chipset Name | Node Size | ANE TOPs |
+|--------------|------------------------------------------------------|-------------------------------------------------------|-----------|----------|
+| 2017 | [iPhone X](https://en.wikipedia.org/wiki/IPhone_X) | [A11 Bionic](https://en.wikipedia.org/wiki/Apple_A11) | 10 nm | 0.6 |
+| 2018 | [iPhone XS](https://en.wikipedia.org/wiki/IPhone_XS) | [A12 Bionic](https://en.wikipedia.org/wiki/Apple_A12) | 7 nm | 5 |
+| 2019 | [iPhone 11](https://en.wikipedia.org/wiki/IPhone_11) | [A13 Bionic](https://en.wikipedia.org/wiki/Apple_A13) | 7 nm | 6 |
+| 2020 | [iPhone 12](https://en.wikipedia.org/wiki/IPhone_12) | [A14 Bionic](https://en.wikipedia.org/wiki/Apple_A14) | 5 nm | 11 |
+| 2021 | [iPhone 13](https://en.wikipedia.org/wiki/IPhone_13) | [A15 Bionic](https://en.wikipedia.org/wiki/Apple_A15) | 5 nm | 15.8 |
+| 2022 | [iPhone 14](https://en.wikipedia.org/wiki/IPhone_14) | [A16 Bionic](https://en.wikipedia.org/wiki/Apple_A16) | 4 nm | 17.0 |
+
+Please note that this list only includes iPhone models from 2017 onwards, and the ANE TOPs values are approximate.
+
+## Getting Started with the Ultralytics iOS App
+
+To get started with the Ultralytics iOS App, follow these steps:
+
+1. Download the Ultralytics App from the [App Store](https://apps.apple.com/xk/app/ultralytics/id1583935240).
+
+2. Launch the app on your iOS device and sign in with your Ultralytics account. If you don't have an account yet, create one [here](https://hub.ultralytics.com/).
+
+3. Once signed in, you will see a list of your trained YOLO models. Select a model to use for object detection.
+
+4. Grant the app permission to access your device's camera.
+
+5. Point your device's camera at objects you want to detect. The app will display bounding boxes and class labels in real-time as it detects objects.
+
+6. Explore the app's settings to adjust the detection threshold, enable or disable specific object classes, and more.
+
+With the Ultralytics iOS App, you can now leverage the power of YOLO models for real-time object detection on your iPhone or iPad, powered by the Apple Neural Engine and optimized with FP16 or INT8 quantization.
diff --git a/ultralytics/docs/en/hub/app/ios.md:Zone.Identifier b/ultralytics/docs/en/hub/app/ios.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/app/ios.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/datasets.md b/ultralytics/docs/en/hub/datasets.md
new file mode 100755
index 0000000..1ab7c45
--- /dev/null
+++ b/ultralytics/docs/en/hub/datasets.md
@@ -0,0 +1,159 @@
+---
+comments: true
+description: Learn how Ultralytics HUB datasets streamline your ML workflow. Upload, format, validate, access, share, edit or delete datasets for Ultralytics YOLO model training.
+keywords: Ultralytics, HUB datasets, YOLO model training, upload datasets, dataset validation, ML workflow, share datasets
+---
+
+# HUB Datasets
+
+[Ultralytics HUB](https://hub.ultralytics.com/) datasets are a practical solution for managing and leveraging your custom datasets.
+
+Once uploaded, datasets can be immediately utilized for model training. This integrated approach facilitates a seamless transition from dataset management to model training, significantly simplifying the entire process.
+
+## Upload Dataset
+
+Ultralytics HUB datasets are just like YOLOv5 and YOLOv8 ๐ datasets. They use the same structure and the same label formats to keep everything simple.
+
+Before you upload a dataset to Ultralytics HUB, make sure to **place your dataset YAML file inside the dataset root directory** and that **your dataset YAML, directory and ZIP have the same name**, as shown in the example below, and then zip the dataset directory.
+
+For example, if your dataset is called "coco8", as our [COCO8](https://docs.ultralytics.com/datasets/detect/coco8) example dataset, then you should have a `coco8.yaml` inside your `coco8/` directory, which will create a `coco8.zip` when zipped:
+
+```bash
+zip -r coco8.zip coco8
+```
+
+You can download our [COCO8](https://github.com/ultralytics/hub/blob/main/example_datasets/coco8.zip) example dataset and unzip it to see exactly how to structure your dataset.
+
+
+
+
+
+The dataset YAML is the same standard YOLOv5 and YOLOv8 YAML format.
+
+!!! Example "coco8.yaml"
+
+ ```yaml
+ --8<-- "ultralytics/cfg/datasets/coco8.yaml"
+ ```
+
+After zipping your dataset, you should validate it before uploading it to Ultralytics HUB. Ultralytics HUB conducts the dataset validation check post-upload, so by ensuring your dataset is correctly formatted and error-free ahead of time, you can forestall any setbacks due to dataset rejection.
+
+```py
+from ultralytics.hub import check_dataset
+
+check_dataset('path/to/coco8.zip')
+```
+
+Once your dataset ZIP is ready, navigate to the [Datasets](https://hub.ultralytics.com/datasets) page by clicking on the **Datasets** button in the sidebar.
+
+
+
+??? tip "Tip"
+
+ You can also upload a dataset directly from the [Home](https://hub.ultralytics.com/home) page.
+
+ 
+
+Click on the **Upload Dataset** button on the top right of the page. This action will trigger the **Upload Dataset** dialog.
+
+
+
+Upload your dataset in the _Dataset .zip file_ field.
+
+You have the additional option to set a custom name and description for your Ultralytics HUB dataset.
+
+When you're happy with your dataset configuration, click **Upload**.
+
+
+
+After your dataset is uploaded and processed, you will be able to access it from the Datasets page.
+
+
+
+You can view the images in your dataset grouped by splits (Train, Validation, Test).
+
+
+
+??? tip "Tip"
+
+ Each image can be enlarged for better visualization.
+
+ 
+
+ 
+
+Also, you can analyze your dataset by click on the **Overview** tab.
+
+
+
+Next, [train a model](https://docs.ultralytics.com/hub/models/#train-model) on your dataset.
+
+
+
+## Share Dataset
+
+!!! Info "Info"
+
+ Ultralytics HUB's sharing functionality provides a convenient way to share datasets with others. This feature is designed to accommodate both existing Ultralytics HUB users and those who have yet to create an account.
+
+??? note "Note"
+
+ You have control over the general access of your datasets.
+
+ You can choose to set the general access to "Private", in which case, only you will have access to it. Alternatively, you can set the general access to "Unlisted" which grants viewing access to anyone who has the direct link to the dataset, regardless of whether they have an Ultralytics HUB account or not.
+
+Navigate to the Dataset page of the dataset you want to share, open the dataset actions dropdown and click on the **Share** option. This action will trigger the **Share Dataset** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also share a dataset directly from the [Datasets](https://hub.ultralytics.com/datasets) page.
+
+ 
+
+Set the general access to "Unlisted" and click **Save**.
+
+
+
+Now, anyone who has the direct link to your dataset can view it.
+
+??? tip "Tip"
+
+ You can easily click on the dataset's link shown in the **Share Dataset** dialog to copy it.
+
+ 
+
+## Edit Dataset
+
+Navigate to the Dataset page of the dataset you want to edit, open the dataset actions dropdown and click on the **Edit** option. This action will trigger the **Update Dataset** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also edit a dataset directly from the [Datasets](https://hub.ultralytics.com/datasets) page.
+
+ 
+
+Apply the desired modifications to your dataset and then confirm the changes by clicking **Save**.
+
+
+
+## Delete Dataset
+
+Navigate to the Dataset page of the dataset you want to delete, open the dataset actions dropdown and click on the **Delete** option. This action will delete the dataset.
+
+
+
+??? tip "Tip"
+
+ You can also delete a dataset directly from the [Datasets](https://hub.ultralytics.com/datasets) page.
+
+ 
+
+??? note "Note"
+
+ If you change your mind, you can restore the dataset from the [Trash](https://hub.ultralytics.com/trash) page.
+
+ 
diff --git a/ultralytics/docs/en/hub/datasets.md:Zone.Identifier b/ultralytics/docs/en/hub/datasets.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/datasets.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/index.md b/ultralytics/docs/en/hub/index.md
new file mode 100755
index 0000000..6920953
--- /dev/null
+++ b/ultralytics/docs/en/hub/index.md
@@ -0,0 +1,61 @@
+---
+comments: true
+description: Gain insights into training and deploying your YOLOv5 and YOLOv8 models with Ultralytics HUB. Explore pre-trained models, templates and various integrations.
+keywords: Ultralytics HUB, YOLOv5, YOLOv8, model training, model deployment, pretrained models, model integrations
+---
+
+# Ultralytics HUB
+
+
+
+
+
+
+๐ Hello from the [Ultralytics](https://ultralytics.com/) Team! We've been working hard these last few months to launch [Ultralytics HUB](https://bit.ly/ultralytics_hub), a new web tool for training and deploying all your YOLOv5 and YOLOv8 ๐ models from one spot!
+
+## Introduction
+
+HUB is designed to be user-friendly and intuitive, with a drag-and-drop interface that allows users to easily upload their data and train new models quickly. It offers a range of pre-trained models and templates to choose from, making it easy for users to get started with training their own models. Once a model is trained, it can be easily deployed and used for real-time object detection, instance segmentation and classification tasks.
+
+
+
+
+
+ Watch: Train Your Custom YOLO Models In A Few Clicks with Ultralytics HUB.
+
+
+We hope that the resources here will help you get the most out of HUB. Please browse the HUB Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!
+
+- [**Quickstart**](quickstart.md). Start training and deploying YOLO models with HUB in seconds.
+- [**Datasets: Preparing and Uploading**](datasets.md). Learn how to prepare and upload your datasets to HUB in YOLO format.
+- [**Projects: Creating and Managing**](projects.md). Group your models into projects for improved organization.
+- [**Models: Training and Exporting**](models.md). Train YOLOv5 and YOLOv8 models on your custom datasets and export them to various formats for deployment.
+- [**Integrations: Options**](integrations.md). Explore different integration options for your trained models, such as TensorFlow, ONNX, OpenVINO, CoreML, and PaddlePaddle.
+- [**Ultralytics HUB App**](app/index.md). Learn about the Ultralytics App for iOS and Android, which allows you to run models directly on your mobile device.
+ * [**iOS**](app/ios.md). Learn about YOLO CoreML models accelerated on Apple's Neural Engine on iPhones and iPads.
+ * [**Android**](app/android.md). Explore TFLite acceleration on mobile devices.
+- [**Inference API**](inference_api.md). Understand how to use the Inference API for running your trained models in the cloud to generate predictions.
diff --git a/ultralytics/docs/en/hub/index.md:Zone.Identifier b/ultralytics/docs/en/hub/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/inference_api.md b/ultralytics/docs/en/hub/inference_api.md
new file mode 100755
index 0000000..7ca6822
--- /dev/null
+++ b/ultralytics/docs/en/hub/inference_api.md
@@ -0,0 +1,458 @@
+---
+comments: true
+description: Access object detection capabilities of YOLOv8 via our RESTful API. Learn how to use the YOLO Inference API with Python or CLI for swift object detection.
+keywords: Ultralytics, YOLOv8, Inference API, object detection, RESTful API, Python, CLI, Quickstart
+---
+
+# YOLO Inference API
+
+The YOLO Inference API allows you to access the YOLOv8 object detection capabilities via a RESTful API. This enables you to run object detection on images without the need to install and set up the YOLOv8 environment locally.
+
+
+Screenshot of the Inference API section in the trained model Preview tab.
+
+## API URL
+
+The API URL is the address used to access the YOLO Inference API. In this case, the base URL is:
+
+```
+https://api.ultralytics.com/v1/predict
+```
+
+## Example Usage in Python
+
+To access the YOLO Inference API with the specified model and API key using Python, you can use the following code:
+
+```python
+import requests
+
+# API URL, use actual MODEL_ID
+url = f"https://api.ultralytics.com/v1/predict/MODEL_ID"
+
+# Headers, use actual API_KEY
+headers = {"x-api-key": "API_KEY"}
+
+# Inference arguments (optional)
+data = {"size": 640, "confidence": 0.25, "iou": 0.45}
+
+# Load image and send request
+with open("path/to/image.jpg", "rb") as image_file:
+ files = {"image": image_file}
+ response = requests.post(url, headers=headers, files=files, data=data)
+
+print(response.json())
+```
+
+In this example, replace `API_KEY` with your actual API key, `MODEL_ID` with the desired model ID, and `path/to/image.jpg` with the path to the image you want to analyze.
+
+## Example Usage with CLI
+
+You can use the YOLO Inference API with the command-line interface (CLI) by utilizing the `curl` command. Replace `API_KEY` with your actual API key, `MODEL_ID` with the desired model ID, and `image.jpg` with the path to the image you want to analyze:
+
+```bash
+curl -X POST "https://api.ultralytics.com/v1/predict/MODEL_ID" \
+ -H "x-api-key: API_KEY" \
+ -F "image=@/path/to/image.jpg" \
+ -F "size=640" \
+ -F "confidence=0.25" \
+ -F "iou=0.45"
+```
+
+## Passing Arguments
+
+This command sends a POST request to the YOLO Inference API with the specified `MODEL_ID` in the URL and the `API_KEY` in the request `headers`, along with the image file specified by `@path/to/image.jpg`.
+
+Here's an example of passing the `size`, `confidence`, and `iou` arguments via the API URL using the `requests` library in Python:
+
+```python
+import requests
+
+# API URL, use actual MODEL_ID
+url = f"https://api.ultralytics.com/v1/predict/MODEL_ID"
+
+# Headers, use actual API_KEY
+headers = {"x-api-key": "API_KEY"}
+
+# Inference arguments (optional)
+data = {"size": 640, "confidence": 0.25, "iou": 0.45}
+
+# Load image and send request
+with open("path/to/image.jpg", "rb") as image_file:
+ files = {"image": image_file}
+ response = requests.post(url, headers=headers, files=files, data=data)
+
+print(response.json())
+```
+
+In this example, the `data` dictionary contains the query arguments `size`, `confidence`, and `iou`, which tells the API to run inference at image size 640 with confidence and IoU thresholds of 0.25 and 0.45.
+
+This will send the query parameters along with the file in the POST request. See the table below for a full list of available inference arguments.
+
+| Inference Argument | Default | Type | Notes |
+|--------------------|---------|---------|------------------------------------------------|
+| `size` | `640` | `int` | valid range is `32` - `1280` pixels |
+| `confidence` | `0.25` | `float` | valid range is `0.01` - `1.0` |
+| `iou` | `0.45` | `float` | valid range is `0.0` - `0.95` |
+| `url` | `''` | `str` | optional image URL if not image file is passed |
+| `normalize` | `False` | `bool` | |
+
+## Return JSON format
+
+The YOLO Inference API returns a JSON list with the detection results. The format of the JSON list will be the same as the one produced locally by the `results[0].tojson()` command.
+
+The JSON list contains information about the detected objects, their coordinates, classes, and confidence scores.
+
+### Detect Model Format
+
+YOLO detection models, such as `yolov8n.pt`, can return JSON responses from local inference, CLI API inference, and Python API inference. All of these methods produce the same JSON response format.
+
+!!! Example "Detect Model JSON Response"
+
+ === "Local"
+ ```python
+ from ultralytics import YOLO
+
+ # Load model
+ model = YOLO('yolov8n.pt')
+
+ # Run inference
+ results = model('image.jpg')
+
+ # Print image.jpg results in JSON format
+ print(results[0].tojson())
+ ```
+
+ === "CLI API"
+ ```bash
+ curl -X POST "https://api.ultralytics.com/v1/predict/MODEL_ID" \
+ -H "x-api-key: API_KEY" \
+ -F "image=@/path/to/image.jpg" \
+ -F "size=640" \
+ -F "confidence=0.25" \
+ -F "iou=0.45"
+ ```
+
+ === "Python API"
+ ```python
+ import requests
+
+ # API URL, use actual MODEL_ID
+ url = f"https://api.ultralytics.com/v1/predict/MODEL_ID"
+
+ # Headers, use actual API_KEY
+ headers = {"x-api-key": "API_KEY"}
+
+ # Inference arguments (optional)
+ data = {"size": 640, "confidence": 0.25, "iou": 0.45}
+
+ # Load image and send request
+ with open("path/to/image.jpg", "rb") as image_file:
+ files = {"image": image_file}
+ response = requests.post(url, headers=headers, files=files, data=data)
+
+ print(response.json())
+ ```
+
+ === "JSON Response"
+ ```json
+ {
+ "success": True,
+ "message": "Inference complete.",
+ "data": [
+ {
+ "name": "person",
+ "class": 0,
+ "confidence": 0.8359682559967041,
+ "box": {
+ "x1": 0.08974208831787109,
+ "y1": 0.27418340047200523,
+ "x2": 0.8706787109375,
+ "y2": 0.9887352837456598
+ }
+ },
+ {
+ "name": "person",
+ "class": 0,
+ "confidence": 0.8189555406570435,
+ "box": {
+ "x1": 0.5847355842590332,
+ "y1": 0.05813225640190972,
+ "x2": 0.8930277824401855,
+ "y2": 0.9903111775716146
+ }
+ },
+ {
+ "name": "tie",
+ "class": 27,
+ "confidence": 0.2909725308418274,
+ "box": {
+ "x1": 0.3433395862579346,
+ "y1": 0.6070465511745877,
+ "x2": 0.40964522361755373,
+ "y2": 0.9849439832899306
+ }
+ }
+ ]
+ }
+ ```
+
+### Segment Model Format
+
+YOLO segmentation models, such as `yolov8n-seg.pt`, can return JSON responses from local inference, CLI API inference, and Python API inference. All of these methods produce the same JSON response format.
+
+!!! Example "Segment Model JSON Response"
+
+ === "Local"
+ ```python
+ from ultralytics import YOLO
+
+ # Load model
+ model = YOLO('yolov8n-seg.pt')
+
+ # Run inference
+ results = model('image.jpg')
+
+ # Print image.jpg results in JSON format
+ print(results[0].tojson())
+ ```
+
+ === "CLI API"
+ ```bash
+ curl -X POST "https://api.ultralytics.com/v1/predict/MODEL_ID" \
+ -H "x-api-key: API_KEY" \
+ -F "image=@/path/to/image.jpg" \
+ -F "size=640" \
+ -F "confidence=0.25" \
+ -F "iou=0.45"
+ ```
+
+ === "Python API"
+ ```python
+ import requests
+
+ # API URL, use actual MODEL_ID
+ url = f"https://api.ultralytics.com/v1/predict/MODEL_ID"
+
+ # Headers, use actual API_KEY
+ headers = {"x-api-key": "API_KEY"}
+
+ # Inference arguments (optional)
+ data = {"size": 640, "confidence": 0.25, "iou": 0.45}
+
+ # Load image and send request
+ with open("path/to/image.jpg", "rb") as image_file:
+ files = {"image": image_file}
+ response = requests.post(url, headers=headers, files=files, data=data)
+
+ print(response.json())
+ ```
+
+ === "JSON Response"
+ Note `segments` `x` and `y` lengths may vary from one object to another. Larger or more complex objects may have more segment points.
+ ```json
+ {
+ "success": True,
+ "message": "Inference complete.",
+ "data": [
+ {
+ "name": "person",
+ "class": 0,
+ "confidence": 0.856913149356842,
+ "box": {
+ "x1": 0.1064866065979004,
+ "y1": 0.2798851860894097,
+ "x2": 0.8738358497619629,
+ "y2": 0.9894873725043403
+ },
+ "segments": {
+ "x": [
+ 0.421875,
+ 0.4203124940395355,
+ 0.41718751192092896
+ ...
+ ],
+ "y": [
+ 0.2888889014720917,
+ 0.2916666567325592,
+ 0.2916666567325592
+ ...
+ ]
+ }
+ },
+ {
+ "name": "person",
+ "class": 0,
+ "confidence": 0.8512625694274902,
+ "box": {
+ "x1": 0.5757311820983887,
+ "y1": 0.053943040635850696,
+ "x2": 0.8960096359252929,
+ "y2": 0.985154045952691
+ },
+ "segments": {
+ "x": [
+ 0.7515624761581421,
+ 0.75,
+ 0.7437499761581421
+ ...
+ ],
+ "y": [
+ 0.0555555559694767,
+ 0.05833333358168602,
+ 0.05833333358168602
+ ...
+ ]
+ }
+ },
+ {
+ "name": "tie",
+ "class": 27,
+ "confidence": 0.6485961675643921,
+ "box": {
+ "x1": 0.33911995887756347,
+ "y1": 0.6057066175672743,
+ "x2": 0.4081430912017822,
+ "y2": 0.9916408962673611
+ },
+ "segments": {
+ "x": [
+ 0.37187498807907104,
+ 0.37031251192092896,
+ 0.3687500059604645
+ ...
+ ],
+ "y": [
+ 0.6111111044883728,
+ 0.6138888597488403,
+ 0.6138888597488403
+ ...
+ ]
+ }
+ }
+ ]
+ }
+ ```
+
+### Pose Model Format
+
+YOLO pose models, such as `yolov8n-pose.pt`, can return JSON responses from local inference, CLI API inference, and Python API inference. All of these methods produce the same JSON response format.
+
+!!! Example "Pose Model JSON Response"
+
+ === "Local"
+ ```python
+ from ultralytics import YOLO
+
+ # Load model
+ model = YOLO('yolov8n-seg.pt')
+
+ # Run inference
+ results = model('image.jpg')
+
+ # Print image.jpg results in JSON format
+ print(results[0].tojson())
+ ```
+
+ === "CLI API"
+ ```bash
+ curl -X POST "https://api.ultralytics.com/v1/predict/MODEL_ID" \
+ -H "x-api-key: API_KEY" \
+ -F "image=@/path/to/image.jpg" \
+ -F "size=640" \
+ -F "confidence=0.25" \
+ -F "iou=0.45"
+ ```
+
+ === "Python API"
+ ```python
+ import requests
+
+ # API URL, use actual MODEL_ID
+ url = f"https://api.ultralytics.com/v1/predict/MODEL_ID"
+
+ # Headers, use actual API_KEY
+ headers = {"x-api-key": "API_KEY"}
+
+ # Inference arguments (optional)
+ data = {"size": 640, "confidence": 0.25, "iou": 0.45}
+
+ # Load image and send request
+ with open("path/to/image.jpg", "rb") as image_file:
+ files = {"image": image_file}
+ response = requests.post(url, headers=headers, files=files, data=data)
+
+ print(response.json())
+ ```
+
+ === "JSON Response"
+ Note COCO-keypoints pretrained models will have 17 human keypoints. The `visible` part of the keypoints indicates whether a keypoint is visible or obscured. Obscured keypoints may be outside the image or may not be visible, i.e. a person's eyes facing away from the camera.
+ ```json
+ {
+ "success": True,
+ "message": "Inference complete.",
+ "data": [
+ {
+ "name": "person",
+ "class": 0,
+ "confidence": 0.8439509868621826,
+ "box": {
+ "x1": 0.1125,
+ "y1": 0.28194444444444444,
+ "x2": 0.7953125,
+ "y2": 0.9902777777777778
+ },
+ "keypoints": {
+ "x": [
+ 0.5058594942092896,
+ 0.5103894472122192,
+ 0.4920862317085266
+ ...
+ ],
+ "y": [
+ 0.48964157700538635,
+ 0.4643048942089081,
+ 0.4465252459049225
+ ...
+ ],
+ "visible": [
+ 0.8726999163627625,
+ 0.653947651386261,
+ 0.9130823612213135
+ ...
+ ]
+ }
+ },
+ {
+ "name": "person",
+ "class": 0,
+ "confidence": 0.7474289536476135,
+ "box": {
+ "x1": 0.58125,
+ "y1": 0.0625,
+ "x2": 0.8859375,
+ "y2": 0.9888888888888889
+ },
+ "keypoints": {
+ "x": [
+ 0.778544008731842,
+ 0.7976160049438477,
+ 0.7530890107154846
+ ...
+ ],
+ "y": [
+ 0.27595141530036926,
+ 0.2378823608160019,
+ 0.23644638061523438
+ ...
+ ],
+ "visible": [
+ 0.8900790810585022,
+ 0.789978563785553,
+ 0.8974530100822449
+ ...
+ ]
+ }
+ }
+ ]
+ }
+ ```
diff --git a/ultralytics/docs/en/hub/inference_api.md:Zone.Identifier b/ultralytics/docs/en/hub/inference_api.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/inference_api.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/integrations.md b/ultralytics/docs/en/hub/integrations.md
new file mode 100755
index 0000000..d8470cf
--- /dev/null
+++ b/ultralytics/docs/en/hub/integrations.md
@@ -0,0 +1,62 @@
+---
+comments: true
+description: Explore integration options for Ultralytics HUB. Currently featuring Roboflow for dataset integration and multiple export formats for your trained models.
+keywords: Ultralytics HUB, Integrations, Roboflow, Dataset, Export, YOLOv5, YOLOv8, ONNX, CoreML, TensorRT, TensorFlow
+---
+
+# HUB Integrations
+
+๐ง **Under Construction** ๐ง
+
+Welcome to the Integrations guide for [Ultralytics HUB](https://hub.ultralytics.com/)! We are in the process of expanding this section to provide you with comprehensive guidance on integrating your YOLOv5 and YOLOv8 models with various platforms and formats. Currently, Roboflow is our available dataset integration, with a wide range of export integrations for your trained models.
+
+
+
+
+
+ Watch: Train Your Custom YOLO Models In A Few Clicks with Ultralytics HUB.
+
+
+## Available Integrations
+
+### Dataset Integrations
+
+- **Roboflow**: Seamlessly import your datasets for training.
+
+### Export Integrations
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](../integrations/openvino.md) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half`, `int8` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras`, `int8` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [NCNN](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
+
+## Coming Soon
+
+- Additional Dataset Integrations
+- Detailed Export Integration Guides
+- Step-by-Step Tutorials for Each Integration
+
+## Need Immediate Assistance?
+
+While we're in the process of creating detailed guides:
+
+- Browse through other [HUB Docs](https://docs.ultralytics.com/hub/) for detailed guides and tutorials.
+- Raise an issue on our [GitHub](https://github.com/ultralytics/hub/) for technical support.
+- Join our [Discord Community](https://ultralytics.com/discord/) for live discussions and community support.
+
+We appreciate your patience as we work to make this section comprehensive and user-friendly. Stay tuned for updates!
diff --git a/ultralytics/docs/en/hub/integrations.md:Zone.Identifier b/ultralytics/docs/en/hub/integrations.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/integrations.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/models.md b/ultralytics/docs/en/hub/models.md
new file mode 100755
index 0000000..41091ad
--- /dev/null
+++ b/ultralytics/docs/en/hub/models.md
@@ -0,0 +1,213 @@
+---
+comments: true
+description: Learn how to use Ultralytics HUB models for efficient and user-friendly AI model training. For easy model creation, training, evaluation and deployment, follow our detailed guide.
+keywords: Ultralytics, HUB Models, AI model training, model creation, model training, model evaluation, model deployment
+---
+
+# Ultralytics HUB Models
+
+[Ultralytics HUB](https://hub.ultralytics.com/) models provide a streamlined solution for training vision AI models on your custom datasets.
+
+The process is user-friendly and efficient, involving a simple three-step creation and accelerated training powered by Ultralytics YOLOv8. During training, real-time updates on model metrics are available so that you can monitor each step of the progress. Once training is completed, you can preview your model and easily deploy it to real-world applications. Therefore, Ultralytics HUB offers a comprehensive yet straightforward system for model creation, training, evaluation, and deployment.
+
+## Train Model
+
+Navigate to the [Models](https://hub.ultralytics.com/models) page by clicking on the **Models** button in the sidebar.
+
+
+
+??? tip "Tip"
+
+ You can also train a model directly from the [Home](https://hub.ultralytics.com/home) page.
+
+ 
+
+Click on the **Train Model** button on the top right of the page. This action will trigger the **Train Model** dialog.
+
+
+
+The **Train Model** dialog has three simple steps, explained below.
+
+### 1. Dataset
+
+In this step, you have to select the dataset you want to train your model on. After you selected a dataset, click **Continue**.
+
+
+
+??? tip "Tip"
+
+ You can skip this step if you train a model directly from the Dataset page.
+
+ 
+
+### 2. Model
+
+In this step, you have to choose the project in which you want to create your model, the name of your model and your model's architecture.
+
+??? note "Note"
+
+ Ultralytics HUB will try to pre-select the project.
+
+ If you opened the **Train Model** dialog as described above, Ultralytics HUB will pre-select the last project you used.
+
+ If you opened the **Train Model** dialog from the Project page, Ultralytics HUB will pre-select the project you were inside of.
+
+ 
+
+ In case you don't have a project created yet, you can set the name of your project in this step and it will be created together with your model.
+
+ 
+
+!!! Info "Info"
+
+ You can read more about the available [YOLOv8](https://docs.ultralytics.com/models/yolov8) (and [YOLOv5](https://docs.ultralytics.com/models/yolov5)) architectures in our documentation.
+
+When you're happy with your model configuration, click **Continue**.
+
+
+
+??? note "Note"
+
+ By default, your model will use a pre-trained model (trained on the [COCO](https://docs.ultralytics.com/datasets/detect/coco) dataset) to reduce training time.
+
+ You can change this behaviour by opening the **Advanced Options** accordion.
+
+### 3. Train
+
+In this step, you will start training you model.
+
+Ultralytics HUB offers three training options:
+
+- Ultralytics Cloud **(COMING SOON)**
+- Google Colab
+- Bring your own agent
+
+In order to start training your model, follow the instructions presented in this step.
+
+
+
+??? note "Note"
+
+ When you are on this step, before the training starts, you can change the default training configuration by opening the **Advanced Options** accordion.
+
+ 
+
+??? note "Note"
+
+ When you are on this step, you have the option to close the **Train Model** dialog and start training your model from the Model page later.
+
+ 
+
+To start training your model using Google Colab, simply follow the instructions shown above or on the Google Colab notebook.
+
+
+
+
+
+When the training starts, you can click **Done** and monitor the training progress on the Model page.
+
+
+
+
+
+??? note "Note"
+
+ In case the training stops and a checkpoint was saved, you can resume training your model from the Model page.
+
+ 
+
+## Preview Model
+
+Ultralytics HUB offers a variety of ways to preview your trained model.
+
+You can preview your model if you click on the **Preview** tab and upload an image in the **Test** card.
+
+
+
+You can also use our Ultralytics Cloud API to effortlessly [run inference](https://docs.ultralytics.com/hub/inference_api) with your custom model.
+
+
+
+Furthermore, you can preview your model in real-time directly on your [iOS](https://apps.apple.com/xk/app/ultralytics/id1583935240) or [Android](https://play.google.com/store/apps/details?id=com.ultralytics.ultralytics_app) mobile device by [downloading](https://ultralytics.com/app_install) our [Ultralytics HUB Mobile Application](app/index.md).
+
+
+
+## Deploy Model
+
+You can export your model to 13 different formats, including ONNX, OpenVINO, CoreML, TensorFlow, Paddle and many others.
+
+
+
+??? tip "Tip"
+
+ You can customize the export options of each format if you open the export actions dropdown and click on the **Advanced** option.
+
+ 
+
+## Share Model
+
+!!! Info "Info"
+
+ Ultralytics HUB's sharing functionality provides a convenient way to share models with others. This feature is designed to accommodate both existing Ultralytics HUB users and those who have yet to create an account.
+
+??? note "Note"
+
+ You have control over the general access of your models.
+
+ You can choose to set the general access to "Private", in which case, only you will have access to it. Alternatively, you can set the general access to "Unlisted" which grants viewing access to anyone who has the direct link to the model, regardless of whether they have an Ultralytics HUB account or not.
+
+Navigate to the Model page of the model you want to share, open the model actions dropdown and click on the **Share** option. This action will trigger the **Share Model** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also share a model directly from the [Models](https://hub.ultralytics.com/models) page or from the Project page of the project where your model is located.
+
+ 
+
+Set the general access to "Unlisted" and click **Save**.
+
+
+
+Now, anyone who has the direct link to your model can view it.
+
+??? tip "Tip"
+
+ You can easily click on the model's link shown in the **Share Model** dialog to copy it.
+
+ 
+
+## Edit Model
+
+Navigate to the Model page of the model you want to edit, open the model actions dropdown and click on the **Edit** option. This action will trigger the **Update Model** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also edit a model directly from the [Models](https://hub.ultralytics.com/models) page or from the Project page of the project where your model is located.
+
+ 
+
+Apply the desired modifications to your model and then confirm the changes by clicking **Save**.
+
+
+
+## Delete Model
+
+Navigate to the Model page of the model you want to delete, open the model actions dropdown and click on the **Delete** option. This action will delete the model.
+
+
+
+??? tip "Tip"
+
+ You can also delete a model directly from the [Models](https://hub.ultralytics.com/models) page or from the Project page of the project where your model is located.
+
+ 
+
+??? note "Note"
+
+ If you change your mind, you can restore the model from the [Trash](https://hub.ultralytics.com/trash) page.
+
+ 
diff --git a/ultralytics/docs/en/hub/models.md:Zone.Identifier b/ultralytics/docs/en/hub/models.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/models.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/projects.md b/ultralytics/docs/en/hub/projects.md
new file mode 100755
index 0000000..c0cbf20
--- /dev/null
+++ b/ultralytics/docs/en/hub/projects.md
@@ -0,0 +1,180 @@
+---
+comments: true
+description: Learn how to manage Ultralytics HUB projects. Understand effective strategies to create, share, edit, delete, and compare models in an organized workspace.
+keywords: Ultralytics, HUB projects, Create project, Edit project, Share project, Delete project, Compare Models, Model Management
+---
+
+# Ultralytics HUB Projects
+
+[Ultralytics HUB](https://hub.ultralytics.com/) projects provide an effective solution for consolidating and managing your models. If you are working with several models that perform similar tasks or have related purposes, Ultralytics HUB projects allow you to group these models together.
+
+This creates a unified and organized workspace that facilitates easier model management, comparison and development. Having similar models or various iterations together can facilitate rapid benchmarking, as you can compare their effectiveness. This can lead to faster, more insightful iterative development and refinement of your models.
+
+
+
+
+
+ Watch: Train YOLOv8 Pose Model on Tiger-Pose Dataset Using Ultralytics HUB
+
+
+## Create Project
+
+Navigate to the [Projects](https://hub.ultralytics.com/projects) page by clicking on the **Projects** button in the sidebar.
+
+
+
+??? tip "Tip"
+
+ You can also create a project directly from the [Home](https://hub.ultralytics.com/home) page.
+
+ 
+
+Click on the **Create Project** button on the top right of the page. This action will trigger the **Create Project** dialog, opening up a suite of options for tailoring your project to your needs.
+
+
+
+Type the name of your project in the _Project name_ field or keep the default name and finalize the project creation with a single click.
+
+You have the additional option to enrich your project with a description and a unique image, enhancing its recognizability on the Projects page.
+
+When you're happy with your project configuration, click **Create**.
+
+
+
+After your project is created, you will be able to access it from the Projects page.
+
+
+
+Next, [train a model](https://docs.ultralytics.com/hub/models/#train-model) inside your project.
+
+
+
+## Share Project
+
+!!! Info "Info"
+
+ Ultralytics HUB's sharing functionality provides a convenient way to share projects with others. This feature is designed to accommodate both existing Ultralytics HUB users and those who have yet to create an account.
+
+??? note "Note"
+
+ You have control over the general access of your projects.
+
+ You can choose to set the general access to "Private", in which case, only you will have access to it. Alternatively, you can set the general access to "Unlisted" which grants viewing access to anyone who has the direct link to the project, regardless of whether they have an Ultralytics HUB account or not.
+
+Navigate to the Project page of the project you want to share, open the project actions dropdown and click on the **Share** option. This action will trigger the **Share Project** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also share a project directly from the [Projects](https://hub.ultralytics.com/projects) page.
+
+ 
+
+Set the general access to "Unlisted" and click **Save**.
+
+
+
+!!! Warning "Warning"
+
+ When changing the general access of a project, the general access of the models inside the project will be changed as well.
+
+Now, anyone who has the direct link to your project can view it.
+
+??? tip "Tip"
+
+ You can easily click on the project's link shown in the **Share Project** dialog to copy it.
+
+ 
+
+## Edit Project
+
+Navigate to the Project page of the project you want to edit, open the project actions dropdown and click on the **Edit** option. This action will trigger the **Update Project** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also edit a project directly from the [Projects](https://hub.ultralytics.com/projects) page.
+
+ 
+
+Apply the desired modifications to your project and then confirm the changes by clicking **Save**.
+
+
+
+## Delete Project
+
+Navigate to the Project page of the project you want to delete, open the project actions dropdown and click on the **Delete** option. This action will delete the project.
+
+
+
+??? tip "Tip"
+
+ You can also delete a project directly from the [Projects](https://hub.ultralytics.com/projects) page.
+
+ 
+
+!!! Warning "Warning"
+
+ When deleting a project, the models inside the project will be deleted as well.
+
+??? note "Note"
+
+ If you change your mind, you can restore the project from the [Trash](https://hub.ultralytics.com/trash) page.
+
+ 
+
+## Compare Models
+
+Navigate to the Project page of the project where the models you want to compare are located. To use the model comparison feature, click on the **Charts** tab.
+
+
+
+This will display all the relevant charts. Each chart corresponds to a different metric and contains the performance of each model for that metric. The models are represented by different colors and you can hover over each data point to get more information.
+
+
+
+??? tip "Tip"
+
+ Each chart can be enlarged for better visualization.
+
+ 
+
+ 
+
+??? tip "Tip"
+
+ You have the flexibility to customize your view by selectively hiding certain models. This feature allows you to concentrate on the models of interest.
+
+ 
+
+## Reorder Models
+
+??? note "Note"
+
+ Ultralytics HUB's reordering functionality works only inside projects you own.
+
+Navigate to the Project page of the project where the models you want to reorder are located. Click on the designated reorder icon of the model you want to move and drag it to the desired location.
+
+
+
+## Transfer Models
+
+Navigate to the Project page of the project where the model you want to mode is located, open the project actions dropdown and click on the **Transfer** option. This action will trigger the **Transfer Model** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also transfer a model directly from the [Models](https://hub.ultralytics.com/models) page.
+
+ 
+
+Select the project you want to transfer the model to and click **Save**.
+
+
diff --git a/ultralytics/docs/en/hub/projects.md:Zone.Identifier b/ultralytics/docs/en/hub/projects.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/projects.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/hub/quickstart.md b/ultralytics/docs/en/hub/quickstart.md
new file mode 100755
index 0000000..3728dc4
--- /dev/null
+++ b/ultralytics/docs/en/hub/quickstart.md
@@ -0,0 +1,52 @@
+---
+comments: true
+description: Kickstart your journey with Ultralytics HUB. Learn how to train and deploy YOLOv5 and YOLOv8 models in seconds with our Quickstart guide.
+keywords: Ultralytics HUB, Quickstart, YOLOv5, YOLOv8, model training, quick deployment, drag-and-drop interface, real-time object detection
+---
+
+# Quickstart Guide for Ultralytics HUB
+
+๐ง **Under Construction** ๐ง
+
+Thank you for visiting the Quickstart guide for [Ultralytics HUB](https://hub.ultralytics.com/)! We're currently hard at work building out this page to provide you with step-by-step instructions on how to get up and running with HUB in no time.
+
+
+
+
+
+ Watch: Train Your Custom YOLO Models In A Few Clicks with Ultralytics HUB.
+
+
+In the meantime, here's a brief overview of what you can expect from Ultralytics HUB:
+
+## What is Ultralytics HUB?
+
+Ultralytics HUB is your one-stop solution for training and deploying YOLOv5 and YOLOv8 models. It's designed with user experience in mind, featuring a drag-and-drop interface to make uploading data and training new models a breeze. Whether you're a beginner or an experienced machine learning practitioner, HUB has a range of pre-trained models and templates to accelerate your projects.
+
+## Key Features
+
+- **User-Friendly Interface**: Simply drag and drop your data to start training.
+- **Pre-Trained Models**: Choose from a selection of pre-trained models to kick-start your projects.
+- **Real-Time Object Detection**: Deploy trained models easily for real-time object detection, instance segmentation, and classification tasks.
+
+## Coming Soon
+
+- Detailed Steps to Start Your First Project
+- Guide on Preparing and Uploading Datasets
+- Tutorial on Model Training and Exporting
+- Integration Options and How-To's
+- And much more!
+
+## Need Help Now?
+
+While we're polishing this page, feel free to:
+
+- Browse through other [HUB Docs](https://docs.ultralytics.com/hub/) for detailed guides and tutorials.
+- Raise an issue on our [GitHub](https://github.com/ultralytics/hub/) for technical support.
+- Join our [Discord Community](https://ultralytics.com/discord/) for live discussions and community support.
+
+Stay tuned! We'll be back soon with more detailed information to help you get the most out of Ultralytics HUB. Thank you for your patience and interest!
diff --git a/ultralytics/docs/en/hub/quickstart.md:Zone.Identifier b/ultralytics/docs/en/hub/quickstart.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/hub/quickstart.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/index.md b/ultralytics/docs/en/index.md
new file mode 100755
index 0000000..4f4b0d6
--- /dev/null
+++ b/ultralytics/docs/en/index.md
@@ -0,0 +1,79 @@
+---
+comments: true
+description: Explore a complete guide to Ultralytics YOLOv8, a high-speed, high-accuracy object detection & image segmentation model. Installation, prediction, training tutorials and more.
+keywords: Ultralytics, YOLOv8, object detection, image segmentation, machine learning, deep learning, computer vision, YOLOv8 installation, YOLOv8 prediction, YOLOv8 training, YOLO history, YOLO licenses
+---
+
+
+
+Introducing [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), the latest version of the acclaimed real-time object detection and image segmentation model. YOLOv8 is built on cutting-edge advancements in deep learning and computer vision, offering unparalleled performance in terms of speed and accuracy. Its streamlined design makes it suitable for various applications and easily adaptable to different hardware platforms, from edge devices to cloud APIs.
+
+Explore the YOLOv8 Docs, a comprehensive resource designed to help you understand and utilize its features and capabilities. Whether you are a seasoned machine learning practitioner or new to the field, this hub aims to maximize YOLOv8's potential in your projects
+
+## Where to Start
+
+- **Install** `ultralytics` with pip and get up and running in minutes [:material-clock-fast: Get Started](quickstart.md){ .md-button }
+- **Predict** new images and videos with YOLOv8 [:octicons-image-16: Predict on Images](modes/predict.md){ .md-button }
+- **Train** a new YOLOv8 model on your own custom dataset [:fontawesome-solid-brain: Train a Model](modes/train.md){ .md-button }
+- **Explore** YOLOv8 tasks like segment, classify, pose and track [:material-magnify-expand: Explore Tasks](tasks/index.md){ .md-button }
+
+
+
+
+
+ Watch: How to Train a YOLOv8 model on Your Custom Dataset in Google Colab.
+
+
+## YOLO: A Brief History
+
+[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), a popular object detection and image segmentation model, was developed by Joseph Redmon and Ali Farhadi at the University of Washington. Launched in 2015, YOLO quickly gained popularity for its high speed and accuracy.
+
+- [YOLOv2](https://arxiv.org/abs/1612.08242), released in 2016, improved the original model by incorporating batch normalization, anchor boxes, and dimension clusters.
+- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), launched in 2018, further enhanced the model's performance using a more efficient backbone network, multiple anchors and spatial pyramid pooling.
+- [YOLOv4](https://arxiv.org/abs/2004.10934) was released in 2020, introducing innovations like Mosaic data augmentation, a new anchor-free detection head, and a new loss function.
+- [YOLOv5](https://github.com/ultralytics/yolov5) further improved the model's performance and added new features such as hyperparameter optimization, integrated experiment tracking and automatic export to popular export formats.
+- [YOLOv6](https://github.com/meituan/YOLOv6) was open-sourced by [Meituan](https://about.meituan.com/) in 2022 and is in use in many of the company's autonomous delivery robots.
+- [YOLOv7](https://github.com/WongKinYiu/yolov7) added additional tasks such as pose estimation on the COCO keypoints dataset.
+- [YOLOv8](https://github.com/ultralytics/ultralytics) is the latest version of YOLO by Ultralytics. As a cutting-edge, state-of-the-art (SOTA) model, YOLOv8 builds on the success of previous versions, introducing new features and improvements for enhanced performance, flexibility, and efficiency. YOLOv8 supports a full range of vision AI tasks, including [detection](tasks/detect.md), [segmentation](tasks/segment.md), [pose estimation](tasks/pose.md), [tracking](modes/track.md), and [classification](tasks/classify.md). This versatility allows users to leverage YOLOv8's capabilities across diverse applications and domains.
+
+## YOLO Licenses: How is Ultralytics YOLO licensed?
+
+Ultralytics offers two licensing options to accommodate diverse use cases:
+
+- **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/licenses/) 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.
+- **Enterprise License**: Designed for commercial use, this license permits seamless integration of Ultralytics software and AI models into commercial goods and services, bypassing the open-source requirements of AGPL-3.0. If your scenario involves embedding our solutions into a commercial offering, reach out through [Ultralytics Licensing](https://ultralytics.com/license).
+
+Our licensing strategy is designed to ensure that any improvements to our open-source projects are returned to the community. We hold the principles of open source close to our hearts โค๏ธ, and our mission is to guarantee that our contributions can be utilized and expanded upon in ways that are beneficial to all.
diff --git a/ultralytics/docs/en/index.md:Zone.Identifier b/ultralytics/docs/en/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/clearml.md b/ultralytics/docs/en/integrations/clearml.md
new file mode 100755
index 0000000..ca3e85f
--- /dev/null
+++ b/ultralytics/docs/en/integrations/clearml.md
@@ -0,0 +1,184 @@
+---
+comments: true
+description: Learn how to streamline and optimize your YOLOv8 model training with ClearML. This guide provides insights into integrating ClearML's MLOps tools for efficient model training, from initial setup to advanced experiment tracking and model management.
+keywords: Ultralytics, YOLOv8, Object Detection, ClearML, Model Training, MLOps, Experiment Tracking, Workflow Optimization
+---
+
+# Training YOLOv8 with ClearML: Streamlining Your MLOps Workflow
+
+MLOps bridges the gap between creating and deploying machine learning models in real-world settings. It focuses on efficient deployment, scalability, and ongoing management to ensure models perform well in practical applications.
+
+[Ultralytics YOLOv8](https://ultralytics.com) effortlessly integrates with ClearML, streamlining and enhancing your object detection model's training and management. This guide will walk you through the integration process, detailing how to set up ClearML, manage experiments, automate model management, and collaborate effectively.
+
+## ClearML
+
+
+
+
+
+[ClearML](https://clear.ml/) is an innovative open-source MLOps platform that is skillfully designed to automate, monitor, and orchestrate machine learning workflows. Its key features include automated logging of all training and inference data for full experiment reproducibility, an intuitive web UI for easy data visualization and analysis, advanced hyperparameter optimization algorithms, and robust model management for efficient deployment across various platforms.
+
+## YOLOv8 Training with ClearML
+
+You can bring automation and efficiency to your machine learning workflow by improving your training process by integrating YOLOv8 with ClearML.
+
+## Installation
+
+To install the required packages, run:
+
+!!! Tip "Installation"
+
+ === "CLI"
+
+ ```bash
+ # Install the required packages for YOLOv8 and ClearML
+ pip install ultralytics clearml
+ ```
+
+For detailed instructions and best practices related to the installation process, be sure to check our [YOLOv8 Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+
+## Configuring ClearML
+
+Once you have installed the necessary packages, the next step is to initialize and configure your ClearML SDK. This involves setting up your ClearML account and obtaining the necessary credentials for a seamless connection between your development environment and the ClearML server.
+
+Begin by initializing the ClearML SDK in your environment. The โclearml-initโ command starts the setup process and prompts you for the necessary credentials.
+
+!!! Tip "Initial SDK Setup"
+
+ === "CLI"
+
+ ```bash
+ # Initialize your ClearML SDK setup process
+ clearml-init
+ ```
+
+After executing this command, visit the [ClearML Settings page](https://app.clear.ml/settings/workspace-configuration). Navigate to the top right corner and select "Settings." Go to the "Workspace" section and click on "Create new credentials." Use the credentials provided in the "Create Credentials" pop-up to complete the setup as instructed, depending on whether you are configuring ClearML in a Jupyter Notebook or a local Python environment.
+
+## Usage
+
+Before diving into the usage instructions, be sure to check out the range of [YOLOv8 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements.
+
+!!! Example "Usage"
+
+ === "Python"
+
+ ```python
+ from clearml import Task
+ from ultralytics import YOLO
+
+ # Step 1: Creating a ClearML Task
+ task = Task.init(
+ project_name="my_project",
+ task_name="my_yolov8_task"
+ )
+
+ # Step 2: Selecting the YOLOv8 Model
+ model_variant = "yolov8n"
+ task.set_parameter("model_variant", model_variant)
+
+ # Step 3: Loading the YOLOv8 Model
+ model = YOLO(f'{model_variant}.pt')
+
+ # Step 4: Setting Up Training Arguments
+ args = dict(data="coco128.yaml", epochs=16)
+ task.connect(args)
+
+ # Step 5: Initiating Model Training
+ results = model.train(**args)
+ ```
+
+### Understanding the Code
+
+Letโs understand the steps showcased in the usage code snippet above.
+
+**Step 1: Creating a ClearML Task**: A new task is initialized in ClearML, specifying your project and task names. This task will track and manage your model's training.
+
+**Step 2: Selecting the YOLOv8 Model**: The `model_variant` variable is set to 'yolov8n', one of the YOLOv8 models. This variant is then logged in ClearML for tracking.
+
+**Step 3: Loading the YOLOv8 Model**: The selected YOLOv8 model is loaded using Ultralytics' YOLO class, preparing it for training.
+
+**Step 4: Setting Up Training Arguments**: Key training arguments like the dataset (`coco128.yaml`) and the number of epochs (`16`) are organized in a dictionary and connected to the ClearML task. This allows for tracking and potential modification via the ClearML UI. For a detailed understanding of the model training process and best practices, refer to our [YOLOv8 Model Training guide](../modes/train.md).
+
+**Step 5: Initiating Model Training**: The model training is started with the specified arguments. The results of the training process are captured in the `results` variable.
+
+### Understanding the Output
+
+Upon running the usage code snippet above, you can expect the following output:
+
+- A confirmation message indicating the creation of a new ClearML task, along with its unique ID.
+- An informational message about the script code being stored, indicating that the code execution is being tracked by ClearML.
+- A URL link to the ClearML results page where you can monitor the training progress and view detailed logs.
+- Download progress for the YOLOv8 model and the specified dataset, followed by a summary of the model architecture and training configuration.
+- Initialization messages for various training components like TensorBoard, Automatic Mixed Precision (AMP), and dataset preparation.
+- Finally, the training process starts, with progress updates as the model trains on the specified dataset. For an in-depth understanding of the performance metrics used during training, read [our guide on performance metrics](../guides/yolo-performance-metrics.md).
+
+### Viewing the ClearML Results Page
+
+By clicking on the URL link to the ClearML results page in the output of the usage code snippet, you can access a comprehensive view of your model's training process.
+
+#### Key Features of the ClearML Results Page
+
+- **Real-Time Metrics Tracking**
+ - Track critical metrics like loss, accuracy, and validation scores as they occur.
+ - Provides immediate feedback for timely model performance adjustments.
+
+- **Experiment Comparison**
+ - Compare different training runs side-by-side.
+ - Essential for hyperparameter tuning and identifying the most effective models.
+
+- **Detailed Logs and Outputs**
+ - Access comprehensive logs, graphical representations of metrics, and console outputs.
+ - Gain a deeper understanding of model behavior and issue resolution.
+
+- **Resource Utilization Monitoring**
+ - Monitor the utilization of computational resources, including CPU, GPU, and memory.
+ - Key to optimizing training efficiency and costs.
+
+- **Model Artifacts Management**
+ - View, download, and share model artifacts like trained models and checkpoints.
+ - Enhances collaboration and streamlines model deployment and sharing.
+
+For a visual walkthrough of what the ClearML Results Page looks like, watch the video below:
+
+
+
+### Advanced Features in ClearML
+
+ClearML offers several advanced features to enhance your MLOps experience.
+
+#### Remote Execution
+
+ClearML's remote execution feature facilitates the reproduction and manipulation of experiments on different machines. It logs essential details like installed packages and uncommitted changes. When a task is enqueued, the ClearML Agent pulls it, recreates the environment, and runs the experiment, reporting back with detailed results.
+
+Deploying a ClearML Agent is straightforward and can be done on various machines using the following command:
+
+```bash
+clearml-agent daemon --queue [--docker]
+```
+
+This setup is applicable to cloud VMs, local GPUs, or laptops. ClearML Autoscalers help manage cloud workloads on platforms like AWS, GCP, and Azure, automating the deployment of agents and adjusting resources based on your resource budget.
+
+### Cloning, Editing, and Enqueuing
+
+ClearML's user-friendly interface allows easy cloning, editing, and enqueuing of tasks. Users can clone an existing experiment, adjust parameters or other details through the UI, and enqueue the task for execution. This streamlined process ensures that the ClearML Agent executing the task uses updated configurations, making it ideal for iterative experimentation and model fine-tuning.
+
+
+
+
+
+## Summary
+
+This guide has led you through the process of integrating ClearML with Ultralytics' YOLOv8. Covering everything from initial setup to advanced model management, you've discovered how to leverage ClearML for efficient training, experiment tracking, and workflow optimization in your machine learning projects.
+
+For further details on usage, visit [ClearML's official documentation](https://clear.ml/docs/latest/docs/integrations/yolov8/).
+
+Additionally, explore more integrations and capabilities of Ultralytics by visiting the [Ultralytics integration guide page](../integrations/index.md), which is a treasure trove of resources and insights.
diff --git a/ultralytics/docs/en/integrations/clearml.md:Zone.Identifier b/ultralytics/docs/en/integrations/clearml.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/clearml.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/comet.md b/ultralytics/docs/en/integrations/comet.md
new file mode 100755
index 0000000..1aa25d3
--- /dev/null
+++ b/ultralytics/docs/en/integrations/comet.md
@@ -0,0 +1,174 @@
+---
+comments: true
+description: Discover how to track and enhance YOLOv8 model training with Comet ML's logging tools, from setup to monitoring key metrics and managing experiments for in-depth analysis.
+keywords: Ultralytics, YOLOv8, Object Detection, Comet ML, Model Training, Model Metrics Logging, Experiment Tracking, Offline Experiment Management
+---
+
+# Elevating YOLOv8 Training: Simplify Your Logging Process with Comet ML
+
+Logging key training details such as parameters, metrics, image predictions, and model checkpoints is essential in machine learningโit keeps your project transparent, your progress measurable, and your results repeatable.
+
+[Ultralytics YOLOv8](https://ultralytics.com) seamlessly integrates with Comet ML, efficiently capturing and optimizing every aspect of your YOLOv8 object detection model's training process. In this guide, we'll cover the installation process, Comet ML setup, real-time insights, custom logging, and offline usage, ensuring that your YOLOv8 training is thoroughly documented and fine-tuned for outstanding results.
+
+## Comet ML
+
+
+
+
+
+[Comet ML](https://www.comet.ml/) is a platform for tracking, comparing, explaining, and optimizing machine learning models and experiments. It allows you to log metrics, parameters, media, and more during your model training and monitor your experiments through an aesthetically pleasing web interface. Comet ML helps data scientists iterate more rapidly, enhances transparency and reproducibility, and aids in the development of production models.
+
+## Harnessing the Power of YOLOv8 and Comet ML
+
+By combining Ultralytics YOLOv8 with Comet ML, you unlock a range of benefits. These include simplified experiment management, real-time insights for quick adjustments, flexible and tailored logging options, and the ability to log experiments offline when internet access is limited. This integration empowers you to make data-driven decisions, analyze performance metrics, and achieve exceptional results.
+
+## Installation
+
+To install the required packages, run:
+
+!!! Tip "Installation"
+
+ === "CLI"
+
+ ```bash
+ # Install the required packages for YOLOv8 and Comet ML
+ pip install ultralytics comet_ml torch torchvision
+ ```
+
+## Configuring Comet ML
+
+After installing the required packages, youโll need to sign up, get a [Comet API Key](https://www.comet.com/signup), and configure it.
+
+!!! Tip "Configuring Comet ML"
+
+ === "CLI"
+
+ ```bash
+ # Set your Comet Api Key
+ export COMET_API_KEY=
+ ```
+
+Then, you can initialize your Comet project. Comet will automatically detect the API key and proceed with the setup.
+
+```python
+import comet_ml
+
+comet_ml.init(project_name="comet-example-yolov8-coco128")
+```
+
+*Note:* If you are using a Google Colab notebook, the code above will prompt you to enter your API key for initialization.
+
+## Usage
+
+Before diving into the usage instructions, be sure to check out the range of [YOLOv8 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements.
+
+!!! Example "Usage"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO("yolov8n.pt")
+
+ # train the model
+ results = model.train(
+ data="coco128.yaml",
+ project="comet-example-yolov8-coco128",
+ batch=32,
+ save_period=1,
+ save_json=True,
+ epochs=3
+ )
+ ```
+
+After running the training code, Comet ML will create an experiment in your Comet workspace to track the run automatically. You will then be provided with a link to view the detailed logging of your [YOLOv8 model's training](../modes/train.md) process.
+
+Comet automatically logs the following data with no additional configuration: metrics such as mAP and loss, hyperparameters, model checkpoints, interactive confusion matrix, and image bounding box predictions.
+
+## Understanding Your Model's Performance with Comet ML Visualizations
+
+Let's dive into what you'll see on the Comet ML dashboard once your YOLOv8 model begins training. The dashboard is where all the action happens, presenting a range of automatically logged information through visuals and statistics. Hereโs a quick tour:
+
+**Experiment Panels**
+
+The experiment panels section of the Comet ML dashboard organize and present the different runs and their metrics, such as segment mask loss, class loss, precision, and mean average precision.
+
+
+
+
+
+**Metrics**
+
+In the metrics section, you have the option to examine the metrics in a tabular format as well, which is displayed in a dedicated pane as illustrated here.
+
+
+
+
+
+**Interactive Confusion Matrix**
+
+The confusion matrix, found in the Confusion Matrix tab, provides an interactive way to assess the model's classification accuracy. It details the correct and incorrect predictions, allowing you to understand the model's strengths and weaknesses.
+
+
+
+
+
+**System Metrics**
+
+Comet ML logs system metrics to help identify any bottlenecks in the training process. It includes metrics such as GPU utilization, GPU memory usage, CPU utilization, and RAM usage. These are essential for monitoring the efficiency of resource usage during model training.
+
+
+
+
+
+## Customizing Comet ML Logging
+
+Comet ML offers the flexibility to customize its logging behavior by setting environment variables. These configurations allow you to tailor Comet ML to your specific needs and preferences. Here are some helpful customization options:
+
+### Logging Image Predictions
+
+You can control the number of image predictions that Comet ML logs during your experiments. By default, Comet ML logs 100 image predictions from the validation set. However, you can change this number to better suit your requirements. For example, to log 200 image predictions, use the following code:
+
+```python
+import os
+os.environ["COMET_MAX_IMAGE_PREDICTIONS"] = "200"
+```
+
+### Batch Logging Interval
+
+Comet ML allows you to specify how often batches of image predictions are logged. The `COMET_EVAL_BATCH_LOGGING_INTERVAL` environment variable controls this frequency. The default setting is 1, which logs predictions from every validation batch. You can adjust this value to log predictions at a different interval. For instance, setting it to 4 will log predictions from every fourth batch.
+
+```python
+import os
+os.environ['COMET_EVAL_BATCH_LOGGING_INTERVAL'] = "4"
+```
+
+### Disabling Confusion Matrix Logging
+
+In some cases, you may not want to log the confusion matrix from your validation set after every epoch. You can disable this feature by setting the `COMET_EVAL_LOG_CONFUSION_MATRIX` environment variable to "false." The confusion matrix will only be logged once, after the training is completed.
+
+```python
+import os
+os.environ["COMET_EVAL_LOG_CONFUSION_MATRIX"] = "false"
+```
+
+### Offline Logging
+
+If you find yourself in a situation where internet access is limited, Comet ML provides an offline logging option. You can set the `COMET_MODE` environment variable to "offline" to enable this feature. Your experiment data will be saved locally in a directory that you can later upload to Comet ML when internet connectivity is available.
+
+```python
+import os
+os.environ["COMET_MODE"] = "offline"
+```
+
+## Summary
+
+This guide has walked you through integrating Comet ML with Ultralytics' YOLOv8. From installation to customization, you've learned to streamline experiment management, gain real-time insights, and adapt logging to your project's needs.
+
+Explore [Comet ML's official documentation](https://www.comet.com/docs/v2/integrations/third-party-tools/yolov8/) for more insights on integrating with YOLOv8.
+
+Furthermore, if you're looking to dive deeper into the practical applications of YOLOv8, specifically for image segmentation tasks, this detailed guide on [fine-tuning YOLOv8 with Comet ML](https://www.comet.com/site/blog/fine-tuning-yolov8-for-image-segmentation-with-comet/) offers valuable insights and step-by-step instructions to enhance your model's performance.
+
+Additionally, to explore other exciting integrations with Ultralytics, check out the [integration guide page](../integrations/index.md), which offers a wealth of resources and information.
diff --git a/ultralytics/docs/en/integrations/comet.md:Zone.Identifier b/ultralytics/docs/en/integrations/comet.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/comet.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/dvc.md b/ultralytics/docs/en/integrations/dvc.md
new file mode 100755
index 0000000..542a91a
--- /dev/null
+++ b/ultralytics/docs/en/integrations/dvc.md
@@ -0,0 +1,171 @@
+---
+comments: true
+description: This guide provides a step-by-step approach to integrating DVCLive with Ultralytics YOLOv8 for advanced experiment tracking. Learn how to set up your environment, run experiments with varied configurations, and analyze results using DVCLive's powerful tracking and visualization tools.
+keywords: DVCLive, Ultralytics, YOLOv8, Machine Learning, Experiment Tracking, Data Version Control, ML Workflows, Model Training, Hyperparameter Tuning
+---
+
+# Advanced YOLOv8 Experiment Tracking with DVCLive
+
+Experiment tracking in machine learning is critical to model development and evaluation. It involves recording and analyzing various parameters, metrics, and outcomes from numerous training runs. This process is essential for understanding model performance and making data-driven decisions to refine and optimize models.
+
+Integrating DVCLive with [Ultralytics YOLOv8](https://ultralytics.com) transforms the way experiments are tracked and managed. This integration offers a seamless solution for automatically logging key experiment details, comparing results across different runs, and visualizing data for in-depth analysis. In this guide, we'll understand how DVCLive can be used to streamline the process.
+
+## DVCLive
+
+
+
+
+
+[DVCLive](https://dvc.org/doc/dvclive), developed by DVC, is an innovative open-source tool for experiment tracking in machine learning. Integrating seamlessly with Git and DVC, it automates the logging of crucial experiment data like model parameters and training metrics. Designed for simplicity, DVCLive enables effortless comparison and analysis of multiple runs, enhancing the efficiency of machine learning projects with intuitive data visualization and analysis tools.
+
+## YOLOv8 Training with DVCLive
+
+YOLOv8 training sessions can be effectively monitored with DVCLive. Additionally, DVC provides integral features for visualizing these experiments, including the generation of a report that enables the comparison of metric plots across all tracked experiments, offering a comprehensive view of the training process.
+
+## Installation
+
+To install the required packages, run:
+
+!!! Tip "Installation"
+
+ === "CLI"
+
+ ```bash
+ # Install the required packages for YOLOv8 and DVCLive
+ pip install ultralytics dvclive
+ ```
+
+For detailed instructions and best practices related to the installation process, be sure to check our [YOLOv8 Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+
+## Configuring DVCLive
+
+Once you have installed the necessary packages, the next step is to set up and configure your environment with the necessary credentials. This setup ensures a smooth integration of DVCLive into your existing workflow.
+
+Begin by initializing a Git repository, as Git plays a crucial role in version control for both your code and DVCLive configurations.
+
+!!! Tip "Initial Environment Setup"
+
+ === "CLI"
+
+ ```bash
+ # Initialize a Git repository
+ git init -q
+
+ # Configure Git with your details
+ git config --local user.email "you@example.com"
+ git config --local user.name "Your Name"
+
+ # Initialize DVCLive in your project
+ dvc init -q
+
+ # Commit the DVCLive setup to your Git repository
+ git commit -m "DVC init"
+ ```
+
+In these commands, ensure to replace "you@example.com" with the email address associated with your Git account, and "Your Name" with your Git account username.
+
+## Usage
+
+Before diving into the usage instructions, be sure to check out the range of [YOLOv8 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements.
+
+### Training YOLOv8 Models with DVCLive
+
+Start by running your YOLOv8 training sessions. You can use different model configurations and training parameters to suit your project needs. For instance:
+
+```bash
+# Example training commands for YOLOv8 with varying configurations
+yolo train model=yolov8n.pt data=coco8.yaml epochs=5 imgsz=512
+yolo train model=yolov8n.pt data=coco8.yaml epochs=5 imgsz=640
+```
+
+Adjust the model, data, epochs, and imgsz parameters according to your specific requirements. For a detailed understanding of the model training process and best practices, refer to our [YOLOv8 Model Training guide](../modes/train.md).
+
+### Monitoring Experiments with DVCLive
+
+DVCLive enhances the training process by enabling the tracking and visualization of key metrics. When installed, Ultralytics YOLOv8 automatically integrates with DVCLive for experiment tracking, which you can later analyze for performance insights. For a comprehensive understanding of the specific performance metrics used during training, be sure to explore [our detailed guide on performance metrics](../guides/yolo-performance-metrics.md).
+
+### Analyzing Results
+
+After your YOLOv8 training sessions are complete, you can leverage DVCLive's powerful visualization tools for in-depth analysis of the results. DVCLive's integration ensures that all training metrics are systematically logged, facilitating a comprehensive evaluation of your model's performance.
+
+To start the analysis, you can extract the experiment data using DVC's API and process it with Pandas for easier handling and visualization:
+
+```python
+import dvc.api
+import pandas as pd
+
+# Define the columns of interest
+columns = ["Experiment", "epochs", "imgsz", "model", "metrics.mAP50-95(B)"]
+
+# Retrieve experiment data
+df = pd.DataFrame(dvc.api.exp_show(), columns=columns)
+
+# Clean the data
+df.dropna(inplace=True)
+df.reset_index(drop=True, inplace=True)
+
+# Display the DataFrame
+print(df)
+```
+
+The output of the code snippet above provides a clear tabular view of the different experiments conducted with YOLOv8 models. Each row represents a different training run, detailing the experiment's name, the number of epochs, image size (imgsz), the specific model used, and the mAP50-95(B) metric. This metric is crucial for evaluating the model's accuracy, with higher values indicating better performance.
+
+#### Visualizing Results with Plotly
+
+For a more interactive and visual analysis of your experiment results, you can use Plotly's parallel coordinates plot. This type of plot is particularly useful for understanding the relationships and trade-offs between different parameters and metrics.
+
+```python
+from plotly.express import parallel_coordinates
+
+# Create a parallel coordinates plot
+fig = parallel_coordinates(df, columns, color="metrics.mAP50-95(B)")
+
+# Display the plot
+fig.show()
+```
+
+The output of the code snippet above generates a plot that will visually represent the relationships between epochs, image size, model type, and their corresponding mAP50-95(B) scores, enabling you to spot trends and patterns in your experiment data.
+
+#### Generating Comparative Visualizations with DVC
+
+DVC provides a useful command to generate comparative plots for your experiments. This can be especially helpful to compare the performance of different models over various training runs.
+
+```bash
+# Generate DVC comparative plots
+dvc plots diff $(dvc exp list --names-only)
+```
+
+After executing this command, DVC generates plots comparing the metrics across different experiments, which are saved as HTML files. Below is an example image illustrating typical plots generated by this process. The image showcases various graphs, including those representing mAP, recall, precision, loss values, and more, providing a visual overview of key performance metrics:
+
+
+
+
+
+### Displaying DVC Plots
+
+If you are using a Jupyter Notebook and you want to display the generated DVC plots, you can use the IPython display functionality.
+
+```python
+from IPython.display import HTML
+
+# Display the DVC plots as HTML
+HTML(filename='./dvc_plots/index.html')
+```
+
+This code will render the HTML file containing the DVC plots directly in your Jupyter Notebook, providing an easy and convenient way to analyze the visualized experiment data.
+
+### Making Data-Driven Decisions
+
+Use the insights gained from these visualizations to make informed decisions about model optimizations, hyperparameter tuning, and other modifications to enhance your model's performance.
+
+### Iterating on Experiments
+
+Based on your analysis, iterate on your experiments. Adjust model configurations, training parameters, or even the data inputs, and repeat the training and analysis process. This iterative approach is key to refining your model for the best possible performance.
+
+## Summary
+
+This guide has led you through the process of integrating DVCLive with Ultralytics' YOLOv8. You have learned how to harness the power of DVCLive for detailed experiment monitoring, effective visualization, and insightful analysis in your machine learning endeavors.
+
+For further details on usage, visit [DVCLiveโs official documentation](https://dvc.org/doc/dvclive/ml-frameworks/yolo).
+
+Additionally, explore more integrations and capabilities of Ultralytics by visiting the [Ultralytics integration guide page](../integrations/index.md), which is a collection of great resources and insights.
diff --git a/ultralytics/docs/en/integrations/dvc.md:Zone.Identifier b/ultralytics/docs/en/integrations/dvc.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/dvc.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/index.md b/ultralytics/docs/en/integrations/index.md
new file mode 100755
index 0000000..3c26f85
--- /dev/null
+++ b/ultralytics/docs/en/integrations/index.md
@@ -0,0 +1,71 @@
+---
+comments: true
+description: Explore Ultralytics integrations with tools for dataset management, model optimization, ML workflows automation, experiment tracking, version control, and more. Learn about our support for various model export formats for deployment.
+keywords: Ultralytics integrations, Roboflow, Neural Magic, ClearML, Comet ML, DVC, Ultralytics HUB, MLFlow, Neptune, Ray Tune, TensorBoard, W&B, model export formats, PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, CoreML, TF SavedModel, TF GraphDef, TF Lite, TF Edge TPU, TF.js, PaddlePaddle, NCNN
+---
+
+# Ultralytics Integrations
+
+Welcome to the Ultralytics Integrations page! This page provides an overview of our partnerships with various tools and platforms, designed to streamline your machine learning workflows, enhance dataset management, simplify model training, and facilitate efficient deployment.
+
+
+
+## Datasets Integrations
+
+- [Roboflow](roboflow.md): Facilitate seamless dataset management for Ultralytics models, offering robust annotation, preprocessing, and augmentation capabilities.
+
+## Training Integrations
+
+- [Comet ML](comet.md): Enhance your model development with Ultralytics by tracking, comparing, and optimizing your machine learning experiments.
+
+- [ClearML](clearml.md): Automate your Ultralytics ML workflows, monitor experiments, and foster team collaboration.
+
+- [DVC](dvc.md): Implement version control for your Ultralytics machine learning projects, synchronizing data, code, and models effectively.
+
+- [Ultralytics HUB](https://hub.ultralytics.com): Access and contribute to a community of pre-trained Ultralytics models.
+
+- [MLFlow](mlflow.md): Streamline the entire ML lifecycle of Ultralytics models, from experimentation and reproducibility to deployment.
+
+- [Neptune](https://neptune.ai/): Maintain a comprehensive log of your ML experiments with Ultralytics in this metadata store designed for MLOps.
+
+- [Ray Tune](ray-tune.md): Optimize the hyperparameters of your Ultralytics models at any scale.
+
+- [TensorBoard](https://tensorboard.dev/): Visualize your Ultralytics ML workflows, monitor model metrics, and foster team collaboration.
+
+- [Weights & Biases (W&B)](https://wandb.ai/site): Monitor experiments, visualize metrics, and foster reproducibility and collaboration on Ultralytics projects.
+
+## Deployment Integrations
+
+- [Neural Magic](https://neuralmagic.com/): Leverage Quantization Aware Training (QAT) and pruning techniques to optimize Ultralytics models for superior performance and leaner size.
+
+### Export Formats
+
+We also support a variety of model export formats for deployment in different environments. Here are the available formats:
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](openvino.md) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half`, `int8` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras`, `int8` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [NCNN](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
+
+Explore the links to learn more about each integration and how to get the most out of them with Ultralytics.
+
+## Contribute to Our Integrations
+
+We're always excited to see how the community integrates Ultralytics YOLO with other technologies, tools, and platforms! If you have successfully integrated YOLO with a new system or have valuable insights to share, consider contributing to our Integrations Docs.
+
+By writing a guide or tutorial, you can help expand our documentation and provide real-world examples that benefit the community. It's an excellent way to contribute to the growing ecosystem around Ultralytics YOLO.
+
+To contribute, please check out our [Contributing Guide](https://docs.ultralytics.com/help/contributing) for instructions on how to submit a Pull Request (PR) ๐ ๏ธ. We eagerly await your contributions!
+
+Let's collaborate to make the Ultralytics YOLO ecosystem more expansive and feature-rich ๐!
diff --git a/ultralytics/docs/en/integrations/index.md:Zone.Identifier b/ultralytics/docs/en/integrations/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/mlflow.md b/ultralytics/docs/en/integrations/mlflow.md
new file mode 100755
index 0000000..58052df
--- /dev/null
+++ b/ultralytics/docs/en/integrations/mlflow.md
@@ -0,0 +1,112 @@
+---
+comments: true
+description: Uncover the utility of MLflow for effective experiment logging in your Ultralytics YOLO projects.
+keywords: ultralytics docs, YOLO, MLflow, experiment logging, metrics tracking, parameter logging, artifact logging
+---
+
+# MLflow Integration for Ultralytics YOLO
+
+
+
+## Introduction
+
+Experiment logging is a crucial aspect of machine learning workflows that enables tracking of various metrics, parameters, and artifacts. It helps to enhance model reproducibility, debug issues, and improve model performance. [Ultralytics](https://ultralytics.com) YOLO, known for its real-time object detection capabilities, now offers integration with [MLflow](https://mlflow.org/), an open-source platform for complete machine learning lifecycle management.
+
+This documentation page is a comprehensive guide to setting up and utilizing the MLflow logging capabilities for your Ultralytics YOLO project.
+
+## What is MLflow?
+
+[MLflow](https://mlflow.org/) is an open-source platform developed by [Databricks](https://www.databricks.com/) for managing the end-to-end machine learning lifecycle. It includes tools for tracking experiments, packaging code into reproducible runs, and sharing and deploying models. MLflow is designed to work with any machine learning library and programming language.
+
+## Features
+
+- **Metrics Logging**: Logs metrics at the end of each epoch and at the end of the training.
+- **Parameter Logging**: Logs all the parameters used in the training.
+- **Artifacts Logging**: Logs model artifacts, including weights and configuration files, at the end of the training.
+
+## Setup and Prerequisites
+
+Ensure MLflow is installed. If not, install it using pip:
+
+```bash
+pip install mlflow
+```
+
+Make sure that MLflow logging is enabled in Ultralytics settings. Usually, this is controlled by the settings `mflow` key. See the [settings](https://docs.ultralytics.com/quickstart/#ultralytics-settings) page for more info.
+
+!!! Example "Update Ultralytics MLflow Settings"
+
+ === "Python"
+ Within the Python environment, call the `update` method on the `settings` object to change your settings:
+ ```python
+ from ultralytics import settings
+
+ # Update a setting
+ settings.update({'mlflow': True})
+
+ # Reset settings to default values
+ settings.reset()
+ ```
+
+ === "CLI"
+ If you prefer using the command-line interface, the following commands will allow you to modify your settings:
+ ```bash
+ # Update a setting
+ yolo settings runs_dir='/path/to/runs'
+
+ # Reset settings to default values
+ yolo settings reset
+ ```
+
+## How to Use
+
+### Commands
+
+1. **Set a Project Name**: You can set the project name via an environment variable:
+ ```bash
+ export MLFLOW_EXPERIMENT_NAME=
+ ```
+ Or use the `project=` argument when training a YOLO model, i.e. `yolo train project=my_project`.
+
+2. **Set a Run Name**: Similar to setting a project name, you can set the run name via an environment variable:
+ ```bash
+ export MLFLOW_RUN=
+ ```
+ Or use the `name=` argument when training a YOLO model, i.e. `yolo train project=my_project name=my_name`.
+
+3. **Start Local MLflow Server**: To start tracking, use:
+ ```bash
+ mlflow server --backend-store-uri runs/mlflow'
+ ```
+ This will start a local server at http://127.0.0.1:5000 by default and save all mlflow logs to the 'runs/mlflow' directory. To specify a different URI, set the `MLFLOW_TRACKING_URI` environment variable.
+
+4. **Kill MLflow Server Instances**: To stop all running MLflow instances, run:
+ ```bash
+ ps aux | grep 'mlflow' | grep -v 'grep' | awk '{print $2}' | xargs kill -9
+ ```
+
+### Logging
+
+The logging is taken care of by the `on_pretrain_routine_end`, `on_fit_epoch_end`, and `on_train_end` callback functions. These functions are automatically called during the respective stages of the training process, and they handle the logging of parameters, metrics, and artifacts.
+
+## Examples
+
+1. **Logging Custom Metrics**: You can add custom metrics to be logged by modifying the `trainer.metrics` dictionary before `on_fit_epoch_end` is called.
+
+2. **View Experiment**: To view your logs, navigate to your MLflow server (usually http://127.0.0.1:5000) and select your experiment and run.
+
+
+3. **View Run**: Runs are individual models inside an experiment. Click on a Run and see the Run details, including uploaded artifacts and model weights.
+
+
+## Disabling MLflow
+
+To turn off MLflow logging:
+
+```bash
+yolo settings mlflow=False
+```
+
+## Conclusion
+
+MLflow logging integration with Ultralytics YOLO offers a streamlined way to keep track of your machine learning experiments. It empowers you to monitor performance metrics and manage artifacts effectively, thus aiding in robust model development and deployment. For further details please visit the MLflow [official documentation](https://mlflow.org/docs/latest/index.html).
diff --git a/ultralytics/docs/en/integrations/mlflow.md:Zone.Identifier b/ultralytics/docs/en/integrations/mlflow.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/mlflow.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/openvino.md b/ultralytics/docs/en/integrations/openvino.md
new file mode 100755
index 0000000..6f552ff
--- /dev/null
+++ b/ultralytics/docs/en/integrations/openvino.md
@@ -0,0 +1,284 @@
+---
+comments: true
+description: Discover the power of deploying your Ultralytics YOLOv8 model using OpenVINO format for up to 10x speedup vs PyTorch.
+keywords: ultralytics docs, YOLOv8, export YOLOv8, YOLOv8 model deployment, exporting YOLOv8, OpenVINO, OpenVINO format
+---
+
+# Intel OpenVINO Export
+
+
+
+In this guide, we cover exporting YOLOv8 models to the [OpenVINO](https://docs.openvino.ai/) format, which can provide up to 3x [CPU](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_supported_plugins_CPU.html) speedup as well as accelerating on other Intel hardware ([iGPU](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_supported_plugins_GPU.html), [dGPU](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_supported_plugins_GPU.html), [VPU](https://docs.openvino.ai/2022.3/openvino_docs_OV_UG_supported_plugins_VPU.html), etc.).
+
+OpenVINO, short for Open Visual Inference & Neural Network Optimization toolkit, is a comprehensive toolkit for optimizing and deploying AI inference models. Even though the name contains Visual, OpenVINO also supports various additional tasks including language, audio, time series, etc.
+
+
+
+
+
+ Watch: How To Export and Optimize an Ultralytics YOLOv8 Model for Inference with OpenVINO.
+
+
+## Usage Examples
+
+Export a YOLOv8n model to OpenVINO format and run inference with the exported model.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a YOLOv8n PyTorch model
+ model = YOLO('yolov8n.pt')
+
+ # Export the model
+ model.export(format='openvino') # creates 'yolov8n_openvino_model/'
+
+ # Load the exported OpenVINO model
+ ov_model = YOLO('yolov8n_openvino_model/')
+
+ # Run inference
+ results = ov_model('https://ultralytics.com/images/bus.jpg')
+ ```
+ === "CLI"
+
+ ```bash
+ # Export a YOLOv8n PyTorch model to OpenVINO format
+ yolo export model=yolov8n.pt format=openvino # creates 'yolov8n_openvino_model/'
+
+ # Run inference with the exported model
+ yolo predict model=yolov8n_openvino_model source='https://ultralytics.com/images/bus.jpg'
+ ```
+
+## Arguments
+
+| Key | Value | Description |
+|----------|--------------|------------------------------------------------------|
+| `format` | `'openvino'` | format to export to |
+| `imgsz` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `half` | `False` | FP16 quantization |
+
+## Benefits of OpenVINO
+
+1. **Performance**: OpenVINO delivers high-performance inference by utilizing the power of Intel CPUs, integrated and discrete GPUs, and FPGAs.
+2. **Support for Heterogeneous Execution**: OpenVINO provides an API to write once and deploy on any supported Intel hardware (CPU, GPU, FPGA, VPU, etc.).
+3. **Model Optimizer**: OpenVINO provides a Model Optimizer that imports, converts, and optimizes models from popular deep learning frameworks such as PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle, and Caffe.
+4. **Ease of Use**: The toolkit comes with more than [80 tutorial notebooks](https://github.com/openvinotoolkit/openvino_notebooks) (including [YOLOv8 optimization](https://github.com/openvinotoolkit/openvino_notebooks/tree/main/notebooks/230-yolov8-optimization)) teaching different aspects of the toolkit.
+
+## OpenVINO Export Structure
+
+When you export a model to OpenVINO format, it results in a directory containing the following:
+
+1. **XML file**: Describes the network topology.
+2. **BIN file**: Contains the weights and biases binary data.
+3. **Mapping file**: Holds mapping of original model output tensors to OpenVINO tensor names.
+
+You can use these files to run inference with the OpenVINO Inference Engine.
+
+## Using OpenVINO Export in Deployment
+
+Once you have the OpenVINO files, you can use the OpenVINO Runtime to run the model. The Runtime provides a unified API to inference across all supported Intel hardware. It also provides advanced capabilities like load balancing across Intel hardware and asynchronous execution. For more information on running the inference, refer to the [Inference with OpenVINO Runtime Guide](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_OV_Runtime_User_Guide.html).
+
+Remember, you'll need the XML and BIN files as well as any application-specific settings like input size, scale factor for normalization, etc., to correctly set up and use the model with the Runtime.
+
+In your deployment application, you would typically do the following steps:
+
+1. Initialize OpenVINO by creating `core = Core()`.
+2. Load the model using the `core.read_model()` method.
+3. Compile the model using the `core.compile_model()` function.
+4. Prepare the input (image, text, audio, etc.).
+5. Run inference using `compiled_model(input_data)`.
+
+For more detailed steps and code snippets, refer to the [OpenVINO documentation](https://docs.openvino.ai/) or [API tutorial](https://github.com/openvinotoolkit/openvino_notebooks/blob/main/notebooks/002-openvino-api/002-openvino-api.ipynb).
+
+## OpenVINO YOLOv8 Benchmarks
+
+YOLOv8 benchmarks below were run by the Ultralytics team on 4 different model formats measuring speed and accuracy: PyTorch, TorchScript, ONNX and OpenVINO. Benchmarks were run on Intel Flex and Arc GPUs, and on Intel Xeon CPUs at FP32 precision (with the `half=False` argument).
+
+!!! Note
+
+ The benchmarking results below are for reference and might vary based on the exact hardware and software configuration of a system, as well as the current workload of the system at the time the benchmarks are run.
+
+ All benchmarks run with `openvino` Python package version [2023.0.1](https://pypi.org/project/openvino/2023.0.1/).
+
+### Intel Flex GPU
+
+The Intelยฎ Data Center GPU Flex Series is a versatile and robust solution designed for the intelligent visual cloud. This GPU supports a wide array of workloads including media streaming, cloud gaming, AI visual inference, and virtual desktop Infrastructure workloads. It stands out for its open architecture and built-in support for the AV1 encode, providing a standards-based software stack for high-performance, cross-architecture applications. The Flex Series GPU is optimized for density and quality, offering high reliability, availability, and scalability.
+
+Benchmarks below run on Intelยฎ Data Center GPU Flex 170 at FP32 precision.
+
+
+
+
+
+| Model | Format | Status | Size (MB) | mAP50-95(B) | Inference time (ms/im) |
+|---------|-------------|--------|-----------|-------------|------------------------|
+| YOLOv8n | PyTorch | โ | 6.2 | 0.3709 | 21.79 |
+| YOLOv8n | TorchScript | โ | 12.4 | 0.3704 | 23.24 |
+| YOLOv8n | ONNX | โ | 12.2 | 0.3704 | 37.22 |
+| YOLOv8n | OpenVINO | โ | 12.3 | 0.3703 | 3.29 |
+| YOLOv8s | PyTorch | โ | 21.5 | 0.4471 | 31.89 |
+| YOLOv8s | TorchScript | โ | 42.9 | 0.4472 | 32.71 |
+| YOLOv8s | ONNX | โ | 42.8 | 0.4472 | 43.42 |
+| YOLOv8s | OpenVINO | โ | 42.9 | 0.4470 | 3.92 |
+| YOLOv8m | PyTorch | โ | 49.7 | 0.5013 | 50.75 |
+| YOLOv8m | TorchScript | โ | 99.2 | 0.4999 | 47.90 |
+| YOLOv8m | ONNX | โ | 99.0 | 0.4999 | 63.16 |
+| YOLOv8m | OpenVINO | โ | 49.8 | 0.4997 | 7.11 |
+| YOLOv8l | PyTorch | โ | 83.7 | 0.5293 | 77.45 |
+| YOLOv8l | TorchScript | โ | 167.2 | 0.5268 | 85.71 |
+| YOLOv8l | ONNX | โ | 166.8 | 0.5268 | 88.94 |
+| YOLOv8l | OpenVINO | โ | 167.0 | 0.5264 | 9.37 |
+| YOLOv8x | PyTorch | โ | 130.5 | 0.5404 | 100.09 |
+| YOLOv8x | TorchScript | โ | 260.7 | 0.5371 | 114.64 |
+| YOLOv8x | ONNX | โ | 260.4 | 0.5371 | 110.32 |
+| YOLOv8x | OpenVINO | โ | 260.6 | 0.5367 | 15.02 |
+
+This table represents the benchmark results for five different models (YOLOv8n, YOLOv8s, YOLOv8m, YOLOv8l, YOLOv8x) across four different formats (PyTorch, TorchScript, ONNX, OpenVINO), giving us the status, size, mAP50-95(B) metric, and inference time for each combination.
+
+### Intel Arc GPU
+
+Intelยฎ Arcโข represents Intel's foray into the dedicated GPU market. The Arcโข series, designed to compete with leading GPU manufacturers like AMD and Nvidia, caters to both the laptop and desktop markets. The series includes mobile versions for compact devices like laptops, and larger, more powerful versions for desktop computers.
+
+The Arcโข series is divided into three categories: Arcโข 3, Arcโข 5, and Arcโข 7, with each number indicating the performance level. Each category includes several models, and the 'M' in the GPU model name signifies a mobile, integrated variant.
+
+Early reviews have praised the Arcโข series, particularly the integrated A770M GPU, for its impressive graphics performance. The availability of the Arcโข series varies by region, and additional models are expected to be released soon. Intelยฎ Arcโข GPUs offer high-performance solutions for a range of computing needs, from gaming to content creation.
+
+Benchmarks below run on Intelยฎ Arc 770 GPU at FP32 precision.
+
+
+
+
+
+| Model | Format | Status | Size (MB) | metrics/mAP50-95(B) | Inference time (ms/im) |
+|---------|-------------|--------|-----------|---------------------|------------------------|
+| YOLOv8n | PyTorch | โ | 6.2 | 0.3709 | 88.79 |
+| YOLOv8n | TorchScript | โ | 12.4 | 0.3704 | 102.66 |
+| YOLOv8n | ONNX | โ | 12.2 | 0.3704 | 57.98 |
+| YOLOv8n | OpenVINO | โ | 12.3 | 0.3703 | 8.52 |
+| YOLOv8s | PyTorch | โ | 21.5 | 0.4471 | 189.83 |
+| YOLOv8s | TorchScript | โ | 42.9 | 0.4472 | 227.58 |
+| YOLOv8s | ONNX | โ | 42.7 | 0.4472 | 142.03 |
+| YOLOv8s | OpenVINO | โ | 42.9 | 0.4469 | 9.19 |
+| YOLOv8m | PyTorch | โ | 49.7 | 0.5013 | 411.64 |
+| YOLOv8m | TorchScript | โ | 99.2 | 0.4999 | 517.12 |
+| YOLOv8m | ONNX | โ | 98.9 | 0.4999 | 298.68 |
+| YOLOv8m | OpenVINO | โ | 99.1 | 0.4996 | 12.55 |
+| YOLOv8l | PyTorch | โ | 83.7 | 0.5293 | 725.73 |
+| YOLOv8l | TorchScript | โ | 167.1 | 0.5268 | 892.83 |
+| YOLOv8l | ONNX | โ | 166.8 | 0.5268 | 576.11 |
+| YOLOv8l | OpenVINO | โ | 167.0 | 0.5262 | 17.62 |
+| YOLOv8x | PyTorch | โ | 130.5 | 0.5404 | 988.92 |
+| YOLOv8x | TorchScript | โ | 260.7 | 0.5371 | 1186.42 |
+| YOLOv8x | ONNX | โ | 260.4 | 0.5371 | 768.90 |
+| YOLOv8x | OpenVINO | โ | 260.6 | 0.5367 | 19 |
+
+### Intel Xeon CPU
+
+The Intelยฎ Xeonยฎ CPU is a high-performance, server-grade processor designed for complex and demanding workloads. From high-end cloud computing and virtualization to artificial intelligence and machine learning applications, Xeonยฎ CPUs provide the power, reliability, and flexibility required for today's data centers.
+
+Notably, Xeonยฎ CPUs deliver high compute density and scalability, making them ideal for both small businesses and large enterprises. By choosing Intelยฎ Xeonยฎ CPUs, organizations can confidently handle their most demanding computing tasks and foster innovation while maintaining cost-effectiveness and operational efficiency.
+
+Benchmarks below run on 4th Gen Intelยฎ Xeonยฎ Scalable CPU at FP32 precision.
+
+
+
+| Model | Format | Status | Size (MB) | metrics/mAP50-95(B) | Inference time (ms/im) |
+|---------|-------------|--------|-----------|---------------------|------------------------|
+| YOLOv8n | PyTorch | โ | 6.2 | 0.4478 | 104.61 |
+| YOLOv8n | TorchScript | โ | 12.4 | 0.4525 | 112.39 |
+| YOLOv8n | ONNX | โ | 12.2 | 0.4525 | 28.02 |
+| YOLOv8n | OpenVINO | โ | 12.3 | 0.4504 | 23.53 |
+| YOLOv8s | PyTorch | โ | 21.5 | 0.5885 | 194.83 |
+| YOLOv8s | TorchScript | โ | 43.0 | 0.5962 | 202.01 |
+| YOLOv8s | ONNX | โ | 42.8 | 0.5962 | 65.74 |
+| YOLOv8s | OpenVINO | โ | 42.9 | 0.5966 | 38.66 |
+| YOLOv8m | PyTorch | โ | 49.7 | 0.6101 | 355.23 |
+| YOLOv8m | TorchScript | โ | 99.2 | 0.6120 | 424.78 |
+| YOLOv8m | ONNX | โ | 99.0 | 0.6120 | 173.39 |
+| YOLOv8m | OpenVINO | โ | 99.1 | 0.6091 | 69.80 |
+| YOLOv8l | PyTorch | โ | 83.7 | 0.6591 | 593.00 |
+| YOLOv8l | TorchScript | โ | 167.2 | 0.6580 | 697.54 |
+| YOLOv8l | ONNX | โ | 166.8 | 0.6580 | 342.15 |
+| YOLOv8l | OpenVINO | โ | 167.0 | 0.0708 | 117.69 |
+| YOLOv8x | PyTorch | โ | 130.5 | 0.6651 | 804.65 |
+| YOLOv8x | TorchScript | โ | 260.8 | 0.6650 | 921.46 |
+| YOLOv8x | ONNX | โ | 260.4 | 0.6650 | 526.66 |
+| YOLOv8x | OpenVINO | โ | 260.6 | 0.6619 | 158.73 |
+
+## Reproduce Our Results
+
+To reproduce the Ultralytics benchmarks above on all export [formats](../modes/export.md) run this code:
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a YOLOv8n PyTorch model
+ model = YOLO('yolov8n.pt')
+
+ # Benchmark YOLOv8n speed and accuracy on the COCO128 dataset for all all export formats
+ results= model.benchmarks(data='coco128.yaml')
+ ```
+ === "CLI"
+
+ ```bash
+ # Benchmark YOLOv8n speed and accuracy on the COCO128 dataset for all all export formats
+ yolo benchmark model=yolov8n.pt data=coco128.yaml
+ ```
+
+ Note that benchmarking results might vary based on the exact hardware and software configuration of a system, as well as the current workload of the system at the time the benchmarks are run. For the most reliable results use a dataset with a large number of images, i.e. `data='coco128.yaml' (128 val images), or `data='coco.yaml'` (5000 val images).
+
+## Conclusion
+
+The benchmarking results clearly demonstrate the benefits of exporting the YOLOv8 model to the OpenVINO format. Across different models and hardware platforms, the OpenVINO format consistently outperforms other formats in terms of inference speed while maintaining comparable accuracy.
+
+For the Intelยฎ Data Center GPU Flex Series, the OpenVINO format was able to deliver inference speeds almost 10 times faster than the original PyTorch format. On the Xeon CPU, the OpenVINO format was twice as fast as the PyTorch format. The accuracy of the models remained nearly identical across the different formats.
+
+The benchmarks underline the effectiveness of OpenVINO as a tool for deploying deep learning models. By converting models to the OpenVINO format, developers can achieve significant performance improvements, making it easier to deploy these models in real-world applications.
+
+For more detailed information and instructions on using OpenVINO, refer to the [official OpenVINO documentation](https://docs.openvino.ai/).
diff --git a/ultralytics/docs/en/integrations/openvino.md:Zone.Identifier b/ultralytics/docs/en/integrations/openvino.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/openvino.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/ray-tune.md b/ultralytics/docs/en/integrations/ray-tune.md
new file mode 100755
index 0000000..3825cf7
--- /dev/null
+++ b/ultralytics/docs/en/integrations/ray-tune.md
@@ -0,0 +1,179 @@
+---
+comments: true
+description: Discover how to streamline hyperparameter tuning for YOLOv8 models with Ray Tune. Learn to accelerate tuning, integrate with Weights & Biases, and analyze results.
+keywords: Ultralytics, YOLOv8, Ray Tune, hyperparameter tuning, machine learning optimization, Weights & Biases integration, result analysis
+---
+
+# Efficient Hyperparameter Tuning with Ray Tune and YOLOv8
+
+Hyperparameter tuning is vital in achieving peak model performance by discovering the optimal set of hyperparameters. This involves running trials with different hyperparameters and evaluating each trialโs performance.
+
+## Accelerate Tuning with Ultralytics YOLOv8 and Ray Tune
+
+[Ultralytics YOLOv8](https://ultralytics.com) incorporates Ray Tune for hyperparameter tuning, streamlining the optimization of YOLOv8 model hyperparameters. With Ray Tune, you can utilize advanced search strategies, parallelism, and early stopping to expedite the tuning process.
+
+### Ray Tune
+
+
+
+
+
+[Ray Tune](https://docs.ray.io/en/latest/tune/index.html) is a hyperparameter tuning library designed for efficiency and flexibility. It supports various search strategies, parallelism, and early stopping strategies, and seamlessly integrates with popular machine learning frameworks, including Ultralytics YOLOv8.
+
+### Integration with Weights & Biases
+
+YOLOv8 also allows optional integration with [Weights & Biases](https://wandb.ai/site) for monitoring the tuning process.
+
+## Installation
+
+To install the required packages, run:
+
+!!! Tip "Installation"
+
+ === "CLI"
+
+ ```bash
+ # Install and update Ultralytics and Ray Tune packages
+ pip install -U ultralytics "ray[tune]"
+
+ # Optionally install W&B for logging
+ pip install wandb
+ ```
+
+## Usage
+
+!!! Example "Usage"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Start tuning hyperparameters for YOLOv8n training on the COCO8 dataset
+ result_grid = model.tune(data='coco8.yaml', use_ray=True)
+ ```
+
+## `tune()` Method Parameters
+
+The `tune()` method in YOLOv8 provides an easy-to-use interface for hyperparameter tuning with Ray Tune. It accepts several arguments that allow you to customize the tuning process. Below is a detailed explanation of each parameter:
+
+| Parameter | Type | Description | Default Value |
+|-----------------|------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------|
+| `data` | `str` | The dataset configuration file (in YAML format) to run the tuner on. This file should specify the training and validation data paths, as well as other dataset-specific settings. | |
+| `space` | `dict, optional` | A dictionary defining the hyperparameter search space for Ray Tune. Each key corresponds to a hyperparameter name, and the value specifies the range of values to explore during tuning. If not provided, YOLOv8 uses a default search space with various hyperparameters. | |
+| `grace_period` | `int, optional` | The grace period in epochs for the [ASHA scheduler](https://docs.ray.io/en/latest/tune/api/schedulers.html) in Ray Tune. The scheduler will not terminate any trial before this number of epochs, allowing the model to have some minimum training before making a decision on early stopping. | 10 |
+| `gpu_per_trial` | `int, optional` | The number of GPUs to allocate per trial during tuning. This helps manage GPU usage, particularly in multi-GPU environments. If not provided, the tuner will use all available GPUs. | None |
+| `iterations` | `int, optional` | The maximum number of trials to run during tuning. This parameter helps control the total number of hyperparameter combinations tested, ensuring the tuning process does not run indefinitely. | 10 |
+| `**train_args` | `dict, optional` | Additional arguments to pass to the `train()` method during tuning. These arguments can include settings like the number of training epochs, batch size, and other training-specific configurations. | {} |
+
+By customizing these parameters, you can fine-tune the hyperparameter optimization process to suit your specific needs and available computational resources.
+
+## Default Search Space Description
+
+The following table lists the default search space parameters for hyperparameter tuning in YOLOv8 with Ray Tune. Each parameter has a specific value range defined by `tune.uniform()`.
+
+| Parameter | Value Range | Description |
+|-------------------|----------------------------|------------------------------------------|
+| `lr0` | `tune.uniform(1e-5, 1e-1)` | Initial learning rate |
+| `lrf` | `tune.uniform(0.01, 1.0)` | Final learning rate factor |
+| `momentum` | `tune.uniform(0.6, 0.98)` | Momentum |
+| `weight_decay` | `tune.uniform(0.0, 0.001)` | Weight decay |
+| `warmup_epochs` | `tune.uniform(0.0, 5.0)` | Warmup epochs |
+| `warmup_momentum` | `tune.uniform(0.0, 0.95)` | Warmup momentum |
+| `box` | `tune.uniform(0.02, 0.2)` | Box loss weight |
+| `cls` | `tune.uniform(0.2, 4.0)` | Class loss weight |
+| `hsv_h` | `tune.uniform(0.0, 0.1)` | Hue augmentation range |
+| `hsv_s` | `tune.uniform(0.0, 0.9)` | Saturation augmentation range |
+| `hsv_v` | `tune.uniform(0.0, 0.9)` | Value (brightness) augmentation range |
+| `degrees` | `tune.uniform(0.0, 45.0)` | Rotation augmentation range (degrees) |
+| `translate` | `tune.uniform(0.0, 0.9)` | Translation augmentation range |
+| `scale` | `tune.uniform(0.0, 0.9)` | Scaling augmentation range |
+| `shear` | `tune.uniform(0.0, 10.0)` | Shear augmentation range (degrees) |
+| `perspective` | `tune.uniform(0.0, 0.001)` | Perspective augmentation range |
+| `flipud` | `tune.uniform(0.0, 1.0)` | Vertical flip augmentation probability |
+| `fliplr` | `tune.uniform(0.0, 1.0)` | Horizontal flip augmentation probability |
+| `mosaic` | `tune.uniform(0.0, 1.0)` | Mosaic augmentation probability |
+| `mixup` | `tune.uniform(0.0, 1.0)` | Mixup augmentation probability |
+| `copy_paste` | `tune.uniform(0.0, 1.0)` | Copy-paste augmentation probability |
+
+## Custom Search Space Example
+
+In this example, we demonstrate how to use a custom search space for hyperparameter tuning with Ray Tune and YOLOv8. By providing a custom search space, you can focus the tuning process on specific hyperparameters of interest.
+
+!!! Example "Usage"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Define a YOLO model
+ model = YOLO("yolov8n.pt")
+
+ # Run Ray Tune on the model
+ result_grid = model.tune(data="coco128.yaml",
+ space={"lr0": tune.uniform(1e-5, 1e-1)},
+ epochs=50,
+ use_ray=True)
+ ```
+
+In the code snippet above, we create a YOLO model with the "yolov8n.pt" pretrained weights. Then, we call the `tune()` method, specifying the dataset configuration with "coco128.yaml". We provide a custom search space for the initial learning rate `lr0` using a dictionary with the key "lr0" and the value `tune.uniform(1e-5, 1e-1)`. Finally, we pass additional training arguments, such as the number of epochs directly to the tune method as `epochs=50`.
+
+## Processing Ray Tune Results
+
+After running a hyperparameter tuning experiment with Ray Tune, you might want to perform various analyses on the obtained results. This guide will take you through common workflows for processing and analyzing these results.
+
+### Loading Tune Experiment Results from a Directory
+
+After running the tuning experiment with `tuner.fit()`, you can load the results from a directory. This is useful, especially if you're performing the analysis after the initial training script has exited.
+
+```python
+experiment_path = f"{storage_path}/{exp_name}"
+print(f"Loading results from {experiment_path}...")
+
+restored_tuner = tune.Tuner.restore(experiment_path, trainable=train_mnist)
+result_grid = restored_tuner.get_results()
+```
+
+### Basic Experiment-Level Analysis
+
+Get an overview of how trials performed. You can quickly check if there were any errors during the trials.
+
+```python
+if result_grid.errors:
+ print("One or more trials failed!")
+else:
+ print("No errors!")
+```
+
+### Basic Trial-Level Analysis
+
+Access individual trial hyperparameter configurations and the last reported metrics.
+
+```python
+for i, result in enumerate(result_grid):
+ print(f"Trial #{i}: Configuration: {result.config}, Last Reported Metrics: {result.metrics}")
+```
+
+### Plotting the Entire History of Reported Metrics for a Trial
+
+You can plot the history of reported metrics for each trial to see how the metrics evolved over time.
+
+```python
+import matplotlib.pyplot as plt
+
+for result in result_grid:
+ plt.plot(result.metrics_dataframe["training_iteration"], result.metrics_dataframe["mean_accuracy"], label=f"Trial {i}")
+
+plt.xlabel('Training Iterations')
+plt.ylabel('Mean Accuracy')
+plt.legend()
+plt.show()
+```
+
+## Summary
+
+In this documentation, we covered common workflows to analyze the results of experiments run with Ray Tune using Ultralytics. The key steps include loading the experiment results from a directory, performing basic experiment-level and trial-level analysis and plotting metrics.
+
+Explore further by looking into Ray Tuneโs [Analyze Results](https://docs.ray.io/en/latest/tune/examples/tune_analyze_results.html) docs page to get the most out of your hyperparameter tuning experiments.
diff --git a/ultralytics/docs/en/integrations/ray-tune.md:Zone.Identifier b/ultralytics/docs/en/integrations/ray-tune.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/ray-tune.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/integrations/roboflow.md b/ultralytics/docs/en/integrations/roboflow.md
new file mode 100755
index 0000000..b0bfb54
--- /dev/null
+++ b/ultralytics/docs/en/integrations/roboflow.md
@@ -0,0 +1,239 @@
+---
+comments: true
+description: Learn how to use Roboflow with Ultralytics for labeling and managing images for use in training, and for evaluating model performance.
+keywords: Ultralytics, YOLOv8, Roboflow, vector analysis, confusion matrix, data management, image labeling
+---
+
+# Roboflow
+
+[Roboflow](https://roboflow.com/?ref=ultralytics) has everything you need to build and deploy computer vision models. Connect Roboflow at any step in your pipeline with APIs and SDKs, or use the end-to-end interface to automate the entire process from image to inference. Whether youโre in need of [data labeling](https://roboflow.com/annotate?ref=ultralytics), [model training](https://roboflow.com/train?ref=ultralytics), or [model deployment](https://roboflow.com/deploy?ref=ultralytics), Roboflow gives you building blocks to bring custom computer vision solutions to your project.
+
+!!! Warning
+
+ Roboflow users can use Ultralytics under the [AGPL license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) or procure an [Enterprise license](https://ultralytics.com/license) directly from Ultralytics. Be aware that Roboflow does **not** provide Ultralytics licenses, and it is the responsibility of the user to ensure appropriate licensing.
+
+In this guide, we are going to showcase how to find, label, and organize data for use in training a custom Ultralytics YOLOv8 model. Use the table of contents below to jump directly to a specific section:
+
+- Gather data for training a custom YOLOv8 model
+- Upload, convert and label data for YOLOv8 format
+- Pre-process and augment data for model robustness
+- Dataset management for [YOLOv8](https://docs.ultralytics.com/models/yolov8/)
+- Export data in 40+ formats for model training
+- Upload custom YOLOv8 model weights for testing and deployment
+- Gather Data for Training a Custom YOLOv8 Model
+
+Roboflow provides two services that can help you collect data for YOLOv8 models: [Universe](https://universe.roboflow.com/?ref=ultralytics) and [Collect](https://roboflow.com/collect?ref=ultralytics).
+
+Universe is an online repository with over 250,000 vision datasets totalling over 100 million images.
+
+
+
+
+
+With a [free Roboflow account](https://app.roboflow.com/?ref=ultralytics), you can export any dataset available on Universe. To export a dataset, click the "Download this Dataset" button on any dataset.
+
+
+
+
+
+
+For YOLOv8, select "YOLOv8" as the export format:
+
+
+
+
+
+Universe also has a page that aggregates all [public fine-tuned YOLOv8 models uploaded to Roboflow](https://universe.roboflow.com/search?q=model:yolov8). You can use this page to explore pre-trained models you can use for testing or [for automated data labeling](https://docs.roboflow.com/annotate/use-roboflow-annotate/model-assisted-labeling) or to prototype with [Roboflow inference](https://roboflow.com/inference?ref=ultralytics).
+
+If you want to gather images yourself, try [Collect](https://github.com/roboflow/roboflow-collect), an open source project that allows you to automatically gather images using a webcam on the edge. You can use text or image prompts with Collect to instruct what data should be collected, allowing you to capture only the useful data you need to build your vision model.
+
+## Upload, Convert and Label Data for YOLOv8 Format
+
+[Roboflow Annotate](https://docs.roboflow.com/annotate/use-roboflow-annotate) is an online annotation tool for use in labeling images for object detection, classification, and segmentation.
+
+To label data for a YOLOv8 object detection, instance segmentation, or classification model, first create a project in Roboflow.
+
+
+
+
+
+Next, upload your images, and any pre-existing annotations you have from other tools ([using one of the 40+ supported import formats](https://roboflow.com/formats?ref=ultralytics)), into Roboflow.
+
+
+
+
+
+Select the batch of images you have uploaded on the Annotate page to which you are taken after uploading images. Then, click "Start Annotating" to label images.
+
+To label with bounding boxes, press the `B` key on your keyboard or click the box icon in the sidebar. Click on a point where you want to start your bounding box, then drag to create the box:
+
+
+
+
+
+A pop-up will appear asking you to select a class for your annotation once you have created an annotation.
+
+To label with polygons, press the `P` key on your keyboard, or the polygon icon in the sidebar. With the polygon annotation tool enabled, click on individual points in the image to draw a polygon.
+
+Roboflow offers a SAM-based label assistant with which you can label images faster than ever. SAM (Segment Anything Model) is a state-of-the-art computer vision model that can precisely label images. With SAM, you can significantly speed up the image labeling process. Annotating images with polygons becomes as simple as a few clicks, rather than the tedious process of precisely clicking points around an object.
+
+To use the label assistant, click the cursor icon in the sidebar, SAM will be loaded for use in your project.
+
+
+
+
+
+Hover over any object in the image and SAM will recommend an annotation. You can hover to find the right place to annotate, then click to create your annotation. To amend your annotation to be more or less specific, you can click inside or outside the annotation SAM has created on the document.
+
+You can also add tags to images from the Tags panel in the sidebar. You can apply tags to data from a particular area, taken from a specific camera, and more. You can then use these tags to search through data for images matching a tag and generate versions of a dataset with images that contain a particular tag or set of tags.
+
+
+
+
+
+Models hosted on Roboflow can be used with Label Assist, an automated annotation tool that uses your YOLOv8 model to recommend annotations. To use Label Assist, first upload a YOLOv8 model to Roboflow (see instructions later in the guide). Then, click the magic wand icon in the left sidebar and select your model for use in Label Assist.
+
+Choose a model, then click "Continue" to enable Label Assist:
+
+
+
+
+
+When you open new images for annotation, Label Assist will trigger and recommend annotations.
+
+
+
+
+
+## Dataset Management for YOLOv8
+
+Roboflow provides a suite of tools for understanding computer vision datasets.
+
+First, you can use dataset search to find images that meet a semantic text description (i.e. find all images that contain people), or that meet a specified label (i.e. the image is associated with a specific tag). To use dataset search, click "Dataset" in the sidebar. Then, input a search query using the search bar and associated filters at the top of the page.
+
+For example, the following text query finds images that contain people in a dataset:
+
+
+
+
+
+You can narrow your search to images with a particular tag using the "Tags" selector:
+
+
+
+
+
+Before you start training a model with your dataset, we recommend using Roboflow [Health Check](https://docs.roboflow.com/datasets/dataset-health-check), a web tool that provides an insight into your dataset and how you can improve the dataset prior to training a vision model.
+
+To use Health Check, click the "Health Check" sidebar link. A list of statistics will appear that show the average size of images in your dataset, class balance, a heatmap of where annotations are in your images, and more.
+
+
+
+
+
+Health Check may recommend changes to help enhance dataset performance. For example, the class balance feature may show that there is an imbalance in labels that, if solved, may boost performance or your model.
+
+## Export Data in 40+ Formats for Model Training
+
+To export your data, you will need a dataset version. A version is a state of your dataset frozen-in-time. To create a version, first click "Versions" in the sidebar. Then, click the "Create New Version" button. On this page, you will be able to choose augmentations and preprocessing steps to apply to your dataset:
+
+
+
+
+
+For each augmentation you select, a pop-up will appear allowing you to tune the augmentation to your needs. Here is an example of tuning a brightness augmentation within specified parameters:
+
+
+
+
+
+When your dataset version has been generated, you can export your data into a range of formats. Click the "Export Dataset" button on your dataset version page to export your data:
+
+
+
+
+
+You are now ready to train YOLOv8 on a custom dataset. Follow this [written guide](https://blog.roboflow.com/how-to-train-yolov8-on-a-custom-dataset/) and [YouTube video](https://www.youtube.com/watch?v=wuZtUMEiKWY) for step-by-step instructions or refer to the [Ultralytics documentation](https://docs.ultralytics.com/modes/train/).
+
+## Upload Custom YOLOv8 Model Weights for Testing and Deployment
+
+Roboflow offers an infinitely scalable API for deployed models and SDKs for use with NVIDIA Jetsons, Luxonis OAKs, Raspberry Pis, GPU-based devices, and more.
+
+You can deploy YOLOv8 models by uploading YOLOv8 weights to Roboflow. You can do this in a few lines of Python code. Create a new Python file and add the following code:
+
+```python
+import roboflow # install with 'pip install roboflow'
+
+roboflow.login()
+
+rf = roboflow.Roboflow()
+
+project = rf.workspace(WORKSPACE_ID).project("football-players-detection-3zvbc")
+dataset = project.version(VERSION).download("yolov8")
+
+project.version(dataset.version).deploy(model_type="yolov8", model_path=f"{HOME}/runs/detect/train/")
+```
+
+In this code, replace the project ID and version ID with the values for your account and project. [Learn how to retrieve your Roboflow API key](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key).
+
+When you run the code above, you will be asked to authenticate. Then, your model will be uploaded and an API will be created for your project. This process can take up to 30 minutes to complete.
+
+To test your model and find deployment instructions for supported SDKs, go to the "Deploy" tab in the Roboflow sidebar. At the top of this page, a widget will appear with which you can test your model. You can use your webcam for live testing or upload images or videos.
+
+
+
+
+
+You can also use your uploaded model as a [labeling assistant](https://docs.roboflow.com/annotate/use-roboflow-annotate/model-assisted-labeling). This feature uses your trained model to recommend annotations on images uploaded to Roboflow.
+
+## How to Evaluate YOLOv8 Models
+
+Roboflow provides a range of features for use in evaluating models.
+
+Once you have uploaded a model to Roboflow, you can access our model evaluation tool, which provides a confusion matrix showing the performance of your model as well as an interactive vector analysis plot. These features can help you find opportunities to improve your model.
+
+To access a confusion matrix, go to your model page on the Roboflow dashboard, then click "View Detailed Evaluation":
+
+
+
+
+
+A pop-up will appear showing a confusion matrix:
+
+
+
+
+
+Hover over a box on the confusion matrix to see the value associated with the box. Click on a box to see images in the respective category. Click on an image to view the model predictions and ground truth data associated with that image.
+
+For more insights, click Vector Analysis. This will show a scatter plot of the images in your dataset, calculated using CLIP. The closer images are in the plot, the more similar they are, semantically. Each image is represented as a dot with a color between white and red. The more red the dot, the worse the model performed.
+
+
+
+
+
+You can use Vector Analysis to:
+
+- Find clusters of images;
+- Identify clusters where the model performs poorly, and;
+- Visualize commonalities between images on which the model performs poorly.
+
+## Learning Resources
+
+Want to learn more about using Roboflow for creating YOLOv8 models? The following resources may be helpful in your work.
+
+- [Train YOLOv8 on a Custom Dataset](https://github.com/roboflow/notebooks/blob/main/notebooks/train-yolov8-object-detection-on-custom-dataset.ipynb): Follow our interactive notebook that shows you how to train a YOLOv8 model on a custom dataset.
+- [Autodistill](https://autodistill.github.io/autodistill/): Use large foundation vision models to label data for specific models. You can label images for use in training YOLOv8 classification, detection, and segmentation models with Autodistill.
+- [Supervision](https://roboflow.github.io/supervision/): A Python package with helpful utilities for use in working with computer vision models. You can use supervision to filter detections, compute confusion matrices, and more, all in a few lines of Python code.
+- [Roboflow Blog](https://blog.roboflow.com/): The Roboflow Blog features over 500 articles on computer vision, covering topics from how to train a YOLOv8 model to annotation best practices.
+- [Roboflow YouTube channel](https://www.youtube.com/@Roboflow): Browse dozens of in-depth computer vision guides on our YouTube channel, covering topics from training YOLOv8 models to automated image labeling.
+
+## Project Showcase
+
+Below are a few of the many pieces of feedback we have received for using YOLOv8 and Roboflow together to create computer vision models.
+
+
+
+
+
+
diff --git a/ultralytics/docs/en/integrations/roboflow.md:Zone.Identifier b/ultralytics/docs/en/integrations/roboflow.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/integrations/roboflow.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/fast-sam.md b/ultralytics/docs/en/models/fast-sam.md
new file mode 100755
index 0000000..d528d47
--- /dev/null
+++ b/ultralytics/docs/en/models/fast-sam.md
@@ -0,0 +1,193 @@
+---
+comments: true
+description: Explore FastSAM, a CNN-based solution for real-time object segmentation in images. Enhanced user interaction, computational efficiency and adaptable across vision tasks.
+keywords: FastSAM, machine learning, CNN-based solution, object segmentation, real-time solution, Ultralytics, vision tasks, image processing, industrial applications, user interaction
+---
+
+# Fast Segment Anything Model (FastSAM)
+
+The Fast Segment Anything Model (FastSAM) is a novel, real-time CNN-based solution for the Segment Anything task. This task is designed to segment any object within an image based on various possible user interaction prompts. FastSAM significantly reduces computational demands while maintaining competitive performance, making it a practical choice for a variety of vision tasks.
+
+
+
+## Overview
+
+FastSAM is designed to address the limitations of the [Segment Anything Model (SAM)](sam.md), a heavy Transformer model with substantial computational resource requirements. The FastSAM decouples the segment anything task into two sequential stages: all-instance segmentation and prompt-guided selection. The first stage uses [YOLOv8-seg](../tasks/segment.md) to produce the segmentation masks of all instances in the image. In the second stage, it outputs the region-of-interest corresponding to the prompt.
+
+## Key Features
+
+1. **Real-time Solution:** By leveraging the computational efficiency of CNNs, FastSAM provides a real-time solution for the segment anything task, making it valuable for industrial applications that require quick results.
+
+2. **Efficiency and Performance:** FastSAM offers a significant reduction in computational and resource demands without compromising on performance quality. It achieves comparable performance to SAM but with drastically reduced computational resources, enabling real-time application.
+
+3. **Prompt-guided Segmentation:** FastSAM can segment any object within an image guided by various possible user interaction prompts, providing flexibility and adaptability in different scenarios.
+
+4. **Based on YOLOv8-seg:** FastSAM is based on [YOLOv8-seg](../tasks/segment.md), an object detector equipped with an instance segmentation branch. This allows it to effectively produce the segmentation masks of all instances in an image.
+
+5. **Competitive Results on Benchmarks:** On the object proposal task on MS COCO, FastSAM achieves high scores at a significantly faster speed than [SAM](sam.md) on a single NVIDIA RTX 3090, demonstrating its efficiency and capability.
+
+6. **Practical Applications:** The proposed approach provides a new, practical solution for a large number of vision tasks at a really high speed, tens or hundreds of times faster than current methods.
+
+7. **Model Compression Feasibility:** FastSAM demonstrates the feasibility of a path that can significantly reduce the computational effort by introducing an artificial prior to the structure, thus opening new possibilities for large model architecture for general vision tasks.
+
+## Available Models, Supported Tasks, and Operating Modes
+
+This table presents the available models with their specific pre-trained weights, the tasks they support, and their compatibility with different operating modes like [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md), indicated by โ emojis for supported modes and โ emojis for unsupported modes.
+
+| Model Type | Pre-trained Weights | Tasks Supported | Inference | Validation | Training | Export |
+|------------|---------------------|----------------------------------------------|-----------|------------|----------|--------|
+| FastSAM-s | `FastSAM-s.pt` | [Instance Segmentation](../tasks/segment.md) | โ | โ | โ | โ |
+| FastSAM-x | `FastSAM-x.pt` | [Instance Segmentation](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Usage Examples
+
+The FastSAM models are easy to integrate into your Python applications. Ultralytics provides user-friendly Python API and CLI commands to streamline development.
+
+### Predict Usage
+
+To perform object detection on an image, use the `predict` method as shown below:
+
+!!! Example
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM
+ from ultralytics.models.fastsam import FastSAMPrompt
+
+ # Define an inference source
+ source = 'path/to/bus.jpg'
+
+ # Create a FastSAM model
+ model = FastSAM('FastSAM-s.pt') # or FastSAM-x.pt
+
+ # Run inference on an image
+ everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
+
+ # Prepare a Prompt Process object
+ prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
+
+ # Everything prompt
+ ann = prompt_process.everything_prompt()
+
+ # Bbox default shape [0,0,0,0] -> [x1,y1,x2,y2]
+ ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
+
+ # Text prompt
+ ann = prompt_process.text_prompt(text='a photo of a dog')
+
+ # Point prompt
+ # points default [[0,0]] [[x1,y1],[x2,y2]]
+ # point_label default [0] [1,0] 0:background, 1:foreground
+ ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
+ prompt_process.plot(annotations=ann, output='./')
+ ```
+
+ === "CLI"
+ ```bash
+ # Load a FastSAM model and segment everything with it
+ yolo segment predict model=FastSAM-s.pt source=path/to/bus.jpg imgsz=640
+ ```
+
+This snippet demonstrates the simplicity of loading a pre-trained model and running a prediction on an image.
+
+### Val Usage
+
+Validation of the model on a dataset can be done as follows:
+
+!!! Example
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM
+
+ # Create a FastSAM model
+ model = FastSAM('FastSAM-s.pt') # or FastSAM-x.pt
+
+ # Validate the model
+ results = model.val(data='coco8-seg.yaml')
+ ```
+
+ === "CLI"
+ ```bash
+ # Load a FastSAM model and validate it on the COCO8 example dataset at image size 640
+ yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
+ ```
+
+Please note that FastSAM only supports detection and segmentation of a single class of object. This means it will recognize and segment all objects as the same class. Therefore, when preparing the dataset, you need to convert all object category IDs to 0.
+
+## FastSAM official Usage
+
+FastSAM is also available directly from the [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM) repository. Here is a brief overview of the typical steps you might take to use FastSAM:
+
+### Installation
+
+1. Clone the FastSAM repository:
+ ```shell
+ git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
+ ```
+
+2. Create and activate a Conda environment with Python 3.9:
+ ```shell
+ conda create -n FastSAM python=3.9
+ conda activate FastSAM
+ ```
+
+3. Navigate to the cloned repository and install the required packages:
+ ```shell
+ cd FastSAM
+ pip install -r requirements.txt
+ ```
+
+4. Install the CLIP model:
+ ```shell
+ pip install git+https://github.com/openai/CLIP.git
+ ```
+
+### Example Usage
+
+1. Download a [model checkpoint](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing).
+
+2. Use FastSAM for inference. Example commands:
+
+ - Segment everything in an image:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
+ ```
+
+ - Segment specific objects using text prompt:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "the yellow dog"
+ ```
+
+ - Segment objects within a bounding box (provide box coordinates in xywh format):
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
+ ```
+
+ - Segment objects near specific points:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
+ ```
+
+Additionally, you can try FastSAM through a [Colab demo](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) or on the [HuggingFace web demo](https://huggingface.co/spaces/An-619/FastSAM) for a visual experience.
+
+## Citations and Acknowledgements
+
+We would like to acknowledge the FastSAM authors for their significant contributions in the field of real-time instance segmentation:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{zhao2023fast,
+ title={Fast Segment Anything},
+ author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
+ year={2023},
+ eprint={2306.12156},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+The original FastSAM paper can be found on [arXiv](https://arxiv.org/abs/2306.12156). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). We appreciate their efforts in advancing the field and making their work accessible to the broader community.
diff --git a/ultralytics/docs/en/models/fast-sam.md:Zone.Identifier b/ultralytics/docs/en/models/fast-sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/fast-sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/index.md b/ultralytics/docs/en/models/index.md
new file mode 100755
index 0000000..93bbdb9
--- /dev/null
+++ b/ultralytics/docs/en/models/index.md
@@ -0,0 +1,94 @@
+---
+comments: true
+description: Explore the diverse range of YOLO family, SAM, MobileSAM, FastSAM, YOLO-NAS, and RT-DETR models supported by Ultralytics. Get started with examples for both CLI and Python usage.
+keywords: Ultralytics, documentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, models, architectures, Python, CLI
+---
+
+# Models Supported by Ultralytics
+
+Welcome to Ultralytics' model documentation! We offer support for a wide range of models, each tailored to specific tasks like [object detection](../tasks/detect.md), [instance segmentation](../tasks/segment.md), [image classification](../tasks/classify.md), [pose estimation](../tasks/pose.md), and [multi-object tracking](../modes/track.md). If you're interested in contributing your model architecture to Ultralytics, check out our [Contributing Guide](../help/contributing.md).
+
+## Featured Models
+
+Here are some of the key models supported:
+
+1. **[YOLOv3](yolov3.md)**: The third iteration of the YOLO model family, originally by Joseph Redmon, known for its efficient real-time object detection capabilities.
+2. **[YOLOv4](yolov4.md)**: A darknet-native update to YOLOv3, released by Alexey Bochkovskiy in 2020.
+3. **[YOLOv5](yolov5.md)**: An improved version of the YOLO architecture by Ultralytics, offering better performance and speed trade-offs compared to previous versions.
+4. **[YOLOv6](yolov6.md)**: Released by [Meituan](https://about.meituan.com/) in 2022, and in use in many of the company's autonomous delivery robots.
+5. **[YOLOv7](yolov7.md)**: Updated YOLO models released in 2022 by the authors of YOLOv4.
+6. **[YOLOv8](yolov8.md) NEW ๐**: The latest version of the YOLO family, featuring enhanced capabilities such as instance segmentation, pose/keypoints estimation, and classification.
+7. **[Segment Anything Model (SAM)](sam.md)**: Meta's Segment Anything Model (SAM).
+8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM for mobile applications, by Kyung Hee University.
+9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: FastSAM by Image & Video Analysis Group, Institute of Automation, Chinese Academy of Sciences.
+10. **[YOLO-NAS](yolo-nas.md)**: YOLO Neural Architecture Search (NAS) Models.
+11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)**: Baidu's PaddlePaddle Realtime Detection Transformer (RT-DETR) models.
+
+
+
+
+
+ Watch: Run Ultralytics YOLO models in just a few lines of code.
+
+
+## Getting Started: Usage Examples
+
+This example provides simple YOLO training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages.
+
+Note the below example is for YOLOv8 [Detect](../tasks/detect.md) models for object detection. For additional supported tasks see the [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) and [Pose](../tasks/pose.md) docs.
+
+!!! Example
+
+ === "Python"
+
+ PyTorch pretrained `*.pt` models as well as configuration `*.yaml` files can be passed to the `YOLO()`, `SAM()`, `NAS()` and `RTDETR()` classes to create a model instance in Python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a COCO-pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Train the model on the COCO8 example dataset for 100 epochs
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Run inference with the YOLOv8n model on the 'bus.jpg' image
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI commands are available to directly run the models:
+
+ ```bash
+ # Load a COCO-pretrained YOLOv8n model and train it on the COCO8 example dataset for 100 epochs
+ yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Load a COCO-pretrained YOLOv8n model and run inference on the 'bus.jpg' image
+ yolo predict model=yolov8n.pt source=path/to/bus.jpg
+ ```
+
+## Contributing New Models
+
+Interested in contributing your model to Ultralytics? Great! We're always open to expanding our model portfolio.
+
+1. **Fork the Repository**: Start by forking the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics).
+
+2. **Clone Your Fork**: Clone your fork to your local machine and create a new branch to work on.
+
+3. **Implement Your Model**: Add your model following the coding standards and guidelines provided in our [Contributing Guide](../help/contributing.md).
+
+4. **Test Thoroughly**: Make sure to test your model rigorously, both in isolation and as part of the pipeline.
+
+5. **Create a Pull Request**: Once you're satisfied with your model, create a pull request to the main repository for review.
+
+6. **Code Review & Merging**: After review, if your model meets our criteria, it will be merged into the main repository.
+
+For detailed steps, consult our [Contributing Guide](../help/contributing.md).
diff --git a/ultralytics/docs/en/models/index.md:Zone.Identifier b/ultralytics/docs/en/models/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/mobile-sam.md b/ultralytics/docs/en/models/mobile-sam.md
new file mode 100755
index 0000000..51700f6
--- /dev/null
+++ b/ultralytics/docs/en/models/mobile-sam.md
@@ -0,0 +1,117 @@
+---
+comments: true
+description: Learn more about MobileSAM, its implementation, comparison with the original SAM, and how to download and test it in the Ultralytics framework. Improve your mobile applications today.
+keywords: MobileSAM, Ultralytics, SAM, mobile applications, Arxiv, GPU, API, image encoder, mask decoder, model download, testing method
+---
+
+
+
+# Mobile Segment Anything (MobileSAM)
+
+The MobileSAM paper is now available on [arXiv](https://arxiv.org/pdf/2306.14289.pdf).
+
+A demonstration of MobileSAM running on a CPU can be accessed at this [demo link](https://huggingface.co/spaces/dhkim2810/MobileSAM). The performance on a Mac i5 CPU takes approximately 3 seconds. On the Hugging Face demo, the interface and lower-performance CPUs contribute to a slower response, but it continues to function effectively.
+
+MobileSAM is implemented in various projects including [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling), and [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D).
+
+MobileSAM is trained on a single GPU with a 100k dataset (1% of the original images) in less than a day. The code for this training will be made available in the future.
+
+## Available Models, Supported Tasks, and Operating Modes
+
+This table presents the available models with their specific pre-trained weights, the tasks they support, and their compatibility with different operating modes like [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md), indicated by โ emojis for supported modes and โ emojis for unsupported modes.
+
+| Model Type | Pre-trained Weights | Tasks Supported | Inference | Validation | Training | Export |
+|------------|---------------------|----------------------------------------------|-----------|------------|----------|--------|
+| MobileSAM | `mobile_sam.pt` | [Instance Segmentation](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Adapting from SAM to MobileSAM
+
+Since MobileSAM retains the same pipeline as the original SAM, we have incorporated the original's pre-processing, post-processing, and all other interfaces. Consequently, those currently using the original SAM can transition to MobileSAM with minimal effort.
+
+MobileSAM performs comparably to the original SAM and retains the same pipeline except for a change in the image encoder. Specifically, we replace the original heavyweight ViT-H encoder (632M) with a smaller Tiny-ViT (5M). On a single GPU, MobileSAM operates at about 12ms per image: 8ms on the image encoder and 4ms on the mask decoder.
+
+The following table provides a comparison of ViT-based image encoders:
+
+| Image Encoder | Original SAM | MobileSAM |
+|---------------|--------------|-----------|
+| Parameters | 611M | 5M |
+| Speed | 452ms | 8ms |
+
+Both the original SAM and MobileSAM utilize the same prompt-guided mask decoder:
+
+| Mask Decoder | Original SAM | MobileSAM |
+|--------------|--------------|-----------|
+| Parameters | 3.876M | 3.876M |
+| Speed | 4ms | 4ms |
+
+Here is the comparison of the whole pipeline:
+
+| Whole Pipeline (Enc+Dec) | Original SAM | MobileSAM |
+|--------------------------|--------------|-----------|
+| Parameters | 615M | 9.66M |
+| Speed | 456ms | 12ms |
+
+The performance of MobileSAM and the original SAM are demonstrated using both a point and a box as prompts.
+
+
+
+
+
+With its superior performance, MobileSAM is approximately 5 times smaller and 7 times faster than the current FastSAM. More details are available at the [MobileSAM project page](https://github.com/ChaoningZhang/MobileSAM).
+
+## Testing MobileSAM in Ultralytics
+
+Just like the original SAM, we offer a straightforward testing method in Ultralytics, including modes for both Point and Box prompts.
+
+### Model Download
+
+You can download the model [here](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt).
+
+### Point Prompt
+
+!!! Example
+
+ === "Python"
+ ```python
+ from ultralytics import SAM
+
+ # Load the model
+ model = SAM('mobile_sam.pt')
+
+ # Predict a segment based on a point prompt
+ model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
+ ```
+
+### Box Prompt
+
+!!! Example
+
+ === "Python"
+ ```python
+ from ultralytics import SAM
+
+ # Load the model
+ model = SAM('mobile_sam.pt')
+
+ # Predict a segment based on a box prompt
+ model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
+ ```
+
+We have implemented `MobileSAM` and `SAM` using the same API. For more usage information, please see the [SAM page](sam.md).
+
+## Citations and Acknowledgements
+
+If you find MobileSAM useful in your research or development work, please consider citing our paper:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{mobile_sam,
+ title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications},
+ author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon},
+ journal={arXiv preprint arXiv:2306.14289},
+ year={2023}
+ }
+ ```
diff --git a/ultralytics/docs/en/models/mobile-sam.md:Zone.Identifier b/ultralytics/docs/en/models/mobile-sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/mobile-sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/rtdetr.md b/ultralytics/docs/en/models/rtdetr.md
new file mode 100755
index 0000000..b7d449a
--- /dev/null
+++ b/ultralytics/docs/en/models/rtdetr.md
@@ -0,0 +1,93 @@
+---
+comments: true
+description: Discover the features and benefits of RT-DETR, Baiduโs efficient and adaptable real-time object detector powered by Vision Transformers, including pre-trained models.
+keywords: RT-DETR, Baidu, Vision Transformers, object detection, real-time performance, CUDA, TensorRT, IoU-aware query selection, Ultralytics, Python API, PaddlePaddle
+---
+
+# Baidu's RT-DETR: A Vision Transformer-Based Real-Time Object Detector
+
+## Overview
+
+Real-Time Detection Transformer (RT-DETR), developed by Baidu, is a cutting-edge end-to-end object detector that provides real-time performance while maintaining high accuracy. It leverages the power of Vision Transformers (ViT) to efficiently process multiscale features by decoupling intra-scale interaction and cross-scale fusion. RT-DETR is highly adaptable, supporting flexible adjustment of inference speed using different decoder layers without retraining. The model excels on accelerated backends like CUDA with TensorRT, outperforming many other real-time object detectors.
+
+
+**Overview of Baidu's RT-DETR.** The RT-DETR model architecture diagram shows the last three stages of the backbone {S3, S4, S5} as the input to the encoder. The efficient hybrid encoder transforms multiscale features into a sequence of image features through intrascale feature interaction (AIFI) and cross-scale feature-fusion module (CCFM). The IoU-aware query selection is employed to select a fixed number of image features to serve as initial object queries for the decoder. Finally, the decoder with auxiliary prediction heads iteratively optimizes object queries to generate boxes and confidence scores ([source](https://arxiv.org/pdf/2304.08069.pdf)).
+
+### Key Features
+
+- **Efficient Hybrid Encoder:** Baidu's RT-DETR uses an efficient hybrid encoder that processes multiscale features by decoupling intra-scale interaction and cross-scale fusion. This unique Vision Transformers-based design reduces computational costs and allows for real-time object detection.
+- **IoU-aware Query Selection:** Baidu's RT-DETR improves object query initialization by utilizing IoU-aware query selection. This allows the model to focus on the most relevant objects in the scene, enhancing the detection accuracy.
+- **Adaptable Inference Speed:** Baidu's RT-DETR supports flexible adjustments of inference speed by using different decoder layers without the need for retraining. This adaptability facilitates practical application in various real-time object detection scenarios.
+
+## Pre-trained Models
+
+The Ultralytics Python API provides pre-trained PaddlePaddle RT-DETR models with different scales:
+
+- RT-DETR-L: 53.0% AP on COCO val2017, 114 FPS on T4 GPU
+- RT-DETR-X: 54.8% AP on COCO val2017, 74 FPS on T4 GPU
+
+## Usage Examples
+
+This example provides simple RT-DETRR training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import RTDETR
+
+ # Load a COCO-pretrained RT-DETR-l model
+ model = RTDETR('rtdetr-l.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Train the model on the COCO8 example dataset for 100 epochs
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Run inference with the RT-DETR-l model on the 'bus.jpg' image
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Load a COCO-pretrained RT-DETR-l model and train it on the COCO8 example dataset for 100 epochs
+ yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Load a COCO-pretrained RT-DETR-l model and run inference on the 'bus.jpg' image
+ yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
+ ```
+
+## Supported Tasks and Modes
+
+This table presents the model types, the specific pre-trained weights, the tasks supported by each model, and the various modes ([Train](../modes/train.md) , [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)) that are supported, indicated by โ emojis.
+
+| Model Type | Pre-trained Weights | Tasks Supported | Inference | Validation | Training | Export |
+|---------------------|---------------------|----------------------------------------|-----------|------------|----------|--------|
+| RT-DETR Large | `rtdetr-l.pt` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| RT-DETR Extra-Large | `rtdetr-x.pt` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+
+## Citations and Acknowledgements
+
+If you use Baidu's RT-DETR in your research or development work, please cite the [original paper](https://arxiv.org/abs/2304.08069):
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{lv2023detrs,
+ title={DETRs Beat YOLOs on Real-time Object Detection},
+ author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu},
+ year={2023},
+ eprint={2304.08069},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+We would like to acknowledge Baidu and the [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) team for creating and maintaining this valuable resource for the computer vision community. Their contribution to the field with the development of the Vision Transformers-based real-time object detector, RT-DETR, is greatly appreciated.
+
+*Keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, real-time object detection, Vision Transformers-based object detection, pre-trained PaddlePaddle RT-DETR models, Baidu's RT-DETR usage, Ultralytics Python API*
diff --git a/ultralytics/docs/en/models/rtdetr.md:Zone.Identifier b/ultralytics/docs/en/models/rtdetr.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/rtdetr.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/sam.md b/ultralytics/docs/en/models/sam.md
new file mode 100755
index 0000000..3db6f3d
--- /dev/null
+++ b/ultralytics/docs/en/models/sam.md
@@ -0,0 +1,226 @@
+---
+comments: true
+description: Explore the cutting-edge Segment Anything Model (SAM) from Ultralytics that allows real-time image segmentation. Learn about its promptable segmentation, zero-shot performance, and how to use it.
+keywords: Ultralytics, image segmentation, Segment Anything Model, SAM, SA-1B dataset, real-time performance, zero-shot transfer, object detection, image analysis, machine learning
+---
+
+# Segment Anything Model (SAM)
+
+Welcome to the frontier of image segmentation with the Segment Anything Model, or SAM. This revolutionary model has changed the game by introducing promptable image segmentation with real-time performance, setting new standards in the field.
+
+## Introduction to SAM: The Segment Anything Model
+
+The Segment Anything Model, or SAM, is a cutting-edge image segmentation model that allows for promptable segmentation, providing unparalleled versatility in image analysis tasks. SAM forms the heart of the Segment Anything initiative, a groundbreaking project that introduces a novel model, task, and dataset for image segmentation.
+
+SAM's advanced design allows it to adapt to new image distributions and tasks without prior knowledge, a feature known as zero-shot transfer. Trained on the expansive [SA-1B dataset](https://ai.facebook.com/datasets/segment-anything/), which contains more than 1 billion masks spread over 11 million carefully curated images, SAM has displayed impressive zero-shot performance, surpassing previous fully supervised results in many cases.
+
+
+Example images with overlaid masks from our newly introduced dataset, SA-1B. SA-1B contains 11M diverse, high-resolution, licensed, and privacy protecting images and 1.1B high-quality segmentation masks. These masks were annotated fully automatically by SAM, and as verified by human ratings and numerous experiments, are of high quality and diversity. Images are grouped by number of masks per image for visualization (there are โผ100 masks per image on average).
+
+## Key Features of the Segment Anything Model (SAM)
+
+- **Promptable Segmentation Task:** SAM was designed with a promptable segmentation task in mind, allowing it to generate valid segmentation masks from any given prompt, such as spatial or text clues identifying an object.
+- **Advanced Architecture:** The Segment Anything Model employs a powerful image encoder, a prompt encoder, and a lightweight mask decoder. This unique architecture enables flexible prompting, real-time mask computation, and ambiguity awareness in segmentation tasks.
+- **The SA-1B Dataset:** Introduced by the Segment Anything project, the SA-1B dataset features over 1 billion masks on 11 million images. As the largest segmentation dataset to date, it provides SAM with a diverse and large-scale training data source.
+- **Zero-Shot Performance:** SAM displays outstanding zero-shot performance across various segmentation tasks, making it a ready-to-use tool for diverse applications with minimal need for prompt engineering.
+
+For an in-depth look at the Segment Anything Model and the SA-1B dataset, please visit the [Segment Anything website](https://segment-anything.com) and check out the research paper [Segment Anything](https://arxiv.org/abs/2304.02643).
+
+## Available Models, Supported Tasks, and Operating Modes
+
+This table presents the available models with their specific pre-trained weights, the tasks they support, and their compatibility with different operating modes like [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md), indicated by โ emojis for supported modes and โ emojis for unsupported modes.
+
+| Model Type | Pre-trained Weights | Tasks Supported | Inference | Validation | Training | Export |
+|------------|---------------------|----------------------------------------------|-----------|------------|----------|--------|
+| SAM base | `sam_b.pt` | [Instance Segmentation](../tasks/segment.md) | โ | โ | โ | โ |
+| SAM large | `sam_l.pt` | [Instance Segmentation](../tasks/segment.md) | โ | โ | โ | โ |
+
+## How to Use SAM: Versatility and Power in Image Segmentation
+
+The Segment Anything Model can be employed for a multitude of downstream tasks that go beyond its training data. This includes edge detection, object proposal generation, instance segmentation, and preliminary text-to-mask prediction. With prompt engineering, SAM can swiftly adapt to new tasks and data distributions in a zero-shot manner, establishing it as a versatile and potent tool for all your image segmentation needs.
+
+### SAM prediction example
+
+!!! Example "Segment with prompts"
+
+ Segment image with given prompts.
+
+ === "Python"
+
+ ```python
+ from ultralytics import SAM
+
+ # Load a model
+ model = SAM('sam_b.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Run inference with bboxes prompt
+ model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
+
+ # Run inference with points prompt
+ model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
+ ```
+
+!!! Example "Segment everything"
+
+ Segment the whole image.
+
+ === "Python"
+
+ ```python
+ from ultralytics import SAM
+
+ # Load a model
+ model = SAM('sam_b.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Run inference
+ model('path/to/image.jpg')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Run inference with a SAM model
+ yolo predict model=sam_b.pt source=path/to/image.jpg
+ ```
+
+- The logic here is to segment the whole image if you don't pass any prompts(bboxes/points/masks).
+
+!!! Example "SAMPredictor example"
+
+ This way you can set image once and run prompts inference multiple times without running image encoder multiple times.
+
+ === "Prompt inference"
+
+ ```python
+ from ultralytics.models.sam import Predictor as SAMPredictor
+
+ # Create SAMPredictor
+ overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
+ predictor = SAMPredictor(overrides=overrides)
+
+ # Set image
+ predictor.set_image("ultralytics/assets/zidane.jpg") # set with image file
+ predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # set with np.ndarray
+ results = predictor(bboxes=[439, 437, 524, 709])
+ results = predictor(points=[900, 370], labels=[1])
+
+ # Reset image
+ predictor.reset_image()
+ ```
+
+ Segment everything with additional args.
+
+ === "Segment everything"
+
+ ```python
+ from ultralytics.models.sam import Predictor as SAMPredictor
+
+ # Create SAMPredictor
+ overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
+ predictor = SAMPredictor(overrides=overrides)
+
+ # Segment with additional args
+ results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
+ ```
+
+- More additional args for `Segment everything` see [`Predictor/generate` Reference](../reference/models/sam/predict.md).
+
+## SAM comparison vs YOLOv8
+
+Here we compare Meta's smallest SAM model, SAM-b, with Ultralytics smallest segmentation model, [YOLOv8n-seg](../tasks/segment.md):
+
+| Model | Size | Parameters | Speed (CPU) |
+|------------------------------------------------|----------------------------|------------------------|----------------------------|
+| Meta's SAM-b | 358 MB | 94.7 M | 51096 ms/im |
+| [MobileSAM](mobile-sam.md) | 40.7 MB | 10.1 M | 46122 ms/im |
+| [FastSAM-s](fast-sam.md) with YOLOv8 backbone | 23.7 MB | 11.8 M | 115 ms/im |
+| Ultralytics [YOLOv8n-seg](../tasks/segment.md) | **6.7 MB** (53.4x smaller) | **3.4 M** (27.9x less) | **59 ms/im** (866x faster) |
+
+This comparison shows the order-of-magnitude differences in the model sizes and speeds between models. Whereas SAM presents unique capabilities for automatic segmenting, it is not a direct competitor to YOLOv8 segment models, which are smaller, faster and more efficient.
+
+Tests run on a 2023 Apple M2 Macbook with 16GB of RAM. To reproduce this test:
+
+!!! Example
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM, SAM, YOLO
+
+ # Profile SAM-b
+ model = SAM('sam_b.pt')
+ model.info()
+ model('ultralytics/assets')
+
+ # Profile MobileSAM
+ model = SAM('mobile_sam.pt')
+ model.info()
+ model('ultralytics/assets')
+
+ # Profile FastSAM-s
+ model = FastSAM('FastSAM-s.pt')
+ model.info()
+ model('ultralytics/assets')
+
+ # Profile YOLOv8n-seg
+ model = YOLO('yolov8n-seg.pt')
+ model.info()
+ model('ultralytics/assets')
+ ```
+
+## Auto-Annotation: A Quick Path to Segmentation Datasets
+
+Auto-annotation is a key feature of SAM, allowing users to generate a [segmentation dataset](https://docs.ultralytics.com/datasets/segment) using a pre-trained detection model. This feature enables rapid and accurate annotation of a large number of images, bypassing the need for time-consuming manual labeling.
+
+### Generate Your Segmentation Dataset Using a Detection Model
+
+To auto-annotate your dataset with the Ultralytics framework, 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="yolov8x.pt", sam_model='sam_b.pt')
+ ```
+
+| Argument | Type | Description | Default |
+|------------|---------------------|---------------------------------------------------------------------------------------------------------|--------------|
+| data | str | Path to a folder containing images to be annotated. | |
+| det_model | str, optional | Pre-trained YOLO detection model. Defaults to 'yolov8x.pt'. | 'yolov8x.pt' |
+| sam_model | str, optional | Pre-trained SAM segmentation model. Defaults to 'sam_b.pt'. | 'sam_b.pt' |
+| device | str, optional | Device to run the models on. Defaults to an empty string (CPU or GPU, if available). | |
+| output_dir | str, None, optional | Directory to save the annotated results. Defaults to a 'labels' folder in the same directory as 'data'. | None |
+
+The `auto_annotate` function takes the path to your images, with optional arguments for specifying the pre-trained detection and SAM segmentation models, the device to run the models on, and the output directory for saving the annotated results.
+
+Auto-annotation with pre-trained models can dramatically cut down the time and effort required for creating high-quality segmentation datasets. This feature is especially beneficial for researchers and developers dealing with large image collections, as it allows them to focus on model development and evaluation rather than manual annotation.
+
+## Citations and Acknowledgements
+
+If you find SAM useful in your research or development work, please consider citing our paper:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{kirillov2023segment,
+ title={Segment Anything},
+ author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollรกr and Ross Girshick},
+ year={2023},
+ eprint={2304.02643},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+We would like to express our gratitude to Meta AI for creating and maintaining this valuable resource for the computer vision community.
+
+*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, image segmentation, promptable segmentation, zero-shot performance, SA-1B dataset, advanced architecture, auto-annotation, Ultralytics, pre-trained models, SAM base, SAM large, instance segmentation, computer vision, AI, artificial intelligence, machine learning, data annotation, segmentation masks, detection model, YOLO detection model, bibtex, Meta AI.*
diff --git a/ultralytics/docs/en/models/sam.md:Zone.Identifier b/ultralytics/docs/en/models/sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/yolo-nas.md b/ultralytics/docs/en/models/yolo-nas.md
new file mode 100755
index 0000000..a8e550b
--- /dev/null
+++ b/ultralytics/docs/en/models/yolo-nas.md
@@ -0,0 +1,121 @@
+---
+comments: true
+description: Explore detailed documentation of YOLO-NAS, a superior object detection model. Learn about its features, pre-trained models, usage with Ultralytics Python API, and more.
+keywords: YOLO-NAS, Deci AI, object detection, deep learning, neural architecture search, Ultralytics Python API, YOLO model, pre-trained models, quantization, optimization, COCO, Objects365, Roboflow 100
+---
+
+# YOLO-NAS
+
+## Overview
+
+Developed by Deci AI, YOLO-NAS is a groundbreaking object detection foundational model. It is the product of advanced Neural Architecture Search technology, meticulously designed to address the limitations of previous YOLO models. With significant improvements in quantization support and accuracy-latency trade-offs, YOLO-NAS represents a major leap in object detection.
+
+
+**Overview of YOLO-NAS.** YOLO-NAS employs quantization-aware blocks and selective quantization for optimal performance. The model, when converted to its INT8 quantized version, experiences a minimal precision drop, a significant improvement over other models. These advancements culminate in a superior architecture with unprecedented object detection capabilities and outstanding performance.
+
+### Key Features
+
+- **Quantization-Friendly Basic Block:** YOLO-NAS introduces a new basic block that is friendly to quantization, addressing one of the significant limitations of previous YOLO models.
+- **Sophisticated Training and Quantization:** YOLO-NAS leverages advanced training schemes and post-training quantization to enhance performance.
+- **AutoNAC Optimization and Pre-training:** YOLO-NAS utilizes AutoNAC optimization and is pre-trained on prominent datasets such as COCO, Objects365, and Roboflow 100. This pre-training makes it extremely suitable for downstream object detection tasks in production environments.
+
+## Pre-trained Models
+
+Experience the power of next-generation object detection with the pre-trained YOLO-NAS models provided by Ultralytics. These models are designed to deliver top-notch performance in terms of both speed and accuracy. Choose from a variety of options tailored to your specific needs:
+
+| Model | mAP | Latency (ms) |
+|------------------|-------|--------------|
+| YOLO-NAS S | 47.5 | 3.21 |
+| YOLO-NAS M | 51.55 | 5.85 |
+| YOLO-NAS L | 52.22 | 7.87 |
+| YOLO-NAS S INT-8 | 47.03 | 2.36 |
+| YOLO-NAS M INT-8 | 51.0 | 3.78 |
+| YOLO-NAS L INT-8 | 52.1 | 4.78 |
+
+Each model variant is designed to offer a balance between Mean Average Precision (mAP) and latency, helping you optimize your object detection tasks for both performance and speed.
+
+## Usage Examples
+
+Ultralytics has made YOLO-NAS models easy to integrate into your Python applications via our `ultralytics` python package. The package provides a user-friendly Python API to streamline the process.
+
+The following examples show how to use YOLO-NAS models with the `ultralytics` package for inference and validation:
+
+### Inference and Validation Examples
+
+In this example we validate YOLO-NAS-s on the COCO8 dataset.
+
+!!! Example
+
+ This example provides simple inference and validation code for YOLO-NAS. For handling inference results see [Predict](../modes/predict.md) mode. For using YOLO-NAS with additional modes see [Val](../modes/val.md) and [Export](../modes/export.md). YOLO-NAS on the `ultralytics` package does not support training.
+
+ === "Python"
+
+ PyTorch pretrained `*.pt` models files can be passed to the `NAS()` class to create a model instance in python:
+
+ ```python
+ from ultralytics import NAS
+
+ # Load a COCO-pretrained YOLO-NAS-s model
+ model = NAS('yolo_nas_s.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Validate the model on the COCO8 example dataset
+ results = model.val(data='coco8.yaml')
+
+ # Run inference with the YOLO-NAS-s model on the 'bus.jpg' image
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI commands are available to directly run the models:
+
+ ```bash
+ # Load a COCO-pretrained YOLO-NAS-s model and validate it's performance on the COCO8 example dataset
+ yolo val model=yolo_nas_s.pt data=coco8.yaml
+
+ # Load a COCO-pretrained YOLO-NAS-s model and run inference on the 'bus.jpg' image
+ yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
+ ```
+
+## Supported Tasks and Modes
+
+We offer three variants of the YOLO-NAS models: Small (s), Medium (m), and Large (l). Each variant is designed to cater to different computational and performance needs:
+
+- **YOLO-NAS-s**: Optimized for environments where computational resources are limited but efficiency is key.
+- **YOLO-NAS-m**: Offers a balanced approach, suitable for general-purpose object detection with higher accuracy.
+- **YOLO-NAS-l**: Tailored for scenarios requiring the highest accuracy, where computational resources are less of a constraint.
+
+Below is a detailed overview of each model, including links to their pre-trained weights, the tasks they support, and their compatibility with different operating modes.
+
+| Model Type | Pre-trained Weights | Tasks Supported | Inference | Validation | Training | Export |
+|------------|-----------------------------------------------------------------------------------------------|----------------------------------------|-----------|------------|----------|--------|
+| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_s.pt) | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_m.pt) | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_l.pt) | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+
+## Citations and Acknowledgements
+
+If you employ YOLO-NAS in your research or development work, please cite SuperGradients:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{supergradients,
+ doi = {10.5281/ZENODO.7789328},
+ url = {https://zenodo.org/record/7789328},
+ author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}},
+ title = {Super-Gradients},
+ publisher = {GitHub},
+ journal = {GitHub repository},
+ year = {2021},
+ }
+ ```
+
+We express our gratitude to Deci AI's [SuperGradients](https://github.com/Deci-AI/super-gradients/) team for their efforts in creating and maintaining this valuable resource for the computer vision community. We believe YOLO-NAS, with its innovative architecture and superior object detection capabilities, will become a critical tool for developers and researchers alike.
+
+*Keywords: YOLO-NAS, Deci AI, object detection, deep learning, neural architecture search, Ultralytics Python API, YOLO model, SuperGradients, pre-trained models, quantization-friendly basic block, advanced training schemes, post-training quantization, AutoNAC optimization, COCO, Objects365, Roboflow 100*
diff --git a/ultralytics/docs/en/models/yolo-nas.md:Zone.Identifier b/ultralytics/docs/en/models/yolo-nas.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/yolo-nas.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/yolov3.md b/ultralytics/docs/en/models/yolov3.md
new file mode 100755
index 0000000..2e6d34b
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov3.md
@@ -0,0 +1,98 @@
+---
+comments: true
+description: Get an overview of YOLOv3, YOLOv3-Ultralytics and YOLOv3u. Learn about their key features, usage, and supported tasks for object detection.
+keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Object Detection, Inference, Training, Ultralytics
+---
+
+# YOLOv3, YOLOv3-Ultralytics, and YOLOv3u
+
+## Overview
+
+This document presents an overview of three closely related object detection models, namely [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3), and [YOLOv3u](https://github.com/ultralytics/ultralytics).
+
+1. **YOLOv3:** This is the third version of the You Only Look Once (YOLO) object detection algorithm. Originally developed by Joseph Redmon, YOLOv3 improved on its predecessors by introducing features such as multiscale predictions and three different sizes of detection kernels.
+
+2. **YOLOv3-Ultralytics:** This is Ultralytics' implementation of the YOLOv3 model. It reproduces the original YOLOv3 architecture and offers additional functionalities, such as support for more pre-trained models and easier customization options.
+
+3. **YOLOv3u:** This is an updated version of YOLOv3-Ultralytics that incorporates the anchor-free, objectness-free split head used in YOLOv8 models. YOLOv3u maintains the same backbone and neck architecture as YOLOv3 but with the updated detection head from YOLOv8.
+
+
+
+## Key Features
+
+- **YOLOv3:** Introduced the use of three different scales for detection, leveraging three different sizes of detection kernels: 13x13, 26x26, and 52x52. This significantly improved detection accuracy for objects of different sizes. Additionally, YOLOv3 added features such as multi-label predictions for each bounding box and a better feature extractor network.
+
+- **YOLOv3-Ultralytics:** Ultralytics' implementation of YOLOv3 provides the same performance as the original model but comes with added support for more pre-trained models, additional training methods, and easier customization options. This makes it more versatile and user-friendly for practical applications.
+
+- **YOLOv3u:** This updated model incorporates the anchor-free, objectness-free split head from YOLOv8. By eliminating the need for pre-defined anchor boxes and objectness scores, this detection head design can improve the model's ability to detect objects of varying sizes and shapes. This makes YOLOv3u more robust and accurate for object detection tasks.
+
+## Supported Tasks and Modes
+
+The YOLOv3 series, including YOLOv3, YOLOv3-Ultralytics, and YOLOv3u, are designed specifically for object detection tasks. These models are renowned for their effectiveness in various real-world scenarios, balancing accuracy and speed. Each variant offers unique features and optimizations, making them suitable for a range of applications.
+
+All three models support a comprehensive set of modes, ensuring versatility in various stages of model deployment and development. These modes include [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md), providing users with a complete toolkit for effective object detection.
+
+| Model Type | Tasks Supported | Inference | Validation | Training | Export |
+|--------------------|----------------------------------------|-----------|------------|----------|--------|
+| YOLOv3 | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv3-Ultralytics | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv3u | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+
+This table provides an at-a-glance view of the capabilities of each YOLOv3 variant, highlighting their versatility and suitability for various tasks and operational modes in object detection workflows.
+
+## Usage Examples
+
+This example provides simple YOLOv3 training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages.
+
+!!! Example
+
+ === "Python"
+
+ PyTorch pretrained `*.pt` models as well as configuration `*.yaml` files can be passed to the `YOLO()` class to create a model instance in python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a COCO-pretrained YOLOv3n model
+ model = YOLO('yolov3n.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Train the model on the COCO8 example dataset for 100 epochs
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Run inference with the YOLOv3n model on the 'bus.jpg' image
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI commands are available to directly run the models:
+
+ ```bash
+ # Load a COCO-pretrained YOLOv3n model and train it on the COCO8 example dataset for 100 epochs
+ yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Load a COCO-pretrained YOLOv3n model and run inference on the 'bus.jpg' image
+ yolo predict model=yolov3n.pt source=path/to/bus.jpg
+ ```
+
+## Citations and Acknowledgements
+
+If you use YOLOv3 in your research, please cite the original YOLO papers and the Ultralytics YOLOv3 repository:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{redmon2018yolov3,
+ title={YOLOv3: An Incremental Improvement},
+ author={Redmon, Joseph and Farhadi, Ali},
+ journal={arXiv preprint arXiv:1804.02767},
+ year={2018}
+ }
+ ```
+
+Thank you to Joseph Redmon and Ali Farhadi for developing the original YOLOv3.
diff --git a/ultralytics/docs/en/models/yolov3.md:Zone.Identifier b/ultralytics/docs/en/models/yolov3.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov3.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/yolov4.md b/ultralytics/docs/en/models/yolov4.md
new file mode 100755
index 0000000..b24ec75
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov4.md
@@ -0,0 +1,71 @@
+---
+comments: true
+description: Explore our detailed guide on YOLOv4, a state-of-the-art real-time object detector. Understand its architectural highlights, innovative features, and application examples.
+keywords: ultralytics, YOLOv4, object detection, neural network, real-time detection, object detector, machine learning
+---
+
+# YOLOv4: High-Speed and Precise Object Detection
+
+Welcome to the Ultralytics documentation page for YOLOv4, a state-of-the-art, real-time object detector launched in 2020 by Alexey Bochkovskiy at [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). YOLOv4 is designed to provide the optimal balance between speed and accuracy, making it an excellent choice for many applications.
+
+
+**YOLOv4 architecture diagram**. Showcasing the intricate network design of YOLOv4, including the backbone, neck, and head components, and their interconnected layers for optimal real-time object detection.
+
+## Introduction
+
+YOLOv4 stands for You Only Look Once version 4. It is a real-time object detection model developed to address the limitations of previous YOLO versions like [YOLOv3](yolov3.md) and other object detection models. Unlike other convolutional neural network (CNN) based object detectors, YOLOv4 is not only applicable for recommendation systems but also for standalone process management and human input reduction. Its operation on conventional graphics processing units (GPUs) allows for mass usage at an affordable price, and it is designed to work in real-time on a conventional GPU while requiring only one such GPU for training.
+
+## Architecture
+
+YOLOv4 makes use of several innovative features that work together to optimize its performance. These include Weighted-Residual-Connections (WRC), Cross-Stage-Partial-connections (CSP), Cross mini-Batch Normalization (CmBN), Self-adversarial-training (SAT), Mish-activation, Mosaic data augmentation, DropBlock regularization, and CIoU loss. These features are combined to achieve state-of-the-art results.
+
+A typical object detector is composed of several parts including the input, the backbone, the neck, and the head. The backbone of YOLOv4 is pre-trained on ImageNet and is used to predict classes and bounding boxes of objects. The backbone could be from several models including VGG, ResNet, ResNeXt, or DenseNet. The neck part of the detector is used to collect feature maps from different stages and usually includes several bottom-up paths and several top-down paths. The head part is what is used to make the final object detections and classifications.
+
+## Bag of Freebies
+
+YOLOv4 also makes use of methods known as "bag of freebies," which are techniques that improve the accuracy of the model during training without increasing the cost of inference. Data augmentation is a common bag of freebies technique used in object detection, which increases the variability of the input images to improve the robustness of the model. Some examples of data augmentation include photometric distortions (adjusting the brightness, contrast, hue, saturation, and noise of an image) and geometric distortions (adding random scaling, cropping, flipping, and rotating). These techniques help the model to generalize better to different types of images.
+
+## Features and Performance
+
+YOLOv4 is designed for optimal speed and accuracy in object detection. The architecture of YOLOv4 includes CSPDarknet53 as the backbone, PANet as the neck, and YOLOv3 as the detection head. This design allows YOLOv4 to perform object detection at an impressive speed, making it suitable for real-time applications. YOLOv4 also excels in accuracy, achieving state-of-the-art results in object detection benchmarks.
+
+## Usage Examples
+
+As of the time of writing, Ultralytics does not currently support YOLOv4 models. Therefore, any users interested in using YOLOv4 will need to refer directly to the YOLOv4 GitHub repository for installation and usage instructions.
+
+Here is a brief overview of the typical steps you might take to use YOLOv4:
+
+1. Visit the YOLOv4 GitHub repository: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
+
+2. Follow the instructions provided in the README file for installation. This typically involves cloning the repository, installing necessary dependencies, and setting up any necessary environment variables.
+
+3. Once installation is complete, you can train and use the model as per the usage instructions provided in the repository. This usually involves preparing your dataset, configuring the model parameters, training the model, and then using the trained model to perform object detection.
+
+Please note that the specific steps may vary depending on your specific use case and the current state of the YOLOv4 repository. Therefore, it is strongly recommended to refer directly to the instructions provided in the YOLOv4 GitHub repository.
+
+We regret any inconvenience this may cause and will strive to update this document with usage examples for Ultralytics once support for YOLOv4 is implemented.
+
+## Conclusion
+
+YOLOv4 is a powerful and efficient object detection model that strikes a balance between speed and accuracy. Its use of unique features and bag of freebies techniques during training allows it to perform excellently in real-time object detection tasks. YOLOv4 can be trained and used by anyone with a conventional GPU, making it accessible and practical for a wide range of applications.
+
+## Citations and Acknowledgements
+
+We would like to acknowledge the YOLOv4 authors for their significant contributions in the field of real-time object detection:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{bochkovskiy2020yolov4,
+ title={YOLOv4: Optimal Speed and Accuracy of Object Detection},
+ author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao},
+ year={2020},
+ eprint={2004.10934},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+The original YOLOv4 paper can be found on [arXiv](https://arxiv.org/abs/2004.10934). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/AlexeyAB/darknet). We appreciate their efforts in advancing the field and making their work accessible to the broader community.
diff --git a/ultralytics/docs/en/models/yolov4.md:Zone.Identifier b/ultralytics/docs/en/models/yolov4.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov4.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/yolov5.md b/ultralytics/docs/en/models/yolov5.md
new file mode 100755
index 0000000..ab55225
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov5.md
@@ -0,0 +1,113 @@
+---
+comments: true
+description: Discover YOLOv5u, a boosted version of the YOLOv5 model featuring an improved accuracy-speed tradeoff and numerous pre-trained models for various object detection tasks.
+keywords: YOLOv5u, object detection, pre-trained models, Ultralytics, Inference, Validation, YOLOv5, YOLOv8, anchor-free, objectness-free, real-time applications, machine learning
+---
+
+# YOLOv5
+
+## Overview
+
+YOLOv5u represents an advancement in object detection methodologies. Originating from the foundational architecture of the [YOLOv5](https://github.com/ultralytics/yolov5) model developed by Ultralytics, YOLOv5u integrates the anchor-free, objectness-free split head, a feature previously introduced in the [YOLOv8](yolov8.md) models. This adaptation refines the model's architecture, leading to an improved accuracy-speed tradeoff in object detection tasks. Given the empirical results and its derived features, YOLOv5u provides an efficient alternative for those seeking robust solutions in both research and practical applications.
+
+
+
+## Key Features
+
+- **Anchor-free Split Ultralytics Head:** Traditional object detection models rely on predefined anchor boxes to predict object locations. However, YOLOv5u modernizes this approach. By adopting an anchor-free split Ultralytics head, it ensures a more flexible and adaptive detection mechanism, consequently enhancing the performance in diverse scenarios.
+
+- **Optimized Accuracy-Speed Tradeoff:** Speed and accuracy often pull in opposite directions. But YOLOv5u challenges this tradeoff. It offers a calibrated balance, ensuring real-time detections without compromising on accuracy. This feature is particularly invaluable for applications that demand swift responses, such as autonomous vehicles, robotics, and real-time video analytics.
+
+- **Variety of Pre-trained Models:** Understanding that different tasks require different toolsets, YOLOv5u provides a plethora of pre-trained models. Whether you're focusing on Inference, Validation, or Training, there's a tailor-made model awaiting you. This variety ensures you're not just using a one-size-fits-all solution, but a model specifically fine-tuned for your unique challenge.
+
+## Supported Tasks and Modes
+
+The YOLOv5u models, with various pre-trained weights, excel in [Object Detection](../tasks/detect.md) tasks. They support a comprehensive range of modes, making them suitable for diverse applications, from development to deployment.
+
+| Model Type | Pre-trained Weights | Task | Inference | Validation | Training | Export |
+|------------|-----------------------------------------------------------------------------------------------------------------------------|----------------------------------------|-----------|------------|----------|--------|
+| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+
+This table provides a detailed overview of the YOLOv5u model variants, highlighting their applicability in object detection tasks and support for various operational modes such as [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md). This comprehensive support ensures that users can fully leverage the capabilities of YOLOv5u models in a wide range of object detection scenarios.
+
+## Performance Metrics
+
+!!! Performance
+
+ === "Detection"
+
+ See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [COCO](https://docs.ultralytics.com/datasets/detect/coco/), which include 80 pre-trained classes.
+
+ | Model | YAML | size (pixels) | mAPval 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+ |---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
+ | [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34.3 | 73.6 | 1.06 | 2.6 | 7.7 |
+ | [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43.0 | 120.7 | 1.27 | 9.1 | 24.0 |
+ | [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49.0 | 233.9 | 1.86 | 25.1 | 64.2 |
+ | [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52.2 | 408.4 | 2.50 | 53.2 | 135.0 |
+ | [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53.2 | 763.2 | 3.81 | 97.2 | 246.4 |
+ | | | | | | | | |
+ | [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42.1 | 211.0 | 1.83 | 4.3 | 7.8 |
+ | [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48.6 | 422.6 | 2.34 | 15.3 | 24.6 |
+ | [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53.6 | 810.9 | 4.36 | 41.2 | 65.7 |
+ | [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55.7 | 1470.9 | 5.47 | 86.1 | 137.4 |
+ | [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56.8 | 2436.5 | 8.98 | 155.4 | 250.7 |
+
+## Usage Examples
+
+This example provides simple YOLOv5 training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages.
+
+!!! Example
+
+ === "Python"
+
+ PyTorch pretrained `*.pt` models as well as configuration `*.yaml` files can be passed to the `YOLO()` class to create a model instance in python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a COCO-pretrained YOLOv5n model
+ model = YOLO('yolov5n.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Train the model on the COCO8 example dataset for 100 epochs
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Run inference with the YOLOv5n model on the 'bus.jpg' image
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI commands are available to directly run the models:
+
+ ```bash
+ # Load a COCO-pretrained YOLOv5n model and train it on the COCO8 example dataset for 100 epochs
+ yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Load a COCO-pretrained YOLOv5n model and run inference on the 'bus.jpg' image
+ yolo predict model=yolov5n.pt source=path/to/bus.jpg
+ ```
+
+## Citations and Acknowledgements
+
+If you use YOLOv5 or YOLOv5u in your research, please cite the Ultralytics YOLOv5 repository as follows:
+
+!!! Quote ""
+
+ === "BibTeX"
+ ```bibtex
+ @software{yolov5,
+ title = {Ultralytics YOLOv5},
+ author = {Glenn Jocher},
+ year = {2020},
+ version = {7.0},
+ license = {AGPL-3.0},
+ url = {https://github.com/ultralytics/yolov5},
+ doi = {10.5281/zenodo.3908559},
+ orcid = {0000-0001-5950-6979}
+ }
+ ```
+
+Please note that YOLOv5 models are provided under [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) and [Enterprise](https://ultralytics.com/license) licenses.
diff --git a/ultralytics/docs/en/models/yolov5.md:Zone.Identifier b/ultralytics/docs/en/models/yolov5.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov5.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/yolov6.md b/ultralytics/docs/en/models/yolov6.md
new file mode 100755
index 0000000..a3aaca5
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov6.md
@@ -0,0 +1,107 @@
+---
+comments: true
+description: Explore Meituan YOLOv6, a state-of-the-art object detection model striking a balance between speed and accuracy. Dive into features, pre-trained models, and Python usage.
+keywords: Meituan YOLOv6, object detection, Ultralytics, YOLOv6 docs, Bi-directional Concatenation, Anchor-Aided Training, pretrained models, real-time applications
+---
+
+# Meituan YOLOv6
+
+## Overview
+
+[Meituan](https://about.meituan.com/) YOLOv6 is a cutting-edge object detector that offers remarkable balance between speed and accuracy, making it a popular choice for real-time applications. This model introduces several notable enhancements on its architecture and training scheme, including the implementation of a Bi-directional Concatenation (BiC) module, an anchor-aided training (AAT) strategy, and an improved backbone and neck design for state-of-the-art accuracy on the COCO dataset.
+
+
+
+**Overview of YOLOv6.** Model architecture diagram showing the redesigned network components and training strategies that have led to significant performance improvements. (a) The neck of YOLOv6 (N and S are shown). Note for M/L, RepBlocks is replaced with CSPStackRep. (b) The structure of a BiC module. (c) A SimCSPSPPF block. ([source](https://arxiv.org/pdf/2301.05586.pdf)).
+
+### Key Features
+
+- **Bidirectional Concatenation (BiC) Module:** YOLOv6 introduces a BiC module in the neck of the detector, enhancing localization signals and delivering performance gains with negligible speed degradation.
+- **Anchor-Aided Training (AAT) Strategy:** This model proposes AAT to enjoy the benefits of both anchor-based and anchor-free paradigms without compromising inference efficiency.
+- **Enhanced Backbone and Neck Design:** By deepening YOLOv6 to include another stage in the backbone and neck, this model achieves state-of-the-art performance on the COCO dataset at high-resolution input.
+- **Self-Distillation Strategy:** A new self-distillation strategy is implemented to boost the performance of smaller models of YOLOv6, enhancing the auxiliary regression branch during training and removing it at inference to avoid a marked speed decline.
+
+## Performance Metrics
+
+YOLOv6 provides various pre-trained models with different scales:
+
+- YOLOv6-N: 37.5% AP on COCO val2017 at 1187 FPS with NVIDIA Tesla T4 GPU.
+- YOLOv6-S: 45.0% AP at 484 FPS.
+- YOLOv6-M: 50.0% AP at 226 FPS.
+- YOLOv6-L: 52.8% AP at 116 FPS.
+- YOLOv6-L6: State-of-the-art accuracy in real-time.
+
+YOLOv6 also provides quantized models for different precisions and models optimized for mobile platforms.
+
+## Usage Examples
+
+This example provides simple YOLOv6 training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages.
+
+!!! Example
+
+ === "Python"
+
+ PyTorch pretrained `*.pt` models as well as configuration `*.yaml` files can be passed to the `YOLO()` class to create a model instance in python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Build a YOLOv6n model from scratch
+ model = YOLO('yolov6n.yaml')
+
+ # Display model information (optional)
+ model.info()
+
+ # Train the model on the COCO8 example dataset for 100 epochs
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Run inference with the YOLOv6n model on the 'bus.jpg' image
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI commands are available to directly run the models:
+
+ ```bash
+ # Build a YOLOv6n model from scratch and train it on the COCO8 example dataset for 100 epochs
+ yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
+
+ # Build a YOLOv6n model from scratch and run inference on the 'bus.jpg' image
+ yolo predict model=yolov6n.yaml source=path/to/bus.jpg
+ ```
+
+## Supported Tasks and Modes
+
+The YOLOv6 series offers a range of models, each optimized for high-performance [Object Detection](../tasks/detect.md). These models cater to varying computational needs and accuracy requirements, making them versatile for a wide array of applications.
+
+| Model Type | Pre-trained Weights | Tasks Supported | Inference | Validation | Training | Export |
+|------------|---------------------|----------------------------------------|-----------|------------|----------|--------|
+| YOLOv6-N | `yolov6-n.pt` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-S | `yolov6-s.pt` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-M | `yolov6-m.pt` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-L | `yolov6-l.pt` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-L6 | `yolov6-l6.pt` | [Object Detection](../tasks/detect.md) | โ | โ | โ | โ |
+
+This table provides a detailed overview of the YOLOv6 model variants, highlighting their capabilities in object detection tasks and their compatibility with various operational modes such as [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md). This comprehensive support ensures that users can fully leverage the capabilities of YOLOv6 models in a broad range of object detection scenarios.
+
+## Citations and Acknowledgements
+
+We would like to acknowledge the authors for their significant contributions in the field of real-time object detection:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{li2023yolov6,
+ title={YOLOv6 v3.0: A Full-Scale Reloading},
+ author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
+ year={2023},
+ eprint={2301.05586},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+The original YOLOv6 paper can be found on [arXiv](https://arxiv.org/abs/2301.05586). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/meituan/YOLOv6). We appreciate their efforts in advancing the field and making their work accessible to the broader community.
diff --git a/ultralytics/docs/en/models/yolov6.md:Zone.Identifier b/ultralytics/docs/en/models/yolov6.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov6.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/yolov7.md b/ultralytics/docs/en/models/yolov7.md
new file mode 100755
index 0000000..f3d99d5
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov7.md
@@ -0,0 +1,65 @@
+---
+comments: true
+description: Explore the YOLOv7, a real-time object detector. Understand its superior speed, impressive accuracy, and unique trainable bag-of-freebies optimization focus.
+keywords: YOLOv7, real-time object detector, state-of-the-art, Ultralytics, MS COCO dataset, model re-parameterization, dynamic label assignment, extended scaling, compound scaling
+---
+
+# YOLOv7: Trainable Bag-of-Freebies
+
+YOLOv7 is a state-of-the-art real-time object detector that surpasses all known object detectors in both speed and accuracy in the range from 5 FPS to 160 FPS. It has the highest accuracy (56.8% AP) among all known real-time object detectors with 30 FPS or higher on GPU V100. Moreover, YOLOv7 outperforms other object detectors such as YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5, and many others in speed and accuracy. The model is trained on the MS COCO dataset from scratch without using any other datasets or pre-trained weights. Source code for YOLOv7 is available on GitHub.
+
+
+**Comparison of state-of-the-art object detectors.** From the results in Table 2 we know that the proposed method has the best speed-accuracy trade-off comprehensively. If we compare YOLOv7-tiny-SiLU with YOLOv5-N (r6.1), our method is 127 fps faster and 10.7% more accurate on AP. In addition, YOLOv7 has 51.4% AP at frame rate of 161 fps, while PPYOLOE-L with the same AP has only 78 fps frame rate. In terms of parameter usage, YOLOv7 is 41% less than PPYOLOE-L. If we compare YOLOv7-X with 114 fps inference speed to YOLOv5-L (r6.1) with 99 fps inference speed, YOLOv7-X can improve AP by 3.9%. If YOLOv7-X is compared with YOLOv5-X (r6.1) of similar scale, the inference speed of YOLOv7-X is 31 fps faster. In addition, in terms the amount of parameters and computation, YOLOv7-X reduces 22% of parameters and 8% of computation compared to YOLOv5-X (r6.1), but improves AP by 2.2% ([Source](https://arxiv.org/pdf/2207.02696.pdf)).
+
+## Overview
+
+Real-time object detection is an important component in many computer vision systems, including multi-object tracking, autonomous driving, robotics, and medical image analysis. In recent years, real-time object detection development has focused on designing efficient architectures and improving the inference speed of various CPUs, GPUs, and neural processing units (NPUs). YOLOv7 supports both mobile GPU and GPU devices, from the edge to the cloud.
+
+Unlike traditional real-time object detectors that focus on architecture optimization, YOLOv7 introduces a focus on the optimization of the training process. This includes modules and optimization methods designed to improve the accuracy of object detection without increasing the inference cost, a concept known as the "trainable bag-of-freebies".
+
+## Key Features
+
+YOLOv7 introduces several key features:
+
+1. **Model Re-parameterization**: YOLOv7 proposes a planned re-parameterized model, which is a strategy applicable to layers in different networks with the concept of gradient propagation path.
+
+2. **Dynamic Label Assignment**: The training of the model with multiple output layers presents a new issue: "How to assign dynamic targets for the outputs of different branches?" To solve this problem, YOLOv7 introduces a new label assignment method called coarse-to-fine lead guided label assignment.
+
+3. **Extended and Compound Scaling**: YOLOv7 proposes "extend" and "compound scaling" methods for the real-time object detector that can effectively utilize parameters and computation.
+
+4. **Efficiency**: The method proposed by YOLOv7 can effectively reduce about 40% parameters and 50% computation of state-of-the-art real-time object detector, and has faster inference speed and higher detection accuracy.
+
+## Usage Examples
+
+As of the time of writing, Ultralytics does not currently support YOLOv7 models. Therefore, any users interested in using YOLOv7 will need to refer directly to the YOLOv7 GitHub repository for installation and usage instructions.
+
+Here is a brief overview of the typical steps you might take to use YOLOv7:
+
+1. Visit the YOLOv7 GitHub repository: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
+
+2. Follow the instructions provided in the README file for installation. This typically involves cloning the repository, installing necessary dependencies, and setting up any necessary environment variables.
+
+3. Once installation is complete, you can train and use the model as per the usage instructions provided in the repository. This usually involves preparing your dataset, configuring the model parameters, training the model, and then using the trained model to perform object detection.
+
+Please note that the specific steps may vary depending on your specific use case and the current state of the YOLOv7 repository. Therefore, it is strongly recommended to refer directly to the instructions provided in the YOLOv7 GitHub repository.
+
+We regret any inconvenience this may cause and will strive to update this document with usage examples for Ultralytics once support for YOLOv7 is implemented.
+
+## Citations and Acknowledgements
+
+We would like to acknowledge the YOLOv7 authors for their significant contributions in the field of real-time object detection:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{wang2022yolov7,
+ title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
+ author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
+ journal={arXiv preprint arXiv:2207.02696},
+ year={2022}
+ }
+ ```
+
+The original YOLOv7 paper can be found on [arXiv](https://arxiv.org/pdf/2207.02696.pdf). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/WongKinYiu/yolov7). We appreciate their efforts in advancing the field and making their work accessible to the broader community.
diff --git a/ultralytics/docs/en/models/yolov7.md:Zone.Identifier b/ultralytics/docs/en/models/yolov7.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov7.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/models/yolov8.md b/ultralytics/docs/en/models/yolov8.md
new file mode 100755
index 0000000..fd70130
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov8.md
@@ -0,0 +1,173 @@
+---
+comments: true
+description: Explore the thrilling features of YOLOv8, the latest version of our real-time object detector! Learn how advanced architectures, pre-trained models and optimal balance between accuracy & speed make YOLOv8 the perfect choice for your object detection tasks.
+keywords: YOLOv8, Ultralytics, real-time object detector, pre-trained models, documentation, object detection, YOLO series, advanced architectures, accuracy, speed
+---
+
+# YOLOv8
+
+## Overview
+
+YOLOv8 is the latest iteration in the YOLO series of real-time object detectors, offering cutting-edge performance in terms of accuracy and speed. Building upon the advancements of previous YOLO versions, YOLOv8 introduces new features and optimizations that make it an ideal choice for various object detection tasks in a wide range of applications.
+
+
+
+
+
+
+
+ Watch: Ultralytics YOLOv8 Model Overview
+
+
+## Key Features
+
+- **Advanced Backbone and Neck Architectures:** YOLOv8 employs state-of-the-art backbone and neck architectures, resulting in improved feature extraction and object detection performance.
+- **Anchor-free Split Ultralytics Head:** YOLOv8 adopts an anchor-free split Ultralytics head, which contributes to better accuracy and a more efficient detection process compared to anchor-based approaches.
+- **Optimized Accuracy-Speed Tradeoff:** With a focus on maintaining an optimal balance between accuracy and speed, YOLOv8 is suitable for real-time object detection tasks in diverse application areas.
+- **Variety of Pre-trained Models:** YOLOv8 offers a range of pre-trained models to cater to various tasks and performance requirements, making it easier to find the right model for your specific use case.
+
+## Supported Tasks and Modes
+
+The YOLOv8 series offers a diverse range of models, each specialized for specific tasks in computer vision. These models are designed to cater to various requirements, from object detection to more complex tasks like instance segmentation, pose/keypoints detection, and classification.
+
+Each variant of the YOLOv8 series is optimized for its respective task, ensuring high performance and accuracy. Additionally, these models are compatible with various operational modes including [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md), facilitating their use in different stages of deployment and development.
+
+| Model | Filenames | Task | Inference | Validation | Training | Export |
+|-------------|----------------------------------------------------------------------------------------------------------------|----------------------------------------------|-----------|------------|----------|--------|
+| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Detection](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Instance Segmentation](../tasks/segment.md) | โ | โ | โ | โ |
+| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Keypoints](../tasks/pose.md) | โ | โ | โ | โ |
+| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Classification](../tasks/classify.md) | โ | โ | โ | โ |
+
+This table provides an overview of the YOLOv8 model variants, highlighting their applicability in specific tasks and their compatibility with various operational modes such as Inference, Validation, Training, and Export. It showcases the versatility and robustness of the YOLOv8 series, making them suitable for a variety of applications in computer vision.
+
+## Performance Metrics
+
+!!! Performance
+
+ === "Detection (COCO)"
+
+ See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [COCO](https://docs.ultralytics.com/datasets/detect/coco/), which include 80 pre-trained classes.
+
+ | Model | size (pixels) | mAPval 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+ | ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
+ | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
+ | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
+ | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
+ | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
+
+ === "Detection (Open Images V7)"
+
+ See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), which include 600 pre-trained classes.
+
+ | Model | size (pixels) | mAPval 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+ | ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
+ | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
+ | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
+ | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
+ | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
+
+ === "Segmentation (COCO)"
+
+ See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for usage examples with these models trained on [COCO](https://docs.ultralytics.com/datasets/segment/coco/), which include 80 pre-trained classes.
+
+ | Model | size (pixels) | mAPbox 50-95 | mAPmask 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+ | -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
+ | [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
+ | [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
+ | [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
+ | [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
+
+ === "Classification (ImageNet)"
+
+ See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for usage examples with these models trained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), which include 1000 pre-trained classes.
+
+ | Model | size (pixels) | acc top1 | acc top5 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) at 640 |
+ | -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------ | ----------------------------------- | ------------------ | ------------------------ |
+ | [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
+ | [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
+ | [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
+ | [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
+ | [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
+
+ === "Pose (COCO)"
+
+ See [Pose Estimation Docs](https://docs.ultralytics.com/tasks/segment/) for usage examples with these models trained on [COCO](https://docs.ultralytics.com/datasets/pose/coco/), which include 1 pre-trained class, 'person'.
+
+ | Model | size (pixels) | mAPpose 50-95 | mAPpose 50 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+ | ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
+ | [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
+ | [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
+ | [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
+ | [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
+ | [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
+ | [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
+
+## Usage Examples
+
+This example provides simple YOLOv8 training and inference examples. For full documentation on these and other [modes](../modes/index.md) see the [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) and [Export](../modes/export.md) docs pages.
+
+Note the below example is for YOLOv8 [Detect](../tasks/detect.md) models for object detection. For additional supported tasks see the [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) and [Pose](../tasks/pose.md) docs.
+
+!!! Example
+
+ === "Python"
+
+ PyTorch pretrained `*.pt` models as well as configuration `*.yaml` files can be passed to the `YOLO()` class to create a model instance in python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a COCO-pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Train the model on the COCO8 example dataset for 100 epochs
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Run inference with the YOLOv8n model on the 'bus.jpg' image
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ CLI commands are available to directly run the models:
+
+ ```bash
+ # Load a COCO-pretrained YOLOv8n model and train it on the COCO8 example dataset for 100 epochs
+ yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Load a COCO-pretrained YOLOv8n model and run inference on the 'bus.jpg' image
+ yolo predict model=yolov8n.pt source=path/to/bus.jpg
+ ```
+
+## Citations and Acknowledgements
+
+If you use the YOLOv8 model or any other software from this repository in your work, please cite it using the following format:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @software{yolov8_ultralytics,
+ author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu},
+ title = {Ultralytics YOLOv8},
+ version = {8.0.0},
+ year = {2023},
+ url = {https://github.com/ultralytics/ultralytics},
+ orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069},
+ license = {AGPL-3.0}
+ }
+ ```
+
+Please note that the DOI is pending and will be added to the citation once it is available. YOLOv8 models are provided under [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) and [Enterprise](https://ultralytics.com/license) licenses.
diff --git a/ultralytics/docs/en/models/yolov8.md:Zone.Identifier b/ultralytics/docs/en/models/yolov8.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/models/yolov8.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/modes/benchmark.md b/ultralytics/docs/en/modes/benchmark.md
new file mode 100755
index 0000000..892e732
--- /dev/null
+++ b/ultralytics/docs/en/modes/benchmark.md
@@ -0,0 +1,105 @@
+---
+comments: true
+description: Learn how to profile speed and accuracy of YOLOv8 across various export formats; get insights on mAP50-95, accuracy_top5 metrics, and more.
+keywords: Ultralytics, YOLOv8, benchmarking, speed profiling, accuracy profiling, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, YOLO export formats
+---
+
+# Model Benchmarking with Ultralytics YOLO
+
+
+
+## Introduction
+
+Once your model is trained and validated, the next logical step is to evaluate its performance in various real-world scenarios. Benchmark mode in Ultralytics YOLOv8 serves this purpose by providing a robust framework for assessing the speed and accuracy of your model across a range of export formats.
+
+
+
+## Why Is Benchmarking Crucial?
+
+- **Informed Decisions:** Gain insights into the trade-offs between speed and accuracy.
+- **Resource Allocation:** Understand how different export formats perform on different hardware.
+- **Optimization:** Learn which export format offers the best performance for your specific use case.
+- **Cost Efficiency:** Make more efficient use of hardware resources based on benchmark results.
+
+### Key Metrics in Benchmark Mode
+
+- **mAP50-95:** For object detection, segmentation, and pose estimation.
+- **accuracy_top5:** For image classification.
+- **Inference Time:** Time taken for each image in milliseconds.
+
+### Supported Export Formats
+
+- **ONNX:** For optimal CPU performance
+- **TensorRT:** For maximal GPU efficiency
+- **OpenVINO:** For Intel hardware optimization
+- **CoreML, TensorFlow SavedModel, and More:** For diverse deployment needs.
+
+!!! Tip "Tip"
+
+ * Export to ONNX or OpenVINO for up to 3x CPU speedup.
+ * Export to TensorRT for up to 5x GPU speedup.
+
+## Usage Examples
+
+Run YOLOv8n benchmarks on all supported export formats including ONNX, TensorRT etc. See Arguments section below for a full list of export arguments.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics.utils.benchmarks import benchmark
+
+ # Benchmark on GPU
+ benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
+ ```
+ === "CLI"
+
+ ```bash
+ yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
+ ```
+
+## Arguments
+
+Arguments such as `model`, `data`, `imgsz`, `half`, `device`, and `verbose` provide users with the flexibility to fine-tune the benchmarks to their specific needs and compare the performance of different export formats with ease.
+
+| Key | Value | Description |
+|-----------|---------|-----------------------------------------------------------------------|
+| `model` | `None` | path to model file, i.e. yolov8n.pt, yolov8n.yaml |
+| `data` | `None` | path to YAML referencing the benchmarking dataset (under `val` label) |
+| `imgsz` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `half` | `False` | FP16 quantization |
+| `int8` | `False` | INT8 quantization |
+| `device` | `None` | device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu |
+| `verbose` | `False` | do not continue on error (bool), or val floor threshold (float) |
+
+## Export Formats
+
+Benchmarks will attempt to run automatically on all possible export formats below.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half`, `int8` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras`, `int8` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
+
+See full `export` details in the [Export](https://docs.ultralytics.com/modes/export/) page.
diff --git a/ultralytics/docs/en/modes/benchmark.md:Zone.Identifier b/ultralytics/docs/en/modes/benchmark.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/modes/benchmark.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/modes/export.md b/ultralytics/docs/en/modes/export.md
new file mode 100755
index 0000000..9077481
--- /dev/null
+++ b/ultralytics/docs/en/modes/export.md
@@ -0,0 +1,108 @@
+---
+comments: true
+description: Step-by-step guide on exporting your YOLOv8 models to various format like ONNX, TensorRT, CoreML and more for deployment. Explore now!.
+keywords: YOLO, YOLOv8, Ultralytics, Model export, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, export model
+---
+
+# Model Export with Ultralytics YOLO
+
+
+
+## Introduction
+
+The ultimate goal of training a model is to deploy it for real-world applications. Export mode in Ultralytics YOLOv8 offers a versatile range of options for exporting your trained model to different formats, making it deployable across various platforms and devices. This comprehensive guide aims to walk you through the nuances of model exporting, showcasing how to achieve maximum compatibility and performance.
+
+
+
+
+
+ Watch: How To Export Custom Trained Ultralytics YOLOv8 Model and Run Live Inference on Webcam.
+
+
+## Why Choose YOLOv8's Export Mode?
+
+- **Versatility:** Export to multiple formats including ONNX, TensorRT, CoreML, and more.
+- **Performance:** Gain up to 5x GPU speedup with TensorRT and 3x CPU speedup with ONNX or OpenVINO.
+- **Compatibility:** Make your model universally deployable across numerous hardware and software environments.
+- **Ease of Use:** Simple CLI and Python API for quick and straightforward model exporting.
+
+### Key Features of Export Mode
+
+Here are some of the standout functionalities:
+
+- **One-Click Export:** Simple commands for exporting to different formats.
+- **Batch Export:** Export batched-inference capable models.
+- **Optimized Inference:** Exported models are optimized for quicker inference times.
+- **Tutorial Videos:** In-depth guides and tutorials for a smooth exporting experience.
+
+!!! Tip "Tip"
+
+ * Export to ONNX or OpenVINO for up to 3x CPU speedup.
+ * Export to TensorRT for up to 5x GPU speedup.
+
+## Usage Examples
+
+Export a YOLOv8n model to a different format like ONNX or TensorRT. See Arguments section below for a full list of export arguments.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom trained model
+
+ # Export the model
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n.pt format=onnx # export official model
+ yolo export model=path/to/best.pt format=onnx # export custom trained model
+ ```
+
+## Arguments
+
+Export settings for YOLO models refer to the various configurations and options used to save or export the model for use in other environments or platforms. These settings can affect the model's performance, size, and compatibility with different systems. Some common YOLO export settings include the format of the exported model file (e.g. ONNX, TensorFlow SavedModel), the device on which the model will be run (e.g. CPU, GPU), and the presence of additional features such as masks or multiple labels per box. Other factors that may affect the export process include the specific task the model is being used for and the requirements or constraints of the target environment or platform. It is important to carefully consider and configure these settings to ensure that the exported model is optimized for the intended use case and can be used effectively in the target environment.
+
+| Key | Value | Description |
+|-------------|-----------------|------------------------------------------------------|
+| `format` | `'torchscript'` | format to export to |
+| `imgsz` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `keras` | `False` | use Keras for TF SavedModel export |
+| `optimize` | `False` | TorchScript: optimize for mobile |
+| `half` | `False` | FP16 quantization |
+| `int8` | `False` | INT8 quantization |
+| `dynamic` | `False` | ONNX/TensorRT: dynamic axes |
+| `simplify` | `False` | ONNX/TensorRT: simplify model |
+| `opset` | `None` | ONNX: opset version (optional, defaults to latest) |
+| `workspace` | `4` | TensorRT: workspace size (GB) |
+| `nms` | `False` | CoreML: add NMS |
+
+## Export Formats
+
+Available YOLOv8 export formats are in the table below. You can export to any format using the `format` argument, i.e. `format='onnx'` or `format='engine'`.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half`, `int8` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras`, `int8` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
diff --git a/ultralytics/docs/en/modes/export.md:Zone.Identifier b/ultralytics/docs/en/modes/export.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/modes/export.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/modes/index.md b/ultralytics/docs/en/modes/index.md
new file mode 100755
index 0000000..d0a0f9e
--- /dev/null
+++ b/ultralytics/docs/en/modes/index.md
@@ -0,0 +1,74 @@
+---
+comments: true
+description: From training to tracking, make the most of YOLOv8 with Ultralytics. Get insights and examples for each supported mode including validation, export, and benchmarking.
+keywords: Ultralytics, YOLOv8, Machine Learning, Object Detection, Training, Validation, Prediction, Export, Tracking, Benchmarking
+---
+
+# Ultralytics YOLOv8 Modes
+
+
+
+## Introduction
+
+Ultralytics YOLOv8 is not just another object detection model; it's a versatile framework designed to cover the entire lifecycle of machine learning modelsโfrom data ingestion and model training to validation, deployment, and real-world tracking. Each mode serves a specific purpose and is engineered to offer you the flexibility and efficiency required for different tasks and use-cases.
+
+
+
+### Modes at a Glance
+
+Understanding the different **modes** that Ultralytics YOLOv8 supports is critical to getting the most out of your models:
+
+- **Train** mode: Fine-tune your model on custom or preloaded datasets.
+- **Val** mode: A post-training checkpoint to validate model performance.
+- **Predict** mode: Unleash the predictive power of your model on real-world data.
+- **Export** mode: Make your model deployment-ready in various formats.
+- **Track** mode: Extend your object detection model into real-time tracking applications.
+- **Benchmark** mode: Analyze the speed and accuracy of your model in diverse deployment environments.
+
+This comprehensive guide aims to give you an overview and practical insights into each mode, helping you harness the full potential of YOLOv8.
+
+## [Train](train.md)
+
+Train mode is used for training a YOLOv8 model on a custom dataset. In this mode, the model is trained using the specified dataset and hyperparameters. The training process involves optimizing the model's parameters so that it can accurately predict the classes and locations of objects in an image.
+
+[Train Examples](train.md){ .md-button }
+
+## [Val](val.md)
+
+Val mode is used for validating a YOLOv8 model after it has been trained. In this mode, the model is evaluated on a validation set to measure its accuracy and generalization performance. This mode can be used to tune the hyperparameters of the model to improve its performance.
+
+[Val Examples](val.md){ .md-button }
+
+## [Predict](predict.md)
+
+Predict mode is used for making predictions using a trained YOLOv8 model on new images or videos. In this mode, the model is loaded from a checkpoint file, and the user can provide images or videos to perform inference. The model predicts the classes and locations of objects in the input images or videos.
+
+[Predict Examples](predict.md){ .md-button }
+
+## [Export](export.md)
+
+Export mode is used for exporting a YOLOv8 model to a format that can be used for deployment. In this mode, the model is converted to a format that can be used by other software applications or hardware devices. This mode is useful when deploying the model to production environments.
+
+[Export Examples](export.md){ .md-button }
+
+## [Track](track.md)
+
+Track mode is used for tracking objects in real-time using a YOLOv8 model. In this mode, the model is loaded from a checkpoint file, and the user can provide a live video stream to perform real-time object tracking. This mode is useful for applications such as surveillance systems or self-driving cars.
+
+[Track Examples](track.md){ .md-button }
+
+## [Benchmark](benchmark.md)
+
+Benchmark mode is used to profile the speed and accuracy of various export formats for YOLOv8. The benchmarks provide information on the size of the exported format, its `mAP50-95` metrics (for object detection, segmentation and pose)
+or `accuracy_top5` metrics (for classification), and the inference time in milliseconds per image across various export formats like ONNX, OpenVINO, TensorRT and others. This information can help users choose the optimal export format for their specific use case based on their requirements for speed and accuracy.
+
+[Benchmark Examples](benchmark.md){ .md-button }
diff --git a/ultralytics/docs/en/modes/index.md:Zone.Identifier b/ultralytics/docs/en/modes/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/modes/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/modes/predict.md b/ultralytics/docs/en/modes/predict.md
new file mode 100755
index 0000000..6c4561f
--- /dev/null
+++ b/ultralytics/docs/en/modes/predict.md
@@ -0,0 +1,728 @@
+---
+comments: true
+description: Discover how to use YOLOv8 predict mode for various tasks. Learn about different inference sources like images, videos, and data formats.
+keywords: Ultralytics, YOLOv8, predict mode, inference sources, prediction tasks, streaming mode, image processing, video processing, machine learning, AI
+---
+
+# Model Prediction with Ultralytics YOLO
+
+
+
+## Introduction
+
+In the world of machine learning and computer vision, the process of making sense out of visual data is called 'inference' or 'prediction'. Ultralytics YOLOv8 offers a powerful feature known as **predict mode** that is tailored for high-performance, real-time inference on a wide range of data sources.
+
+
+
+
+
+ Watch: How to Extract the Outputs from Ultralytics YOLOv8 Model for Custom Projects.
+
+
+## Real-world Applications
+
+| Manufacturing | Sports | Safety |
+|:-------------------------------------------------:|:----------------------------------------------------:|:-------------------------------------------:|
+| ![Vehicle Spare Parts Detection][car spare parts] | ![Football Player Detection][football player detect] | ![People Fall Detection][human fall detect] |
+| Vehicle Spare Parts Detection | Football Player Detection | People Fall Detection |
+
+## Why Use Ultralytics YOLO for Inference?
+
+Here's why you should consider YOLOv8's predict mode for your various inference needs:
+
+- **Versatility:** Capable of making inferences on images, videos, and even live streams.
+- **Performance:** Engineered for real-time, high-speed processing without sacrificing accuracy.
+- **Ease of Use:** Intuitive Python and CLI interfaces for rapid deployment and testing.
+- **Highly Customizable:** Various settings and parameters to tune the model's inference behavior according to your specific requirements.
+
+### Key Features of Predict Mode
+
+YOLOv8's predict mode is designed to be robust and versatile, featuring:
+
+- **Multiple Data Source Compatibility:** Whether your data is in the form of individual images, a collection of images, video files, or real-time video streams, predict mode has you covered.
+- **Streaming Mode:** Use the streaming feature to generate a memory-efficient generator of `Results` objects. Enable this by setting `stream=True` in the predictor's call method.
+- **Batch Processing:** The ability to process multiple images or video frames in a single batch, further speeding up inference time.
+- **Integration Friendly:** Easily integrate with existing data pipelines and other software components, thanks to its flexible API.
+
+Ultralytics YOLO models return either a Python list of `Results` objects, or a memory-efficient Python generator of `Results` objects when `stream=True` is passed to the model during inference:
+
+!!! Example "Predict"
+
+ === "Return a list with `stream=False`"
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # pretrained YOLOv8n model
+
+ # Run batched inference on a list of images
+ results = model(['im1.jpg', 'im2.jpg']) # return a list of Results objects
+
+ # Process results list
+ for result in results:
+ boxes = result.boxes # Boxes object for bbox outputs
+ masks = result.masks # Masks object for segmentation masks outputs
+ keypoints = result.keypoints # Keypoints object for pose outputs
+ probs = result.probs # Probs object for classification outputs
+ ```
+
+ === "Return a generator with `stream=True`"
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # pretrained YOLOv8n model
+
+ # Run batched inference on a list of images
+ results = model(['im1.jpg', 'im2.jpg'], stream=True) # return a generator of Results objects
+
+ # Process results generator
+ for result in results:
+ boxes = result.boxes # Boxes object for bbox outputs
+ masks = result.masks # Masks object for segmentation masks outputs
+ keypoints = result.keypoints # Keypoints object for pose outputs
+ probs = result.probs # Probs object for classification outputs
+ ```
+
+## Inference Sources
+
+YOLOv8 can process different types of input sources for inference, as shown in the table below. The sources include static images, video streams, and various data formats. The table also indicates whether each source can be used in streaming mode with the argument `stream=True` โ . Streaming mode is beneficial for processing videos or live streams as it creates a generator of results instead of loading all frames into memory.
+
+!!! Tip "Tip"
+
+ Use `stream=True` for processing long videos or large datasets to efficiently manage memory. When `stream=False`, the results for all frames or data points are stored in memory, which can quickly add up and cause out-of-memory errors for large inputs. In contrast, `stream=True` utilizes a generator, which only keeps the results of the current frame or data point in memory, significantly reducing memory consumption and preventing out-of-memory issues.
+
+| Source | Argument | Type | Notes |
+|----------------|--------------------------------------------|-----------------|---------------------------------------------------------------------------------------------|
+| image | `'image.jpg'` | `str` or `Path` | Single image file. |
+| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL to an image. |
+| screenshot | `'screen'` | `str` | Capture a screenshot. |
+| PIL | `Image.open('im.jpg')` | `PIL.Image` | HWC format with RGB channels. |
+| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | HWC format with BGR channels `uint8 (0-255)`. |
+| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | HWC format with BGR channels `uint8 (0-255)`. |
+| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | BCHW format with RGB channels `float32 (0.0-1.0)`. |
+| CSV | `'sources.csv'` | `str` or `Path` | CSV file containing paths to images, videos, or directories. |
+| video โ | `'video.mp4'` | `str` or `Path` | Video file in formats like MP4, AVI, etc. |
+| directory โ | `'path/'` | `str` or `Path` | Path to a directory containing images or videos. |
+| glob โ | `'path/*.jpg'` | `str` | Glob pattern to match multiple files. Use the `*` character as a wildcard. |
+| YouTube โ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL to a YouTube video. |
+| stream โ | `'rtsp://example.com/media.mp4'` | `str` | URL for streaming protocols such as RTSP, RTMP, TCP, or an IP address. |
+| multi-stream โ | `'list.streams'` | `str` or `Path` | `*.streams` text file with one stream URL per row, i.e. 8 streams will run at batch-size 8. |
+
+Below are code examples for using each source type:
+
+!!! Example "Prediction sources"
+
+ === "image"
+ Run inference on an image file.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define path to the image file
+ source = 'path/to/image.jpg'
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "screenshot"
+ Run inference on the current screen content as a screenshot.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define current screenshot as source
+ source = 'screen'
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "URL"
+ Run inference on an image or video hosted remotely via URL.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define remote image or video URL
+ source = 'https://ultralytics.com/images/bus.jpg'
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "PIL"
+ Run inference on an image opened with Python Imaging Library (PIL).
+ ```python
+ from PIL import Image
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Open an image using PIL
+ source = Image.open('path/to/image.jpg')
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "OpenCV"
+ Run inference on an image read with OpenCV.
+ ```python
+ import cv2
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Read an image using OpenCV
+ source = cv2.imread('path/to/image.jpg')
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "numpy"
+ Run inference on an image represented as a numpy array.
+ ```python
+ import numpy as np
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Create a random numpy array of HWC shape (640, 640, 3) with values in range [0, 255] and type uint8
+ source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "torch"
+ Run inference on an image represented as a PyTorch tensor.
+ ```python
+ import torch
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32
+ source = torch.rand(1, 3, 640, 640, dtype=torch.float32)
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "CSV"
+ Run inference on a collection of images, URLs, videos and directories listed in a CSV file.
+ ```python
+ import torch
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define a path to a CSV file with images, URLs, videos and directories
+ source = 'path/to/file.csv'
+
+ # Run inference on the source
+ results = model(source) # list of Results objects
+ ```
+
+ === "video"
+ Run inference on a video file. By using `stream=True`, you can create a generator of Results objects to reduce memory usage.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define path to video file
+ source = 'path/to/video.mp4'
+
+ # Run inference on the source
+ results = model(source, stream=True) # generator of Results objects
+ ```
+
+ === "directory"
+ Run inference on all images and videos in a directory. To also capture images and videos in subdirectories use a glob pattern, i.e. `path/to/dir/**/*`.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define path to directory containing images and videos for inference
+ source = 'path/to/dir'
+
+ # Run inference on the source
+ results = model(source, stream=True) # generator of Results objects
+ ```
+
+ === "glob"
+ Run inference on all images and videos that match a glob expression with `*` characters.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define a glob search for all JPG files in a directory
+ source = 'path/to/dir/*.jpg'
+
+ # OR define a recursive glob search for all JPG files including subdirectories
+ source = 'path/to/dir/**/*.jpg'
+
+ # Run inference on the source
+ results = model(source, stream=True) # generator of Results objects
+ ```
+
+ === "YouTube"
+ Run inference on a YouTube video. By using `stream=True`, you can create a generator of Results objects to reduce memory usage for long videos.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Define source as YouTube video URL
+ source = 'https://youtu.be/LNwODJXcvt4'
+
+ # Run inference on the source
+ results = model(source, stream=True) # generator of Results objects
+ ```
+
+ === "Streams"
+ Run inference on remote streaming sources using RTSP, RTMP, TCP and IP address protocols. If multiple streams are provided in a `*.streams` text file then batched inference will run, i.e. 8 streams will run at batch-size 8, otherwise single streams will run at batch-size 1.
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Single stream with batch-size 1 inference
+ source = 'rtsp://example.com/media.mp4' # RTSP, RTMP, TCP or IP streaming address
+
+ # Multiple streams with batched inference (i.e. batch-size 8 for 8 streams)
+ source = 'path/to/list.streams' # *.streams text file with one streaming address per row
+
+ # Run inference on the source
+ results = model(source, stream=True) # generator of Results objects
+ ```
+
+## Inference Arguments
+
+`model.predict()` accepts multiple arguments that can be passed at inference time to override defaults:
+
+!!! Example
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Run inference on 'bus.jpg' with arguments
+ model.predict('bus.jpg', save=True, imgsz=320, conf=0.5)
+ ```
+
+Inference arguments:
+
+| Name | Type | Default | Description |
+|-----------------|----------------|------------------------|----------------------------------------------------------------------------|
+| `source` | `str` | `'ultralytics/assets'` | source directory for images or videos |
+| `conf` | `float` | `0.25` | object confidence threshold for detection |
+| `iou` | `float` | `0.7` | intersection over union (IoU) threshold for NMS |
+| `imgsz` | `int or tuple` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `half` | `bool` | `False` | use half precision (FP16) |
+| `device` | `None or str` | `None` | device to run on, i.e. cuda device=0/1/2/3 or device=cpu |
+| `max_det` | `int` | `300` | maximum number of detections per image |
+| `vid_stride` | `bool` | `False` | video frame-rate stride |
+| `stream_buffer` | `bool` | `False` | buffer all streaming frames (True) or return the most recent frame (False) |
+| `visualize` | `bool` | `False` | visualize model features |
+| `augment` | `bool` | `False` | apply image augmentation to prediction sources |
+| `agnostic_nms` | `bool` | `False` | class-agnostic NMS |
+| `classes` | `list[int]` | `None` | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+| `retina_masks` | `bool` | `False` | use high-resolution segmentation masks |
+| `embed` | `list[int]` | `None` | return feature vectors/embeddings from given layers |
+
+Visualization arguments:
+
+| Name | Type | Default | Description |
+|---------------|---------------|---------|-----------------------------------------------------------------|
+| `show` | `bool` | `False` | show predicted images and videos if environment allows |
+| `save` | `bool` | `False` | save predicted images and videos |
+| `save_frames` | `bool` | `False` | save predicted individual video frames |
+| `save_txt` | `bool` | `False` | save results as `.txt` file |
+| `save_conf` | `bool` | `False` | save results with confidence scores |
+| `save_crop` | `bool` | `False` | save cropped images with results |
+| `show_labels` | `bool` | `True` | show prediction labels, i.e. 'person' |
+| `show_conf` | `bool` | `True` | show prediction confidence, i.e. '0.99' |
+| `show_boxes` | `bool` | `True` | show prediction boxes |
+| `line_width` | `None or int` | `None` | line width of the bounding boxes. Scaled to image size if None. |
+
+## Image and Video Formats
+
+YOLOv8 supports various image and video formats, as specified in [data/utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/utils.py). See the tables below for the valid suffixes and example predict commands.
+
+### Images
+
+The below table contains valid Ultralytics image formats.
+
+| Image Suffixes | Example Predict Command | Reference |
+|----------------|----------------------------------|-------------------------------------------------------------------------------|
+| .bmp | `yolo predict source=image.bmp` | [Microsoft BMP File Format](https://en.wikipedia.org/wiki/BMP_file_format) |
+| .dng | `yolo predict source=image.dng` | [Adobe DNG](https://www.adobe.com/products/photoshop/extend.displayTab2.html) |
+| .jpeg | `yolo predict source=image.jpeg` | [JPEG](https://en.wikipedia.org/wiki/JPEG) |
+| .jpg | `yolo predict source=image.jpg` | [JPEG](https://en.wikipedia.org/wiki/JPEG) |
+| .mpo | `yolo predict source=image.mpo` | [Multi Picture Object](https://fileinfo.com/extension/mpo) |
+| .png | `yolo predict source=image.png` | [Portable Network Graphics](https://en.wikipedia.org/wiki/PNG) |
+| .tif | `yolo predict source=image.tif` | [Tag Image File Format](https://en.wikipedia.org/wiki/TIFF) |
+| .tiff | `yolo predict source=image.tiff` | [Tag Image File Format](https://en.wikipedia.org/wiki/TIFF) |
+| .webp | `yolo predict source=image.webp` | [WebP](https://en.wikipedia.org/wiki/WebP) |
+| .pfm | `yolo predict source=image.pfm` | [Portable FloatMap](https://en.wikipedia.org/wiki/Netpbm#File_formats) |
+
+### Videos
+
+The below table contains valid Ultralytics video formats.
+
+| Video Suffixes | Example Predict Command | Reference |
+|----------------|----------------------------------|----------------------------------------------------------------------------------|
+| .asf | `yolo predict source=video.asf` | [Advanced Systems Format](https://en.wikipedia.org/wiki/Advanced_Systems_Format) |
+| .avi | `yolo predict source=video.avi` | [Audio Video Interleave](https://en.wikipedia.org/wiki/Audio_Video_Interleave) |
+| .gif | `yolo predict source=video.gif` | [Graphics Interchange Format](https://en.wikipedia.org/wiki/GIF) |
+| .m4v | `yolo predict source=video.m4v` | [MPEG-4 Part 14](https://en.wikipedia.org/wiki/M4V) |
+| .mkv | `yolo predict source=video.mkv` | [Matroska](https://en.wikipedia.org/wiki/Matroska) |
+| .mov | `yolo predict source=video.mov` | [QuickTime File Format](https://en.wikipedia.org/wiki/QuickTime_File_Format) |
+| .mp4 | `yolo predict source=video.mp4` | [MPEG-4 Part 14 - Wikipedia](https://en.wikipedia.org/wiki/MPEG-4_Part_14) |
+| .mpeg | `yolo predict source=video.mpeg` | [MPEG-1 Part 2](https://en.wikipedia.org/wiki/MPEG-1) |
+| .mpg | `yolo predict source=video.mpg` | [MPEG-1 Part 2](https://en.wikipedia.org/wiki/MPEG-1) |
+| .ts | `yolo predict source=video.ts` | [MPEG Transport Stream](https://en.wikipedia.org/wiki/MPEG_transport_stream) |
+| .wmv | `yolo predict source=video.wmv` | [Windows Media Video](https://en.wikipedia.org/wiki/Windows_Media_Video) |
+| .webm | `yolo predict source=video.webm` | [WebM Project](https://en.wikipedia.org/wiki/WebM) |
+
+## Working with Results
+
+All Ultralytics `predict()` calls will return a list of `Results` objects:
+
+!!! Example "Results"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Run inference on an image
+ results = model('bus.jpg') # list of 1 Results object
+ results = model(['bus.jpg', 'zidane.jpg']) # list of 2 Results objects
+ ```
+
+`Results` objects have the following attributes:
+
+| Attribute | Type | Description |
+|--------------|-----------------------|------------------------------------------------------------------------------------------|
+| `orig_img` | `numpy.ndarray` | The original image as a numpy array. |
+| `orig_shape` | `tuple` | The original image shape in (height, width) format. |
+| `boxes` | `Boxes, optional` | A Boxes object containing the detection bounding boxes. |
+| `masks` | `Masks, optional` | A Masks object containing the detection masks. |
+| `probs` | `Probs, optional` | A Probs object containing probabilities of each class for classification task. |
+| `keypoints` | `Keypoints, optional` | A Keypoints object containing detected keypoints for each object. |
+| `speed` | `dict` | A dictionary of preprocess, inference, and postprocess speeds in milliseconds per image. |
+| `names` | `dict` | A dictionary of class names. |
+| `path` | `str` | The path to the image file. |
+
+`Results` objects have the following methods:
+
+| Method | Return Type | Description |
+|-----------------|-----------------|-------------------------------------------------------------------------------------|
+| `__getitem__()` | `Results` | Return a Results object for the specified index. |
+| `__len__()` | `int` | Return the number of detections in the Results object. |
+| `update()` | `None` | Update the boxes, masks, and probs attributes of the Results object. |
+| `cpu()` | `Results` | Return a copy of the Results object with all tensors on CPU memory. |
+| `numpy()` | `Results` | Return a copy of the Results object with all tensors as numpy arrays. |
+| `cuda()` | `Results` | Return a copy of the Results object with all tensors on GPU memory. |
+| `to()` | `Results` | Return a copy of the Results object with tensors on the specified device and dtype. |
+| `new()` | `Results` | Return a new Results object with the same image, path, and names. |
+| `keys()` | `List[str]` | Return a list of non-empty attribute names. |
+| `plot()` | `numpy.ndarray` | Plots the detection results. Returns a numpy array of the annotated image. |
+| `verbose()` | `str` | Return log string for each task. |
+| `save_txt()` | `None` | Save predictions into a txt file. |
+| `save_crop()` | `None` | Save cropped predictions to `save_dir/cls/file_name.jpg`. |
+| `tojson()` | `None` | Convert the object to JSON format. |
+
+For more details see the `Results` class [documentation](../reference/engine/results.md).
+
+### Boxes
+
+`Boxes` object can be used to index, manipulate, and convert bounding boxes to different formats.
+
+!!! Example "Boxes"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Run inference on an image
+ results = model('bus.jpg') # results list
+
+ # View results
+ for r in results:
+ print(r.boxes) # print the Boxes object containing the detection bounding boxes
+ ```
+
+Here is a table for the `Boxes` class methods and properties, including their name, type, and description:
+
+| Name | Type | Description |
+|-----------|---------------------------|--------------------------------------------------------------------|
+| `cpu()` | Method | Move the object to CPU memory. |
+| `numpy()` | Method | Convert the object to a numpy array. |
+| `cuda()` | Method | Move the object to CUDA memory. |
+| `to()` | Method | Move the object to the specified device. |
+| `xyxy` | Property (`torch.Tensor`) | Return the boxes in xyxy format. |
+| `conf` | Property (`torch.Tensor`) | Return the confidence values of the boxes. |
+| `cls` | Property (`torch.Tensor`) | Return the class values of the boxes. |
+| `id` | Property (`torch.Tensor`) | Return the track IDs of the boxes (if available). |
+| `xywh` | Property (`torch.Tensor`) | Return the boxes in xywh format. |
+| `xyxyn` | Property (`torch.Tensor`) | Return the boxes in xyxy format normalized by original image size. |
+| `xywhn` | Property (`torch.Tensor`) | Return the boxes in xywh format normalized by original image size. |
+
+For more details see the `Boxes` class [documentation](../reference/engine/results.md#ultralytics.engine.results.Boxes).
+
+### Masks
+
+`Masks` object can be used index, manipulate and convert masks to segments.
+
+!!! Example "Masks"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n-seg Segment model
+ model = YOLO('yolov8n-seg.pt')
+
+ # Run inference on an image
+ results = model('bus.jpg') # results list
+
+ # View results
+ for r in results:
+ print(r.masks) # print the Masks object containing the detected instance masks
+ ```
+
+Here is a table for the `Masks` class methods and properties, including their name, type, and description:
+
+| Name | Type | Description |
+|-----------|---------------------------|-----------------------------------------------------------------|
+| `cpu()` | Method | Returns the masks tensor on CPU memory. |
+| `numpy()` | Method | Returns the masks tensor as a numpy array. |
+| `cuda()` | Method | Returns the masks tensor on GPU memory. |
+| `to()` | Method | Returns the masks tensor with the specified device and dtype. |
+| `xyn` | Property (`torch.Tensor`) | A list of normalized segments represented as tensors. |
+| `xy` | Property (`torch.Tensor`) | A list of segments in pixel coordinates represented as tensors. |
+
+For more details see the `Masks` class [documentation](../reference/engine/results.md#ultralytics.engine.results.Masks).
+
+### Keypoints
+
+`Keypoints` object can be used index, manipulate and normalize coordinates.
+
+!!! Example "Keypoints"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n-pose Pose model
+ model = YOLO('yolov8n-pose.pt')
+
+ # Run inference on an image
+ results = model('bus.jpg') # results list
+
+ # View results
+ for r in results:
+ print(r.keypoints) # print the Keypoints object containing the detected keypoints
+ ```
+
+Here is a table for the `Keypoints` class methods and properties, including their name, type, and description:
+
+| Name | Type | Description |
+|-----------|---------------------------|-------------------------------------------------------------------|
+| `cpu()` | Method | Returns the keypoints tensor on CPU memory. |
+| `numpy()` | Method | Returns the keypoints tensor as a numpy array. |
+| `cuda()` | Method | Returns the keypoints tensor on GPU memory. |
+| `to()` | Method | Returns the keypoints tensor with the specified device and dtype. |
+| `xyn` | Property (`torch.Tensor`) | A list of normalized keypoints represented as tensors. |
+| `xy` | Property (`torch.Tensor`) | A list of keypoints in pixel coordinates represented as tensors. |
+| `conf` | Property (`torch.Tensor`) | Returns confidence values of keypoints if available, else None. |
+
+For more details see the `Keypoints` class [documentation](../reference/engine/results.md#ultralytics.engine.results.Keypoints).
+
+### Probs
+
+`Probs` object can be used index, get `top1` and `top5` indices and scores of classification.
+
+!!! Example "Probs"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n-cls Classify model
+ model = YOLO('yolov8n-cls.pt')
+
+ # Run inference on an image
+ results = model('bus.jpg') # results list
+
+ # View results
+ for r in results:
+ print(r.probs) # print the Probs object containing the detected class probabilities
+ ```
+
+Here's a table summarizing the methods and properties for the `Probs` class:
+
+| Name | Type | Description |
+|------------|---------------------------|-------------------------------------------------------------------------|
+| `cpu()` | Method | Returns a copy of the probs tensor on CPU memory. |
+| `numpy()` | Method | Returns a copy of the probs tensor as a numpy array. |
+| `cuda()` | Method | Returns a copy of the probs tensor on GPU memory. |
+| `to()` | Method | Returns a copy of the probs tensor with the specified device and dtype. |
+| `top1` | Property (`int`) | Index of the top 1 class. |
+| `top5` | Property (`list[int]`) | Indices of the top 5 classes. |
+| `top1conf` | Property (`torch.Tensor`) | Confidence of the top 1 class. |
+| `top5conf` | Property (`torch.Tensor`) | Confidences of the top 5 classes. |
+
+For more details see the `Probs` class [documentation](../reference/engine/results.md#ultralytics.engine.results.Probs).
+
+## Plotting Results
+
+You can use the `plot()` method of a `Result` objects to visualize predictions. It plots all prediction types (boxes, masks, keypoints, probabilities, etc.) contained in the `Results` object onto a numpy array that can then be shown or saved.
+
+!!! Example "Plotting"
+
+ ```python
+ from PIL import Image
+ from ultralytics import YOLO
+
+ # Load a pretrained YOLOv8n model
+ model = YOLO('yolov8n.pt')
+
+ # Run inference on 'bus.jpg'
+ results = model('bus.jpg') # results list
+
+ # Show the results
+ for r in results:
+ im_array = r.plot() # plot a BGR numpy array of predictions
+ im = Image.fromarray(im_array[..., ::-1]) # RGB PIL image
+ im.show() # show image
+ im.save('results.jpg') # save image
+ ```
+
+ The `plot()` method supports the following arguments:
+
+ | Argument | Type | Description | Default |
+ |--------------|-----------------|--------------------------------------------------------------------------------|---------------|
+ | `conf` | `bool` | Whether to plot the detection confidence score. | `True` |
+ | `line_width` | `float` | The line width of the bounding boxes. If None, it is scaled to the image size. | `None` |
+ | `font_size` | `float` | The font size of the text. If None, it is scaled to the image size. | `None` |
+ | `font` | `str` | The font to use for the text. | `'Arial.ttf'` |
+ | `pil` | `bool` | Whether to return the image as a PIL Image. | `False` |
+ | `img` | `numpy.ndarray` | Plot to another image. if not, plot to original image. | `None` |
+ | `im_gpu` | `torch.Tensor` | Normalized image in gpu with shape (1, 3, 640, 640), for faster mask plotting. | `None` |
+ | `kpt_radius` | `int` | Radius of the drawn keypoints. Default is 5. | `5` |
+ | `kpt_line` | `bool` | Whether to draw lines connecting keypoints. | `True` |
+ | `labels` | `bool` | Whether to plot the label of bounding boxes. | `True` |
+ | `boxes` | `bool` | Whether to plot the bounding boxes. | `True` |
+ | `masks` | `bool` | Whether to plot the masks. | `True` |
+ | `probs` | `bool` | Whether to plot classification probability | `True` |
+
+## Thread-Safe Inference
+
+Ensuring thread safety during inference is crucial when you are running multiple YOLO models in parallel across different threads. Thread-safe inference guarantees that each thread's predictions are isolated and do not interfere with one another, avoiding race conditions and ensuring consistent and reliable outputs.
+
+When using YOLO models in a multi-threaded application, it's important to instantiate separate model objects for each thread or employ thread-local storage to prevent conflicts:
+
+!!! Example "Thread-Safe Inference"
+
+ Instantiate a single model inside each thread for thread-safe inference:
+ ```python
+ from ultralytics import YOLO
+ from threading import Thread
+
+ def thread_safe_predict(image_path):
+ # Instantiate a new model inside the thread
+ local_model = YOLO("yolov8n.pt")
+ results = local_model.predict(image_path)
+ # Process results
+
+
+ # Starting threads that each have their own model instance
+ Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
+ Thread(target=thread_safe_predict, args=("image2.jpg",)).start()
+ ```
+
+For an in-depth look at thread-safe inference with YOLO models and step-by-step instructions, please refer to our [YOLO Thread-Safe Inference Guide](../guides/yolo-thread-safe-inference.md). This guide will provide you with all the necessary information to avoid common pitfalls and ensure that your multi-threaded inference runs smoothly.
+
+## Streaming Source `for`-loop
+
+Here's a Python script using OpenCV (`cv2`) and YOLOv8 to run inference on video frames. This script assumes you have already installed the necessary packages (`opencv-python` and `ultralytics`).
+
+!!! Example "Streaming for-loop"
+
+ ```python
+ import cv2
+ from ultralytics import YOLO
+
+ # Load the YOLOv8 model
+ model = YOLO('yolov8n.pt')
+
+ # Open the video file
+ video_path = "path/to/your/video/file.mp4"
+ cap = cv2.VideoCapture(video_path)
+
+ # Loop through the video frames
+ while cap.isOpened():
+ # Read a frame from the video
+ success, frame = cap.read()
+
+ if success:
+ # Run YOLOv8 inference on the frame
+ results = model(frame)
+
+ # Visualize the results on the frame
+ annotated_frame = results[0].plot()
+
+ # Display the annotated frame
+ cv2.imshow("YOLOv8 Inference", annotated_frame)
+
+ # Break the loop if 'q' is pressed
+ if cv2.waitKey(1) & 0xFF == ord("q"):
+ break
+ else:
+ # Break the loop if the end of the video is reached
+ break
+
+ # Release the video capture object and close the display window
+ cap.release()
+ cv2.destroyAllWindows()
+ ```
+
+This script will run predictions on each frame of the video, visualize the results, and display them in a window. The loop can be exited by pressing 'q'.
+
+[car spare parts]: https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1
+
+[football player detect]: https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442
+
+[human fall detect]: https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43
diff --git a/ultralytics/docs/en/modes/predict.md:Zone.Identifier b/ultralytics/docs/en/modes/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/modes/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/modes/track.md b/ultralytics/docs/en/modes/track.md
new file mode 100755
index 0000000..8ec5651
--- /dev/null
+++ b/ultralytics/docs/en/modes/track.md
@@ -0,0 +1,360 @@
+---
+comments: true
+description: Learn how to use Ultralytics YOLO for object tracking in video streams. Guides to use different trackers and customise tracker configurations.
+keywords: Ultralytics, YOLO, object tracking, video streams, BoT-SORT, ByteTrack, Python guide, CLI guide
+---
+
+# Multi-Object Tracking with Ultralytics YOLO
+
+
+
+Object tracking in the realm of video analytics is a critical task that not only identifies the location and class of objects within the frame but also maintains a unique ID for each detected object as the video progresses. The applications are limitlessโranging from surveillance and security to real-time sports analytics.
+
+## Why Choose Ultralytics YOLO for Object Tracking?
+
+The output from Ultralytics trackers is consistent with standard object detection but has the added value of object IDs. This makes it easy to track objects in video streams and perform subsequent analytics. Here's why you should consider using Ultralytics YOLO for your object tracking needs:
+
+- **Efficiency:** Process video streams in real-time without compromising accuracy.
+- **Flexibility:** Supports multiple tracking algorithms and configurations.
+- **Ease of Use:** Simple Python API and CLI options for quick integration and deployment.
+- **Customizability:** Easy to use with custom trained YOLO models, allowing integration into domain-specific applications.
+
+
+
+
+
+ Watch: Object Detection and Tracking with Ultralytics YOLOv8.
+
+
+## Real-world Applications
+
+| Transportation | Retail | Aquaculture |
+|:----------------------------------:|:--------------------------------:|:----------------------------:|
+| ![Vehicle Tracking][vehicle track] | ![People Tracking][people track] | ![Fish Tracking][fish track] |
+| Vehicle Tracking | People Tracking | Fish Tracking |
+
+## Features at a Glance
+
+Ultralytics YOLO extends its object detection features to provide robust and versatile object tracking:
+
+- **Real-Time Tracking:** Seamlessly track objects in high-frame-rate videos.
+- **Multiple Tracker Support:** Choose from a variety of established tracking algorithms.
+- **Customizable Tracker Configurations:** Tailor the tracking algorithm to meet specific requirements by adjusting various parameters.
+
+## Available Trackers
+
+Ultralytics YOLO supports the following tracking algorithms. They can be enabled by passing the relevant YAML configuration file such as `tracker=tracker_type.yaml`:
+
+* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Use `botsort.yaml` to enable this tracker.
+* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Use `bytetrack.yaml` to enable this tracker.
+
+The default tracker is BoT-SORT.
+
+## Tracking
+
+To run the tracker on video streams, use a trained Detect, Segment or Pose model such as YOLOv8n, YOLOv8n-seg and YOLOv8n-pose.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load an official or custom model
+ model = YOLO('yolov8n.pt') # Load an official Detect model
+ model = YOLO('yolov8n-seg.pt') # Load an official Segment model
+ model = YOLO('yolov8n-pose.pt') # Load an official Pose model
+ model = YOLO('path/to/best.pt') # Load a custom trained model
+
+ # Perform tracking with the model
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Tracking with default tracker
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Tracking with ByteTrack tracker
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Perform tracking with various models using the command line interface
+ yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Official Detect model
+ yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Official Segment model
+ yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Official Pose model
+ yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Custom trained model
+
+ # Track using ByteTrack tracker
+ yolo track model=path/to/best.pt tracker="bytetrack.yaml"
+ ```
+
+As can be seen in the above usage, tracking is available for all Detect, Segment and Pose models run on videos or streaming sources.
+
+## Configuration
+
+### Tracking Arguments
+
+Tracking configuration shares properties with Predict mode, such as `conf`, `iou`, and `show`. For further configurations, refer to the [Predict](../modes/predict.md#inference-arguments) model page.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Configure the tracking parameters and run the tracker
+ model = YOLO('yolov8n.pt')
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Configure tracking parameters and run the tracker using the command line interface
+ yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
+ ```
+
+### Tracker Selection
+
+Ultralytics also allows you to use a modified tracker configuration file. To do this, simply make a copy of a tracker config file (for example, `custom_tracker.yaml`) from [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) and modify any configurations (except the `tracker_type`) as per your needs.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load the model and run the tracker with a custom configuration file
+ model = YOLO('yolov8n.pt')
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Load the model and run the tracker with a custom configuration file using the command line interface
+ yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
+ ```
+
+For a comprehensive list of tracking arguments, refer to the [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) page.
+
+## Python Examples
+
+### Persisting Tracks Loop
+
+Here is a Python script using OpenCV (`cv2`) and YOLOv8 to run object tracking on video frames. This script still assumes you have already installed the necessary packages (`opencv-python` and `ultralytics`). The `persist=True` argument tells the tracker that the current image or frame is the next in a sequence and to expect tracks from the previous image in the current image.
+
+!!! Example "Streaming for-loop with tracking"
+
+ ```python
+ import cv2
+ from ultralytics import YOLO
+
+ # Load the YOLOv8 model
+ model = YOLO('yolov8n.pt')
+
+ # Open the video file
+ video_path = "path/to/video.mp4"
+ cap = cv2.VideoCapture(video_path)
+
+ # Loop through the video frames
+ while cap.isOpened():
+ # Read a frame from the video
+ success, frame = cap.read()
+
+ if success:
+ # Run YOLOv8 tracking on the frame, persisting tracks between frames
+ results = model.track(frame, persist=True)
+
+ # Visualize the results on the frame
+ annotated_frame = results[0].plot()
+
+ # Display the annotated frame
+ cv2.imshow("YOLOv8 Tracking", annotated_frame)
+
+ # Break the loop if 'q' is pressed
+ if cv2.waitKey(1) & 0xFF == ord("q"):
+ break
+ else:
+ # Break the loop if the end of the video is reached
+ break
+
+ # Release the video capture object and close the display window
+ cap.release()
+ cv2.destroyAllWindows()
+ ```
+
+Please note the change from `model(frame)` to `model.track(frame)`, which enables object tracking instead of simple detection. This modified script will run the tracker on each frame of the video, visualize the results, and display them in a window. The loop can be exited by pressing 'q'.
+
+### Plotting Tracks Over Time
+
+Visualizing object tracks over consecutive frames can provide valuable insights into the movement patterns and behavior of detected objects within a video. With Ultralytics YOLOv8, plotting these tracks is a seamless and efficient process.
+
+In the following example, we demonstrate how to utilize YOLOv8's tracking capabilities to plot the movement of detected objects across multiple video frames. This script involves opening a video file, reading it frame by frame, and utilizing the YOLO model to identify and track various objects. By retaining the center points of the detected bounding boxes and connecting them, we can draw lines that represent the paths followed by the tracked objects.
+
+!!! Example "Plotting tracks over multiple video frames"
+
+ ```python
+ from collections import defaultdict
+
+ import cv2
+ import numpy as np
+
+ from ultralytics import YOLO
+
+ # Load the YOLOv8 model
+ model = YOLO('yolov8n.pt')
+
+ # Open the video file
+ video_path = "path/to/video.mp4"
+ cap = cv2.VideoCapture(video_path)
+
+ # Store the track history
+ track_history = defaultdict(lambda: [])
+
+ # Loop through the video frames
+ while cap.isOpened():
+ # Read a frame from the video
+ success, frame = cap.read()
+
+ if success:
+ # Run YOLOv8 tracking on the frame, persisting tracks between frames
+ results = model.track(frame, persist=True)
+
+ # Get the boxes and track IDs
+ boxes = results[0].boxes.xywh.cpu()
+ track_ids = results[0].boxes.id.int().cpu().tolist()
+
+ # Visualize the results on the frame
+ annotated_frame = results[0].plot()
+
+ # Plot the tracks
+ for box, track_id in zip(boxes, track_ids):
+ x, y, w, h = box
+ track = track_history[track_id]
+ track.append((float(x), float(y))) # x, y center point
+ if len(track) > 30: # retain 90 tracks for 90 frames
+ track.pop(0)
+
+ # Draw the tracking lines
+ points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
+ cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
+
+ # Display the annotated frame
+ cv2.imshow("YOLOv8 Tracking", annotated_frame)
+
+ # Break the loop if 'q' is pressed
+ if cv2.waitKey(1) & 0xFF == ord("q"):
+ break
+ else:
+ # Break the loop if the end of the video is reached
+ break
+
+ # Release the video capture object and close the display window
+ cap.release()
+ cv2.destroyAllWindows()
+ ```
+
+### Multithreaded Tracking
+
+Multithreaded tracking provides the capability to run object tracking on multiple video streams simultaneously. This is particularly useful when handling multiple video inputs, such as from multiple surveillance cameras, where concurrent processing can greatly enhance efficiency and performance.
+
+In the provided Python script, we make use of Python's `threading` module to run multiple instances of the tracker concurrently. Each thread is responsible for running the tracker on one video file, and all the threads run simultaneously in the background.
+
+To ensure that each thread receives the correct parameters (the video file, the model to use and the file index), we define a function `run_tracker_in_thread` that accepts these parameters and contains the main tracking loop. This function reads the video frame by frame, runs the tracker, and displays the results.
+
+Two different models are used in this example: `yolov8n.pt` and `yolov8n-seg.pt`, each tracking objects in a different video file. The video files are specified in `video_file1` and `video_file2`.
+
+The `daemon=True` parameter in `threading.Thread` means that these threads will be closed as soon as the main program finishes. We then start the threads with `start()` and use `join()` to make the main thread wait until both tracker threads have finished.
+
+Finally, after all threads have completed their task, the windows displaying the results are closed using `cv2.destroyAllWindows()`.
+
+!!! Example "Streaming for-loop with tracking"
+
+ ```python
+ import threading
+ import cv2
+ from ultralytics import YOLO
+
+
+ def run_tracker_in_thread(filename, model, file_index):
+ """
+ Runs a video file or webcam stream concurrently with the YOLOv8 model using threading.
+
+ This function captures video frames from a given file or camera source and utilizes the YOLOv8 model for object
+ tracking. The function runs in its own thread for concurrent processing.
+
+ Args:
+ filename (str): The path to the video file or the identifier for the webcam/external camera source.
+ model (obj): The YOLOv8 model object.
+ file_index (int): An index to uniquely identify the file being processed, used for display purposes.
+
+ Note:
+ Press 'q' to quit the video display window.
+ """
+ video = cv2.VideoCapture(filename) # Read the video file
+
+ while True:
+ ret, frame = video.read() # Read the video frames
+
+ # Exit the loop if no more frames in either video
+ if not ret:
+ break
+
+ # Track objects in frames if available
+ results = model.track(frame, persist=True)
+ res_plotted = results[0].plot()
+ cv2.imshow(f"Tracking_Stream_{file_index}", res_plotted)
+
+ key = cv2.waitKey(1)
+ if key == ord('q'):
+ break
+
+ # Release video sources
+ video.release()
+
+
+ # Load the models
+ model1 = YOLO('yolov8n.pt')
+ model2 = YOLO('yolov8n-seg.pt')
+
+ # Define the video files for the trackers
+ video_file1 = "path/to/video1.mp4" # Path to video file, 0 for webcam
+ video_file2 = 0 # Path to video file, 0 for webcam, 1 for external camera
+
+ # Create the tracker threads
+ tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
+ tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)
+
+ # Start the tracker threads
+ tracker_thread1.start()
+ tracker_thread2.start()
+
+ # Wait for the tracker threads to finish
+ tracker_thread1.join()
+ tracker_thread2.join()
+
+ # Clean up and close windows
+ cv2.destroyAllWindows()
+ ```
+
+This example can easily be extended to handle more video files and models by creating more threads and applying the same methodology.
+
+## Contribute New Trackers
+
+Are you proficient in multi-object tracking and have successfully implemented or adapted a tracking algorithm with Ultralytics YOLO? We invite you to contribute to our Trackers section in [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Your real-world applications and solutions could be invaluable for users working on tracking tasks.
+
+By contributing to this section, you help expand the scope of tracking solutions available within the Ultralytics YOLO framework, adding another layer of functionality and utility for the community.
+
+To initiate your contribution, please refer to our [Contributing Guide](https://docs.ultralytics.com/help/contributing) for comprehensive instructions on submitting a Pull Request (PR) ๐ ๏ธ. We are excited to see what you bring to the table!
+
+Together, let's enhance the tracking capabilities of the Ultralytics YOLO ecosystem ๐!
+
+[vehicle track]: https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab
+
+[people track]: https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527
+
+[fish track]: https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142
diff --git a/ultralytics/docs/en/modes/track.md:Zone.Identifier b/ultralytics/docs/en/modes/track.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/modes/track.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/modes/train.md b/ultralytics/docs/en/modes/train.md
new file mode 100755
index 0000000..331d7cd
--- /dev/null
+++ b/ultralytics/docs/en/modes/train.md
@@ -0,0 +1,296 @@
+---
+comments: true
+description: Step-by-step guide to train YOLOv8 models with Ultralytics YOLO including examples of single-GPU and multi-GPU training
+keywords: Ultralytics, YOLOv8, YOLO, object detection, train mode, custom dataset, GPU training, multi-GPU, hyperparameters, CLI examples, Python examples
+---
+
+# Model Training with Ultralytics YOLO
+
+
+
+## Introduction
+
+Training a deep learning model involves feeding it data and adjusting its parameters so that it can make accurate predictions. Train mode in Ultralytics YOLOv8 is engineered for effective and efficient training of object detection models, fully utilizing modern hardware capabilities. This guide aims to cover all the details you need to get started with training your own models using YOLOv8's robust set of features.
+
+
+
+
+
+ Watch: How to Train a YOLOv8 model on Your Custom Dataset in Google Colab.
+
+
+## Why Choose Ultralytics YOLO for Training?
+
+Here are some compelling reasons to opt for YOLOv8's Train mode:
+
+- **Efficiency:** Make the most out of your hardware, whether you're on a single-GPU setup or scaling across multiple GPUs.
+- **Versatility:** Train on custom datasets in addition to readily available ones like COCO, VOC, and ImageNet.
+- **User-Friendly:** Simple yet powerful CLI and Python interfaces for a straightforward training experience.
+- **Hyperparameter Flexibility:** A broad range of customizable hyperparameters to fine-tune model performance.
+
+### Key Features of Train Mode
+
+The following are some notable features of YOLOv8's Train mode:
+
+- **Automatic Dataset Download:** Standard datasets like COCO, VOC, and ImageNet are downloaded automatically on first use.
+- **Multi-GPU Support:** Scale your training efforts seamlessly across multiple GPUs to expedite the process.
+- **Hyperparameter Configuration:** The option to modify hyperparameters through YAML configuration files or CLI arguments.
+- **Visualization and Monitoring:** Real-time tracking of training metrics and visualization of the learning process for better insights.
+
+!!! Tip "Tip"
+
+ * YOLOv8 datasets like COCO, VOC, ImageNet and many others automatically download on first use, i.e. `yolo train data=coco.yaml`
+
+## Usage Examples
+
+Train YOLOv8n on the COCO128 dataset for 100 epochs at image size 640. The training device can be specified using the `device` argument. If no argument is passed GPU `device=0` will be used if available, otherwise `device=cpu` will be used. See Arguments section below for a full list of training arguments.
+
+!!! Example "Single-GPU and CPU Training Example"
+
+ Device is determined automatically. If a GPU is available then it will be used, otherwise training will start on CPU.
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.yaml') # build a new model from YAML
+ model = YOLO('yolov8n.pt') # load a pretrained model (recommended for training)
+ model = YOLO('yolov8n.yaml').load('yolov8n.pt') # build from YAML and transfer weights
+
+ # Train the model
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Build a new model from YAML and start training from scratch
+ yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
+
+ # Start training from a pretrained *.pt model
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
+
+ # Build a new model from YAML, transfer pretrained weights to it and start training
+ yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+### Multi-GPU Training
+
+Multi-GPU training allows for more efficient utilization of available hardware resources by distributing the training load across multiple GPUs. This feature is available through both the Python API and the command-line interface. To enable multi-GPU training, specify the GPU device IDs you wish to use.
+
+!!! Example "Multi-GPU Training Example"
+
+ To train with 2 GPUs, CUDA devices 0 and 1 use the following commands. Expand to additional GPUs as required.
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load a pretrained model (recommended for training)
+
+ # Train the model with 2 GPUs
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Start training from a pretrained *.pt model using GPUs 0 and 1
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
+ ```
+
+### Apple M1 and M2 MPS Training
+
+With the support for Apple M1 and M2 chips integrated in the Ultralytics YOLO models, it's now possible to train your models on devices utilizing the powerful Metal Performance Shaders (MPS) framework. The MPS offers a high-performance way of executing computation and image processing tasks on Apple's custom silicon.
+
+To enable training on Apple M1 and M2 chips, you should specify 'mps' as your device when initiating the training process. Below is an example of how you could do this in Python and via the command line:
+
+!!! Example "MPS Training Example"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load a pretrained model (recommended for training)
+
+ # Train the model with 2 GPUs
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Start training from a pretrained *.pt model using GPUs 0 and 1
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
+ ```
+
+While leveraging the computational power of the M1/M2 chips, this enables more efficient processing of the training tasks. For more detailed guidance and advanced configuration options, please refer to the [PyTorch MPS documentation](https://pytorch.org/docs/stable/notes/mps.html).
+
+### Resuming Interrupted Trainings
+
+Resuming training from a previously saved state is a crucial feature when working with deep learning models. This can come in handy in various scenarios, like when the training process has been unexpectedly interrupted, or when you wish to continue training a model with new data or for more epochs.
+
+When training is resumed, Ultralytics YOLO loads the weights from the last saved model and also restores the optimizer state, learning rate scheduler, and the epoch number. This allows you to continue the training process seamlessly from where it was left off.
+
+You can easily resume training in Ultralytics YOLO by setting the `resume` argument to `True` when calling the `train` method, and specifying the path to the `.pt` file containing the partially trained model weights.
+
+Below is an example of how to resume an interrupted training using Python and via the command line:
+
+!!! Example "Resume Training Example"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('path/to/last.pt') # load a partially trained model
+
+ # Resume training
+ results = model.train(resume=True)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Resume an interrupted training
+ yolo train resume model=path/to/last.pt
+ ```
+
+By setting `resume=True`, the `train` function will continue training from where it left off, using the state stored in the 'path/to/last.pt' file. If the `resume` argument is omitted or set to `False`, the `train` function will start a new training session.
+
+Remember that checkpoints are saved at the end of every epoch by default, or at fixed interval using the `save_period` argument, so you must complete at least 1 epoch to resume a training run.
+
+## Arguments
+
+Training settings for YOLO models refer to the various hyperparameters and configurations used to train the model on a dataset. These settings can affect the model's performance, speed, and accuracy. Some common YOLO training settings include the batch size, learning rate, momentum, and weight decay. Other factors that may affect the training process include the choice of optimizer, the choice of loss function, and the size and composition of the training dataset. It is important to carefully tune and experiment with these settings to achieve the best possible performance for a given task.
+
+| Key | Value | Description |
+|-------------------|----------|------------------------------------------------------------------------------------------------|
+| `model` | `None` | path to model file, i.e. yolov8n.pt, yolov8n.yaml |
+| `data` | `None` | path to data file, i.e. coco128.yaml |
+| `epochs` | `100` | number of epochs to train for |
+| `time` | `None` | number of hours to train for, overrides epochs if supplied |
+| `patience` | `50` | epochs to wait for no observable improvement for early stopping of training |
+| `batch` | `16` | number of images per batch (-1 for AutoBatch) |
+| `imgsz` | `640` | size of input images as integer |
+| `save` | `True` | save train checkpoints and predict results |
+| `save_period` | `-1` | Save checkpoint every x epochs (disabled if < 1) |
+| `cache` | `False` | True/ram, disk or False. Use cache for data loading |
+| `device` | `None` | device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu |
+| `workers` | `8` | number of worker threads for data loading (per RANK if DDP) |
+| `project` | `None` | project name |
+| `name` | `None` | experiment name |
+| `exist_ok` | `False` | whether to overwrite existing experiment |
+| `pretrained` | `True` | (bool or str) whether to use a pretrained model (bool) or a model to load weights from (str) |
+| `optimizer` | `'auto'` | optimizer to use, choices=[SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto] |
+| `verbose` | `False` | whether to print verbose output |
+| `seed` | `0` | random seed for reproducibility |
+| `deterministic` | `True` | whether to enable deterministic mode |
+| `single_cls` | `False` | train multi-class data as single-class |
+| `rect` | `False` | rectangular training with each batch collated for minimum padding |
+| `cos_lr` | `False` | use cosine learning rate scheduler |
+| `close_mosaic` | `10` | (int) disable mosaic augmentation for final epochs (0 to disable) |
+| `resume` | `False` | resume training from last checkpoint |
+| `amp` | `True` | Automatic Mixed Precision (AMP) training, choices=[True, False] |
+| `fraction` | `1.0` | dataset fraction to train on (default is 1.0, all images in train set) |
+| `profile` | `False` | profile ONNX and TensorRT speeds during training for loggers |
+| `freeze` | `None` | (int or list, optional) freeze first n layers, or freeze list of layer indices during training |
+| `lr0` | `0.01` | initial learning rate (i.e. SGD=1E-2, Adam=1E-3) |
+| `lrf` | `0.01` | final learning rate (lr0 * lrf) |
+| `momentum` | `0.937` | SGD momentum/Adam beta1 |
+| `weight_decay` | `0.0005` | optimizer weight decay 5e-4 |
+| `warmup_epochs` | `3.0` | warmup epochs (fractions ok) |
+| `warmup_momentum` | `0.8` | warmup initial momentum |
+| `warmup_bias_lr` | `0.1` | warmup initial bias lr |
+| `box` | `7.5` | box loss gain |
+| `cls` | `0.5` | cls loss gain (scale with pixels) |
+| `dfl` | `1.5` | dfl loss gain |
+| `pose` | `12.0` | pose loss gain (pose-only) |
+| `kobj` | `2.0` | keypoint obj loss gain (pose-only) |
+| `label_smoothing` | `0.0` | label smoothing (fraction) |
+| `nbs` | `64` | nominal batch size |
+| `overlap_mask` | `True` | masks should overlap during training (segment train only) |
+| `mask_ratio` | `4` | mask downsample ratio (segment train only) |
+| `dropout` | `0.0` | use dropout regularization (classify train only) |
+| `val` | `True` | validate/test during training |
+| `plots` | `False` | save plots and images during train/val |
+
+## Logging
+
+In training a YOLOv8 model, you might find it valuable to keep track of the model's performance over time. This is where logging comes into play. Ultralytics' YOLO provides support for three types of loggers - Comet, ClearML, and TensorBoard.
+
+To use a logger, select it from the dropdown menu in the code snippet above and run it. The chosen logger will be installed and initialized.
+
+### Comet
+
+[Comet](../integrations/comet.md) is a platform that allows data scientists and developers to track, compare, explain and optimize experiments and models. It provides functionalities such as real-time metrics, code diffs, and hyperparameters tracking.
+
+To use Comet:
+
+!!! Example
+
+ === "Python"
+ ```python
+ # pip install comet_ml
+ import comet_ml
+
+ comet_ml.init()
+ ```
+
+Remember to sign in to your Comet account on their website and get your API key. You will need to add this to your environment variables or your script to log your experiments.
+
+### ClearML
+
+[ClearML](https://www.clear.ml/) is an open-source platform that automates tracking of experiments and helps with efficient sharing of resources. It is designed to help teams manage, execute, and reproduce their ML work more efficiently.
+
+To use ClearML:
+
+!!! Example
+
+ === "Python"
+ ```python
+ # pip install clearml
+ import clearml
+
+ clearml.browser_login()
+ ```
+
+After running this script, you will need to sign in to your ClearML account on the browser and authenticate your session.
+
+### TensorBoard
+
+[TensorBoard](https://www.tensorflow.org/tensorboard) is a visualization toolkit for TensorFlow. It allows you to visualize your TensorFlow graph, plot quantitative metrics about the execution of your graph, and show additional data like images that pass through it.
+
+To use TensorBoard in [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb):
+
+!!! Example
+
+ === "CLI"
+ ```bash
+ load_ext tensorboard
+ tensorboard --logdir ultralytics/runs # replace with 'runs' directory
+ ```
+
+To use TensorBoard locally run the below command and view results at http://localhost:6006/.
+
+!!! Example
+
+ === "CLI"
+ ```bash
+ tensorboard --logdir ultralytics/runs # replace with 'runs' directory
+ ```
+
+This will load TensorBoard and direct it to the directory where your training logs are saved.
+
+After setting up your logger, you can then proceed with your model training. All training metrics will be automatically logged in your chosen platform, and you can access these logs to monitor your model's performance over time, compare different models, and identify areas for improvement.
diff --git a/ultralytics/docs/en/modes/train.md:Zone.Identifier b/ultralytics/docs/en/modes/train.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/modes/train.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/modes/val.md b/ultralytics/docs/en/modes/val.md
new file mode 100755
index 0000000..d9e2c96
--- /dev/null
+++ b/ultralytics/docs/en/modes/val.md
@@ -0,0 +1,96 @@
+---
+comments: true
+description: Guide for Validating YOLOv8 Models. Learn how to evaluate the performance of your YOLO models using validation settings and metrics with Python and CLI examples.
+keywords: Ultralytics, YOLO Docs, YOLOv8, validation, model evaluation, hyperparameters, accuracy, metrics, Python, CLI
+---
+
+# Model Validation with Ultralytics YOLO
+
+
+
+## Introduction
+
+Validation is a critical step in the machine learning pipeline, allowing you to assess the quality of your trained models. Val mode in Ultralytics YOLOv8 provides a robust suite of tools and metrics for evaluating the performance of your object detection models. This guide serves as a complete resource for understanding how to effectively use the Val mode to ensure that your models are both accurate and reliable.
+
+
+
+## Why Validate with Ultralytics YOLO?
+
+Here's why using YOLOv8's Val mode is advantageous:
+
+- **Precision:** Get accurate metrics like mAP50, mAP75, and mAP50-95 to comprehensively evaluate your model.
+- **Convenience:** Utilize built-in features that remember training settings, simplifying the validation process.
+- **Flexibility:** Validate your model with the same or different datasets and image sizes.
+- **Hyperparameter Tuning:** Use validation metrics to fine-tune your model for better performance.
+
+### Key Features of Val Mode
+
+These are the notable functionalities offered by YOLOv8's Val mode:
+
+- **Automated Settings:** Models remember their training configurations for straightforward validation.
+- **Multi-Metric Support:** Evaluate your model based on a range of accuracy metrics.
+- **CLI and Python API:** Choose from command-line interface or Python API based on your preference for validation.
+- **Data Compatibility:** Works seamlessly with datasets used during the training phase as well as custom datasets.
+
+!!! Tip "Tip"
+
+ * YOLOv8 models automatically remember their training settings, so you can validate a model at the same image size and on the original dataset easily with just `yolo val model=yolov8n.pt` or `model('yolov8n.pt').val()`
+
+## Usage Examples
+
+Validate trained YOLOv8n model accuracy on the COCO128 dataset. No argument need to passed as the `model` retains it's training `data` and arguments as model attributes. See Arguments section below for a full list of export arguments.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Validate the model
+ metrics = model.val() # no arguments needed, dataset and settings remembered
+ metrics.box.map # map50-95
+ metrics.box.map50 # map50
+ metrics.box.map75 # map75
+ metrics.box.maps # a list contains map50-95 of each category
+ ```
+ === "CLI"
+
+ ```bash
+ yolo detect val model=yolov8n.pt # val official model
+ yolo detect val model=path/to/best.pt # val custom model
+ ```
+
+## Arguments
+
+Validation settings for YOLO models refer to the various hyperparameters and configurations used to evaluate the model's performance on a validation dataset. These settings can affect the model's performance, speed, and accuracy. Some common YOLO validation settings include the batch size, the frequency with which validation is performed during training, and the metrics used to evaluate the model's performance. Other factors that may affect the validation process include the size and composition of the validation dataset and the specific task the model is being used for. It is important to carefully tune and experiment with these settings to ensure that the model is performing well on the validation dataset and to detect and prevent overfitting.
+
+| Key | Value | Description |
+|---------------|---------|--------------------------------------------------------------------|
+| `data` | `None` | path to data file, i.e. coco128.yaml |
+| `imgsz` | `640` | size of input images as integer |
+| `batch` | `16` | number of images per batch (-1 for AutoBatch) |
+| `save_json` | `False` | save results to JSON file |
+| `save_hybrid` | `False` | save hybrid version of labels (labels + additional predictions) |
+| `conf` | `0.001` | object confidence threshold for detection |
+| `iou` | `0.6` | intersection over union (IoU) threshold for NMS |
+| `max_det` | `300` | maximum number of detections per image |
+| `half` | `True` | use half precision (FP16) |
+| `device` | `None` | device to run on, i.e. cuda device=0/1/2/3 or device=cpu |
+| `dnn` | `False` | use OpenCV DNN for ONNX inference |
+| `plots` | `False` | save plots and images during train/val |
+| `rect` | `False` | rectangular val with each batch collated for minimum padding |
+| `split` | `val` | dataset split to use for validation, i.e. 'val', 'test' or 'train' |
diff --git a/ultralytics/docs/en/modes/val.md:Zone.Identifier b/ultralytics/docs/en/modes/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/modes/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/quickstart.md b/ultralytics/docs/en/quickstart.md
new file mode 100755
index 0000000..4dd0eae
--- /dev/null
+++ b/ultralytics/docs/en/quickstart.md
@@ -0,0 +1,327 @@
+---
+comments: true
+description: Explore various methods to install Ultralytics using pip, conda, git and Docker. Learn how to use Ultralytics with command line interface or within your Python projects.
+keywords: Ultralytics installation, pip install Ultralytics, Docker install Ultralytics, Ultralytics command line interface, Ultralytics Python interface
+---
+
+## Install Ultralytics
+
+Ultralytics provides various installation methods including pip, conda, and Docker. Install YOLOv8 via the `ultralytics` pip package for the latest stable release or by cloning the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics) for the most up-to-date version. Docker can be used to execute the package in an isolated container, avoiding local installation.
+
+
+
+!!! Example "Install"
+
+ === "Pip install (recommended)"
+ Install the `ultralytics` package using pip, or update an existing installation by running `pip install -U ultralytics`. Visit the Python Package Index (PyPI) for more details on the `ultralytics` package: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
+
+ [](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics)
+
+ ```bash
+ # Install the ultralytics package from PyPI
+ pip install ultralytics
+ ```
+
+ You can also install the `ultralytics` package directly from the GitHub [repository](https://github.com/ultralytics/ultralytics). This might be useful if you want the latest development version. Make sure to have the Git command-line tool installed on your system. The `@main` command installs the `main` branch and may be modified to another branch, i.e. `@my-branch`, or removed entirely to default to `main` branch.
+
+ ```bash
+ # Install the ultralytics package from GitHub
+ pip install git+https://github.com/ultralytics/ultralytics.git@main
+ ```
+
+
+ === "Conda install"
+ Conda is an alternative package manager to pip which may also be used for installation. Visit Anaconda for more details at [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Ultralytics feedstock repository for updating the conda package is at [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
+
+
+ [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics)
+
+ ```bash
+ # Install the ultralytics package using conda
+ conda install -c conda-forge ultralytics
+ ```
+
+ !!! Note
+
+ If you are installing in a CUDA environment best practice is to install `ultralytics`, `pytorch` and `pytorch-cuda` in the same command to allow the conda package manager to resolve any conflicts, or else to install `pytorch-cuda` last to allow it override the CPU-specific `pytorch` package if necessary.
+ ```bash
+ # Install all packages together using conda
+ conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
+ ```
+
+ ### Conda Docker Image
+
+ Ultralytics Conda Docker images are also available from [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). These images are based on [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) and are an simple way to start using `ultralytics` in a Conda environment.
+
+ ```bash
+ # Set image name as a variable
+ t=ultralytics/ultralytics:latest-conda
+
+ # Pull the latest ultralytics image from Docker Hub
+ sudo docker pull $t
+
+ # Run the ultralytics image in a container with GPU support
+ sudo docker run -it --ipc=host --gpus all $t # all GPUs
+ sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
+ ```
+
+ === "Git clone"
+ Clone the `ultralytics` repository if you are interested in contributing to the development or wish to experiment with the latest source code. After cloning, navigate into the directory and install the package in editable mode `-e` using pip.
+ ```bash
+ # Clone the ultralytics repository
+ git clone https://github.com/ultralytics/ultralytics
+
+ # Navigate to the cloned directory
+ cd ultralytics
+
+ # Install the package in editable mode for development
+ pip install -e .
+ ```
+
+ === "Docker"
+
+ Utilize Docker to effortlessly execute the `ultralytics` package in an isolated container, ensuring consistent and smooth performance across various environments. By choosing one of the official `ultralytics` images from [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics), you not only avoid the complexity of local installation but also benefit from access to a verified working environment. Ultralytics offers 5 main supported Docker images, each designed to provide high compatibility and efficiency for different platforms and use cases:
+
+
+
+ - **Dockerfile:** GPU image recommended for training.
+ - **Dockerfile-arm64:** Optimized for ARM64 architecture, allowing deployment on devices like Raspberry Pi and other ARM64-based platforms.
+ - **Dockerfile-cpu:** Ubuntu-based CPU-only version suitable for inference and environments without GPUs.
+ - **Dockerfile-jetson:** Tailored for NVIDIA Jetson devices, integrating GPU support optimized for these platforms.
+ - **Dockerfile-python:** Minimal image with just Python and necessary dependencies, ideal for lightweight applications and development.
+ - **Dockerfile-conda:** Based on Miniconda3 with conda installation of ultralytics package.
+
+ Below are the commands to get the latest image and execute it:
+
+ ```bash
+ # Set image name as a variable
+ t=ultralytics/ultralytics:latest
+
+ # Pull the latest ultralytics image from Docker Hub
+ sudo docker pull $t
+
+ # Run the ultralytics image in a container with GPU support
+ sudo docker run -it --ipc=host --gpus all $t # all GPUs
+ sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
+ ```
+
+ The above command initializes a Docker container with the latest `ultralytics` image. The `-it` flag assigns a pseudo-TTY and maintains stdin open, enabling you to interact with the container. The `--ipc=host` flag sets the IPC (Inter-Process Communication) namespace to the host, which is essential for sharing memory between processes. The `--gpus all` flag enables access to all available GPUs inside the container, which is crucial for tasks that require GPU computation.
+
+ Note: To work with files on your local machine within the container, use Docker volumes for mounting a local directory into the container:
+
+ ```bash
+ # Mount local directory to a directory inside the container
+ sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
+ ```
+
+ Alter `/path/on/host` with the directory path on your local machine, and `/path/in/container` with the desired path inside the Docker container for accessibility.
+
+ For advanced Docker usage, feel free to explore the [Ultralytics Docker Guide](https://docs.ultralytics.com/guides/docker-quickstart/).
+
+See the `ultralytics` [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) file for a list of dependencies. Note that all examples above install all required dependencies.
+
+!!! Tip "Tip"
+
+ PyTorch requirements vary by operating system and CUDA requirements, so it's recommended to install PyTorch first following instructions at [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
+
+
+
+
+
+## Use Ultralytics with CLI
+
+The Ultralytics command line interface (CLI) allows for simple single-line commands without the need for a Python environment. CLI requires no customization or Python code. You can simply run all tasks from the terminal with the `yolo` command. Check out the [CLI Guide](usage/cli.md) to learn more about using YOLOv8 from the command line.
+
+!!! Example
+
+ === "Syntax"
+
+ Ultralytics `yolo` commands use the following syntax:
+ ```bash
+ yolo TASK MODE ARGS
+ ```
+
+ - `TASK` (optional) is one of ([detect](tasks/detect.md), [segment](tasks/segment.md), [classify](tasks/classify.md), [pose](tasks/pose.md))
+ - `MODE` (required) is one of ([train](modes/train.md), [val](modes/val.md), [predict](modes/predict.md), [export](modes/export.md), [track](modes/track.md))
+ - `ARGS` (optional) are `arg=value` pairs like `imgsz=640` that override defaults.
+
+ See all `ARGS` in the full [Configuration Guide](usage/cfg.md) or with the `yolo cfg` CLI command.
+
+ === "Train"
+
+ Train a detection model for 10 epochs with an initial learning_rate of 0.01
+ ```bash
+ yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+ ```
+
+ === "Predict"
+
+ Predict a YouTube video using a pretrained segmentation model at image size 320:
+ ```bash
+ yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+ ```
+
+ === "Val"
+
+ Val a pretrained detection model at batch-size 1 and image size 640:
+ ```bash
+ yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+ ```
+
+ === "Export"
+
+ Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
+ ```bash
+ yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+ ```
+
+ === "Special"
+
+ Run special commands to see version, view settings, run checks and more:
+ ```bash
+ yolo help
+ yolo checks
+ yolo version
+ yolo settings
+ yolo copy-cfg
+ yolo cfg
+ ```
+
+!!! Warning "Warning"
+
+ Arguments must be passed as `arg=val` pairs, split by an equals `=` sign and delimited by spaces between pairs. Do not use `--` argument prefixes or commas `,` between arguments.
+
+ - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` โ
+ - `yolo predict model yolov8n.pt imgsz 640 conf 0.25` โ (missing `=`)
+ - `yolo predict model=yolov8n.pt, imgsz=640, conf=0.25` โ (do not use `,`)
+ - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` โ (do not use `--`)
+
+[CLI Guide](usage/cli.md){ .md-button }
+
+## Use Ultralytics with Python
+
+YOLOv8's Python interface allows for seamless integration into your Python projects, making it easy to load, run, and process the model's output. Designed with simplicity and ease of use in mind, the Python interface enables users to quickly implement object detection, segmentation, and classification in their projects. This makes YOLOv8's Python interface an invaluable tool for anyone looking to incorporate these functionalities into their Python projects.
+
+For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code. Check out the [Python Guide](usage/python.md) to learn more about using YOLOv8 within your Python projects.
+
+!!! Example
+
+ ```python
+ from ultralytics import YOLO
+
+ # Create a new YOLO model from scratch
+ model = YOLO('yolov8n.yaml')
+
+ # Load a pretrained YOLO model (recommended for training)
+ model = YOLO('yolov8n.pt')
+
+ # Train the model using the 'coco128.yaml' dataset for 3 epochs
+ results = model.train(data='coco128.yaml', epochs=3)
+
+ # Evaluate the model's performance on the validation set
+ results = model.val()
+
+ # Perform object detection on an image using the model
+ results = model('https://ultralytics.com/images/bus.jpg')
+
+ # Export the model to ONNX format
+ success = model.export(format='onnx')
+ ```
+
+[Python Guide](usage/python.md){.md-button .md-button--primary}
+
+## Ultralytics Settings
+
+The Ultralytics library provides a powerful settings management system to enable fine-grained control over your experiments. By making use of the `SettingsManager` housed within the `ultralytics.utils` module, users can readily access and alter their settings. These are stored in a YAML file and can be viewed or modified either directly within the Python environment or via the Command-Line Interface (CLI).
+
+### Inspecting Settings
+
+To gain insight into the current configuration of your settings, you can view them directly:
+
+!!! Example "View settings"
+
+ === "Python"
+ You can use Python to view your settings. Start by importing the `settings` object from the `ultralytics` module. Print and return settings using the following commands:
+ ```python
+ from ultralytics import settings
+
+ # View all settings
+ print(settings)
+
+ # Return a specific setting
+ value = settings['runs_dir']
+ ```
+
+ === "CLI"
+ Alternatively, the command-line interface allows you to check your settings with a simple command:
+ ```bash
+ yolo settings
+ ```
+
+### Modifying Settings
+
+Ultralytics allows users to easily modify their settings. Changes can be performed in the following ways:
+
+!!! Example "Update settings"
+
+ === "Python"
+ Within the Python environment, call the `update` method on the `settings` object to change your settings:
+ ```python
+ from ultralytics import settings
+
+ # Update a setting
+ settings.update({'runs_dir': '/path/to/runs'})
+
+ # Update multiple settings
+ settings.update({'runs_dir': '/path/to/runs', 'tensorboard': False})
+
+ # Reset settings to default values
+ settings.reset()
+ ```
+
+ === "CLI"
+ If you prefer using the command-line interface, the following commands will allow you to modify your settings:
+ ```bash
+ # Update a setting
+ yolo settings runs_dir='/path/to/runs'
+
+ # Update multiple settings
+ yolo settings runs_dir='/path/to/runs' tensorboard=False
+
+ # Reset settings to default values
+ yolo settings reset
+ ```
+
+### Understanding Settings
+
+The table below provides an overview of the settings available for adjustment within Ultralytics. Each setting is outlined along with an example value, the data type, and a brief description.
+
+| Name | Example Value | Data Type | Description |
+|--------------------|-----------------------|-----------|------------------------------------------------------------------------------------------------------------------|
+| `settings_version` | `'0.0.4'` | `str` | Ultralytics _settings_ version (different from Ultralytics [pip](https://pypi.org/project/ultralytics/) version) |
+| `datasets_dir` | `'/path/to/datasets'` | `str` | The directory where the datasets are stored |
+| `weights_dir` | `'/path/to/weights'` | `str` | The directory where the model weights are stored |
+| `runs_dir` | `'/path/to/runs'` | `str` | The directory where the experiment runs are stored |
+| `uuid` | `'a1b2c3d4'` | `str` | The unique identifier for the current settings |
+| `sync` | `True` | `bool` | Whether to sync analytics and crashes to HUB |
+| `api_key` | `''` | `str` | Ultralytics HUB [API Key](https://hub.ultralytics.com/settings?tab=api+keys) |
+| `clearml` | `True` | `bool` | Whether to use ClearML logging |
+| `comet` | `True` | `bool` | Whether to use [Comet ML](https://bit.ly/yolov8-readme-comet) for experiment tracking and visualization |
+| `dvc` | `True` | `bool` | Whether to use [DVC for experiment tracking](https://dvc.org/doc/dvclive/ml-frameworks/yolo) and version control |
+| `hub` | `True` | `bool` | Whether to use [Ultralytics HUB](https://hub.ultralytics.com) integration |
+| `mlflow` | `True` | `bool` | Whether to use MLFlow for experiment tracking |
+| `neptune` | `True` | `bool` | Whether to use Neptune for experiment tracking |
+| `raytune` | `True` | `bool` | Whether to use Ray Tune for hyperparameter tuning |
+| `tensorboard` | `True` | `bool` | Whether to use TensorBoard for visualization |
+| `wandb` | `True` | `bool` | Whether to use Weights & Biases logging |
+
+As you navigate through your projects or experiments, be sure to revisit these settings to ensure that they are optimally configured for your needs.
diff --git a/ultralytics/docs/en/quickstart.md:Zone.Identifier b/ultralytics/docs/en/quickstart.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/quickstart.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/cfg/__init__.md b/ultralytics/docs/en/reference/cfg/__init__.md
new file mode 100755
index 0000000..d73a9f2
--- /dev/null
+++ b/ultralytics/docs/en/reference/cfg/__init__.md
@@ -0,0 +1,60 @@
+---
+description: Explore Ultralytics cfg functions like cfg2dict, handle_deprecation, merge_equal_args & more to handle YOLO settings and configurations efficiently.
+keywords: Ultralytics, YOLO, Configuration, cfg2dict, handle_deprecation, merge_equals_args, handle_yolo_settings, copy_default_cfg, Image Detection
+---
+
+# Reference for `ultralytics/cfg/__init__.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/__init__.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/__init__.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/cfg/__init__.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/cfg/__init__.md:Zone.Identifier b/ultralytics/docs/en/reference/cfg/__init__.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/cfg/__init__.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/annotator.md b/ultralytics/docs/en/reference/data/annotator.md
new file mode 100755
index 0000000..ab685b2
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/annotator.md
@@ -0,0 +1,16 @@
+---
+description: Enhance your machine learning model with Ultralyticsโ auto_annotate function. Simplify data annotation for improved model training.
+keywords: Ultralytics, Auto-Annotate, Machine Learning, AI, Annotation, Data Processing, Model Training
+---
+
+# Reference for `ultralytics/data/annotator.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/annotator.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/annotator.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/annotator.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/data/annotator.md:Zone.Identifier b/ultralytics/docs/en/reference/data/annotator.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/annotator.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/augment.md b/ultralytics/docs/en/reference/data/augment.md
new file mode 100755
index 0000000..3b16090
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/augment.md
@@ -0,0 +1,88 @@
+---
+description: Detailed exploration into Ultralytics data augmentation methods including BaseTransform, MixUp, LetterBox, ToTensor, and more for enhancing model performance.
+keywords: Ultralytics, Data Augmentation, BaseTransform, MixUp, RandomHSV, LetterBox, Albumentations, classify_transforms, classify_albumentations
+---
+
+# Reference for `ultralytics/data/augment.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/augment.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/augment.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/augment.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/data/augment.md:Zone.Identifier b/ultralytics/docs/en/reference/data/augment.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/augment.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/base.md b/ultralytics/docs/en/reference/data/base.md
new file mode 100755
index 0000000..c98a7c3
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/base.md
@@ -0,0 +1,16 @@
+---
+description: Explore BaseDataset in Ultralytics docs. Learn how this implementation simplifies dataset creation and manipulation.
+keywords: Ultralytics, docs, BaseDataset, data manipulation, dataset creation
+---
+
+# Reference for `ultralytics/data/base.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/base.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/base.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/base.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.data.base.BaseDataset
+
+
diff --git a/ultralytics/docs/en/reference/data/base.md:Zone.Identifier b/ultralytics/docs/en/reference/data/base.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/base.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/build.md b/ultralytics/docs/en/reference/data/build.md
new file mode 100755
index 0000000..811c11d
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/build.md
@@ -0,0 +1,40 @@
+---
+description: Explore the Ultralytics YOLO v3 data build procedures, including the InfiniteDataLoader, seed_worker, build_dataloader, and load_inference_source.
+keywords: Ultralytics, YOLO v3, Data build, DataLoader, InfiniteDataLoader, seed_worker, build_dataloader, load_inference_source
+---
+
+# Reference for `ultralytics/data/build.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/build.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/build.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/build.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/data/build.md:Zone.Identifier b/ultralytics/docs/en/reference/data/build.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/build.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/converter.md b/ultralytics/docs/en/reference/data/converter.md
new file mode 100755
index 0000000..bbad9d3
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/converter.md
@@ -0,0 +1,36 @@
+---
+description: Explore Ultralytics data converter functions like coco91_to_coco80_class, merge_multi_segment, rle2polygon for efficient data handling.
+keywords: Ultralytics, Data Converter, coco91_to_coco80_class, merge_multi_segment, rle2polygon
+---
+
+# Reference for `ultralytics/data/converter.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/converter.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/converter.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/converter.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/data/converter.md:Zone.Identifier b/ultralytics/docs/en/reference/data/converter.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/converter.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/dataset.md b/ultralytics/docs/en/reference/data/dataset.md
new file mode 100755
index 0000000..242a054
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/dataset.md
@@ -0,0 +1,32 @@
+---
+description: Explore the YOLODataset and SemanticDataset classes in YOLO data. Learn how to efficiently handle and manipulate your data with Ultralytics.
+keywords: Ultralytics, YOLO, YOLODataset, SemanticDataset, data handling, data manipulation
+---
+
+# Reference for `ultralytics/data/dataset.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/dataset.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/dataset.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/dataset.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/data/dataset.md:Zone.Identifier b/ultralytics/docs/en/reference/data/dataset.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/dataset.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/loaders.md b/ultralytics/docs/en/reference/data/loaders.md
new file mode 100755
index 0000000..3ba4c16
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/loaders.md
@@ -0,0 +1,44 @@
+---
+description: Find detailed guides on Ultralytics YOLO data loaders, including LoadStreams, LoadImages and LoadTensor. Learn how to get the best YouTube URLs.
+keywords: Ultralytics, data loaders, LoadStreams, LoadImages, LoadTensor, YOLO, YouTube URLs
+---
+
+# Reference for `ultralytics/data/loaders.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/loaders.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/loaders.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/loaders.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/data/loaders.md:Zone.Identifier b/ultralytics/docs/en/reference/data/loaders.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/loaders.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/data/utils.md b/ultralytics/docs/en/reference/data/utils.md
new file mode 100755
index 0000000..af06ce8
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/utils.md
@@ -0,0 +1,68 @@
+---
+description: Uncover a detailed guide to Ultralytics data utilities. Learn functions from img2label_paths to autosplit, all boosting your YOLO modelโs efficiency.
+keywords: Ultralytics, data utils, YOLO, img2label_paths, exif_size, polygon2mask, polygons2masks_overlap, check_cls_dataset, delete_dsstore, autosplit
+---
+
+# Reference for `ultralytics/data/utils.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/utils.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/utils.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/data/utils.md:Zone.Identifier b/ultralytics/docs/en/reference/data/utils.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/data/utils.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/engine/exporter.md b/ultralytics/docs/en/reference/engine/exporter.md
new file mode 100755
index 0000000..e8daeac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/exporter.md
@@ -0,0 +1,32 @@
+---
+description: Explore the exporter functionality of Ultralytics. Learn about exporting formats, IOSDetectModel, and try exporting with examples.
+keywords: Ultralytics, Exporter, IOSDetectModel, Export Formats, Try export
+---
+
+# Reference for `ultralytics/engine/exporter.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/exporter.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/exporter.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/exporter.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/engine/exporter.md:Zone.Identifier b/ultralytics/docs/en/reference/engine/exporter.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/exporter.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/engine/model.md b/ultralytics/docs/en/reference/engine/model.md
new file mode 100755
index 0000000..5579d75
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/model.md
@@ -0,0 +1,16 @@
+---
+description: Explore the detailed guide on using the Ultralytics YOLO Engine Model. Learn better ways to implement, train and evaluate YOLO models.
+keywords: Ultralytics, YOLO, engine model, documentation, guide, implementation, training, evaluation
+---
+
+# Reference for `ultralytics/engine/model.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/model.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/model.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/model.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.engine.model.Model
+
+
diff --git a/ultralytics/docs/en/reference/engine/model.md:Zone.Identifier b/ultralytics/docs/en/reference/engine/model.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/model.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/engine/predictor.md b/ultralytics/docs/en/reference/engine/predictor.md
new file mode 100755
index 0000000..ad50352
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/predictor.md
@@ -0,0 +1,16 @@
+---
+description: Learn about Ultralytics BasePredictor, an essential component of our engine that serves as the foundation for all prediction operations.
+keywords: Ultralytics, BasePredictor, YOLO, prediction, engine
+---
+
+# Reference for `ultralytics/engine/predictor.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/predictor.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/predictor.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/predictor.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/engine/predictor.md:Zone.Identifier b/ultralytics/docs/en/reference/engine/predictor.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/predictor.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/engine/results.md b/ultralytics/docs/en/reference/engine/results.md
new file mode 100755
index 0000000..b4b709e
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/results.md
@@ -0,0 +1,36 @@
+---
+description: Master Ultralytics engine results including base tensors, boxes, and keypoints with our thorough documentation.
+keywords: Ultralytics, engine, results, base tensor, boxes, keypoints
+---
+
+# Reference for `ultralytics/engine/results.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/results.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/results.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/results.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/engine/results.md:Zone.Identifier b/ultralytics/docs/en/reference/engine/results.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/results.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/engine/trainer.md b/ultralytics/docs/en/reference/engine/trainer.md
new file mode 100755
index 0000000..7c74b04
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/trainer.md
@@ -0,0 +1,16 @@
+---
+description: Learn about the BaseTrainer class in the Ultralytics library. From training control, customization to advanced usage.
+keywords: Ultralytics, BaseTrainer, Machine Learning, Training Control, Python library
+---
+
+# Reference for `ultralytics/engine/trainer.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/trainer.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/trainer.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/trainer.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/engine/trainer.md:Zone.Identifier b/ultralytics/docs/en/reference/engine/trainer.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/trainer.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/engine/tuner.md b/ultralytics/docs/en/reference/engine/tuner.md
new file mode 100755
index 0000000..7882b8c
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/tuner.md
@@ -0,0 +1,16 @@
+---
+description: Explore the Ultralytics Tuner, a powerful tool designed for hyperparameter tuning of YOLO models to optimize performance across various tasks like object detection, image classification, and more.
+keywords: Ultralytics, Tuner, YOLO, hyperparameter tuning, optimization, object detection, image classification, instance segmentation, pose estimation, multi-object tracking
+---
+
+# Reference for `ultralytics/engine/tuner.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/tuner.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/tuner.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/tuner.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.engine.tuner.Tuner
+
+
diff --git a/ultralytics/docs/en/reference/engine/tuner.md:Zone.Identifier b/ultralytics/docs/en/reference/engine/tuner.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/tuner.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/engine/validator.md b/ultralytics/docs/en/reference/engine/validator.md
new file mode 100755
index 0000000..5c0f4cd
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/validator.md
@@ -0,0 +1,16 @@
+---
+description: Learn about the Ultralytics BaseValidator module. Understand its principles, uses, and how it interacts with other components.
+keywords: Ultralytics, BaseValidator, Ultralytics engine, module, components
+---
+
+# Reference for `ultralytics/engine/validator.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/validator.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/validator.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/validator.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/engine/validator.md:Zone.Identifier b/ultralytics/docs/en/reference/engine/validator.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/engine/validator.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/hub/__init__.md b/ultralytics/docs/en/reference/hub/__init__.md
new file mode 100755
index 0000000..912de06
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/__init__.md
@@ -0,0 +1,40 @@
+---
+description: Explore Ultralytics hub functions for model resetting, checking datasets, model exporting and more. Easy-to-follow instructions provided.
+keywords: Ultralytics, hub functions, model export, dataset check, reset model, YOLO Docs
+---
+
+# Reference for `ultralytics/hub/__init__.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/__init__.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/__init__.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/hub/__init__.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.hub.login
+
+
+
+## ::: ultralytics.hub.logout
+
+
+
+## ::: ultralytics.hub.reset_model
+
+
+
+## ::: ultralytics.hub.export_fmts_hub
+
+
+
+## ::: ultralytics.hub.export_model
+
+
+
+## ::: ultralytics.hub.get_export
+
+
+
+## ::: ultralytics.hub.check_dataset
+
+
diff --git a/ultralytics/docs/en/reference/hub/__init__.md:Zone.Identifier b/ultralytics/docs/en/reference/hub/__init__.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/__init__.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/hub/auth.md b/ultralytics/docs/en/reference/hub/auth.md
new file mode 100755
index 0000000..964dc73
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/auth.md
@@ -0,0 +1,16 @@
+---
+description: Dive into the Ultralytics Auth API documentation & learn how to manage authentication in your AI & ML projects easily and effectively.
+keywords: Ultralytics, Auth, API documentation, User Authentication, AI, Machine Learning
+---
+
+# Reference for `ultralytics/hub/auth.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/auth.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/auth.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/hub/auth.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.hub.auth.Auth
+
+
diff --git a/ultralytics/docs/en/reference/hub/auth.md:Zone.Identifier b/ultralytics/docs/en/reference/hub/auth.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/auth.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/hub/session.md b/ultralytics/docs/en/reference/hub/session.md
new file mode 100755
index 0000000..fb30715
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/session.md
@@ -0,0 +1,16 @@
+---
+description: Explore details about the HUBTrainingSession in Ultralytics framework. Learn to utilize this functionality for effective model training.
+keywords: Ultralytics, HUBTrainingSession, Documentation, Model Training, AI, Machine Learning, YOLO
+---
+
+# Reference for `ultralytics/hub/session.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/session.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/session.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/hub/session.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/hub/session.md:Zone.Identifier b/ultralytics/docs/en/reference/hub/session.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/session.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/hub/utils.md b/ultralytics/docs/en/reference/hub/utils.md
new file mode 100755
index 0000000..e310a01
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/utils.md
@@ -0,0 +1,28 @@
+---
+description: Explore Ultralytics docs for various Events, including "request_with_credentials" and "requests_with_progress". Also, understand the use of the "smart_request".
+keywords: Ultralytics, Events, request_with_credentials, smart_request, Ultralytics hub utils, requests_with_progress
+---
+
+# Reference for `ultralytics/hub/utils.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/hub/utils.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/hub/utils.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/hub/utils.md:Zone.Identifier b/ultralytics/docs/en/reference/hub/utils.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/hub/utils.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/fastsam/model.md b/ultralytics/docs/en/reference/models/fastsam/model.md
new file mode 100755
index 0000000..0e99a8c
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/model.md
@@ -0,0 +1,16 @@
+---
+description: Learn all about Ultralytics FastSAM model. Dive into our comprehensive guide for seamless integration and efficient model training.
+keywords: Ultralytics, FastSAM model, Model documentation, Efficient model training
+---
+
+# Reference for `ultralytics/models/fastsam/model.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/model.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/model.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/fastsam/model.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/fastsam/model.md:Zone.Identifier b/ultralytics/docs/en/reference/models/fastsam/model.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/model.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/fastsam/predict.md b/ultralytics/docs/en/reference/models/fastsam/predict.md
new file mode 100755
index 0000000..7c7196e
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/predict.md
@@ -0,0 +1,16 @@
+---
+description: Get detailed insights about Ultralytics FastSAMPredictor. Learn to predict and optimize your AI models with our properly documented guidelines.
+keywords: Ultralytics, FastSAMPredictor, predictive modeling, AI optimization, machine learning, deep learning, Ultralytics documentation
+---
+
+# Reference for `ultralytics/models/fastsam/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/fastsam/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/fastsam/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/fastsam/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/fastsam/prompt.md b/ultralytics/docs/en/reference/models/fastsam/prompt.md
new file mode 100755
index 0000000..0a37023
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/prompt.md
@@ -0,0 +1,16 @@
+---
+description: Learn to effectively utilize FastSAMPrompt model from Ultralytics. Detailed guide to help you get the most out of your machine learning models.
+keywords: Ultralytics, FastSAMPrompt, machine learning, model, guide, documentation
+---
+
+# Reference for `ultralytics/models/fastsam/prompt.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/prompt.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/prompt.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/fastsam/prompt.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/fastsam/prompt.md:Zone.Identifier b/ultralytics/docs/en/reference/models/fastsam/prompt.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/prompt.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/fastsam/utils.md b/ultralytics/docs/en/reference/models/fastsam/utils.md
new file mode 100755
index 0000000..0ba33ab
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/utils.md
@@ -0,0 +1,20 @@
+---
+description: Learn how to adjust bounding boxes to image borders in Ultralytics models using the bbox_iou utility. Enhance your object detection performance.
+keywords: Ultralytics, bounding boxes, Bboxes, image borders, object detection, bbox_iou, model utilities
+---
+
+# Reference for `ultralytics/models/fastsam/utils.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/utils.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/fastsam/utils.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/fastsam/utils.md:Zone.Identifier b/ultralytics/docs/en/reference/models/fastsam/utils.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/utils.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/fastsam/val.md b/ultralytics/docs/en/reference/models/fastsam/val.md
new file mode 100755
index 0000000..4064f05
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/val.md
@@ -0,0 +1,16 @@
+---
+description: Learn about FastSAMValidator in Ultralytics models. Comprehensive guide to enhancing AI capabilities with Ultralytics.
+keywords: Ultralytics, FastSAMValidator, model, synthetic, AI, machine learning, validation
+---
+
+# Reference for `ultralytics/models/fastsam/val.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/val.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/fastsam/val.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/fastsam/val.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/fastsam/val.md:Zone.Identifier b/ultralytics/docs/en/reference/models/fastsam/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/fastsam/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/nas/model.md b/ultralytics/docs/en/reference/models/nas/model.md
new file mode 100755
index 0000000..9536e54
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/nas/model.md
@@ -0,0 +1,16 @@
+---
+description: Learn how our NAS model operates in Ultralytics. Comprehensive guide with detailed examples. Master the nuances of Ultralytics NAS model.
+keywords: Ultralytics, NAS model, NAS guide, machine learning, model documentation
+---
+
+# Reference for `ultralytics/models/nas/model.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/nas/model.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/nas/model.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/nas/model.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.models.nas.model.NAS
+
+
diff --git a/ultralytics/docs/en/reference/models/nas/model.md:Zone.Identifier b/ultralytics/docs/en/reference/models/nas/model.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/nas/model.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/nas/predict.md b/ultralytics/docs/en/reference/models/nas/predict.md
new file mode 100755
index 0000000..3dcc0fd
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/nas/predict.md
@@ -0,0 +1,16 @@
+---
+description: Explore Ultralytics NASPredictor. Understand high-level architecture of the model for effective implementation and efficient predictions.
+keywords: NASPredictor, Ultralytics, Ultralytics model, model architecture, efficient predictions
+---
+
+# Reference for `ultralytics/models/nas/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/nas/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/nas/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/nas/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/nas/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/nas/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/nas/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/nas/val.md b/ultralytics/docs/en/reference/models/nas/val.md
new file mode 100755
index 0000000..5d0adf6
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/nas/val.md
@@ -0,0 +1,16 @@
+---
+description: Explore the utilities and functions of the Ultralytics NASValidator. Find out how it benefits allocation and optimization in AI models.
+keywords: Ultralytics, NASValidator, models.nas.val.NASValidator, AI models, allocation, optimization
+---
+
+# Reference for `ultralytics/models/nas/val.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/nas/val.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/nas/val.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/nas/val.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/nas/val.md:Zone.Identifier b/ultralytics/docs/en/reference/models/nas/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/nas/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/rtdetr/model.md b/ultralytics/docs/en/reference/models/rtdetr/model.md
new file mode 100755
index 0000000..a4578b2
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/model.md
@@ -0,0 +1,16 @@
+---
+description: Explore the specifics of using the RTDETR model in Ultralytics. Detailed documentation layered with explanations and examples.
+keywords: Ultralytics, RTDETR model, Ultralytics models, object detection, Ultralytics documentation
+---
+
+# Reference for `ultralytics/models/rtdetr/model.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/model.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/model.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/rtdetr/model.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/rtdetr/model.md:Zone.Identifier b/ultralytics/docs/en/reference/models/rtdetr/model.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/model.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/rtdetr/predict.md b/ultralytics/docs/en/reference/models/rtdetr/predict.md
new file mode 100755
index 0000000..4763381
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/predict.md
@@ -0,0 +1,16 @@
+---
+description: Learn how to use the RTDETRPredictor model of the Ultralytics package. Detailed documentation, usage instructions, and advice.
+keywords: Ultralytics, RTDETRPredictor, model documentation, guide, real-time object detection
+---
+
+# Reference for `ultralytics/models/rtdetr/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/rtdetr/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/rtdetr/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/rtdetr/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/rtdetr/train.md b/ultralytics/docs/en/reference/models/rtdetr/train.md
new file mode 100755
index 0000000..4f9faaa
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/train.md
@@ -0,0 +1,16 @@
+---
+description: Get insights into RTDETRTrainer, a crucial component of Ultralytics for effective model training. Explore detailed documentation at Ultralytics.
+keywords: Ultralytics, RTDETRTrainer, model training, Ultralytics models, PyTorch models, neural networks, machine learning, deep learning
+---
+
+# Reference for `ultralytics/models/rtdetr/train.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/train.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/train.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/rtdetr/train.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/rtdetr/train.md:Zone.Identifier b/ultralytics/docs/en/reference/models/rtdetr/train.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/train.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/rtdetr/val.md b/ultralytics/docs/en/reference/models/rtdetr/val.md
new file mode 100755
index 0000000..d31bc86
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/val.md
@@ -0,0 +1,20 @@
+---
+description: Explore RTDETRDataset in Ultralytics Models. Learn about the RTDETRValidator function, understand its usage in real-time object detection.
+keywords: Ultralytics, RTDETRDataset, RTDETRValidator, real-time object detection, models documentation
+---
+
+# Reference for `ultralytics/models/rtdetr/val.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/val.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/rtdetr/val.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/rtdetr/val.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/rtdetr/val.md:Zone.Identifier b/ultralytics/docs/en/reference/models/rtdetr/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/rtdetr/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/amg.md b/ultralytics/docs/en/reference/models/sam/amg.md
new file mode 100755
index 0000000..dea35e4
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/amg.md
@@ -0,0 +1,56 @@
+---
+description: Explore Ultralytics methods for mask data processing, transformation and encoding. Deepen your understanding of RLE encoding, image cropping and more.
+keywords: Ultralytics, Mask Data, Transformation, Encoding, RLE encoding, Image cropping, Pytorch, SAM, AMG, Ultralytics model
+---
+
+# Reference for `ultralytics/models/sam/amg.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/amg.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/amg.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/amg.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/amg.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/amg.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/amg.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/build.md b/ultralytics/docs/en/reference/models/sam/build.md
new file mode 100755
index 0000000..9adeeb4
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/build.md
@@ -0,0 +1,36 @@
+---
+description: Master building SAM ViT models with Ultralytics. Discover steps to leverage the power of SAM and Vision Transformer sessions.
+keywords: Ultralytics, SAM, build sam, vision transformer, vits, build_sam_vit_l, build_sam_vit_b, build_sam
+---
+
+# Reference for `ultralytics/models/sam/build.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/build.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/build.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/build.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/build.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/build.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/build.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/model.md b/ultralytics/docs/en/reference/models/sam/model.md
new file mode 100755
index 0000000..32444bc
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/model.md
@@ -0,0 +1,16 @@
+---
+description: Dive into the SAM model details in the Ultralytics YOLO documentation. Understand, implement, and optimize your model use.
+keywords: Ultralytics, YOLO, SAM Model, Documentations, Machine Learning, AI, Convolutional neural network
+---
+
+# Reference for `ultralytics/models/sam/model.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/model.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/model.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/model.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.models.sam.model.SAM
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/model.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/model.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/model.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/modules/decoders.md b/ultralytics/docs/en/reference/models/sam/modules/decoders.md
new file mode 100755
index 0000000..215b832
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/decoders.md
@@ -0,0 +1,20 @@
+---
+description: Explore MaskDecoder, a part of the Ultralytics models. Gain insights on how to utilize it effectively in the SAM modules decoders MLP.
+keywords: Ultralytics, MaskDecoder, SAM modules, decoders, MLP, YOLO, machine learning, image recognition
+---
+
+# Reference for `ultralytics/models/sam/modules/decoders.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/decoders.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/decoders.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/modules/decoders.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/modules/decoders.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/modules/decoders.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/decoders.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/modules/encoders.md b/ultralytics/docs/en/reference/models/sam/modules/encoders.md
new file mode 100755
index 0000000..ffcbf44
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/encoders.md
@@ -0,0 +1,52 @@
+---
+description: Discover detailed information on ImageEncoderViT, PositionEmbeddingRandom, Attention, window_partition, get_rel_pos and more in Ultralytics models encoders documentation.
+keywords: Ultralytics, Encoders, Modules, Documentation, ImageEncoderViT, PositionEmbeddingRandom, Attention, window_partition, get_rel_pos
+---
+
+# Reference for `ultralytics/models/sam/modules/encoders.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/encoders.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/encoders.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/modules/encoders.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/modules/encoders.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/modules/encoders.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/encoders.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/modules/sam.md b/ultralytics/docs/en/reference/models/sam/modules/sam.md
new file mode 100755
index 0000000..d309e24
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/sam.md
@@ -0,0 +1,16 @@
+---
+description: Explore the Sam module of Ultralytics. Discover detailed methods, classes, and information for efficient deep-learning model training!.
+keywords: Ultralytics, Sam module, deep learning, model training, Ultralytics documentation
+---
+
+# Reference for `ultralytics/models/sam/modules/sam.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/sam.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/sam.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/modules/sam.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/modules/sam.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/modules/sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/modules/tiny_encoder.md b/ultralytics/docs/en/reference/models/sam/modules/tiny_encoder.md
new file mode 100755
index 0000000..1d945be
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/tiny_encoder.md
@@ -0,0 +1,56 @@
+---
+description: Get in-depth insights about Ultralytics Tiny Encoder Modules such as Conv2d_BN, MBConv, ConvLayer, Attention, BasicLayer, and TinyViT. Improve your understanding of machine learning model components.
+keywords: Ultralytics, Tiny Encoder, Conv2d_BN, MBConv, ConvLayer, Attention, BasicLayer, TinyViT, Machine learning modules, Ultralytics models
+---
+
+# Reference for `ultralytics/models/sam/modules/tiny_encoder.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/tiny_encoder.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/tiny_encoder.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/modules/tiny_encoder.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/modules/tiny_encoder.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/modules/tiny_encoder.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/tiny_encoder.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/modules/transformer.md b/ultralytics/docs/en/reference/models/sam/modules/transformer.md
new file mode 100755
index 0000000..d36a31e
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/transformer.md
@@ -0,0 +1,24 @@
+---
+description: Learn about TwoWayTransformer and Attention modules in Ultralytics. Leverage these tools to enhance your AI models.
+keywords: Ultralytics, TwoWayTransformer, Attention, AI models, transformers
+---
+
+# Reference for `ultralytics/models/sam/modules/transformer.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/transformer.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/modules/transformer.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/modules/transformer.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/modules/transformer.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/modules/transformer.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/modules/transformer.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/sam/predict.md b/ultralytics/docs/en/reference/models/sam/predict.md
new file mode 100755
index 0000000..ae4c788
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/predict.md
@@ -0,0 +1,16 @@
+---
+description: Master the ultralytics.models.sam.predict.Predictor class with our comprehensive guide. Discover techniques to enhance your model predictions.
+keywords: Ultralytics, predictor, models, sam.predict.Predictor, AI, machine learning, predictive models
+---
+
+# Reference for `ultralytics/models/sam/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/sam/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/sam/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/sam/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/sam/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/sam/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/utils/loss.md b/ultralytics/docs/en/reference/models/utils/loss.md
new file mode 100755
index 0000000..567308e
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/utils/loss.md
@@ -0,0 +1,20 @@
+---
+description: Learn to use the DETRLoss function provided by Ultralytics YOLO. Understand how to utilize loss in RTDETR detection models to improve accuracy.
+keywords: Ultralytics, YOLO, Documentation, DETRLoss, Detection Loss, Loss function, DETR, RTDETR Detection Models
+---
+
+# Reference for `ultralytics/models/utils/loss.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/utils/loss.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/utils/loss.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/utils/loss.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/utils/loss.md:Zone.Identifier b/ultralytics/docs/en/reference/models/utils/loss.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/utils/loss.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/utils/ops.md b/ultralytics/docs/en/reference/models/utils/ops.md
new file mode 100755
index 0000000..4ca7614
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/utils/ops.md
@@ -0,0 +1,20 @@
+---
+description: Discover details for "HungarianMatcher" & "inverse_sigmoid" functions in Ultralytics YOLO, advanced tools supporting detection models.
+keywords: Ultralytics, YOLO, HungarianMatcher, inverse_sigmoid, detection models, model utilities, ops
+---
+
+# Reference for `ultralytics/models/utils/ops.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/utils/ops.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/utils/ops.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/utils/ops.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/utils/ops.md:Zone.Identifier b/ultralytics/docs/en/reference/models/utils/ops.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/utils/ops.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/classify/predict.md b/ultralytics/docs/en/reference/models/yolo/classify/predict.md
new file mode 100755
index 0000000..581107b
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/classify/predict.md
@@ -0,0 +1,16 @@
+---
+description: Explore the Ultralytics ClassificationPredictor guide for model prediction and visualization. Build powerful AI models with YOLO.
+keywords: Ultralytics, classification predictor, predict, YOLO, AI models, model visualization
+---
+
+# Reference for `ultralytics/models/yolo/classify/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/classify/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/classify/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/classify/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/classify/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/classify/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/classify/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/classify/train.md b/ultralytics/docs/en/reference/models/yolo/classify/train.md
new file mode 100755
index 0000000..e4b9ea8
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/classify/train.md
@@ -0,0 +1,16 @@
+---
+description: Delve into Classification Trainer at Ultralytics YOLO docs and optimize your model's training process with insights from the masters!.
+keywords: Ultralytics, YOLO, Classification Trainer, deep learning, training process, AI models, documentation
+---
+
+# Reference for `ultralytics/models/yolo/classify/train.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/classify/train.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/classify/train.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/classify/train.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/classify/train.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/classify/train.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/classify/train.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/classify/val.md b/ultralytics/docs/en/reference/models/yolo/classify/val.md
new file mode 100755
index 0000000..27f64ff
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/classify/val.md
@@ -0,0 +1,16 @@
+---
+description: Explore YOLO ClassificationValidator, a key element of Ultralytics YOLO models. Learn how it validates and fine-tunes model outputs.
+keywords: Ultralytics, YOLO, ClassificationValidator, model validation, model fine-tuning, deep learning, computer vision
+---
+
+# Reference for `ultralytics/models/yolo/classify/val.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/classify/val.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/classify/val.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/classify/val.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/classify/val.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/classify/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/classify/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/detect/predict.md b/ultralytics/docs/en/reference/models/yolo/detect/predict.md
new file mode 100755
index 0000000..4b6cafd
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/detect/predict.md
@@ -0,0 +1,16 @@
+---
+description: Explore the guide to using the DetectionPredictor in Ultralytics YOLO. Learn how to predict, detect and analyze objects accurately.
+keywords: Ultralytics, YOLO, DetectionPredictor, detect, predict, object detection, analysis
+---
+
+# Reference for `ultralytics/models/yolo/detect/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/detect/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/detect/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/detect/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/detect/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/detect/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/detect/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/detect/train.md b/ultralytics/docs/en/reference/models/yolo/detect/train.md
new file mode 100755
index 0000000..bca6faf
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/detect/train.md
@@ -0,0 +1,16 @@
+---
+description: Maximize your model's potential with Ultralytics YOLO Detection Trainer. Learn advanced techniques, tips, and tricks for training.
+keywords: Ultralytics YOLO, YOLO, Detection Trainer, Model Training, Machine Learning, Deep Learning, Computer Vision
+---
+
+# Reference for `ultralytics/models/yolo/detect/train.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/detect/train.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/detect/train.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/detect/train.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/detect/train.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/detect/train.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/detect/train.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/detect/val.md b/ultralytics/docs/en/reference/models/yolo/detect/val.md
new file mode 100755
index 0000000..c5333d0
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/detect/val.md
@@ -0,0 +1,16 @@
+---
+description: Discover function valuation of your YOLO models with the Ultralytics Detection Validator. Enhance precision and recall rates today.
+keywords: Ultralytics, YOLO, Detection Validator, model valuation, precision, recall
+---
+
+# Reference for `ultralytics/models/yolo/detect/val.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/detect/val.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/detect/val.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/detect/val.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/detect/val.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/detect/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/detect/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/model.md b/ultralytics/docs/en/reference/models/yolo/model.md
new file mode 100755
index 0000000..742685f
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/model.md
@@ -0,0 +1,16 @@
+---
+description: Discover the Ultralytics YOLO model class. Learn advanced techniques, tips, and tricks for training.
+keywords: Ultralytics YOLO, YOLO, YOLO model, Model Training, Machine Learning, Deep Learning, Computer Vision
+---
+
+# Reference for `ultralytics/models/yolo/model.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/model.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/model.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/model.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.models.yolo.model.YOLO
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/model.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/model.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/model.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/pose/predict.md b/ultralytics/docs/en/reference/models/yolo/pose/predict.md
new file mode 100755
index 0000000..9eb4af4
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/pose/predict.md
@@ -0,0 +1,16 @@
+---
+description: Discover how to use PosePredictor in the Ultralytics YOLO model. Includes detailed guides, code examples, and explanations.
+keywords: Ultralytics, YOLO, PosePredictor, machine learning, AI, predictive models
+---
+
+# Reference for `ultralytics/models/yolo/pose/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/pose/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/pose/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/pose/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/pose/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/pose/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/pose/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/pose/train.md b/ultralytics/docs/en/reference/models/yolo/pose/train.md
new file mode 100755
index 0000000..1d02bf2
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/pose/train.md
@@ -0,0 +1,16 @@
+---
+description: Explore Ultralytics PoseTrainer for YOLO models. Get a step-by-step guide on how to train on custom pose data for more accurate AI modeling.
+keywords: Ultralytics, YOLO, PoseTrainer, pose training, AI modeling, custom data training
+---
+
+# Reference for `ultralytics/models/yolo/pose/train.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/pose/train.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/pose/train.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/pose/train.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/pose/train.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/pose/train.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/pose/train.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/pose/val.md b/ultralytics/docs/en/reference/models/yolo/pose/val.md
new file mode 100755
index 0000000..77207be
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/pose/val.md
@@ -0,0 +1,16 @@
+---
+description: Explore the PoseValidatorโreview how Ultralytics YOLO validates poses for object detection. Improve your understanding of YOLO.
+keywords: PoseValidator, Ultralytics, YOLO, Object detection, Pose validation
+---
+
+# Reference for `ultralytics/models/yolo/pose/val.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/pose/val.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/pose/val.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/pose/val.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/pose/val.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/pose/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/pose/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/segment/predict.md b/ultralytics/docs/en/reference/models/yolo/segment/predict.md
new file mode 100755
index 0000000..a92b6f6
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/segment/predict.md
@@ -0,0 +1,16 @@
+---
+description: Discover how to utilize the YOLO Segmentation Predictor in Ultralytics. Enhance your objects detection skills with us.
+keywords: YOLO, Ultralytics, object detection, segmentation predictor
+---
+
+# Reference for `ultralytics/models/yolo/segment/predict.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/segment/predict.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/segment/predict.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/segment/predict.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/segment/predict.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/segment/predict.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/segment/predict.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/segment/train.md b/ultralytics/docs/en/reference/models/yolo/segment/train.md
new file mode 100755
index 0000000..1b5c3d5
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/segment/train.md
@@ -0,0 +1,16 @@
+---
+description: Maximize your YOLO model's performance with our SegmentationTrainer. Explore comprehensive guides and tutorials on ultralytics.com.
+keywords: Ultralytics, YOLO, SegmentationTrainer, image segmentation, object detection, model training, YOLO model
+---
+
+# Reference for `ultralytics/models/yolo/segment/train.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/segment/train.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/segment/train.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/segment/train.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/segment/train.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/segment/train.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/segment/train.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/models/yolo/segment/val.md b/ultralytics/docs/en/reference/models/yolo/segment/val.md
new file mode 100755
index 0000000..745b22c
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/segment/val.md
@@ -0,0 +1,16 @@
+---
+description: Get practical insights about our SegmentationValidator in YOLO Ultralytics models. Discover functionality details, methods, inputs, and outputs.
+keywords: Ultralytics, YOLO, SegmentationValidator, model segmentation, image classification, object detection
+---
+
+# Reference for `ultralytics/models/yolo/segment/val.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/segment/val.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/models/yolo/segment/val.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/models/yolo/segment/val.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/models/yolo/segment/val.md:Zone.Identifier b/ultralytics/docs/en/reference/models/yolo/segment/val.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/models/yolo/segment/val.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/nn/autobackend.md b/ultralytics/docs/en/reference/nn/autobackend.md
new file mode 100755
index 0000000..3e8c2f7
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/autobackend.md
@@ -0,0 +1,24 @@
+---
+description: Get to know more about Ultralytics nn.autobackend.check_class_names functionality. Optimize your YOLO models seamlessly.
+keywords: Ultralytics, AutoBackend, check_class_names, YOLO, YOLO models, optimization
+---
+
+# Reference for `ultralytics/nn/autobackend.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/autobackend.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/autobackend.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/nn/autobackend.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/nn/autobackend.md:Zone.Identifier b/ultralytics/docs/en/reference/nn/autobackend.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/autobackend.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/nn/modules/block.md b/ultralytics/docs/en/reference/nn/modules/block.md
new file mode 100755
index 0000000..f8b1e58
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/block.md
@@ -0,0 +1,88 @@
+---
+description: Explore Ultralytics YOLO neural network modules, Proto to BottleneckCSP. Detailed explanation of each module with easy-to-follow code examples.
+keywords: YOLO, Ultralytics, neural network, nn.modules.block, Proto, HGBlock, SPPF, C2, C3, RepC3, C3Ghost, Bottleneck, BottleneckCSP
+---
+
+# Reference for `ultralytics/nn/modules/block.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/block.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/block.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/nn/modules/block.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/nn/modules/block.md:Zone.Identifier b/ultralytics/docs/en/reference/nn/modules/block.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/block.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/nn/modules/conv.md b/ultralytics/docs/en/reference/nn/modules/conv.md
new file mode 100755
index 0000000..6c9fb35
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/conv.md
@@ -0,0 +1,68 @@
+---
+description: Explore various Ultralytics convolution modules including Conv2, DWConv, ConvTranspose, GhostConv, Channel Attention and more.
+keywords: Ultralytics, Convolution Modules, Conv2, DWConv, ConvTranspose, GhostConv, ChannelAttention, CBAM, autopad
+---
+
+# Reference for `ultralytics/nn/modules/conv.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/conv.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/conv.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/nn/modules/conv.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/nn/modules/conv.md:Zone.Identifier b/ultralytics/docs/en/reference/nn/modules/conv.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/conv.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/nn/modules/head.md b/ultralytics/docs/en/reference/nn/modules/head.md
new file mode 100755
index 0000000..40ffb25
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/head.md
@@ -0,0 +1,32 @@
+---
+description: Explore docs covering Ultralytics YOLO detection, pose & RTDETRDecoder. Comprehensive guides to help you understand Ultralytics nn modules.
+keywords: Ultralytics, YOLO, Detection, Pose, RTDETRDecoder, nn modules, guides
+---
+
+# Reference for `ultralytics/nn/modules/head.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/head.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/head.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/nn/modules/head.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/nn/modules/head.md:Zone.Identifier b/ultralytics/docs/en/reference/nn/modules/head.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/head.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/nn/modules/transformer.md b/ultralytics/docs/en/reference/nn/modules/transformer.md
new file mode 100755
index 0000000..91904be
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/transformer.md
@@ -0,0 +1,52 @@
+---
+description: Learn about Ultralytics transformer encoder, layer, MLP block, LayerNorm2d and the deformable transformer decoder layer. Expand your understanding of these crucial AI modules.
+keywords: Ultralytics, Ultralytics documentation, TransformerEncoderLayer, TransformerLayer, MLPBlock, LayerNorm2d, DeformableTransformerDecoderLayer
+---
+
+# Reference for `ultralytics/nn/modules/transformer.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/transformer.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/transformer.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/nn/modules/transformer.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/nn/modules/transformer.md:Zone.Identifier b/ultralytics/docs/en/reference/nn/modules/transformer.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/transformer.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/nn/modules/utils.md b/ultralytics/docs/en/reference/nn/modules/utils.md
new file mode 100755
index 0000000..25b0b1c
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/utils.md
@@ -0,0 +1,32 @@
+---
+description: Explore Ultralytics neural network utils, such as bias_init_with_prob, inverse_sigmoid and multi_scale_deformable_attn_pytorch functions.
+keywords: Ultralytics, neural network, nn.modules.utils, bias_init_with_prob, inverse_sigmoid, multi_scale_deformable_attn_pytorch
+---
+
+# Reference for `ultralytics/nn/modules/utils.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/utils.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/nn/modules/utils.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/nn/modules/utils.md:Zone.Identifier b/ultralytics/docs/en/reference/nn/modules/utils.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/modules/utils.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/nn/tasks.md b/ultralytics/docs/en/reference/nn/tasks.md
new file mode 100755
index 0000000..aa84d88
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/tasks.md
@@ -0,0 +1,72 @@
+---
+description: Dive into the intricacies of YOLO tasks.py. Learn about DetectionModel, PoseModel and more for powerful AI development.
+keywords: Ultralytics, YOLO, nn tasks, DetectionModel, PoseModel, RTDETRDetectionModel, model weights, parse model, AI development
+---
+
+# Reference for `ultralytics/nn/tasks.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/tasks.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/tasks.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/nn/tasks.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/nn/tasks.md:Zone.Identifier b/ultralytics/docs/en/reference/nn/tasks.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/nn/tasks.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/solutions/ai_gym.md b/ultralytics/docs/en/reference/solutions/ai_gym.md
new file mode 100755
index 0000000..eb3e634
--- /dev/null
+++ b/ultralytics/docs/en/reference/solutions/ai_gym.md
@@ -0,0 +1,16 @@
+---
+description: Explore Ultralytics YOLO's advanced AI Gym feature for real-time pose estimation and gym exercise tracking using cutting-edge machine learning technology.
+keywords: Ultralytics, YOLO, AI Gym, pose estimation, real-time tracking, machine learning, exercise counting, AI fitness, computer vision, gym workout analysis, YOLOv8, artificial intelligence, fitness technology
+---
+
+# Reference for `ultralytics/solutions/ai_gym.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/solutions/ai_gym.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/solutions/ai_gym.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/solutions/ai_gym.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.solutions.ai_gym.AIGym
+
+
diff --git a/ultralytics/docs/en/reference/solutions/ai_gym.md:Zone.Identifier b/ultralytics/docs/en/reference/solutions/ai_gym.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/solutions/ai_gym.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/solutions/heatmap.md b/ultralytics/docs/en/reference/solutions/heatmap.md
new file mode 100755
index 0000000..133125c
--- /dev/null
+++ b/ultralytics/docs/en/reference/solutions/heatmap.md
@@ -0,0 +1,16 @@
+---
+description: Explore Ultralytics YOLO's advanced Heatmaps feature designed to highlight areas of interest, providing an immediate, impactful way to interpret spatial information.
+keywords: Ultralytics, YOLO, heatmaps, object tracking, data visualization, real-time tracking, machine learning, object counting, computer vision, retail analytics, YOLOv8, artificial intelligence
+---
+
+# Reference for `ultralytics/solutions/heatmap.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/solutions/heatmap.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/solutions/heatmap.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/solutions/heatmap.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/solutions/object_counter.md:Zone.Identifier b/ultralytics/docs/en/reference/solutions/object_counter.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/solutions/object_counter.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/trackers/basetrack.md b/ultralytics/docs/en/reference/trackers/basetrack.md
new file mode 100755
index 0000000..97f5c4a
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/basetrack.md
@@ -0,0 +1,20 @@
+---
+description: Get familiar with TrackState in Ultralytics. Learn how it is used in the BaseTrack of the Ultralytics tracker for enhanced functionality.
+keywords: Ultralytics, TrackState, BaseTrack, Ultralytics tracker, Ultralytics documentation
+---
+
+# Reference for `ultralytics/trackers/basetrack.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/basetrack.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/basetrack.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/trackers/basetrack.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/trackers/basetrack.md:Zone.Identifier b/ultralytics/docs/en/reference/trackers/basetrack.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/basetrack.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/trackers/bot_sort.md b/ultralytics/docs/en/reference/trackers/bot_sort.md
new file mode 100755
index 0000000..85dfeee
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/bot_sort.md
@@ -0,0 +1,20 @@
+---
+description: Master the use of Ultralytics BOTrack, a key component of the powerful Ultralytics tracking system. Learn to integrate and use BOTSORT in your projects.
+keywords: Ultralytics, BOTSORT, BOTrack, tracking system, official documentation, machine learning, AI tracking
+---
+
+# Reference for `ultralytics/trackers/bot_sort.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/bot_sort.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/bot_sort.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/trackers/bot_sort.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/trackers/bot_sort.md:Zone.Identifier b/ultralytics/docs/en/reference/trackers/bot_sort.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/bot_sort.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/trackers/byte_tracker.md b/ultralytics/docs/en/reference/trackers/byte_tracker.md
new file mode 100755
index 0000000..e240d44
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/byte_tracker.md
@@ -0,0 +1,20 @@
+---
+description: Step-in to explore in-depth the functionalities of Ultralytics BYTETracker under STrack. Gain advanced feature insights to streamline your operations.
+keywords: STrack, Ultralytics, BYTETracker, documentation, Ultralytics tracker, object tracking, YOLO
+---
+
+# Reference for `ultralytics/trackers/byte_tracker.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/byte_tracker.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/byte_tracker.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/trackers/byte_tracker.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/trackers/byte_tracker.md:Zone.Identifier b/ultralytics/docs/en/reference/trackers/byte_tracker.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/byte_tracker.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/trackers/track.md b/ultralytics/docs/en/reference/trackers/track.md
new file mode 100755
index 0000000..7f15130
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/track.md
@@ -0,0 +1,24 @@
+---
+description: Explore Ultralytics documentation on prediction function starters & register trackers. Understand our code & its applications better.
+keywords: Ultralytics, YOLO, on predict start, register tracker, prediction functions, documentation
+---
+
+# Reference for `ultralytics/trackers/track.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/track.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/track.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/trackers/track.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/trackers/track.md:Zone.Identifier b/ultralytics/docs/en/reference/trackers/track.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/track.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/trackers/utils/gmc.md b/ultralytics/docs/en/reference/trackers/utils/gmc.md
new file mode 100755
index 0000000..fa51e8e
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/utils/gmc.md
@@ -0,0 +1,16 @@
+---
+description: Explore the Ultralytics GMC tool in our comprehensive documentation. Learn how it works, best practices, and implementation advice.
+keywords: Ultralytics, GMC utility, Ultralytics documentation, Ultralytics tracker, machine learning tools
+---
+
+# Reference for `ultralytics/trackers/utils/gmc.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/utils/gmc.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/utils/gmc.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/trackers/utils/gmc.py) ๐ ๏ธ. Thank you ๐!
+
+
+
+## ::: ultralytics.trackers.utils.gmc.GMC
+
+
diff --git a/ultralytics/docs/en/reference/trackers/utils/gmc.md:Zone.Identifier b/ultralytics/docs/en/reference/trackers/utils/gmc.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/utils/gmc.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/trackers/utils/kalman_filter.md b/ultralytics/docs/en/reference/trackers/utils/kalman_filter.md
new file mode 100755
index 0000000..11063ef
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/utils/kalman_filter.md
@@ -0,0 +1,20 @@
+---
+description: Explore KalmanFilterXYAH, a key component of Ultralytics trackers. Understand its utilities and learn to leverage it in your own projects.
+keywords: Ultralytics, KalmanFilterXYAH, tracker, documentation, guide
+---
+
+# Reference for `ultralytics/trackers/utils/kalman_filter.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/utils/kalman_filter.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/utils/kalman_filter.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/trackers/utils/kalman_filter.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/trackers/utils/kalman_filter.md:Zone.Identifier b/ultralytics/docs/en/reference/trackers/utils/kalman_filter.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/utils/kalman_filter.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/trackers/utils/matching.md b/ultralytics/docs/en/reference/trackers/utils/matching.md
new file mode 100755
index 0000000..fb7d326
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/utils/matching.md
@@ -0,0 +1,28 @@
+---
+description: Explore in-depth guidance for using Ultralytics trackers utils matching, including merge_matches, linear_assignment, iou_distance, embedding_distance, fuse_motion, and fuse_score.
+keywords: Ultralytics, Trackers Utils, Matching, merge_matches, linear_assignment, iou_distance, embedding_distance, fuse_motion, fuse_score, documentation
+---
+
+# Reference for `ultralytics/trackers/utils/matching.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/utils/matching.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/trackers/utils/matching.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/trackers/utils/matching.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/trackers/utils/matching.md:Zone.Identifier b/ultralytics/docs/en/reference/trackers/utils/matching.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/trackers/utils/matching.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/__init__.md b/ultralytics/docs/en/reference/utils/__init__.md
new file mode 100755
index 0000000..43b245f
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/__init__.md
@@ -0,0 +1,156 @@
+---
+description: Explore the Ultralytics Utils package, with handy functions like colorstr, yaml_save, set_logging & more, designed to enhance your coding experience.
+keywords: Ultralytics, Utils, utilitarian functions, colorstr, yaml_save, set_logging, is_kaggle, is_docker, clean_url
+---
+
+# Reference for `ultralytics/utils/__init__.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/__init__.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/__init__.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/__init__.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/__init__.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/__init__.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/__init__.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/autobatch.md b/ultralytics/docs/en/reference/utils/autobatch.md
new file mode 100755
index 0000000..4dc132b
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/autobatch.md
@@ -0,0 +1,20 @@
+---
+description: Explore Ultralytics documentation for check_train_batch_size utility in the autobatch module. Understand how it could improve your machine learning process.
+keywords: Ultralytics, check_train_batch_size, autobatch, utility, machine learning, documentation
+---
+
+# Reference for `ultralytics/utils/autobatch.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/autobatch.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/autobatch.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/autobatch.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/autobatch.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/autobatch.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/autobatch.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/benchmarks.md b/ultralytics/docs/en/reference/utils/benchmarks.md
new file mode 100755
index 0000000..76d4885
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/benchmarks.md
@@ -0,0 +1,20 @@
+---
+description: Discover how to profile your models using Ultralytics utilities. Enhance performance, optimize your benchmarks, and learn best practices.
+keywords: Ultralytics, ProfileModels, benchmarks, model profiling, performance optimization
+---
+
+# Reference for `ultralytics/utils/benchmarks.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/benchmarks.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/benchmarks.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/benchmarks.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/benchmarks.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/benchmarks.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/benchmarks.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/base.md b/ultralytics/docs/en/reference/utils/callbacks/base.md
new file mode 100755
index 0000000..609e34b
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/base.md
@@ -0,0 +1,120 @@
+---
+description: Explore how to use the on-train, on-validation, on-pretrain, and on-predict callbacks in Ultralytics. Learn to update params, save models, and add integration callbacks.
+keywords: Ultralytics, Callbacks, On-train, On-validation, On-pretrain, On-predict, Parameters update, Model saving, Integration callbacks
+---
+
+# Reference for `ultralytics/utils/callbacks/base.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/base.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/base.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/base.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/base.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/base.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/base.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/clearml.md b/ultralytics/docs/en/reference/utils/callbacks/clearml.md
new file mode 100755
index 0000000..a05b08c
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/clearml.md
@@ -0,0 +1,40 @@
+---
+description: Uncover the specifics of Ultralytics ClearML callbacks, from pretrain routine start to training end. Boost your ML model performance.
+keywords: Ultralytics, clearML, callbacks, pretrain routine start, validation end, train epoch end, training end
+---
+
+# Reference for `ultralytics/utils/callbacks/clearml.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/clearml.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/clearml.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/clearml.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/clearml.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/clearml.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/clearml.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/comet.md b/ultralytics/docs/en/reference/utils/callbacks/comet.md
new file mode 100755
index 0000000..2ba62fa
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/comet.md
@@ -0,0 +1,108 @@
+---
+description: Explore comprehensive documentation for utilising Comet Callbacks in Ultralytics. Learn to optimise training, logging, and experiment workflows.
+keywords: Ultralytics, Comet Callbacks, Training optimisation, Logging, Experiment Workflows
+---
+
+# Reference for `ultralytics/utils/callbacks/comet.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/comet.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/comet.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/comet.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/comet.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/comet.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/comet.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/dvc.md b/ultralytics/docs/en/reference/utils/callbacks/dvc.md
new file mode 100755
index 0000000..a325989
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/dvc.md
@@ -0,0 +1,48 @@
+---
+description: Browse through Ultralytics YOLO docs to learn about important logging and callback functions used in training and pretraining models.
+keywords: Ultralytics, YOLO, callbacks, logger, training, pretraining, machine learning, models
+---
+
+# Reference for `ultralytics/utils/callbacks/dvc.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/dvc.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/dvc.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/dvc.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/dvc.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/dvc.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/dvc.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/hub.md b/ultralytics/docs/en/reference/utils/callbacks/hub.md
new file mode 100755
index 0000000..3735e90
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/hub.md
@@ -0,0 +1,44 @@
+---
+description: Explore the detailed information on key Ultralytics callbacks such as on_pretrain_routine_end, on_model_save, on_train_start, and on_predict_start.
+keywords: Ultralytics, callbacks, on_pretrain_routine_end, on_model_save, on_train_start, on_predict_start, hub, training
+---
+
+# Reference for `ultralytics/utils/callbacks/hub.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/hub.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/hub.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/hub.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/hub.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/hub.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/hub.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/mlflow.md b/ultralytics/docs/en/reference/utils/callbacks/mlflow.md
new file mode 100755
index 0000000..e3fab6c
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/mlflow.md
@@ -0,0 +1,28 @@
+---
+description: Understand routines at the end of pre-training and training in Ultralytics. Elevate your MLflow callbacks expertise.
+keywords: Ultralytics, MLflow, Callbacks, on_pretrain_routine_end, on_train_end, Machine Learning, Training
+---
+
+# Reference for `ultralytics/utils/callbacks/mlflow.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/mlflow.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/mlflow.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/mlflow.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/mlflow.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/mlflow.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/mlflow.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/neptune.md b/ultralytics/docs/en/reference/utils/callbacks/neptune.md
new file mode 100755
index 0000000..82906ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/neptune.md
@@ -0,0 +1,44 @@
+---
+description: Explore exhaustive details about Ultralytics callbacks in Neptune, with specifics about scalar logging, routine start, and more.
+keywords: Ultralytics, Neptune callbacks, on_train_epoch_end, on_val_end, _log_plot, _log_images, on_pretrain_routine_start, on_fit_epoch_end, on_train_end
+---
+
+# Reference for `ultralytics/utils/callbacks/neptune.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/neptune.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/neptune.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/neptune.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/neptune.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/neptune.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/neptune.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/raytune.md b/ultralytics/docs/en/reference/utils/callbacks/raytune.md
new file mode 100755
index 0000000..2ed6191
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/raytune.md
@@ -0,0 +1,16 @@
+---
+description: Discover the functionality of the on_fit_epoch_end callback in the Ultralytics YOLO framework. Learn how to end an epoch in your deep learning projects.
+keywords: Ultralytics, YOLO, on_fit_epoch_end, callbacks, documentation, deep learning, YOLO framework
+---
+
+# Reference for `ultralytics/utils/callbacks/raytune.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/raytune.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/raytune.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/raytune.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/raytune.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/raytune.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/raytune.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/tensorboard.md b/ultralytics/docs/en/reference/utils/callbacks/tensorboard.md
new file mode 100755
index 0000000..74fb3b1
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/tensorboard.md
@@ -0,0 +1,36 @@
+---
+description: Explore Ultralytics YOLO Docs for a deep understanding of log_scalars, on_batch_end & other callback utilities embedded in the tensorboard module.
+keywords: Ultralytics, YOLO, documentation, callback utilities, log_scalars, on_batch_end, tensorboard
+---
+
+# Reference for `ultralytics/utils/callbacks/tensorboard.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/tensorboard.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/tensorboard.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/tensorboard.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/tensorboard.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/tensorboard.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/tensorboard.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/callbacks/wb.md b/ultralytics/docs/en/reference/utils/callbacks/wb.md
new file mode 100755
index 0000000..59a2088
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/wb.md
@@ -0,0 +1,40 @@
+---
+description: Deep dive into Ultralytics callbacks. Learn how to use the _log_plots, on_fit_epoch_end, and on_train_end functions effectively.
+keywords: Ultralytics, callbacks, _log_plots, on_fit_epoch_end, on_train_end
+---
+
+# Reference for `ultralytics/utils/callbacks/wb.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/wb.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/wb.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/callbacks/wb.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/callbacks/wb.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/callbacks/wb.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/callbacks/wb.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/checks.md b/ultralytics/docs/en/reference/utils/checks.md
new file mode 100755
index 0000000..f2e4ed9
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/checks.md
@@ -0,0 +1,112 @@
+---
+description: Learn about our routine checks that safeguard Ultralytics operations including ASCII, font, YOLO file, YAML, Python and torchvision checks.
+keywords: Ultralytics, utility checks, ASCII, check_version, pip_update, check_python, check_torchvision, check_yaml, YOLO filename
+---
+
+# Reference for `ultralytics/utils/checks.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/checks.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/checks.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/checks.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/checks.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/checks.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/checks.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/dist.md b/ultralytics/docs/en/reference/utils/dist.md
new file mode 100755
index 0000000..1ca18e3
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/dist.md
@@ -0,0 +1,28 @@
+---
+description: Discover the role of dist.find_free_network_port & dist.generate_ddp_command in Ultralytics DDP utilities. Use our guide for efficient deployment.
+keywords: Ultralytics, DDP, DDP utility functions, Distributed Data Processing, find free network port, generate DDP command
+---
+
+# Reference for `ultralytics/utils/dist.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/dist.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/dist.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/dist.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/dist.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/dist.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/dist.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/downloads.md b/ultralytics/docs/en/reference/utils/downloads.md
new file mode 100755
index 0000000..aeef4c9
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/downloads.md
@@ -0,0 +1,52 @@
+---
+description: Learn about the download utilities in Ultralytics YOLO, featuring functions like is_url, check_disk_space, get_github_assets, and download.
+keywords: Ultralytics, YOLO, download utilities, is_url, check_disk_space, get_github_assets, download, documentation
+---
+
+# Reference for `ultralytics/utils/downloads.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/downloads.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/downloads.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/downloads.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/downloads.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/downloads.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/downloads.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/errors.md b/ultralytics/docs/en/reference/utils/errors.md
new file mode 100755
index 0000000..816328a
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/errors.md
@@ -0,0 +1,16 @@
+---
+description: Learn about the HUBModelError in Ultralytics. Enhance your understanding, troubleshoot errors and optimize your machine learning projects.
+keywords: Ultralytics, HUBModelError, Machine Learning, Error troubleshooting, Ultralytics documentation
+---
+
+# Reference for `ultralytics/utils/errors.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/errors.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/errors.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/errors.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/errors.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/errors.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/errors.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/files.md b/ultralytics/docs/en/reference/utils/files.md
new file mode 100755
index 0000000..586373b
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/files.md
@@ -0,0 +1,40 @@
+---
+description: Discover how to use Ultralytics utility functions for file-related operations including incrementing paths, finding file age, checking file size and creating directories.
+keywords: Ultralytics, utility functions, file operations, working directory, file age, file size, create directories
+---
+
+# Reference for `ultralytics/utils/files.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/files.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/files.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/files.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/files.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/files.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/files.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/instance.md b/ultralytics/docs/en/reference/utils/instance.md
new file mode 100755
index 0000000..6771cd8
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/instance.md
@@ -0,0 +1,24 @@
+---
+description: Dive into Ultralytics detailed utility guide. Learn about Bboxes, _ntuple and more from Ultralytics utils.instance module.
+keywords: Ultralytics, Bboxes, _ntuple, utility, ultralytics utils.instance
+---
+
+# Reference for `ultralytics/utils/instance.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/instance.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/instance.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/instance.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/instance.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/instance.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/instance.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/loss.md b/ultralytics/docs/en/reference/utils/loss.md
new file mode 100755
index 0000000..922ad6c
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/loss.md
@@ -0,0 +1,44 @@
+---
+description: Explore Ultralytics' versatile loss functions - VarifocalLoss, BboxLoss, v8DetectionLoss, v8PoseLoss. Improve your accuracy on YOLO implementations.
+keywords: Ultralytics, Loss functions, VarifocalLoss, BboxLoss, v8DetectionLoss, v8PoseLoss, YOLO, Ultralytics Documentation
+---
+
+# Reference for `ultralytics/utils/loss.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/loss.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/loss.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/loss.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/metrics.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/metrics.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/metrics.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/ops.md b/ultralytics/docs/en/reference/utils/ops.md
new file mode 100755
index 0000000..c366fd9
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/ops.md
@@ -0,0 +1,128 @@
+---
+description: Explore detailed documentation for Ultralytics utility operations. Learn about methods like segment2box, make_divisible, clip_boxes, and many more.
+keywords: Ultralytics YOLO, Utility Operations, segment2box, make_divisible, clip_boxes, scale_image, xywh2xyxy, xyxy2xywhn, xywh2ltwh, ltwh2xywh, segments2boxes, crop_mask, process_mask, scale_masks, masks2segments
+---
+
+# Reference for `ultralytics/utils/ops.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/ops.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/ops.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/ops.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/ops.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/ops.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/ops.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/patches.md b/ultralytics/docs/en/reference/utils/patches.md
new file mode 100755
index 0000000..fdcf394
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/patches.md
@@ -0,0 +1,28 @@
+---
+description: Learn about Ultralytics utils patches including imread, imshow and torch_save. Enhance your image processing skills.
+keywords: Ultralytics, Utils, Patches, imread, imshow, torch_save, image processing
+---
+
+# Reference for `ultralytics/utils/patches.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/patches.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/patches.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/patches.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/patches.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/patches.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/patches.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/plotting.md b/ultralytics/docs/en/reference/utils/plotting.md
new file mode 100755
index 0000000..b465af4
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/plotting.md
@@ -0,0 +1,52 @@
+---
+description: Master advanced plotting utils from Ultralytics including color annotations, label and image plotting, and feature visualization.
+keywords: Ultralytics, plotting, utils, color annotation, label plotting, image plotting, feature visualization
+---
+
+# Reference for `ultralytics/utils/plotting.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/plotting.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/plotting.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/plotting.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/plotting.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/plotting.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/plotting.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/tal.md b/ultralytics/docs/en/reference/utils/tal.md
new file mode 100755
index 0000000..6519d35
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/tal.md
@@ -0,0 +1,36 @@
+---
+description: Explore Ultralytics utilities for optimized task assignment, bounding box creation, and distance calculation. Learn more about algorithm implementations.
+keywords: Ultralytics, task aligned assigner, select highest overlaps, make anchors, dist2bbox, bbox2dist, utilities, algorithm
+---
+
+# Reference for `ultralytics/utils/tal.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/tal.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/tal.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/tal.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/tal.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/tal.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/tal.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/torch_utils.md b/ultralytics/docs/en/reference/utils/torch_utils.md
new file mode 100755
index 0000000..5c88f29
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/torch_utils.md
@@ -0,0 +1,120 @@
+---
+description: Explore Ultralytics-tailored torch utility features like Model EMA, early stopping, smart inference, image scaling, get_flops, and many more.
+keywords: Ultralytics, Torch Utils, Model EMA, Early Stopping, Smart Inference, Get CPU Info, Time Sync, Fuse Deconv and bn, Get num params, Get FLOPs, Scale img, Copy attr, Intersect dicts, De_parallel, Init seeds, Profile
+---
+
+# Reference for `ultralytics/utils/torch_utils.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/torch_utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/torch_utils.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/torch_utils.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/torch_utils.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/torch_utils.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/torch_utils.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/triton.md b/ultralytics/docs/en/reference/utils/triton.md
new file mode 100755
index 0000000..6a86de6
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/triton.md
@@ -0,0 +1,16 @@
+---
+description: Deploy ML models effortlessly with Ultralytics TritonRemoteModel. Simplify serving with our comprehensive utils guide.
+keywords: Ultralytics, YOLO, TritonRemoteModel, machine learning, model serving, deployment, utils, documentation
+---
+
+# Reference for `ultralytics/utils/triton.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/triton.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/triton.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/triton.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/triton.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/triton.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/triton.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/reference/utils/tuner.md b/ultralytics/docs/en/reference/utils/tuner.md
new file mode 100755
index 0000000..d05f83d
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/tuner.md
@@ -0,0 +1,16 @@
+---
+description: Learn to utilize the run_ray_tune function with Ultralytics. Make your machine learning tuning process easier and more efficient.
+keywords: Ultralytics, run_ray_tune, machine learning tuning, machine learning efficiency
+---
+
+# Reference for `ultralytics/utils/tuner.py`
+
+!!! Note
+
+ This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/tuner.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/tuner.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/utils/tuner.py) ๐ ๏ธ. Thank you ๐!
+
+
diff --git a/ultralytics/docs/en/reference/utils/tuner.md:Zone.Identifier b/ultralytics/docs/en/reference/utils/tuner.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/reference/utils/tuner.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/robots.txt b/ultralytics/docs/en/robots.txt
new file mode 100755
index 0000000..6d80eae
--- /dev/null
+++ b/ultralytics/docs/en/robots.txt
@@ -0,0 +1,12 @@
+User-agent: *
+Sitemap: http://docs.ultralytics.com/sitemap.xml
+Sitemap: http://docs.ultralytics.com/ar/sitemap.xml
+Sitemap: http://docs.ultralytics.com/de/sitemap.xml
+Sitemap: http://docs.ultralytics.com/es/sitemap.xml
+Sitemap: http://docs.ultralytics.com/fr/sitemap.xml
+Sitemap: http://docs.ultralytics.com/hi/sitemap.xml
+Sitemap: http://docs.ultralytics.com/ja/sitemap.xml
+Sitemap: http://docs.ultralytics.com/ko/sitemap.xml
+Sitemap: http://docs.ultralytics.com/pt/sitemap.xml
+Sitemap: http://docs.ultralytics.com/ru/sitemap.xml
+Sitemap: http://docs.ultralytics.com/zh/sitemap.xml
diff --git a/ultralytics/docs/en/robots.txt:Zone.Identifier b/ultralytics/docs/en/robots.txt:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/robots.txt:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/tasks/classify.md b/ultralytics/docs/en/tasks/classify.md
new file mode 100755
index 0000000..fc5ec08
--- /dev/null
+++ b/ultralytics/docs/en/tasks/classify.md
@@ -0,0 +1,184 @@
+---
+comments: true
+description: Learn about YOLOv8 Classify models for image classification. Get detailed information on List of Pretrained Models & how to Train, Validate, Predict & Export models.
+keywords: Ultralytics, YOLOv8, Image Classification, Pretrained Models, YOLOv8n-cls, Training, Validation, Prediction, Model Export
+---
+
+# Image Classification
+
+
+
+Image classification is the simplest of the three tasks and involves classifying an entire image into one of a set of predefined classes.
+
+The output of an image classifier is a single class label and a confidence score. Image classification is useful when you need to know only what class an image belongs to and don't need to know where objects of that class are located or what their exact shape is.
+
+
+
+!!! Tip "Tip"
+
+ YOLOv8 Classify models use the `-cls` suffix, i.e. `yolov8n-cls.pt` and are pretrained on [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+YOLOv8 pretrained Classify models are shown here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+| Model | size (pixels) | acc top1 | acc top5 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) at 640 |
+|----------------------------------------------------------------------------------------------|-----------------------|------------------|------------------|--------------------------------|-------------------------------------|--------------------|--------------------------|
+| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
+| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
+| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
+| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
+| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
+
+- **acc** values are model accuracies on the [ImageNet](https://www.image-net.org/) dataset validation set.
+ Reproduce by `yolo val classify data=path/to/ImageNet device=0`
+- **Speed** averaged over ImageNet val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
+ instance.
+ Reproduce by `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
+
+## Train
+
+Train YOLOv8n-cls on the MNIST160 dataset for 100 epochs at image size 64. For a full list of available arguments see the [Configuration](../usage/cfg.md) page.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-cls.yaml') # build a new model from YAML
+ model = YOLO('yolov8n-cls.pt') # load a pretrained model (recommended for training)
+ model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # build from YAML and transfer weights
+
+ # Train the model
+ results = model.train(data='mnist160', epochs=100, imgsz=64)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Build a new model from YAML and start training from scratch
+ yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
+
+ # Start training from a pretrained *.pt model
+ yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
+
+ # Build a new model from YAML, transfer pretrained weights to it and start training
+ yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
+ ```
+
+### Dataset format
+
+YOLO classification dataset format can be found in detail in the [Dataset Guide](../datasets/classify/index.md).
+
+## Val
+
+Validate trained YOLOv8n-cls model accuracy on the MNIST160 dataset. No argument need to passed as the `model` retains it's training `data` and arguments as model attributes.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-cls.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Validate the model
+ metrics = model.val() # no arguments needed, dataset and settings remembered
+ metrics.top1 # top1 accuracy
+ metrics.top5 # top5 accuracy
+ ```
+ === "CLI"
+
+ ```bash
+ yolo classify val model=yolov8n-cls.pt # val official model
+ yolo classify val model=path/to/best.pt # val custom model
+ ```
+
+## Predict
+
+Use a trained YOLOv8n-cls model to run predictions on images.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-cls.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Predict with the model
+ results = model('https://ultralytics.com/images/bus.jpg') # predict on an image
+ ```
+ === "CLI"
+
+ ```bash
+ yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # predict with official model
+ yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model
+ ```
+
+See full `predict` mode details in the [Predict](https://docs.ultralytics.com/modes/predict/) page.
+
+## Export
+
+Export a YOLOv8n-cls model to a different format like ONNX, CoreML, etc.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-cls.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom trained model
+
+ # Export the model
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n-cls.pt format=onnx # export official model
+ yolo export model=path/to/best.pt format=onnx # export custom trained model
+ ```
+
+Available YOLOv8-cls export formats are in the table below. You can predict or validate directly on exported models, i.e. `yolo predict model=yolov8n-cls.onnx`. Usage examples are shown for your model after export completes.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|-------------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | โ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | โ | `imgsz`, `half` |
+
+See full `export` details in the [Export](https://docs.ultralytics.com/modes/export/) page.
diff --git a/ultralytics/docs/en/tasks/classify.md:Zone.Identifier b/ultralytics/docs/en/tasks/classify.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/tasks/classify.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/tasks/detect.md b/ultralytics/docs/en/tasks/detect.md
new file mode 100755
index 0000000..e4891f5
--- /dev/null
+++ b/ultralytics/docs/en/tasks/detect.md
@@ -0,0 +1,185 @@
+---
+comments: true
+description: Official documentation for YOLOv8 by Ultralytics. Learn how to train, validate, predict and export models in various formats. Including detailed performance stats.
+keywords: YOLOv8, Ultralytics, object detection, pretrained models, training, validation, prediction, export models, COCO, ImageNet, PyTorch, ONNX, CoreML
+---
+
+# Object Detection
+
+
+
+Object detection is a task that involves identifying the location and class of objects in an image or video stream.
+
+The output of an object detector is a set of bounding boxes that enclose the objects in the image, along with class labels and confidence scores for each box. Object detection is a good choice when you need to identify objects of interest in a scene, but don't need to know exactly where the object is or its exact shape.
+
+
+
+!!! Tip "Tip"
+
+ YOLOv8 Detect models are the default YOLOv8 models, i.e. `yolov8n.pt` and are pretrained on [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+YOLOv8 pretrained Detect models are shown here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+| Model | size (pixels) | mAPval 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+|--------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
+| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
+| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
+| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
+| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
+| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
+
+- **mAPval** values are for single-model single-scale on [COCO val2017](http://cocodataset.org) dataset.
+ Reproduce by `yolo val detect data=coco.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
+ instance.
+ Reproduce by `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
+
+## Train
+
+Train YOLOv8n on the COCO128 dataset for 100 epochs at image size 640. For a full list of available arguments see the [Configuration](../usage/cfg.md) page.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.yaml') # build a new model from YAML
+ model = YOLO('yolov8n.pt') # load a pretrained model (recommended for training)
+ model = YOLO('yolov8n.yaml').load('yolov8n.pt') # build from YAML and transfer weights
+
+ # Train the model
+ results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
+ ```
+ === "CLI"
+
+ ```bash
+ # Build a new model from YAML and start training from scratch
+ yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
+
+ # Start training from a pretrained *.pt model
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
+
+ # Build a new model from YAML, transfer pretrained weights to it and start training
+ yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+### Dataset format
+
+YOLO detection dataset format can be found in detail in the [Dataset Guide](../datasets/detect/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+
+## Val
+
+Validate trained YOLOv8n model accuracy on the COCO128 dataset. No argument need to passed as the `model` retains it's training `data` and arguments as model attributes.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Validate the model
+ metrics = model.val() # no arguments needed, dataset and settings remembered
+ metrics.box.map # map50-95
+ metrics.box.map50 # map50
+ metrics.box.map75 # map75
+ metrics.box.maps # a list contains map50-95 of each category
+ ```
+ === "CLI"
+
+ ```bash
+ yolo detect val model=yolov8n.pt # val official model
+ yolo detect val model=path/to/best.pt # val custom model
+ ```
+
+## Predict
+
+Use a trained YOLOv8n model to run predictions on images.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Predict with the model
+ results = model('https://ultralytics.com/images/bus.jpg') # predict on an image
+ ```
+ === "CLI"
+
+ ```bash
+ yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # predict with official model
+ yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model
+ ```
+
+See full `predict` mode details in the [Predict](https://docs.ultralytics.com/modes/predict/) page.
+
+## Export
+
+Export a YOLOv8n model to a different format like ONNX, CoreML, etc.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom trained model
+
+ # Export the model
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n.pt format=onnx # export official model
+ yolo export model=path/to/best.pt format=onnx # export custom trained model
+ ```
+
+Available YOLOv8 export formats are in the table below. You can predict or validate directly on exported models, i.e. `yolo predict model=yolov8n.onnx`. Usage examples are shown for your model after export completes.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half`, `int8` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras`, `int8` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
+
+See full `export` details in the [Export](https://docs.ultralytics.com/modes/export/) page.
diff --git a/ultralytics/docs/en/tasks/detect.md:Zone.Identifier b/ultralytics/docs/en/tasks/detect.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/tasks/detect.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/tasks/index.md b/ultralytics/docs/en/tasks/index.md
new file mode 100755
index 0000000..a5de275
--- /dev/null
+++ b/ultralytics/docs/en/tasks/index.md
@@ -0,0 +1,51 @@
+---
+comments: true
+description: Learn about the cornerstone computer vision tasks YOLOv8 can perform including detection, segmentation, classification, and pose estimation. Understand their uses in your AI projects.
+keywords: Ultralytics, YOLOv8, Detection, Segmentation, Classification, Pose Estimation, AI Framework, Computer Vision Tasks
+---
+
+# Ultralytics YOLOv8 Tasks
+
+
+
+
+YOLOv8 is an AI framework that supports multiple computer vision **tasks**. The framework can be used to perform [detection](detect.md), [segmentation](segment.md), [classification](classify.md), and [pose](pose.md) estimation. Each of these tasks has a different objective and use case.
+
+
+
+## [Detection](detect.md)
+
+Detection is the primary task supported by YOLOv8. It involves detecting objects in an image or video frame and drawing bounding boxes around them. The detected objects are classified into different categories based on their features. YOLOv8 can detect multiple objects in a single image or video frame with high accuracy and speed.
+
+[Detection Examples](detect.md){ .md-button }
+
+## [Segmentation](segment.md)
+
+Segmentation is a task that involves segmenting an image into different regions based on the content of the image. Each region is assigned a label based on its content. This task is useful in applications such as image segmentation and medical imaging. YOLOv8 uses a variant of the U-Net architecture to perform segmentation.
+
+[Segmentation Examples](segment.md){ .md-button }
+
+## [Classification](classify.md)
+
+Classification is a task that involves classifying an image into different categories. YOLOv8 can be used to classify images based on their content. It uses a variant of the EfficientNet architecture to perform classification.
+
+[Classification Examples](classify.md){ .md-button }
+
+## [Pose](pose.md)
+
+Pose/keypoint detection is a task that involves detecting specific points in an image or video frame. These points are referred to as keypoints and are used to track movement or pose estimation. YOLOv8 can detect keypoints in an image or video frame with high accuracy and speed.
+
+[Pose Examples](pose.md){ .md-button }
+
+## Conclusion
+
+YOLOv8 supports multiple tasks, including detection, segmentation, classification, and keypoints detection. Each of these tasks has different objectives and use cases. By understanding the differences between these tasks, you can choose the appropriate task for your computer vision application.
diff --git a/ultralytics/docs/en/tasks/index.md:Zone.Identifier b/ultralytics/docs/en/tasks/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/tasks/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/tasks/pose.md b/ultralytics/docs/en/tasks/pose.md
new file mode 100755
index 0000000..292c94b
--- /dev/null
+++ b/ultralytics/docs/en/tasks/pose.md
@@ -0,0 +1,189 @@
+---
+comments: true
+description: Learn how to use Ultralytics YOLOv8 for pose estimation tasks. Find pretrained models, learn how to train, validate, predict, and export your own.
+keywords: Ultralytics, YOLO, YOLOv8, pose estimation, keypoints detection, object detection, pre-trained models, machine learning, artificial intelligence
+---
+
+# Pose Estimation
+
+
+
+Pose estimation is a task that involves identifying the location of specific points in an image, usually referred to as keypoints. The keypoints can represent various parts of the object such as joints, landmarks, or other distinctive features. The locations of the keypoints are usually represented as a set of 2D `[x, y]` or 3D `[x, y, visible]`
+coordinates.
+
+The output of a pose estimation model is a set of points that represent the keypoints on an object in the image, usually along with the confidence scores for each point. Pose estimation is a good choice when you need to identify specific parts of an object in a scene, and their location in relation to each other.
+
+
+
+!!! Tip "Tip"
+
+ YOLOv8 _pose_ models use the `-pose` suffix, i.e. `yolov8n-pose.pt`. These models are trained on the [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) dataset and are suitable for a variety of pose estimation tasks.
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+YOLOv8 pretrained Pose models are shown here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+| Model | size (pixels) | mAPpose 50-95 | mAPpose 50 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+|------------------------------------------------------------------------------------------------------|-----------------------|-----------------------|--------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
+| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
+| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
+| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
+| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
+| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
+| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
+
+- **mAPval** values are for single-model single-scale on [COCO Keypoints val2017](http://cocodataset.org)
+ dataset.
+ Reproduce by `yolo val pose data=coco-pose.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
+ instance.
+ Reproduce by `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`
+
+## Train
+
+Train a YOLOv8-pose model on the COCO128-pose dataset.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-pose.yaml') # build a new model from YAML
+ model = YOLO('yolov8n-pose.pt') # load a pretrained model (recommended for training)
+ model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # build from YAML and transfer weights
+
+ # Train the model
+ results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
+ ```
+ === "CLI"
+
+ ```bash
+ # Build a new model from YAML and start training from scratch
+ yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
+
+ # Start training from a pretrained *.pt model
+ yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
+
+ # Build a new model from YAML, transfer pretrained weights to it and start training
+ yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
+ ```
+
+### Dataset format
+
+YOLO pose dataset format can be found in detail in the [Dataset Guide](../datasets/pose/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+
+## Val
+
+Validate trained YOLOv8n-pose model accuracy on the COCO128-pose dataset. No argument need to passed as the `model`
+retains it's training `data` and arguments as model attributes.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-pose.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Validate the model
+ metrics = model.val() # no arguments needed, dataset and settings remembered
+ metrics.box.map # map50-95
+ metrics.box.map50 # map50
+ metrics.box.map75 # map75
+ metrics.box.maps # a list contains map50-95 of each category
+ ```
+ === "CLI"
+
+ ```bash
+ yolo pose val model=yolov8n-pose.pt # val official model
+ yolo pose val model=path/to/best.pt # val custom model
+ ```
+
+## Predict
+
+Use a trained YOLOv8n-pose model to run predictions on images.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-pose.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Predict with the model
+ results = model('https://ultralytics.com/images/bus.jpg') # predict on an image
+ ```
+ === "CLI"
+
+ ```bash
+ yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # predict with official model
+ yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model
+ ```
+
+See full `predict` mode details in the [Predict](https://docs.ultralytics.com/modes/predict/) page.
+
+## Export
+
+Export a YOLOv8n Pose model to a different format like ONNX, CoreML, etc.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-pose.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom trained model
+
+ # Export the model
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n-pose.pt format=onnx # export official model
+ yolo export model=path/to/best.pt format=onnx # export custom trained model
+ ```
+
+Available YOLOv8-pose export formats are in the table below. You can predict or validate directly on exported models, i.e. `yolo predict model=yolov8n-pose.onnx`. Usage examples are shown for your model after export completes.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|--------------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | โ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | โ | `imgsz`, `half` |
+
+See full `export` details in the [Export](https://docs.ultralytics.com/modes/export/) page.
diff --git a/ultralytics/docs/en/tasks/pose.md:Zone.Identifier b/ultralytics/docs/en/tasks/pose.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/tasks/pose.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/tasks/segment.md b/ultralytics/docs/en/tasks/segment.md
new file mode 100755
index 0000000..7c3eaac
--- /dev/null
+++ b/ultralytics/docs/en/tasks/segment.md
@@ -0,0 +1,190 @@
+---
+comments: true
+description: Learn how to use instance segmentation models with Ultralytics YOLO. Instructions on training, validation, image prediction, and model export.
+keywords: yolov8, instance segmentation, Ultralytics, COCO dataset, image segmentation, object detection, model training, model validation, image prediction, model export
+---
+
+# Instance Segmentation
+
+
+
+Instance segmentation goes a step further than object detection and involves identifying individual objects in an image and segmenting them from the rest of the image.
+
+The output of an instance segmentation model is a set of masks or contours that outline each object in the image, along with class labels and confidence scores for each object. Instance segmentation is useful when you need to know not only where objects are in an image, but also what their exact shape is.
+
+
+
+
+
+ Watch: Run Segmentation with Pre-Trained Ultralytics YOLOv8 Model in Python.
+
+
+!!! Tip "Tip"
+
+ YOLOv8 Segment models use the `-seg` suffix, i.e. `yolov8n-seg.pt` and are pretrained on [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+YOLOv8 pretrained Segment models are shown here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+| Model | size (pixels) | mAPbox 50-95 | mAPmask 50-95 | Speed CPU ONNX (ms) | Speed A100 TensorRT (ms) | params (M) | FLOPs (B) |
+|----------------------------------------------------------------------------------------------|-----------------------|----------------------|-----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
+| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
+| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
+| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
+| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
+| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
+
+- **mAPval** values are for single-model single-scale on [COCO val2017](http://cocodataset.org) dataset.
+ Reproduce by `yolo val segment data=coco.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
+ instance.
+ Reproduce by `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
+
+## Train
+
+Train YOLOv8n-seg on the COCO128-seg dataset for 100 epochs at image size 640. For a full list of available arguments see the [Configuration](../usage/cfg.md) page.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-seg.yaml') # build a new model from YAML
+ model = YOLO('yolov8n-seg.pt') # load a pretrained model (recommended for training)
+ model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # build from YAML and transfer weights
+
+ # Train the model
+ results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
+ ```
+ === "CLI"
+
+ ```bash
+ # Build a new model from YAML and start training from scratch
+ yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
+
+ # Start training from a pretrained *.pt model
+ yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
+
+ # Build a new model from YAML, transfer pretrained weights to it and start training
+ yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
+ ```
+
+### Dataset format
+
+YOLO segmentation dataset format can be found in detail in the [Dataset Guide](../datasets/segment/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+
+## Val
+
+Validate trained YOLOv8n-seg model accuracy on the COCO128-seg dataset. No argument need to passed as the `model`
+retains it's training `data` and arguments as model attributes.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-seg.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Validate the model
+ metrics = model.val() # no arguments needed, dataset and settings remembered
+ metrics.box.map # map50-95(B)
+ metrics.box.map50 # map50(B)
+ metrics.box.map75 # map75(B)
+ metrics.box.maps # a list contains map50-95(B) of each category
+ metrics.seg.map # map50-95(M)
+ metrics.seg.map50 # map50(M)
+ metrics.seg.map75 # map75(M)
+ metrics.seg.maps # a list contains map50-95(M) of each category
+ ```
+ === "CLI"
+
+ ```bash
+ yolo segment val model=yolov8n-seg.pt # val official model
+ yolo segment val model=path/to/best.pt # val custom model
+ ```
+
+## Predict
+
+Use a trained YOLOv8n-seg model to run predictions on images.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-seg.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Predict with the model
+ results = model('https://ultralytics.com/images/bus.jpg') # predict on an image
+ ```
+ === "CLI"
+
+ ```bash
+ yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # predict with official model
+ yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model
+ ```
+
+See full `predict` mode details in the [Predict](https://docs.ultralytics.com/modes/predict/) page.
+
+## Export
+
+Export a YOLOv8n-seg model to a different format like ONNX, CoreML, etc.
+
+!!! Example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-seg.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom trained model
+
+ # Export the model
+ model.export(format='onnx')
+ ```
+ === "CLI"
+
+ ```bash
+ yolo export model=yolov8n-seg.pt format=onnx # export official model
+ yolo export model=path/to/best.pt format=onnx # export custom trained model
+ ```
+
+Available YOLOv8-seg export formats are in the table below. You can predict or validate directly on exported models, i.e. `yolo predict model=yolov8n-seg.onnx`. Usage examples are shown for your model after export completes.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|-------------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | โ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | โ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | โ | `imgsz`, `half` |
+
+See full `export` details in the [Export](https://docs.ultralytics.com/modes/export/) page.
diff --git a/ultralytics/docs/en/tasks/segment.md:Zone.Identifier b/ultralytics/docs/en/tasks/segment.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/tasks/segment.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/usage/callbacks.md b/ultralytics/docs/en/usage/callbacks.md
new file mode 100755
index 0000000..51ff0bd
--- /dev/null
+++ b/ultralytics/docs/en/usage/callbacks.md
@@ -0,0 +1,101 @@
+---
+comments: true
+description: Learn how to utilize callbacks in the Ultralytics framework during train, val, export, and predict modes for enhanced functionality.
+keywords: Ultralytics, YOLO, callbacks guide, training callback, validation callback, export callback, prediction callback
+---
+
+## Callbacks
+
+Ultralytics framework supports callbacks as entry points in strategic stages of train, val, export, and predict modes. Each callback accepts a `Trainer`, `Validator`, or `Predictor` object depending on the operation type. All properties of these objects can be found in Reference section of the docs.
+
+
+
+## Examples
+
+### Returning additional information with Prediction
+
+In this example, we want to return the original frame with each result object. Here's how we can do that
+
+```python
+from ultralytics import YOLO
+
+
+def on_predict_batch_end(predictor):
+ # Retrieve the batch data
+ _, image, _, _ = predictor.batch
+
+ # Ensure that image is a list
+ image = image if isinstance(image, list) else [image]
+
+ # Combine the prediction results with the corresponding frames
+ predictor.results = zip(predictor.results, image)
+
+
+# Create a YOLO model instance
+model = YOLO(f'yolov8n.pt')
+
+# Add the custom callback to the model
+model.add_callback("on_predict_batch_end", on_predict_batch_end)
+
+# Iterate through the results and frames
+for (result, frame) in model.predict(): # or model.track()
+ pass
+```
+
+## All callbacks
+
+Here are all supported callbacks. See callbacks [source code](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/base.py) for additional details.
+
+### Trainer Callbacks
+
+| Callback | Description |
+|-----------------------------|---------------------------------------------------------|
+| `on_pretrain_routine_start` | Triggered at the beginning of pre-training routine |
+| `on_pretrain_routine_end` | Triggered at the end of pre-training routine |
+| `on_train_start` | Triggered when the training starts |
+| `on_train_epoch_start` | Triggered at the start of each training epoch |
+| `on_train_batch_start` | Triggered at the start of each training batch |
+| `optimizer_step` | Triggered during the optimizer step |
+| `on_before_zero_grad` | Triggered before gradients are zeroed |
+| `on_train_batch_end` | Triggered at the end of each training batch |
+| `on_train_epoch_end` | Triggered at the end of each training epoch |
+| `on_fit_epoch_end` | Triggered at the end of each fit epoch |
+| `on_model_save` | Triggered when the model is saved |
+| `on_train_end` | Triggered when the training process ends |
+| `on_params_update` | Triggered when model parameters are updated |
+| `teardown` | Triggered when the training process is being cleaned up |
+
+### Validator Callbacks
+
+| Callback | Description |
+|----------------------|-------------------------------------------------|
+| `on_val_start` | Triggered when the validation starts |
+| `on_val_batch_start` | Triggered at the start of each validation batch |
+| `on_val_batch_end` | Triggered at the end of each validation batch |
+| `on_val_end` | Triggered when the validation ends |
+
+### Predictor Callbacks
+
+| Callback | Description |
+|------------------------------|---------------------------------------------------|
+| `on_predict_start` | Triggered when the prediction process starts |
+| `on_predict_batch_start` | Triggered at the start of each prediction batch |
+| `on_predict_postprocess_end` | Triggered at the end of prediction postprocessing |
+| `on_predict_batch_end` | Triggered at the end of each prediction batch |
+| `on_predict_end` | Triggered when the prediction process ends |
+
+### Exporter Callbacks
+
+| Callback | Description |
+|-------------------|------------------------------------------|
+| `on_export_start` | Triggered when the export process starts |
+| `on_export_end` | Triggered when the export process ends |
diff --git a/ultralytics/docs/en/usage/callbacks.md:Zone.Identifier b/ultralytics/docs/en/usage/callbacks.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/usage/callbacks.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/usage/cfg.md b/ultralytics/docs/en/usage/cfg.md
new file mode 100755
index 0000000..2e822ae
--- /dev/null
+++ b/ultralytics/docs/en/usage/cfg.md
@@ -0,0 +1,260 @@
+---
+comments: true
+description: Master YOLOv8 settings and hyperparameters for improved model performance. Learn to use YOLO CLI commands, adjust training settings, and optimize YOLO tasks & modes.
+keywords: YOLOv8, settings, hyperparameters, YOLO CLI commands, YOLO tasks, YOLO modes, Ultralytics documentation, model optimization, YOLOv8 training
+---
+
+YOLO settings and hyperparameters play a critical role in the model's performance, speed, and accuracy. These settings and hyperparameters can affect the model's behavior at various stages of the model development process, including training, validation, and prediction.
+
+
+
+Ultralytics commands use the following syntax:
+
+!!! Example
+
+ === "CLI"
+
+ ```bash
+ yolo TASK MODE ARGS
+ ```
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a YOLOv8 model from a pre-trained weights file
+ model = YOLO('yolov8n.pt')
+
+ # Run MODE mode using the custom arguments ARGS (guess TASK)
+ model.MODE(ARGS)
+ ```
+
+Where:
+
+- `TASK` (optional) is one of ([detect](../tasks/detect.md), [segment](../tasks/segment.md), [classify](../tasks/classify.md), [pose](../tasks/pose.md))
+- `MODE` (required) is one of ([train](../modes/train.md), [val](../modes/val.md), [predict](../modes/predict.md), [export](../modes/export.md), [track](../modes/track.md))
+- `ARGS` (optional) are `arg=value` pairs like `imgsz=640` that override defaults.
+
+Default `ARG` values are defined on this page from the `cfg/defaults.yaml` [file](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/default.yaml).
+
+#### Tasks
+
+YOLO models can be used for a variety of tasks, including detection, segmentation, classification and pose. These tasks differ in the type of output they produce and the specific problem they are designed to solve.
+
+**Detect**: For identifying and localizing objects or regions of interest in an image or video.
+**Segment**: For dividing an image or video into regions or pixels that correspond to different objects or classes.
+**Classify**: For predicting the class label of an input image.
+**Pose**: For identifying objects and estimating their keypoints in an image or video.
+
+| Key | Value | Description |
+|--------|------------|-------------------------------------------------|
+| `task` | `'detect'` | YOLO task, i.e. detect, segment, classify, pose |
+
+[Tasks Guide](../tasks/index.md){ .md-button }
+
+#### Modes
+
+YOLO models can be used in different modes depending on the specific problem you are trying to solve. These modes include:
+
+**Train**: For training a YOLOv8 model on a custom dataset.
+**Val**: For validating a YOLOv8 model after it has been trained.
+**Predict**: For making predictions using a trained YOLOv8 model on new images or videos.
+**Export**: For exporting a YOLOv8 model to a format that can be used for deployment.
+**Track**: For tracking objects in real-time using a YOLOv8 model.
+**Benchmark**: For benchmarking YOLOv8 exports (ONNX, TensorRT, etc.) speed and accuracy.
+
+| Key | Value | Description |
+|--------|-----------|---------------------------------------------------------------|
+| `mode` | `'train'` | YOLO mode, i.e. train, val, predict, export, track, benchmark |
+
+[Modes Guide](../modes/index.md){ .md-button }
+
+## Train
+
+The training settings for YOLO models encompass various hyperparameters and configurations used during the training process. These settings influence the model's performance, speed, and accuracy. Key training settings include batch size, learning rate, momentum, and weight decay. Additionally, the choice of optimizer, loss function, and training dataset composition can impact the training process. Careful tuning and experimentation with these settings are crucial for optimizing performance.
+
+| Key | Value | Description |
+|-------------------|----------|------------------------------------------------------------------------------------------------|
+| `model` | `None` | path to model file, i.e. yolov8n.pt, yolov8n.yaml |
+| `data` | `None` | path to data file, i.e. coco128.yaml |
+| `epochs` | `100` | number of epochs to train for |
+| `time` | `None` | number of hours to train for, overrides epochs if supplied |
+| `patience` | `50` | epochs to wait for no observable improvement for early stopping of training |
+| `batch` | `16` | number of images per batch (-1 for AutoBatch) |
+| `imgsz` | `640` | size of input images as integer |
+| `save` | `True` | save train checkpoints and predict results |
+| `save_period` | `-1` | Save checkpoint every x epochs (disabled if < 1) |
+| `cache` | `False` | True/ram, disk or False. Use cache for data loading |
+| `device` | `None` | device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu |
+| `workers` | `8` | number of worker threads for data loading (per RANK if DDP) |
+| `project` | `None` | project name |
+| `name` | `None` | experiment name |
+| `exist_ok` | `False` | whether to overwrite existing experiment |
+| `pretrained` | `True` | (bool or str) whether to use a pretrained model (bool) or a model to load weights from (str) |
+| `optimizer` | `'auto'` | optimizer to use, choices=[SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto] |
+| `verbose` | `False` | whether to print verbose output |
+| `seed` | `0` | random seed for reproducibility |
+| `deterministic` | `True` | whether to enable deterministic mode |
+| `single_cls` | `False` | train multi-class data as single-class |
+| `rect` | `False` | rectangular training with each batch collated for minimum padding |
+| `cos_lr` | `False` | use cosine learning rate scheduler |
+| `close_mosaic` | `10` | (int) disable mosaic augmentation for final epochs (0 to disable) |
+| `resume` | `False` | resume training from last checkpoint |
+| `amp` | `True` | Automatic Mixed Precision (AMP) training, choices=[True, False] |
+| `fraction` | `1.0` | dataset fraction to train on (default is 1.0, all images in train set) |
+| `profile` | `False` | profile ONNX and TensorRT speeds during training for loggers |
+| `freeze` | `None` | (int or list, optional) freeze first n layers, or freeze list of layer indices during training |
+| `lr0` | `0.01` | initial learning rate (i.e. SGD=1E-2, Adam=1E-3) |
+| `lrf` | `0.01` | final learning rate (lr0 * lrf) |
+| `momentum` | `0.937` | SGD momentum/Adam beta1 |
+| `weight_decay` | `0.0005` | optimizer weight decay 5e-4 |
+| `warmup_epochs` | `3.0` | warmup epochs (fractions ok) |
+| `warmup_momentum` | `0.8` | warmup initial momentum |
+| `warmup_bias_lr` | `0.1` | warmup initial bias lr |
+| `box` | `7.5` | box loss gain |
+| `cls` | `0.5` | cls loss gain (scale with pixels) |
+| `dfl` | `1.5` | dfl loss gain |
+| `pose` | `12.0` | pose loss gain (pose-only) |
+| `kobj` | `2.0` | keypoint obj loss gain (pose-only) |
+| `label_smoothing` | `0.0` | label smoothing (fraction) |
+| `nbs` | `64` | nominal batch size |
+| `overlap_mask` | `True` | masks should overlap during training (segment train only) |
+| `mask_ratio` | `4` | mask downsample ratio (segment train only) |
+| `dropout` | `0.0` | use dropout regularization (classify train only) |
+| `val` | `True` | validate/test during training |
+| `plots` | `False` | save plots and images during train/val |
+
+[Train Guide](../modes/train.md){ .md-button }
+
+## Predict
+
+The prediction settings for YOLO models encompass a range of hyperparameters and configurations that influence the model's performance, speed, and accuracy during inference on new data. Careful tuning and experimentation with these settings are essential to achieve optimal performance for a specific task. Key settings include the confidence threshold, Non-Maximum Suppression (NMS) threshold, and the number of classes considered. Additional factors affecting the prediction process are input data size and format, the presence of supplementary features such as masks or multiple labels per box, and the particular task the model is employed for.
+
+Inference arguments:
+
+| Name | Type | Default | Description |
+|-----------------|----------------|------------------------|----------------------------------------------------------------------------|
+| `source` | `str` | `'ultralytics/assets'` | source directory for images or videos |
+| `conf` | `float` | `0.25` | object confidence threshold for detection |
+| `iou` | `float` | `0.7` | intersection over union (IoU) threshold for NMS |
+| `imgsz` | `int or tuple` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `half` | `bool` | `False` | use half precision (FP16) |
+| `device` | `None or str` | `None` | device to run on, i.e. cuda device=0/1/2/3 or device=cpu |
+| `max_det` | `int` | `300` | maximum number of detections per image |
+| `vid_stride` | `bool` | `False` | video frame-rate stride |
+| `stream_buffer` | `bool` | `False` | buffer all streaming frames (True) or return the most recent frame (False) |
+| `visualize` | `bool` | `False` | visualize model features |
+| `augment` | `bool` | `False` | apply image augmentation to prediction sources |
+| `agnostic_nms` | `bool` | `False` | class-agnostic NMS |
+| `classes` | `list[int]` | `None` | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+| `retina_masks` | `bool` | `False` | use high-resolution segmentation masks |
+| `embed` | `list[int]` | `None` | return feature vectors/embeddings from given layers |
+
+Visualization arguments:
+
+| Name | Type | Default | Description |
+|---------------|---------------|---------|-----------------------------------------------------------------|
+| `show` | `bool` | `False` | show predicted images and videos if environment allows |
+| `save` | `bool` | `False` | save predicted images and videos |
+| `save_frames` | `bool` | `False` | save predicted individual video frames |
+| `save_txt` | `bool` | `False` | save results as `.txt` file |
+| `save_conf` | `bool` | `False` | save results with confidence scores |
+| `save_crop` | `bool` | `False` | save cropped images with results |
+| `show_labels` | `bool` | `True` | show prediction labels, i.e. 'person' |
+| `show_conf` | `bool` | `True` | show prediction confidence, i.e. '0.99' |
+| `show_boxes` | `bool` | `True` | show prediction boxes |
+| `line_width` | `None or int` | `None` | line width of the bounding boxes. Scaled to image size if None. |
+
+[Predict Guide](../modes/predict.md){ .md-button }
+
+## Val
+
+The val (validation) settings for YOLO models involve various hyperparameters and configurations used to evaluate the model's performance on a validation dataset. These settings influence the model's performance, speed, and accuracy. Common YOLO validation settings include batch size, validation frequency during training, and performance evaluation metrics. Other factors affecting the validation process include the validation dataset's size and composition, as well as the specific task the model is employed for. Careful tuning and experimentation with these settings are crucial to ensure optimal performance on the validation dataset and detect and prevent overfitting.
+
+| Key | Value | Description |
+|---------------|---------|--------------------------------------------------------------------|
+| `data` | `None` | path to data file, i.e. coco128.yaml |
+| `imgsz` | `640` | size of input images as integer |
+| `batch` | `16` | number of images per batch (-1 for AutoBatch) |
+| `save_json` | `False` | save results to JSON file |
+| `save_hybrid` | `False` | save hybrid version of labels (labels + additional predictions) |
+| `conf` | `0.001` | object confidence threshold for detection |
+| `iou` | `0.6` | intersection over union (IoU) threshold for NMS |
+| `max_det` | `300` | maximum number of detections per image |
+| `half` | `True` | use half precision (FP16) |
+| `device` | `None` | device to run on, i.e. cuda device=0/1/2/3 or device=cpu |
+| `dnn` | `False` | use OpenCV DNN for ONNX inference |
+| `plots` | `False` | save plots and images during train/val |
+| `rect` | `False` | rectangular val with each batch collated for minimum padding |
+| `split` | `val` | dataset split to use for validation, i.e. 'val', 'test' or 'train' |
+
+[Val Guide](../modes/val.md){ .md-button }
+
+## Export
+
+Export settings for YOLO models encompass configurations and options related to saving or exporting the model for use in different environments or platforms. These settings can impact the model's performance, size, and compatibility with various systems. Key export settings include the exported model file format (e.g., ONNX, TensorFlow SavedModel), the target device (e.g., CPU, GPU), and additional features such as masks or multiple labels per box. The export process may also be affected by the model's specific task and the requirements or constraints of the destination environment or platform. It is crucial to thoughtfully configure these settings to ensure the exported model is optimized for the intended use case and functions effectively in the target environment.
+
+| Key | Value | Description |
+|-------------|-----------------|------------------------------------------------------|
+| `format` | `'torchscript'` | format to export to |
+| `imgsz` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `keras` | `False` | use Keras for TF SavedModel export |
+| `optimize` | `False` | TorchScript: optimize for mobile |
+| `half` | `False` | FP16 quantization |
+| `int8` | `False` | INT8 quantization |
+| `dynamic` | `False` | ONNX/TensorRT: dynamic axes |
+| `simplify` | `False` | ONNX/TensorRT: simplify model |
+| `opset` | `None` | ONNX: opset version (optional, defaults to latest) |
+| `workspace` | `4` | TensorRT: workspace size (GB) |
+| `nms` | `False` | CoreML: add NMS |
+
+[Export Guide](../modes/export.md){ .md-button }
+
+## Augmentation
+
+Augmentation settings for YOLO models refer to the various transformations and modifications applied to the training data to increase the diversity and size of the dataset. These settings can affect the model's performance, speed, and accuracy. Some common YOLO augmentation settings include the type and intensity of the transformations applied (e.g. random flips, rotations, cropping, color changes), the probability with which each transformation is applied, and the presence of additional features such as masks or multiple labels per box. Other factors that may affect the augmentation process include the size and composition of the original dataset and the specific task the model is being used for. It is important to carefully tune and experiment with these settings to ensure that the augmented dataset is diverse and representative enough to train a high-performing model.
+
+| Key | Value | Description |
+|---------------|---------|-------------------------------------------------|
+| `hsv_h` | `0.015` | image HSV-Hue augmentation (fraction) |
+| `hsv_s` | `0.7` | image HSV-Saturation augmentation (fraction) |
+| `hsv_v` | `0.4` | image HSV-Value augmentation (fraction) |
+| `degrees` | `0.0` | image rotation (+/- deg) |
+| `translate` | `0.1` | image translation (+/- fraction) |
+| `scale` | `0.5` | image scale (+/- gain) |
+| `shear` | `0.0` | image shear (+/- deg) |
+| `perspective` | `0.0` | image perspective (+/- fraction), range 0-0.001 |
+| `flipud` | `0.0` | image flip up-down (probability) |
+| `fliplr` | `0.5` | image flip left-right (probability) |
+| `mosaic` | `1.0` | image mosaic (probability) |
+| `mixup` | `0.0` | image mixup (probability) |
+| `copy_paste` | `0.0` | segment copy-paste (probability) |
+
+## Logging, checkpoints, plotting and file management
+
+Logging, checkpoints, plotting, and file management are important considerations when training a YOLO model.
+
+- Logging: It is often helpful to log various metrics and statistics during training to track the model's progress and diagnose any issues that may arise. This can be done using a logging library such as TensorBoard or by writing log messages to a file.
+- Checkpoints: It is a good practice to save checkpoints of the model at regular intervals during training. This allows you to resume training from a previous point if the training process is interrupted or if you want to experiment with different training configurations.
+- Plotting: Visualizing the model's performance and training progress can be helpful for understanding how the model is behaving and identifying potential issues. This can be done using a plotting library such as matplotlib or by generating plots using a logging library such as TensorBoard.
+- File management: Managing the various files generated during the training process, such as model checkpoints, log files, and plots, can be challenging. It is important to have a clear and organized file structure to keep track of these files and make it easy to access and analyze them as needed.
+
+Effective logging, checkpointing, plotting, and file management can help you keep track of the model's progress and make it easier to debug and optimize the training process.
+
+| Key | Value | Description |
+|------------|----------|------------------------------------------------------------------------------------------------|
+| `project` | `'runs'` | project name |
+| `name` | `'exp'` | experiment name. `exp` gets automatically incremented if not specified, i.e, `exp`, `exp2` ... |
+| `exist_ok` | `False` | whether to overwrite existing experiment |
+| `plots` | `False` | save plots during train/val |
+| `save` | `False` | save train checkpoints and predict results |
diff --git a/ultralytics/docs/en/usage/cfg.md:Zone.Identifier b/ultralytics/docs/en/usage/cfg.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/usage/cfg.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/usage/cli.md b/ultralytics/docs/en/usage/cli.md
new file mode 100755
index 0000000..eeae078
--- /dev/null
+++ b/ultralytics/docs/en/usage/cli.md
@@ -0,0 +1,227 @@
+---
+comments: true
+description: 'Learn how to use Ultralytics YOLO through Command Line: train models, run predictions and exports models to different formats easily using terminal commands.'
+keywords: Ultralytics, YOLO, CLI, train, validation, prediction, command line interface, YOLO CLI, YOLO terminal, model training, prediction, exporting
+---
+
+# Command Line Interface Usage
+
+The YOLO command line interface (CLI) allows for simple single-line commands without the need for a Python environment. CLI requires no customization or Python code. You can simply run all tasks from the terminal with the `yolo` command.
+
+
+
+!!! Example
+
+ === "Syntax"
+
+ Ultralytics `yolo` commands use the following syntax:
+ ```bash
+ yolo TASK MODE ARGS
+
+ Where TASK (optional) is one of [detect, segment, classify]
+ MODE (required) is one of [train, val, predict, export, track]
+ ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
+ ```
+ See all ARGS in the full [Configuration Guide](cfg.md) or with `yolo cfg`
+
+ === "Train"
+
+ Train a detection model for 10 epochs with an initial learning_rate of 0.01
+ ```bash
+ yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+ ```
+
+ === "Predict"
+
+ Predict a YouTube video using a pretrained segmentation model at image size 320:
+ ```bash
+ yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+ ```
+
+ === "Val"
+
+ Val a pretrained detection model at batch-size 1 and image size 640:
+ ```bash
+ yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+ ```
+
+ === "Export"
+
+ Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
+ ```bash
+ yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+ ```
+
+ === "Special"
+
+ Run special commands to see version, view settings, run checks and more:
+ ```bash
+ yolo help
+ yolo checks
+ yolo version
+ yolo settings
+ yolo copy-cfg
+ yolo cfg
+ ```
+
+Where:
+
+- `TASK` (optional) is one of `[detect, segment, classify]`. If it is not passed explicitly YOLOv8 will try to guess the `TASK` from the model type.
+- `MODE` (required) is one of `[train, val, predict, export, track]`
+- `ARGS` (optional) are any number of custom `arg=value` pairs like `imgsz=320` that override defaults. For a full list of available `ARGS` see the [Configuration](cfg.md) page and `defaults.yaml`
+ GitHub [source](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/default.yaml).
+
+!!! Warning "Warning"
+
+ Arguments must be passed as `arg=val` pairs, split by an equals `=` sign and delimited by spaces ` ` between pairs. Do not use `--` argument prefixes or commas `,` between arguments.
+
+ - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` โ
+ - `yolo predict model yolov8n.pt imgsz 640 conf 0.25` โ
+ - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` โ
+
+## Train
+
+Train YOLOv8n on the COCO128 dataset for 100 epochs at image size 640. For a full list of available arguments see the [Configuration](cfg.md) page.
+
+!!! Example "Example"
+
+ === "Train"
+
+ Start training YOLOv8n on COCO128 for 100 epochs at image-size 640.
+ ```bash
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+ === "Resume"
+
+ Resume an interrupted training.
+ ```bash
+ yolo detect train resume model=last.pt
+ ```
+
+## Val
+
+Validate trained YOLOv8n model accuracy on the COCO128 dataset. No argument need to passed as the `model` retains it's training `data` and arguments as model attributes.
+
+!!! Example "Example"
+
+ === "Official"
+
+ Validate an official YOLOv8n model.
+ ```bash
+ yolo detect val model=yolov8n.pt
+ ```
+
+ === "Custom"
+
+ Validate a custom-trained model.
+ ```bash
+ yolo detect val model=path/to/best.pt
+ ```
+
+## Predict
+
+Use a trained YOLOv8n model to run predictions on images.
+
+!!! Example "Example"
+
+ === "Official"
+
+ Predict with an official YOLOv8n model.
+ ```bash
+ yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'
+ ```
+
+ === "Custom"
+
+ Predict with a custom model.
+ ```bash
+ yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg'
+ ```
+
+## Export
+
+Export a YOLOv8n model to a different format like ONNX, CoreML, etc.
+
+!!! Example "Example"
+
+ === "Official"
+
+ Export an official YOLOv8n model to ONNX format.
+ ```bash
+ yolo export model=yolov8n.pt format=onnx
+ ```
+
+ === "Custom"
+
+ Export a custom-trained model to ONNX format.
+ ```bash
+ yolo export model=path/to/best.pt format=onnx
+ ```
+
+Available YOLOv8 export formats are in the table below. You can export to any format using the `format` argument, i.e. `format='onnx'` or `format='engine'`.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | โ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | โ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | โ | `imgsz`, `half`, `int8` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | โ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | โ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | โ | `imgsz`, `keras`, `int8` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | โ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | โ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | โ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | โ | `imgsz`, `half`, `int8` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | โ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | โ | `imgsz`, `half` |
+
+## Overriding default arguments
+
+Default arguments can be overridden by simply passing them as arguments in the CLI in `arg=value` pairs.
+
+!!! Tip ""
+
+ === "Train"
+ Train a detection model for `10 epochs` with `learning_rate` of `0.01`
+ ```bash
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+ ```
+
+ === "Predict"
+ Predict a YouTube video using a pretrained segmentation model at image size 320:
+ ```bash
+ yolo segment predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+ ```
+
+ === "Val"
+ Validate a pretrained detection model at batch-size 1 and image size 640:
+ ```bash
+ yolo detect val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+ ```
+
+## Overriding default config file
+
+You can override the `default.yaml` config file entirely by passing a new file with the `cfg` arguments, i.e. `cfg=custom.yaml`.
+
+To do this first create a copy of `default.yaml` in your current working dir with the `yolo copy-cfg` command.
+
+This will create `default_copy.yaml`, which you can then pass as `cfg=default_copy.yaml` along with any additional args, like `imgsz=320` in this example:
+
+!!! Example
+
+ === "CLI"
+ ```bash
+ yolo copy-cfg
+ yolo cfg=default_copy.yaml imgsz=320
+ ```
diff --git a/ultralytics/docs/en/usage/cli.md:Zone.Identifier b/ultralytics/docs/en/usage/cli.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/usage/cli.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/usage/engine.md b/ultralytics/docs/en/usage/engine.md
new file mode 100755
index 0000000..12d25e3
--- /dev/null
+++ b/ultralytics/docs/en/usage/engine.md
@@ -0,0 +1,93 @@
+---
+comments: true
+description: Discover how to customize and extend base Ultralytics YOLO Trainer engines. Support your custom model and dataloader by overriding built-in functions.
+keywords: Ultralytics, YOLO, trainer engines, BaseTrainer, DetectionTrainer, customizing trainers, extending trainers, custom model, custom dataloader
+---
+
+Both the Ultralytics YOLO command-line and Python interfaces are simply a high-level abstraction on the base engine executors. Let's take a look at the Trainer engine.
+
+
+
+## BaseTrainer
+
+BaseTrainer contains the generic boilerplate training routine. It can be customized for any task based over overriding the required functions or operations as long the as correct formats are followed. For example, you can support your own custom model and dataloader by just overriding these functions:
+
+* `get_model(cfg, weights)` - The function that builds the model to be trained
+* `get_dataloader()` - The function that builds the dataloader More details and source code can be found in [`BaseTrainer` Reference](../reference/engine/trainer.md)
+
+## DetectionTrainer
+
+Here's how you can use the YOLOv8 `DetectionTrainer` and customize it.
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+
+trainer = DetectionTrainer(overrides={...})
+trainer.train()
+trained_model = trainer.best # get best model
+```
+
+### Customizing the DetectionTrainer
+
+Let's customize the trainer **to train a custom detection model** that is not supported directly. You can do this by simply overloading the existing the `get_model` functionality:
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+
+
+class CustomTrainer(DetectionTrainer):
+ def get_model(self, cfg, weights):
+ ...
+
+
+trainer = CustomTrainer(overrides={...})
+trainer.train()
+```
+
+You now realize that you need to customize the trainer further to:
+
+* Customize the `loss function`.
+* Add `callback` that uploads model to your Google Drive after every 10 `epochs`
+ Here's how you can do it:
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+from ultralytics.nn.tasks import DetectionModel
+
+
+class MyCustomModel(DetectionModel):
+ def init_criterion(self):
+ ...
+
+
+class CustomTrainer(DetectionTrainer):
+ def get_model(self, cfg, weights):
+ return MyCustomModel(...)
+
+
+# callback to upload model weights
+def log_model(trainer):
+ last_weight_path = trainer.last
+ print(last_weight_path)
+
+
+trainer = CustomTrainer(overrides={...})
+trainer.add_callback("on_train_epoch_end", log_model) # Adds to existing callback
+trainer.train()
+```
+
+To know more about Callback triggering events and entry point, checkout our [Callbacks Guide](callbacks.md)
+
+## Other engine components
+
+There are other components that can be customized similarly like `Validators` and `Predictors`
+See Reference section for more information on these.
diff --git a/ultralytics/docs/en/usage/engine.md:Zone.Identifier b/ultralytics/docs/en/usage/engine.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/usage/engine.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/usage/python.md b/ultralytics/docs/en/usage/python.md
new file mode 100755
index 0000000..53a456e
--- /dev/null
+++ b/ultralytics/docs/en/usage/python.md
@@ -0,0 +1,273 @@
+---
+comments: true
+description: Boost your Python projects with object detection, segmentation and classification using YOLOv8. Explore how to load, train, validate, predict, export, track and benchmark models with ease.
+keywords: YOLOv8, Ultralytics, Python, object detection, segmentation, classification, model training, validation, prediction, model export, benchmark, real-time tracking
+---
+
+# Python Usage
+
+Welcome to the YOLOv8 Python Usage documentation! This guide is designed to help you seamlessly integrate YOLOv8 into your Python projects for object detection, segmentation, and classification. Here, you'll learn how to load and use pretrained models, train new models, and perform predictions on images. The easy-to-use Python interface is a valuable resource for anyone looking to incorporate YOLOv8 into their Python projects, allowing you to quickly implement advanced object detection capabilities. Let's get started!
+
+
+
+For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code.
+
+!!! Example "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Create a new YOLO model from scratch
+ model = YOLO('yolov8n.yaml')
+
+ # Load a pretrained YOLO model (recommended for training)
+ model = YOLO('yolov8n.pt')
+
+ # Train the model using the 'coco128.yaml' dataset for 3 epochs
+ results = model.train(data='coco128.yaml', epochs=3)
+
+ # Evaluate the model's performance on the validation set
+ results = model.val()
+
+ # Perform object detection on an image using the model
+ results = model('https://ultralytics.com/images/bus.jpg')
+
+ # Export the model to ONNX format
+ success = model.export(format='onnx')
+ ```
+
+## [Train](../modes/train.md)
+
+Train mode is used for training a YOLOv8 model on a custom dataset. In this mode, the model is trained using the specified dataset and hyperparameters. The training process involves optimizing the model's parameters so that it can accurately predict the classes and locations of objects in an image.
+
+!!! Example "Train"
+
+ === "From pretrained(recommended)"
+ ```python
+ from ultralytics import YOLO
+
+ model = YOLO('yolov8n.pt') # pass any model type
+ results = model.train(epochs=5)
+ ```
+
+ === "From scratch"
+ ```python
+ from ultralytics import YOLO
+
+ model = YOLO('yolov8n.yaml')
+ results = model.train(data='coco128.yaml', epochs=5)
+ ```
+
+ === "Resume"
+ ```python
+ model = YOLO("last.pt")
+ results = model.train(resume=True)
+ ```
+
+[Train Examples](../modes/train.md){ .md-button }
+
+## [Val](../modes/val.md)
+
+Val mode is used for validating a YOLOv8 model after it has been trained. In this mode, the model is evaluated on a validation set to measure its accuracy and generalization performance. This mode can be used to tune the hyperparameters of the model to improve its performance.
+
+!!! Example "Val"
+
+ === "Val after training"
+ ```python
+ from ultralytics import YOLO
+
+ model = YOLO('yolov8n.yaml')
+ model.train(data='coco128.yaml', epochs=5)
+ model.val() # It'll automatically evaluate the data you trained.
+ ```
+
+ === "Val independently"
+ ```python
+ from ultralytics import YOLO
+
+ model = YOLO("model.pt")
+ # It'll use the data YAML file in model.pt if you don't set data.
+ model.val()
+ # or you can set the data you want to val
+ model.val(data='coco128.yaml')
+ ```
+
+[Val Examples](../modes/val.md){ .md-button }
+
+## [Predict](../modes/predict.md)
+
+Predict mode is used for making predictions using a trained YOLOv8 model on new images or videos. In this mode, the model is loaded from a checkpoint file, and the user can provide images or videos to perform inference. The model predicts the classes and locations of objects in the input images or videos.
+
+!!! Example "Predict"
+
+ === "From source"
+ ```python
+ from ultralytics import YOLO
+ from PIL import Image
+ import cv2
+
+ model = YOLO("model.pt")
+ # accepts all formats - image/dir/Path/URL/video/PIL/ndarray. 0 for webcam
+ results = model.predict(source="0")
+ results = model.predict(source="folder", show=True) # Display preds. Accepts all YOLO predict arguments
+
+ # from PIL
+ im1 = Image.open("bus.jpg")
+ results = model.predict(source=im1, save=True) # save plotted images
+
+ # from ndarray
+ im2 = cv2.imread("bus.jpg")
+ results = model.predict(source=im2, save=True, save_txt=True) # save predictions as labels
+
+ # from list of PIL/ndarray
+ results = model.predict(source=[im1, im2])
+ ```
+
+ === "Results usage"
+ ```python
+ # results would be a list of Results object including all the predictions by default
+ # but be careful as it could occupy a lot memory when there're many images,
+ # especially the task is segmentation.
+ # 1. return as a list
+ results = model.predict(source="folder")
+
+ # results would be a generator which is more friendly to memory by setting stream=True
+ # 2. return as a generator
+ results = model.predict(source=0, stream=True)
+
+ for result in results:
+ # Detection
+ result.boxes.xyxy # box with xyxy format, (N, 4)
+ result.boxes.xywh # box with xywh format, (N, 4)
+ result.boxes.xyxyn # box with xyxy format but normalized, (N, 4)
+ result.boxes.xywhn # box with xywh format but normalized, (N, 4)
+ result.boxes.conf # confidence score, (N, 1)
+ result.boxes.cls # cls, (N, 1)
+
+ # Segmentation
+ result.masks.data # masks, (N, H, W)
+ result.masks.xy # x,y segments (pixels), List[segment] * N
+ result.masks.xyn # x,y segments (normalized), List[segment] * N
+
+ # Classification
+ result.probs # cls prob, (num_class, )
+
+ # Each result is composed of torch.Tensor by default,
+ # in which you can easily use following functionality:
+ result = result.cuda()
+ result = result.cpu()
+ result = result.to("cpu")
+ result = result.numpy()
+ ```
+
+[Predict Examples](../modes/predict.md){ .md-button }
+
+## [Export](../modes/export.md)
+
+Export mode is used for exporting a YOLOv8 model to a format that can be used for deployment. In this mode, the model is converted to a format that can be used by other software applications or hardware devices. This mode is useful when deploying the model to production environments.
+
+!!! Example "Export"
+
+ === "Export to ONNX"
+
+ Export an official YOLOv8n model to ONNX with dynamic batch-size and image-size.
+ ```python
+ from ultralytics import YOLO
+
+ model = YOLO('yolov8n.pt')
+ model.export(format='onnx', dynamic=True)
+ ```
+
+ === "Export to TensorRT"
+
+ Export an official YOLOv8n model to TensorRT on `device=0` for acceleration on CUDA devices.
+ ```python
+ from ultralytics import YOLO
+
+ model = YOLO('yolov8n.pt')
+ model.export(format='onnx', device=0)
+ ```
+
+[Export Examples](../modes/export.md){ .md-button }
+
+## [Track](../modes/track.md)
+
+Track mode is used for tracking objects in real-time using a YOLOv8 model. In this mode, the model is loaded from a checkpoint file, and the user can provide a live video stream to perform real-time object tracking. This mode is useful for applications such as surveillance systems or self-driving cars.
+
+!!! Example "Track"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load an official detection model
+ model = YOLO('yolov8n-seg.pt') # load an official segmentation model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Track with the model
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
+ results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")
+ ```
+
+[Track Examples](../modes/track.md){ .md-button }
+
+## [Benchmark](../modes/benchmark.md)
+
+Benchmark mode is used to profile the speed and accuracy of various export formats for YOLOv8. The benchmarks provide information on the size of the exported format, its `mAP50-95` metrics (for object detection and segmentation)
+or `accuracy_top5` metrics (for classification), and the inference time in milliseconds per image across various export formats like ONNX, OpenVINO, TensorRT and others. This information can help users choose the optimal export format for their specific use case based on their requirements for speed and accuracy.
+
+!!! Example "Benchmark"
+
+ === "Python"
+
+ Benchmark an official YOLOv8n model across all export formats.
+ ```python
+ from ultralytics.utils.benchmarks import benchmark
+
+ # Benchmark
+ benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
+ ```
+
+[Benchmark Examples](../modes/benchmark.md){ .md-button }
+
+## Using Trainers
+
+`YOLO` model class is a high-level wrapper on the Trainer classes. Each YOLO task has its own trainer that inherits from `BaseTrainer`.
+
+!!! Tip "Detection Trainer Example"
+
+ ```python
+ from ultralytics.models.yolo import DetectionTrainer, DetectionValidator, DetectionPredictor
+
+ # trainer
+ trainer = DetectionTrainer(overrides={})
+ trainer.train()
+ trained_model = trainer.best
+
+ # Validator
+ val = DetectionValidator(args=...)
+ val(model=trained_model)
+
+ # predictor
+ pred = DetectionPredictor(overrides={})
+ pred(source=SOURCE, model=trained_model)
+
+ # resume from last weight
+ overrides["resume"] = trainer.last
+ trainer = detect.DetectionTrainer(overrides=overrides)
+ ```
+
+You can easily customize Trainers to support custom tasks or explore R&D ideas. Learn more about Customizing `Trainers`, `Validators` and `Predictors` to suit your project needs in the Customization Section.
+
+[Customization tutorials](engine.md){ .md-button }
diff --git a/ultralytics/docs/en/usage/python.md:Zone.Identifier b/ultralytics/docs/en/usage/python.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/usage/python.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/environments/aws_quickstart_tutorial.md b/ultralytics/docs/en/yolov5/environments/aws_quickstart_tutorial.md
new file mode 100755
index 0000000..2bf3240
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/aws_quickstart_tutorial.md
@@ -0,0 +1,95 @@
+---
+comments: true
+description: Follow this comprehensive guide to set up and operate YOLOv5 on an AWS Deep Learning instance for object detection tasks. Get started with model training and deployment.
+keywords: YOLOv5, AWS Deep Learning AMIs, object detection, machine learning, AI, model training, instance setup, Ultralytics
+---
+
+# YOLOv5 ๐ on AWS Deep Learning Instance: Your Complete Guide
+
+Setting up a high-performance deep learning environment can be daunting for newcomers, but fear not! ๐ ๏ธ With this guide, we'll walk you through the process of getting YOLOv5 up and running on an AWS Deep Learning instance. By leveraging the power of Amazon Web Services (AWS), even those new to machine learning can get started quickly and cost-effectively. The AWS platform's scalability is perfect for both experimentation and production deployment.
+
+Other quickstart options for YOLOv5 include our [Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) , [GCP Deep Learning VM](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial), and our Docker image at [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) .
+
+## Step 1: AWS Console Sign-In
+
+Start by creating an account or signing in to the AWS console at [https://aws.amazon.com/console/](https://aws.amazon.com/console/). Once logged in, select the **EC2** service to manage and set up your instances.
+
+
+
+## Step 2: Launch Your Instance
+
+In the EC2 dashboard, you'll find the **Launch Instance** button which is your gateway to creating a new virtual server.
+
+
+
+### Selecting the Right Amazon Machine Image (AMI)
+
+Here's where you choose the operating system and software stack for your instance. Type 'Deep Learning' into the search field and select the latest Ubuntu-based Deep Learning AMI, unless your needs dictate otherwise. Amazon's Deep Learning AMIs come pre-installed with popular frameworks and GPU drivers to streamline your setup process.
+
+
+
+### Picking an Instance Type
+
+For deep learning tasks, selecting a GPU instance type is generally recommended as it can vastly accelerate model training. For instance size considerations, remember that the model's memory requirements should never exceed what your instance can provide.
+
+**Note:** The size of your model should be a factor in selecting an instance. If your model exceeds an instance's available RAM, select a different instance type with enough memory for your application.
+
+For a list of available GPU instance types, visit [EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/), specifically under Accelerated Computing.
+
+
+
+For more information on GPU monitoring and optimization, see [GPU Monitoring and Optimization](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-gpu.html). For pricing, see [On-Demand Pricing](https://aws.amazon.com/ec2/pricing/on-demand/) and [Spot Pricing](https://aws.amazon.com/ec2/spot/pricing/).
+
+### Configuring Your Instance
+
+Amazon EC2 Spot Instances offer a cost-effective way to run applications as they allow you to bid for unused capacity at a fraction of the standard cost. For a persistent experience that retains data even when the Spot Instance goes down, opt for a persistent request.
+
+
+
+Remember to adjust the rest of your instance settings and security configurations as needed in Steps 4-7 before launching.
+
+## Step 3: Connect to Your Instance
+
+Once your instance is running, select its checkbox and click Connect to access the SSH information. Use the displayed SSH command in your preferred terminal to establish a connection to your instance.
+
+
+
+## Step 4: Running YOLOv5
+
+Logged into your instance, you're now ready to clone the YOLOv5 repository and install dependencies within a Python 3.8 or later environment. YOLOv5's models and datasets will automatically download from the latest [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone repository
+cd yolov5
+pip install -r requirements.txt # install dependencies
+```
+
+With your environment set up, you can begin training, validating, performing inference, and exporting your YOLOv5 models:
+
+```bash
+# Train a model on your data
+python train.py
+
+# Validate the trained model for Precision, Recall, and mAP
+python val.py --weights yolov5s.pt
+
+# Run inference using the trained model on your images or videos
+python detect.py --weights yolov5s.pt --source path/to/images
+
+# Export the trained model to other formats for deployment
+python export.py --weights yolov5s.pt --include onnx coreml tflite
+```
+
+## Optional Extras
+
+To add more swap memory, which can be a savior for large datasets, run:
+
+```bash
+sudo fallocate -l 64G /swapfile # allocate 64GB swap file
+sudo chmod 600 /swapfile # modify permissions
+sudo mkswap /swapfile # set up a Linux swap area
+sudo swapon /swapfile # activate swap file
+free -h # verify swap memory
+```
+
+And that's it! ๐ You've successfully created an AWS Deep Learning instance and run YOLOv5. Whether you're just starting with object detection or scaling up for production, this setup can help you achieve your machine learning goals. Happy training, validating, and deploying! If you encounter any hiccups along the way, the robust AWS documentation and the active Ultralytics community are here to support you.
diff --git a/ultralytics/docs/en/yolov5/environments/aws_quickstart_tutorial.md:Zone.Identifier b/ultralytics/docs/en/yolov5/environments/aws_quickstart_tutorial.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/aws_quickstart_tutorial.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/environments/azureml_quickstart_tutorial.md b/ultralytics/docs/en/yolov5/environments/azureml_quickstart_tutorial.md
new file mode 100755
index 0000000..e1e58a4
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/azureml_quickstart_tutorial.md
@@ -0,0 +1,95 @@
+---
+comments: true
+description: Azure Machine Learning YOLOv5 quickstart
+keywords: Ultralytics, YOLO, Deep Learning, Object detection, quickstart, Azure, AzureML
+---
+
+# YOLOv5 ๐ on AzureML
+
+This guide provides a quickstart to use YOLOv5 from an AzureML compute instance.
+
+Note that this guide is a quickstart for quick trials. If you want to unlock the full power AzureML, you can find the documentation to:
+
+- [Create a data asset](https://learn.microsoft.com/azure/machine-learning/how-to-create-data-assets)
+- [Create an AzureML job](https://learn.microsoft.com/azure/machine-learning/how-to-train-model)
+- [Register a model](https://learn.microsoft.com/azure/machine-learning/how-to-manage-models)
+
+## Prerequisites
+
+You need an [AzureML workspace](https://learn.microsoft.com/azure/machine-learning/concept-workspace?view=azureml-api-2).
+
+## Create a compute instance
+
+From your AzureML workspace, select Compute > Compute instances > New, select the instance with the resources you need.
+
+
+
+## Open a Terminal
+
+Now from the Notebooks view, open a Terminal and select your compute.
+
+
+
+## Setup and run YOLOv5
+
+Now you can, create a virtual environment:
+
+```bash
+conda create --name yolov5env -y
+conda activate yolov5env
+conda install pip -y
+```
+
+Clone YOLOv5 repository with its submodules:
+
+```bash
+git clone https://github.com/ultralytics/yolov5
+cd yolov5
+git submodule update --init --recursive # Note that you might have a message asking you to add your folder as a safe.directory just copy the recommended command
+```
+
+Install the required dependencies:
+
+```bash
+pip install -r yolov5/requirements.txt
+pip install onnx>=1.10.0
+```
+
+Train the YOLOv5 model:
+
+```bash
+python train.py
+```
+
+Validate the model for Precision, Recall, and mAP
+
+```bash
+python val.py --weights yolov5s.pt
+```
+
+Run inference on images and videos:
+
+```bash
+python detect.py --weights yolov5s.pt --source path/to/images
+```
+
+Export models to other formats:
+
+```bash
+python detect.py --weights yolov5s.pt --source path/to/images
+```
+
+## Notes on using a notebook
+
+Note that if you want to run these commands from a Notebook, you need to [create a new Kernel](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-access-terminal?view=azureml-api-2#add-new-kernels)
+and select your new Kernel on the top of your Notebook.
+
+If you create Python cells it will automatically use your custom environment, but if you add bash cells, you will need to run `source activate ` on each of these cells to make sure it uses your custom environment.
+
+For example:
+
+```bash
+%%bash
+source activate newenv
+python val.py --weights yolov5s.pt
+```
diff --git a/ultralytics/docs/en/yolov5/environments/azureml_quickstart_tutorial.md:Zone.Identifier b/ultralytics/docs/en/yolov5/environments/azureml_quickstart_tutorial.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/azureml_quickstart_tutorial.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/environments/docker_image_quickstart_tutorial.md b/ultralytics/docs/en/yolov5/environments/docker_image_quickstart_tutorial.md
new file mode 100755
index 0000000..2e2bd81
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/docker_image_quickstart_tutorial.md
@@ -0,0 +1,71 @@
+---
+comments: true
+description: Learn how to set up and run YOLOv5 in a Docker container. This tutorial includes the prerequisites and step-by-step instructions.
+keywords: YOLOv5, Docker, Ultralytics, Image Detection, YOLOv5 Docker Image, Docker Container, Machine Learning, AI
+---
+
+# Get Started with YOLOv5 ๐ in Docker
+
+This tutorial will guide you through the process of setting up and running YOLOv5 in a Docker container.
+
+You can also explore other quickstart options for YOLOv5, such as our [Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) , [GCP Deep Learning VM](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial), and [Amazon AWS](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial).
+
+## Prerequisites
+
+1. **Nvidia Driver**: Version 455.23 or higher. Download from [Nvidia's website](https://www.nvidia.com/Download/index.aspx).
+2. **Nvidia-Docker**: Allows Docker to interact with your local GPU. Installation instructions are available on the [Nvidia-Docker GitHub repository](https://github.com/NVIDIA/nvidia-docker).
+3. **Docker Engine - CE**: Version 19.03 or higher. Download and installation instructions can be found on the [Docker website](https://docs.docker.com/install/).
+
+## Step 1: Pull the YOLOv5 Docker Image
+
+The Ultralytics YOLOv5 DockerHub repository is available at [https://hub.docker.com/r/ultralytics/yolov5](https://hub.docker.com/r/ultralytics/yolov5). Docker Autobuild ensures that the `ultralytics/yolov5:latest` image is always in sync with the most recent repository commit. To pull the latest image, run the following command:
+
+```bash
+sudo docker pull ultralytics/yolov5:latest
+```
+
+## Step 2: Run the Docker Container
+
+### Basic container:
+
+Run an interactive instance of the YOLOv5 Docker image (called a "container") using the `-it` flag:
+
+```bash
+sudo docker run --ipc=host -it ultralytics/yolov5:latest
+```
+
+### Container with local file access:
+
+To run a container with access to local files (e.g., COCO training data in `/datasets`), use the `-v` flag:
+
+```bash
+sudo docker run --ipc=host -it -v "$(pwd)"/datasets:/usr/src/datasets ultralytics/yolov5:latest
+```
+
+### Container with GPU access:
+
+To run a container with GPU access, use the `--gpus all` flag:
+
+```bash
+sudo docker run --ipc=host -it --gpus all ultralytics/yolov5:latest
+```
+
+## Step 3: Use YOLOv5 ๐ within the Docker Container
+
+Now you can train, test, detect, and export YOLOv5 models within the running Docker container:
+
+```bash
+# Train a model on your data
+python train.py
+
+# Validate the trained model for Precision, Recall, and mAP
+python val.py --weights yolov5s.pt
+
+# Run inference using the trained model on your images or videos
+python detect.py --weights yolov5s.pt --source path/to/images
+
+# Export the trained model to other formats for deployment
+python export.py --weights yolov5s.pt --include onnx coreml tflite
+```
+
+
diff --git a/ultralytics/docs/en/yolov5/environments/docker_image_quickstart_tutorial.md:Zone.Identifier b/ultralytics/docs/en/yolov5/environments/docker_image_quickstart_tutorial.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/docker_image_quickstart_tutorial.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md b/ultralytics/docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md
new file mode 100755
index 0000000..fd96e84
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md
@@ -0,0 +1,87 @@
+---
+comments: true
+description: Discover how to deploy YOLOv5 on a GCP Deep Learning VM for seamless object detection. Ideal for ML beginners and cloud learners. Get started with our easy-to-follow tutorial!
+keywords: YOLOv5, Google Cloud Platform, GCP, Deep Learning VM, ML model training, object detection, AI tutorial, cloud-based AI, machine learning setup
+---
+
+# Mastering YOLOv5 ๐ Deployment on Google Cloud Platform (GCP) Deep Learning Virtual Machine (VM) โญ
+
+Embarking on the journey of artificial intelligence and machine learning can be exhilarating, especially when you leverage the power and flexibility of a cloud platform. Google Cloud Platform (GCP) offers robust tools tailored for machine learning enthusiasts and professionals alike. One such tool is the Deep Learning VM that is preconfigured for data science and ML tasks. In this tutorial, we will navigate through the process of setting up YOLOv5 on a GCP Deep Learning VM. Whether youโre taking your first steps in ML or youโre a seasoned practitioner, this guide is designed to provide you with a clear pathway to implementing object detection models powered by YOLOv5.
+
+๐ Plus, if you're a fresh GCP user, youโre in luck with a [$300 free credit offer](https://cloud.google.com/free/docs/gcp-free-tier#free-trial) to kickstart your projects.
+
+In addition to GCP, explore other accessible quickstart options for YOLOv5, like our [Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) for a browser-based experience, or the scalability of [Amazon AWS](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial). Furthermore, container aficionados can utilize our official Docker image at [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) for an encapsulated environment.
+
+## Step 1: Create and Configure Your Deep Learning VM
+
+Letโs begin by creating a virtual machine thatโs tuned for deep learning:
+
+1. Head over to the [GCP marketplace](https://console.cloud.google.com/marketplace/details/click-to-deploy-images/deeplearning) and select the **Deep Learning VM**.
+2. Opt for a **n1-standard-8** instance; it offers a balance of 8 vCPUs and 30 GB of memory, ideally suited for our needs.
+3. Next, select a GPU. This depends on your workload; even a basic one like the Tesla T4 will markedly accelerate your model training.
+4. Tick the box for 'Install NVIDIA GPU driver automatically on first startup?' for hassle-free setup.
+5. Allocate a 300 GB SSD Persistent Disk to ensure you don't bottleneck on I/O operations.
+6. Hit 'Deploy' and let GCP do its magic in provisioning your custom Deep Learning VM.
+
+This VM comes loaded with a treasure trove of preinstalled tools and frameworks, including the [Anaconda](https://www.anaconda.com/) Python distribution, which conveniently bundles all the necessary dependencies for YOLOv5.
+
+
+
+## Step 2: Ready the VM for YOLOv5
+
+Following the environment setup, let's get YOLOv5 up and running:
+
+```bash
+# Clone the YOLOv5 repository
+git clone https://github.com/ultralytics/yolov5
+
+# Change the directory to the cloned repository
+cd yolov5
+
+# Install the necessary Python packages from requirements.txt
+pip install -r requirements.txt
+```
+
+This setup process ensures you're working with a Python environment version 3.8.0 or newer and PyTorch 1.8 or above. Our scripts smoothly download [models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) rending from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases), making it hassle-free to start model training.
+
+## Step 3: Train and Deploy Your YOLOv5 Models ๐
+
+With the setup complete, you're ready to delve into training and inference with YOLOv5 on your GCP VM:
+
+```bash
+# Train a model on your data
+python train.py
+
+# Validate the trained model for Precision, Recall, and mAP
+python val.py --weights yolov5s.pt
+
+# Run inference using the trained model on your images or videos
+python detect.py --weights yolov5s.pt --source path/to/images
+
+# Export the trained model to other formats for deployment
+python export.py --weights yolov5s.pt --include onnx coreml tflite
+```
+
+With just a few commands, YOLOv5 allows you to train custom object detection models tailored to your specific needs or utilize pre-trained weights for quick results on a variety of tasks.
+
+
+
+## Allocate Swap Space (optional)
+
+For those dealing with hefty datasets, consider amplifying your GCP instance with an additional 64GB of swap memory:
+
+```bash
+sudo fallocate -l 64G /swapfile
+sudo chmod 600 /swapfile
+sudo mkswap /swapfile
+sudo swapon /swapfile
+free -h # confirm the memory increment
+```
+
+### Concluding Thoughts
+
+Congratulations! You are now empowered to harness the capabilities of YOLOv5 with the computational prowess of Google Cloud Platform. This combination provides scalability, efficiency, and versatility for your object detection tasks. Whether for personal projects, academic research, or industrial applications, you have taken a pivotal step into the world of AI and machine learning on the cloud.
+
+Do remember to document your journey, share insights with the Ultralytics community, and leverage the collaborative arenas such as [GitHub discussions](https://github.com/ultralytics/yolov5/discussions) to grow further. Now, go forth and innovate with YOLOv5 and GCP! ๐
+
+Want to keep improving your ML skills and knowledge? Dive into our [documentation and tutorials](https://docs.ultralytics.com/) for more resources. Let your AI adventure continue!
diff --git a/ultralytics/docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md:Zone.Identifier b/ultralytics/docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/index.md b/ultralytics/docs/en/yolov5/index.md
new file mode 100755
index 0000000..1e8303d
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/index.md
@@ -0,0 +1,91 @@
+---
+comments: true
+description: Deep dive into Ultralytics' YOLOv5. Learn about object detection model - YOLOv5, how to train it on custom data, multi-GPU training and more.
+keywords: YOLOv5, object detection, computer vision, CUDA, PyTorch tutorial, multi-GPU training, custom dataset, model export, deployment, CI tests
+---
+
+# Comprehensive Guide to Ultralytics YOLOv5
+
+
+
+
+
+
+
+
+
+
+
+
+
+Welcome to the Ultralytics' YOLOv5๐ Documentation! YOLOv5, the fifth iteration of the revolutionary "You Only Look Once" object detection model, is designed to deliver high-speed, high-accuracy results in real-time.
+
+Built on PyTorch, this powerful deep learning framework has garnered immense popularity for its versatility, ease of use, and high performance. Our documentation guides you through the installation process, explains the architectural nuances of the model, showcases various use-cases, and provides a series of detailed tutorials. These resources will help you harness the full potential of YOLOv5 for your computer vision projects. Let's get started!
+
+
+
+## Explore and Learn
+
+Here's a compilation of comprehensive tutorials that will guide you through different aspects of YOLOv5.
+
+* [Train Custom Data](tutorials/train_custom_data.md) ๐ RECOMMENDED: Learn how to train the YOLOv5 model on your custom dataset.
+* [Tips for Best Training Results](tutorials/tips_for_best_training_results.md) โ๏ธ: Uncover practical tips to optimize your model training process.
+* [Multi-GPU Training](tutorials/multi_gpu_training.md): Understand how to leverage multiple GPUs to expedite your training.
+* [PyTorch Hub](tutorials/pytorch_hub_model_loading.md) ๐ NEW: Learn to load pre-trained models via PyTorch Hub.
+* [TFLite, ONNX, CoreML, TensorRT Export](tutorials/model_export.md) ๐: Understand how to export your model to different formats.
+* [NVIDIA Jetson platform Deployment](tutorials/running_on_jetson_nano.md) ๐ NEW: Learn how to deploy your YOLOv5 model on NVIDIA Jetson platform.
+* [Test-Time Augmentation (TTA)](tutorials/test_time_augmentation.md): Explore how to use TTA to improve your model's prediction accuracy.
+* [Model Ensembling](tutorials/model_ensembling.md): Learn the strategy of combining multiple models for improved performance.
+* [Model Pruning/Sparsity](tutorials/model_pruning_and_sparsity.md): Understand pruning and sparsity concepts, and how to create a more efficient model.
+* [Hyperparameter Evolution](tutorials/hyperparameter_evolution.md): Discover the process of automated hyperparameter tuning for better model performance.
+* [Transfer Learning with Frozen Layers](tutorials/transfer_learning_with_frozen_layers.md): Learn how to implement transfer learning by freezing layers in YOLOv5.
+* [Architecture Summary](tutorials/architecture_description.md) ๐ Delve into the structural details of the YOLOv5 model.
+* [Roboflow for Datasets](tutorials/roboflow_datasets_integration.md): Understand how to utilize Roboflow for dataset management, labeling, and active learning.
+* [ClearML Logging](tutorials/clearml_logging_integration.md) ๐ Learn how to integrate ClearML for efficient logging during your model training.
+* [YOLOv5 with Neural Magic](tutorials/neural_magic_pruning_quantization.md) Discover how to use Neural Magic's Deepsparse to prune and quantize your YOLOv5 model.
+* [Comet Logging](tutorials/comet_logging_integration.md) ๐ NEW: Explore how to utilize Comet for improved model training logging.
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Connect and Contribute
+
+Your journey with YOLOv5 doesn't have to be a solitary one. Join our vibrant community on [GitHub](https://github.com/ultralytics/yolov5), connect with professionals on [LinkedIn](https://www.linkedin.com/company/ultralytics/), share your results on [Twitter](https://twitter.com/ultralytics), and find educational resources on [YouTube](https://youtube.com/ultralytics). Follow us on [TikTok](https://www.tiktok.com/@ultralytics) and [Instagram](https://www.instagram.com/ultralytics/) for more engaging content.
+
+Interested in contributing? We welcome contributions of all forms; from code improvements and bug reports to documentation updates. Check out our [contributing guidelines](https://github.com/ultralytics/yolov5/blob/master/CONTRIBUTING.md) for more information.
+
+We're excited to see the innovative ways you'll use YOLOv5. Dive in, experiment, and revolutionize your computer vision projects! ๐
diff --git a/ultralytics/docs/en/yolov5/index.md:Zone.Identifier b/ultralytics/docs/en/yolov5/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/quickstart_tutorial.md b/ultralytics/docs/en/yolov5/quickstart_tutorial.md
new file mode 100755
index 0000000..e5a379c
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/quickstart_tutorial.md
@@ -0,0 +1,72 @@
+---
+comments: true
+description: Dive into YOLOv5 for object detection with our easy-to-follow guide on setup, model training, and image inference using PyTorch. Get started now!
+keywords: YOLOv5 Tutorial, Object Detection Guide, PyTorch Model Training, Inference with YOLOv5, Ultralytics YOLOv5 Setup
+---
+
+# YOLOv5 Quickstart ๐
+
+Embark on your journey into the dynamic realm of real-time object detection with YOLOv5! This guide is crafted to serve as a comprehensive starting point for AI enthusiasts and professionals aiming to master YOLOv5. From initial setup to advanced training techniques, we've got you covered. By the end of this guide, you'll have the knowledge to implement YOLOv5 into your projects confidently. Let's ignite the engines and soar into YOLOv5!
+
+## Install
+
+Prepare for launch by cloning the repository and establishing the environment. This ensures that all the necessary [requirements](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) are installed. Check that you have [**Python>=3.8.0**](https://www.python.org/) and [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/) ready for takeoff.
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone repository
+cd yolov5
+pip install -r requirements.txt # install dependencies
+```
+
+## Inference with PyTorch Hub
+
+Experience the simplicity of YOLOv5 [PyTorch Hub](https://docs.ultralytics.com/yolov5/tutorials/pytorch_hub_model_loading) inference, where [models](https://github.com/ultralytics/yolov5/tree/master/models) are seamlessly downloaded from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```python
+import torch
+
+# Model loading
+model = torch.hub.load("ultralytics/yolov5", "yolov5s") # Can be 'yolov5n' - 'yolov5x6', or 'custom'
+
+# Inference on images
+img = "https://ultralytics.com/images/zidane.jpg" # Can be a file, Path, PIL, OpenCV, numpy, or list of images
+
+# Run inference
+results = model(img)
+
+# Display results
+results.print() # Other options: .show(), .save(), .crop(), .pandas(), etc.
+```
+
+## Inference with detect.py
+
+Harness `detect.py` for versatile inference on various sources. It automatically fetches [models](https://github.com/ultralytics/yolov5/tree/master/models) from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases) and saves results with ease.
+
+```bash
+python detect.py --weights yolov5s.pt --source 0 # webcam
+ img.jpg # image
+ vid.mp4 # video
+ screen # screenshot
+ path/ # directory
+ list.txt # list of images
+ list.streams # list of streams
+ 'path/*.jpg' # glob
+ 'https://youtu.be/LNwODJXcvt4' # YouTube
+ 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP stream
+```
+
+## Training
+
+Replicate the YOLOv5 [COCO](https://github.com/ultralytics/yolov5/blob/master/data/scripts/get_coco.sh) benchmarks with the instructions below. The necessary [models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) are pulled directly from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases). Training YOLOv5n/s/m/l/x on a V100 GPU should typically take 1/2/4/6/8 days respectively (note that [Multi-GPU](https://docs.ultralytics.com/yolov5/tutorials/multi_gpu_training) setups work faster). Maximize performance by using the highest possible `--batch-size` or use `--batch-size -1` for the YOLOv5 [AutoBatch](https://github.com/ultralytics/yolov5/pull/5092) feature. The following batch sizes are ideal for V100-16GB GPUs.
+
+```bash
+python train.py --data coco.yaml --epochs 300 --weights '' --cfg yolov5n.yaml --batch-size 128
+ yolov5s 64
+ yolov5m 40
+ yolov5l 24
+ yolov5x 16
+```
+
+
+
+To conclude, YOLOv5 is not only a state-of-the-art tool for object detection but also a testament to the power of machine learning in transforming the way we interact with the world through visual understanding. As you progress through this guide and begin applying YOLOv5 to your projects, remember that you are at the forefront of a technological revolution, capable of achieving remarkable feats. Should you need further insights or support from fellow visionaries, you're invited to our [GitHub repository](https://github.com/ultralytics/yolov5) home to a thriving community of developers and researchers. Keep exploring, keep innovating, and enjoy the marvels of YOLOv5. Happy detecting! ๐ ๐
diff --git a/ultralytics/docs/en/yolov5/quickstart_tutorial.md:Zone.Identifier b/ultralytics/docs/en/yolov5/quickstart_tutorial.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/quickstart_tutorial.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/architecture_description.md b/ultralytics/docs/en/yolov5/tutorials/architecture_description.md
new file mode 100755
index 0000000..1fb8233
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/architecture_description.md
@@ -0,0 +1,223 @@
+---
+comments: true
+description: Explore the architecture of YOLOv5, an object detection algorithm by Ultralytics. Understand the model structure, data augmentation methods, training strategies, and loss computation techniques.
+keywords: Ultralytics, YOLOv5, Object Detection, Architecture, Model Structure, Data Augmentation, Training Strategies, Loss Computation
+---
+
+# Ultralytics YOLOv5 Architecture
+
+YOLOv5 (v6.0/6.1) is a powerful object detection algorithm developed by Ultralytics. This article dives deep into the YOLOv5 architecture, data augmentation strategies, training methodologies, and loss computation techniques. This comprehensive understanding will help improve your practical application of object detection in various fields, including surveillance, autonomous vehicles, and image recognition.
+
+## 1. Model Structure
+
+YOLOv5's architecture consists of three main parts:
+
+- **Backbone**: This is the main body of the network. For YOLOv5, the backbone is designed using the `New CSP-Darknet53` structure, a modification of the Darknet architecture used in previous versions.
+- **Neck**: This part connects the backbone and the head. In YOLOv5, `SPPF` and `New CSP-PAN` structures are utilized.
+- **Head**: This part is responsible for generating the final output. YOLOv5 uses the `YOLOv3 Head` for this purpose.
+
+The structure of the model is depicted in the image below. The model structure details can be found in `yolov5l.yaml`.
+
+
+
+YOLOv5 introduces some minor changes compared to its predecessors:
+
+1. The `Focus` structure, found in earlier versions, is replaced with a `6x6 Conv2d` structure. This change boosts efficiency [#4825](https://github.com/ultralytics/yolov5/issues/4825).
+2. The `SPP` structure is replaced with `SPPF`. This alteration more than doubles the speed of processing.
+
+To test the speed of `SPP` and `SPPF`, the following code can be used:
+
+
+SPP vs SPPF speed profiling example (click to open)
+
+```python
+import time
+import torch
+import torch.nn as nn
+
+
+class SPP(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.maxpool1 = nn.MaxPool2d(5, 1, padding=2)
+ self.maxpool2 = nn.MaxPool2d(9, 1, padding=4)
+ self.maxpool3 = nn.MaxPool2d(13, 1, padding=6)
+
+ def forward(self, x):
+ o1 = self.maxpool1(x)
+ o2 = self.maxpool2(x)
+ o3 = self.maxpool3(x)
+ return torch.cat([x, o1, o2, o3], dim=1)
+
+
+class SPPF(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.maxpool = nn.MaxPool2d(5, 1, padding=2)
+
+ def forward(self, x):
+ o1 = self.maxpool(x)
+ o2 = self.maxpool(o1)
+ o3 = self.maxpool(o2)
+ return torch.cat([x, o1, o2, o3], dim=1)
+
+
+def main():
+ input_tensor = torch.rand(8, 32, 16, 16)
+ spp = SPP()
+ sppf = SPPF()
+ output1 = spp(input_tensor)
+ output2 = sppf(input_tensor)
+
+ print(torch.equal(output1, output2))
+
+ t_start = time.time()
+ for _ in range(100):
+ spp(input_tensor)
+ print(f"SPP time: {time.time() - t_start}")
+
+ t_start = time.time()
+ for _ in range(100):
+ sppf(input_tensor)
+ print(f"SPPF time: {time.time() - t_start}")
+
+
+if __name__ == '__main__':
+ main()
+```
+
+result:
+
+```
+True
+SPP time: 0.5373051166534424
+SPPF time: 0.20780706405639648
+```
+
+
+
+## 2. Data Augmentation Techniques
+
+YOLOv5 employs various data augmentation techniques to improve the model's ability to generalize and reduce overfitting. These techniques include:
+
+- **Mosaic Augmentation**: An image processing technique that combines four training images into one in ways that encourage object detection models to better handle various object scales and translations.
+
+ 
+
+- **Copy-Paste Augmentation**: An innovative data augmentation method that copies random patches from an image and pastes them onto another randomly chosen image, effectively generating a new training sample.
+
+ 
+
+- **Random Affine Transformations**: This includes random rotation, scaling, translation, and shearing of the images.
+
+ 
+
+- **MixUp Augmentation**: A method that creates composite images by taking a linear combination of two images and their associated labels.
+
+ 
+
+- **Albumentations**: A powerful library for image augmenting that supports a wide variety of augmentation techniques.
+- **HSV Augmentation**: Random changes to the Hue, Saturation, and Value of the images.
+
+ 
+
+- **Random Horizontal Flip**: An augmentation method that randomly flips images horizontally.
+
+ 
+
+## 3. Training Strategies
+
+YOLOv5 applies several sophisticated training strategies to enhance the model's performance. They include:
+
+- **Multiscale Training**: The input images are randomly rescaled within a range of 0.5 to 1.5 times their original size during the training process.
+- **AutoAnchor**: This strategy optimizes the prior anchor boxes to match the statistical characteristics of the ground truth boxes in your custom data.
+- **Warmup and Cosine LR Scheduler**: A method to adjust the learning rate to enhance model performance.
+- **Exponential Moving Average (EMA)**: A strategy that uses the average of parameters over past steps to stabilize the training process and reduce generalization error.
+- **Mixed Precision Training**: A method to perform operations in half-precision format, reducing memory usage and enhancing computational speed.
+- **Hyperparameter Evolution**: A strategy to automatically tune hyperparameters to achieve optimal performance.
+
+## 4. Additional Features
+
+### 4.1 Compute Losses
+
+The loss in YOLOv5 is computed as a combination of three individual loss components:
+
+- **Classes Loss (BCE Loss)**: Binary Cross-Entropy loss, measures the error for the classification task.
+- **Objectness Loss (BCE Loss)**: Another Binary Cross-Entropy loss, calculates the error in detecting whether an object is present in a particular grid cell or not.
+- **Location Loss (CIoU Loss)**: Complete IoU loss, measures the error in localizing the object within the grid cell.
+
+The overall loss function is depicted by:
+
+
+
+### 4.2 Balance Losses
+
+The objectness losses of the three prediction layers (`P3`, `P4`, `P5`) are weighted differently. The balance weights are `[4.0, 1.0, 0.4]` respectively. This approach ensures that the predictions at different scales contribute appropriately to the total loss.
+
+
+
+### 4.3 Eliminate Grid Sensitivity
+
+The YOLOv5 architecture makes some important changes to the box prediction strategy compared to earlier versions of YOLO. In YOLOv2 and YOLOv3, the box coordinates were directly predicted using the activation of the last layer.
+
++c_x)
++c_y)
+
+
+
+
+
+However, in YOLOv5, the formula for predicting the box coordinates has been updated to reduce grid sensitivity and prevent the model from predicting unbounded box dimensions.
+
+The revised formulas for calculating the predicted bounding box are as follows:
+
+-0.5)+c_x)
+-0.5)+c_y)
+)^2)
+)^2)
+
+Compare the center point offset before and after scaling. The center point offset range is adjusted from (0, 1) to (-0.5, 1.5). Therefore, offset can easily get 0 or 1.
+
+
+
+Compare the height and width scaling ratio(relative to anchor) before and after adjustment. The original yolo/darknet box equations have a serious flaw. Width and Height are completely unbounded as they are simply out=exp(in), which is dangerous, as it can lead to runaway gradients, instabilities, NaN losses and ultimately a complete loss of training. [refer this issue](https://github.com/ultralytics/yolov5/issues/471#issuecomment-662009779)
+
+
+
+### 4.4 Build Targets
+
+The build target process in YOLOv5 is critical for training efficiency and model accuracy. It involves assigning ground truth boxes to the appropriate grid cells in the output map and matching them with the appropriate anchor boxes.
+
+This process follows these steps:
+
+- Calculate the ratio of the ground truth box dimensions and the dimensions of each anchor template.
+
+
+
+
+
+)
+
+)
+
+)
+
+
+
+
+
+- If the calculated ratio is within the threshold, match the ground truth box with the corresponding anchor.
+
+
+
+- Assign the matched anchor to the appropriate cells, keeping in mind that due to the revised center point offset, a ground truth box can be assigned to more than one anchor. Because the center point offset range is adjusted from (0, 1) to (-0.5, 1.5). GT Box can be assigned to more anchors.
+
+
+
+This way, the build targets process ensures that each ground truth object is properly assigned and matched during the training process, allowing YOLOv5 to learn the task of object detection more effectively.
+
+## Conclusion
+
+In conclusion, YOLOv5 represents a significant step forward in the development of real-time object detection models. By incorporating various new features, enhancements, and training strategies, it surpasses previous versions of the YOLO family in performance and efficiency.
+
+The primary enhancements in YOLOv5 include the use of a dynamic architecture, an extensive range of data augmentation techniques, innovative training strategies, as well as important adjustments in computing losses and the process of building targets. All these innovations significantly improve the accuracy and efficiency of object detection while retaining a high degree of speed, which is the trademark of YOLO models.
diff --git a/ultralytics/docs/en/yolov5/tutorials/architecture_description.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/architecture_description.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/architecture_description.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/clearml_logging_integration.md b/ultralytics/docs/en/yolov5/tutorials/clearml_logging_integration.md
new file mode 100755
index 0000000..dda96f8
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/clearml_logging_integration.md
@@ -0,0 +1,237 @@
+---
+comments: true
+description: Learn how ClearML can enhance your YOLOv5 pipeline โ track your training runs, version your data, remotely monitor your models and optimize performance.
+keywords: ClearML, YOLOv5, Ultralytics, AI toolbox, training data, remote training, hyperparameter optimization, YOLOv5 model
+---
+
+# ClearML Integration
+
+
+
+## About ClearML
+
+[ClearML](https://cutt.ly/yolov5-tutorial-clearml) is an [open-source](https://github.com/allegroai/clearml) toolbox designed to save you time โฑ๏ธ.
+
+๐จ Track every YOLOv5 training run in the experiment manager
+
+๐ง Version and easily access your custom training data with the integrated ClearML Data Versioning Tool
+
+๐ฆ Remotely train and monitor your YOLOv5 training runs using ClearML Agent
+
+๐ฌ Get the very best mAP using ClearML Hyperparameter Optimization
+
+๐ญ Turn your newly trained YOLOv5 model into an API with just a few commands using ClearML Serving
+
+
+And so much more. It's up to you how many of these tools you want to use, you can stick to the experiment manager, or chain them all together into an impressive pipeline!
+
+
+
+
+
+
+
+
+## ๐ฆพ Setting Things Up
+
+To keep track of your experiments and/or data, ClearML needs to communicate to a server. You have 2 options to get one:
+
+Either sign up for free to the [ClearML Hosted Service](https://cutt.ly/yolov5-tutorial-clearml) or you can set up your own server, see [here](https://clear.ml/docs/latest/docs/deploying_clearml/clearml_server). Even the server is open-source, so even if you're dealing with sensitive data, you should be good to go!
+
+- Install the `clearml` python package:
+
+ ```bash
+ pip install clearml
+ ```
+
+- Connect the ClearML SDK to the server by [creating credentials](https://app.clear.ml/settings/workspace-configuration) (go right top to Settings -> Workspace -> Create new credentials), then execute the command below and follow the instructions:
+
+ ```bash
+ clearml-init
+ ```
+
+That's it! You're done ๐
+
+
+
+## ๐ Training YOLOv5 With ClearML
+
+To enable ClearML experiment tracking, simply install the ClearML pip package.
+
+```bash
+pip install clearml>=1.2.0
+```
+
+This will enable integration with the YOLOv5 training script. Every training run from now on, will be captured and stored by the ClearML experiment manager.
+
+If you want to change the `project_name` or `task_name`, use the `--project` and `--name` arguments of the `train.py` script, by default the project will be called `YOLOv5` and the task `Training`. PLEASE NOTE: ClearML uses `/` as a delimiter for subprojects, so be careful when using `/` in your project name!
+
+```bash
+python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt --cache
+```
+
+or with custom project and task name:
+
+```bash
+python train.py --project my_project --name my_training --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt --cache
+```
+
+This will capture:
+
+- Source code + uncommitted changes
+- Installed packages
+- (Hyper)parameters
+- Model files (use `--save-period n` to save a checkpoint every n epochs)
+- Console output
+- Scalars (mAP_0.5, mAP_0.5:0.95, precision, recall, losses, learning rates, ...)
+- General info such as machine details, runtime, creation date etc.
+- All produced plots such as label correlogram and confusion matrix
+- Images with bounding boxes per epoch
+- Mosaic per epoch
+- Validation images per epoch
+
+That's a lot right? ๐คฏ Now, we can visualize all of this information in the ClearML UI to get an overview of our training progress. Add custom columns to the table view (such as e.g. mAP_0.5) so you can easily sort on the best performing model. Or select multiple experiments and directly compare them!
+
+There even more we can do with all of this information, like hyperparameter optimization and remote execution, so keep reading if you want to see how that works!
+
+### ๐ Dataset Version Management
+
+Versioning your data separately from your code is generally a good idea and makes it easy to acquire the latest version too. This repository supports supplying a dataset version ID, and it will make sure to get the data if it's not there yet. Next to that, this workflow also saves the used dataset ID as part of the task parameters, so you will always know for sure which data was used in which experiment!
+
+
+
+### Prepare Your Dataset
+
+The YOLOv5 repository supports a number of different datasets by using YAML files containing their information. By default datasets are downloaded to the `../datasets` folder in relation to the repository root folder. So if you downloaded the `coco128` dataset using the link in the YAML or with the scripts provided by yolov5, you get this folder structure:
+
+```
+..
+|_ yolov5
+|_ datasets
+ |_ coco128
+ |_ images
+ |_ labels
+ |_ LICENSE
+ |_ README.txt
+```
+
+But this can be any dataset you wish. Feel free to use your own, as long as you keep to this folder structure.
+
+Next, โ ๏ธ**copy the corresponding YAML file to the root of the dataset folder**โ ๏ธ. This YAML files contains the information ClearML will need to properly use the dataset. You can make this yourself too, of course, just follow the structure of the example YAMLs.
+
+Basically we need the following keys: `path`, `train`, `test`, `val`, `nc`, `names`.
+
+```
+..
+|_ yolov5
+|_ datasets
+ |_ coco128
+ |_ images
+ |_ labels
+ |_ coco128.yaml # <---- HERE!
+ |_ LICENSE
+ |_ README.txt
+```
+
+### Upload Your Dataset
+
+To get this dataset into ClearML as a versioned dataset, go to the dataset root folder and run the following command:
+
+```bash
+cd coco128
+clearml-data sync --project YOLOv5 --name coco128 --folder .
+```
+
+The command `clearml-data sync` is actually a shorthand command. You could also run these commands one after the other:
+
+```bash
+# Optionally add --parent if you want to base
+# this version on another dataset version, so no duplicate files are uploaded!
+clearml-data create --name coco128 --project YOLOv5
+clearml-data add --files .
+clearml-data close
+```
+
+### Run Training Using A ClearML Dataset
+
+Now that you have a ClearML dataset, you can very simply use it to train custom YOLOv5 ๐ models!
+
+```bash
+python train.py --img 640 --batch 16 --epochs 3 --data clearml:// --weights yolov5s.pt --cache
+```
+
+
+
+### ๐ Hyperparameter Optimization
+
+Now that we have our experiments and data versioned, it's time to take a look at what we can build on top!
+
+Using the code information, installed packages and environment details, the experiment itself is now **completely reproducible**. In fact, ClearML allows you to clone an experiment and even change its parameters. We can then just rerun it with these new parameters automatically, this is basically what HPO does!
+
+To **run hyperparameter optimization locally**, we've included a pre-made script for you. Just make sure a training task has been run at least once, so it is in the ClearML experiment manager, we will essentially clone it and change its hyperparameters.
+
+You'll need to fill in the ID of this `template task` in the script found at `utils/loggers/clearml/hpo.py` and then just run it :) You can change `task.execute_locally()` to `task.execute()` to put it in a ClearML queue and have a remote agent work on it instead.
+
+```bash
+# To use optuna, install it first, otherwise you can change the optimizer to just be RandomSearch
+pip install optuna
+python utils/loggers/clearml/hpo.py
+```
+
+
+
+## ๐คฏ Remote Execution (advanced)
+
+Running HPO locally is really handy, but what if we want to run our experiments on a remote machine instead? Maybe you have access to a very powerful GPU machine on-site, or you have some budget to use cloud GPUs. This is where the ClearML Agent comes into play. Check out what the agent can do here:
+
+- [YouTube video](https://youtu.be/MX3BrXnaULs)
+- [Documentation](https://clear.ml/docs/latest/docs/clearml_agent)
+
+In short: every experiment tracked by the experiment manager contains enough information to reproduce it on a different machine (installed packages, uncommitted changes etc.). So a ClearML agent does just that: it listens to a queue for incoming tasks and when it finds one, it recreates the environment and runs it while still reporting scalars, plots etc. to the experiment manager.
+
+You can turn any machine (a cloud VM, a local GPU machine, your own laptop ... ) into a ClearML agent by simply running:
+
+```bash
+clearml-agent daemon --queue [--docker]
+```
+
+### Cloning, Editing And Enqueuing
+
+With our agent running, we can give it some work. Remember from the HPO section that we can clone a task and edit the hyperparameters? We can do that from the interface too!
+
+๐ช Clone the experiment by right-clicking it
+
+๐ฏ Edit the hyperparameters to what you wish them to be
+
+โณ Enqueue the task to any of the queues by right-clicking it
+
+
+
+### Executing A Task Remotely
+
+Now you can clone a task like we explained above, or simply mark your current script by adding `task.execute_remotely()` and on execution it will be put into a queue, for the agent to start working on!
+
+To run the YOLOv5 training script remotely, all you have to do is add this line to the training.py script after the clearml logger has been instantiated:
+
+```python
+# ...
+# Loggers
+data_dict = None
+if RANK in {-1, 0}:
+ loggers = Loggers(save_dir, weights, opt, hyp, LOGGER) # loggers instance
+ if loggers.clearml:
+ loggers.clearml.task.execute_remotely(queue="my_queue") # <------ ADD THIS LINE
+ # Data_dict is either None is user did not choose for ClearML dataset or is filled in by ClearML
+ data_dict = loggers.clearml.data_dict
+# ...
+```
+
+When running the training script after this change, python will run the script up until that line, after which it will package the code and send it to the queue instead!
+
+### Autoscaling workers
+
+ClearML comes with autoscalers too! This tool will automatically spin up new remote machines in the cloud of your choice (AWS, GCP, Azure) and turn them into ClearML agents for you whenever there are experiments detected in the queue. Once the tasks are processed, the autoscaler will automatically shut down the remote machines, and you stop paying!
+
+Check out the autoscalers getting started video below.
+
+[](https://youtu.be/j4XVMAaUt3E)
diff --git a/ultralytics/docs/en/yolov5/tutorials/clearml_logging_integration.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/clearml_logging_integration.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/clearml_logging_integration.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/comet_logging_integration.md b/ultralytics/docs/en/yolov5/tutorials/comet_logging_integration.md
new file mode 100755
index 0000000..a911909
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/comet_logging_integration.md
@@ -0,0 +1,261 @@
+---
+comments: true
+description: Learn how to set up and use Comet to enhance your YOLOv5 model training, metrics tracking and visualization. Includes a step by step guide to integrate Comet with YOLOv5.
+keywords: YOLOv5, Comet, Machine Learning, Ultralytics, Real time metrics tracking, Hyperparameters, Model checkpoints, Model predictions, YOLOv5 training, Comet Credentials
+---
+
+
+
+# YOLOv5 with Comet
+
+This guide will cover how to use YOLOv5 with [Comet](https://bit.ly/yolov5-readme-comet2)
+
+## About Comet
+
+Comet builds tools that help data scientists, engineers, and team leaders accelerate and optimize machine learning and deep learning models.
+
+Track and visualize model metrics in real time, save your hyperparameters, datasets, and model checkpoints, and visualize your model predictions with [Comet Custom Panels](https://www.comet.com/docs/v2/guides/comet-dashboard/code-panels/about-panels/?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)!
+Comet makes sure you never lose track of your work and makes it easy to share results and collaborate across teams of all sizes!
+
+## Getting Started
+
+### Install Comet
+
+```shell
+pip install comet_ml
+```
+
+### Configure Comet Credentials
+
+There are two ways to configure Comet with YOLOv5.
+
+You can either set your credentials through environment variables
+
+**Environment Variables**
+
+```shell
+export COMET_API_KEY=
+export COMET_PROJECT_NAME= # This will default to 'yolov5'
+```
+
+Or create a `.comet.config` file in your working directory and set your credentials there.
+
+**Comet Configuration File**
+
+```
+[comet]
+api_key=
+project_name= # This will default to 'yolov5'
+```
+
+### Run the Training Script
+
+```shell
+# Train YOLOv5s on COCO128 for 5 epochs
+python train.py --img 640 --batch 16 --epochs 5 --data coco128.yaml --weights yolov5s.pt
+```
+
+That's it! Comet will automatically log your hyperparameters, command line arguments, training and validation metrics. You can visualize and analyze your runs in the Comet UI
+
+
+
+## Try out an Example!
+
+Check out an example of a [completed run here](https://www.comet.com/examples/comet-example-yolov5/a0e29e0e9b984e4a822db2a62d0cb357?experiment-tab=chart&showOutliers=true&smoothing=0&transformY=smoothing&xAxis=step&utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
+
+Or better yet, try it out yourself in this Colab Notebook
+
+[](https://colab.research.google.com/drive/1RG0WOQyxlDlo5Km8GogJpIEJlg_5lyYO?usp=sharing)
+
+## Log automatically
+
+By default, Comet will log the following items
+
+## Metrics
+
+- Box Loss, Object Loss, Classification Loss for the training and validation data
+- mAP_0.5, mAP_0.5:0.95 metrics for the validation data.
+- Precision and Recall for the validation data
+
+## Parameters
+
+- Model Hyperparameters
+- All parameters passed through the command line options
+
+## Visualizations
+
+- Confusion Matrix of the model predictions on the validation data
+- Plots for the PR and F1 curves across all classes
+- Correlogram of the Class Labels
+
+## Configure Comet Logging
+
+Comet can be configured to log additional data either through command line flags passed to the training script or through environment variables.
+
+```shell
+export COMET_MODE=online # Set whether to run Comet in 'online' or 'offline' mode. Defaults to online
+export COMET_MODEL_NAME= #Set the name for the saved model. Defaults to yolov5
+export COMET_LOG_CONFUSION_MATRIX=false # Set to disable logging a Comet Confusion Matrix. Defaults to true
+export COMET_MAX_IMAGE_UPLOADS= # Controls how many total image predictions to log to Comet. Defaults to 100.
+export COMET_LOG_PER_CLASS_METRICS=true # Set to log evaluation metrics for each detected class at the end of training. Defaults to false
+export COMET_DEFAULT_CHECKPOINT_FILENAME= # Set this if you would like to resume training from a different checkpoint. Defaults to 'last.pt'
+export COMET_LOG_BATCH_LEVEL_METRICS=true # Set this if you would like to log training metrics at the batch level. Defaults to false.
+export COMET_LOG_PREDICTIONS=true # Set this to false to disable logging model predictions
+```
+
+## Logging Checkpoints with Comet
+
+Logging Models to Comet is disabled by default. To enable it, pass the `save-period` argument to the training script. This will save the logged checkpoints to Comet based on the interval value provided by `save-period`
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--save-period 1
+```
+
+## Logging Model Predictions
+
+By default, model predictions (images, ground truth labels and bounding boxes) will be logged to Comet.
+
+You can control the frequency of logged predictions and the associated images by passing the `bbox_interval` command line argument. Predictions can be visualized using Comet's Object Detection Custom Panel. This frequency corresponds to every Nth batch of data per epoch. In the example below, we are logging every 2nd batch of data for each epoch.
+
+**Note:** The YOLOv5 validation dataloader will default to a batch size of 32, so you will have to set the logging frequency accordingly.
+
+Here is an [example project using the Panel](https://www.comet.com/examples/comet-example-yolov5?shareable=YcwMiJaZSXfcEXpGOHDD12vA1&utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--bbox_interval 2
+```
+
+### Controlling the number of Prediction Images logged to Comet
+
+When logging predictions from YOLOv5, Comet will log the images associated with each set of predictions. By default a maximum of 100 validation images are logged. You can increase or decrease this number using the `COMET_MAX_IMAGE_UPLOADS` environment variable.
+
+```shell
+env COMET_MAX_IMAGE_UPLOADS=200 python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--bbox_interval 1
+```
+
+### Logging Class Level Metrics
+
+Use the `COMET_LOG_PER_CLASS_METRICS` environment variable to log mAP, precision, recall, f1 for each class.
+
+```shell
+env COMET_LOG_PER_CLASS_METRICS=true python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt
+```
+
+## Uploading a Dataset to Comet Artifacts
+
+If you would like to store your data using [Comet Artifacts](https://www.comet.com/docs/v2/guides/data-management/using-artifacts/#learn-more?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github), you can do so using the `upload_dataset` flag.
+
+The dataset be organized in the way described in the [YOLOv5 documentation](train_custom_data.md). The dataset config `yaml` file must follow the same format as that of the `coco128.yaml` file.
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--upload_dataset
+```
+
+You can find the uploaded dataset in the Artifacts tab in your Comet Workspace
+
+
+You can preview the data directly in the Comet UI.
+
+
+Artifacts are versioned and also support adding metadata about the dataset. Comet will automatically log the metadata from your dataset `yaml` file
+
+
+### Using a saved Artifact
+
+If you would like to use a dataset from Comet Artifacts, set the `path` variable in your dataset `yaml` file to point to the following Artifact resource URL.
+
+```
+# contents of artifact.yaml file
+path: "comet:///:"
+```
+
+Then pass this file to your training script in the following way
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data artifact.yaml \
+--weights yolov5s.pt
+```
+
+Artifacts also allow you to track the lineage of data as it flows through your Experimentation workflow. Here you can see a graph that shows you all the experiments that have used your uploaded dataset.
+
+
+## Resuming a Training Run
+
+If your training run is interrupted for any reason, e.g. disrupted internet connection, you can resume the run using the `resume` flag and the Comet Run Path.
+
+The Run Path has the following format `comet:////`.
+
+This will restore the run to its state before the interruption, which includes restoring the model from a checkpoint, restoring all hyperparameters and training arguments and downloading Comet dataset Artifacts if they were used in the original run. The resumed run will continue logging to the existing Experiment in the Comet UI
+
+```shell
+python train.py \
+--resume "comet://"
+```
+
+## Hyperparameter Search with the Comet Optimizer
+
+YOLOv5 is also integrated with Comet's Optimizer, making is simple to visualize hyperparameter sweeps in the Comet UI.
+
+### Configuring an Optimizer Sweep
+
+To configure the Comet Optimizer, you will have to create a JSON file with the information about the sweep. An example file has been provided in `utils/loggers/comet/optimizer_config.json`
+
+```shell
+python utils/loggers/comet/hpo.py \
+ --comet_optimizer_config "utils/loggers/comet/optimizer_config.json"
+```
+
+The `hpo.py` script accepts the same arguments as `train.py`. If you wish to pass additional arguments to your sweep simply add them after the script.
+
+```shell
+python utils/loggers/comet/hpo.py \
+ --comet_optimizer_config "utils/loggers/comet/optimizer_config.json" \
+ --save-period 1 \
+ --bbox_interval 1
+```
+
+### Running a Sweep in Parallel
+
+```shell
+comet optimizer -j utils/loggers/comet/hpo.py \
+ utils/loggers/comet/optimizer_config.json"
+```
+
+## Visualizing Results
+
+Comet provides a number of ways to visualize the results of your sweep. Take a look at a [project with a completed sweep here](https://www.comet.com/examples/comet-example-yolov5/view/PrlArHGuuhDTKC1UuBmTtOSXD/panels?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
+
+
diff --git a/ultralytics/docs/en/yolov5/tutorials/comet_logging_integration.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/comet_logging_integration.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/comet_logging_integration.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/hyperparameter_evolution.md b/ultralytics/docs/en/yolov5/tutorials/hyperparameter_evolution.md
new file mode 100755
index 0000000..13e29ca
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/hyperparameter_evolution.md
@@ -0,0 +1,166 @@
+---
+comments: true
+description: Learn how to optimize YOLOv5 with hyperparameter evolution using Genetic Algorithm. This guide provides steps to initialize, define, evolve and visualize hyperparameters for top performance.
+keywords: Ultralytics, YOLOv5, Hyperparameter Optimization, Genetic Algorithm, Machine Learning, Deep Learning, AI, Object Detection, Image Classification, Python
+---
+
+๐ This guide explains **hyperparameter evolution** for YOLOv5 ๐. Hyperparameter evolution is a method of [Hyperparameter Optimization](https://en.wikipedia.org/wiki/Hyperparameter_optimization) using a [Genetic Algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm) (GA) for optimization.
+
+Hyperparameters in ML control various aspects of training, and finding optimal values for them can be a challenge. Traditional methods like grid searches can quickly become intractable due to 1) the high dimensional search space 2) unknown correlations among the dimensions, and 3) expensive nature of evaluating the fitness at each point, making GA a suitable candidate for hyperparameter searches.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## 1. Initialize Hyperparameters
+
+YOLOv5 has about 30 hyperparameters used for various training settings. These are defined in `*.yaml` files in the `/data/hyps` directory. Better initial guesses will produce better final results, so it is important to initialize these values properly before evolving. If in doubt, simply use the default values, which are optimized for YOLOv5 COCO training from scratch.
+
+```yaml
+# YOLOv5 ๐ by Ultralytics, AGPL-3.0 license
+# Hyperparameters for low-augmentation COCO training from scratch
+# python train.py --batch 64 --cfg yolov5n6.yaml --weights '' --data coco.yaml --img 640 --epochs 300 --linear
+# See tutorials for hyperparameter evolution https://github.com/ultralytics/yolov5#tutorials
+
+lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
+lrf: 0.01 # final OneCycleLR learning rate (lr0 * lrf)
+momentum: 0.937 # SGD momentum/Adam beta1
+weight_decay: 0.0005 # optimizer weight decay 5e-4
+warmup_epochs: 3.0 # warmup epochs (fractions ok)
+warmup_momentum: 0.8 # warmup initial momentum
+warmup_bias_lr: 0.1 # warmup initial bias lr
+box: 0.05 # box loss gain
+cls: 0.5 # cls loss gain
+cls_pw: 1.0 # cls BCELoss positive_weight
+obj: 1.0 # obj loss gain (scale with pixels)
+obj_pw: 1.0 # obj BCELoss positive_weight
+iou_t: 0.20 # IoU training threshold
+anchor_t: 4.0 # anchor-multiple threshold
+# anchors: 3 # anchors per output layer (0 to ignore)
+fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
+hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
+hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
+hsv_v: 0.4 # image HSV-Value augmentation (fraction)
+degrees: 0.0 # image rotation (+/- deg)
+translate: 0.1 # image translation (+/- fraction)
+scale: 0.5 # image scale (+/- gain)
+shear: 0.0 # image shear (+/- deg)
+perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
+flipud: 0.0 # image flip up-down (probability)
+fliplr: 0.5 # image flip left-right (probability)
+mosaic: 1.0 # image mosaic (probability)
+mixup: 0.0 # image mixup (probability)
+copy_paste: 0.0 # segment copy-paste (probability)
+```
+
+## 2. Define Fitness
+
+Fitness is the value we seek to maximize. In YOLOv5 we define a default fitness function as a weighted combination of metrics: `mAP@0.5` contributes 10% of the weight and `mAP@0.5:0.95` contributes the remaining 90%, with [Precision `P` and Recall `R`](https://en.wikipedia.org/wiki/Precision_and_recall) absent. You may adjust these as you see fit or use the default fitness definition in utils/metrics.py (recommended).
+
+```python
+def fitness(x):
+ # Model fitness as a weighted combination of metrics
+ w = [0.0, 0.0, 0.1, 0.9] # weights for [P, R, mAP@0.5, mAP@0.5:0.95]
+ return (x[:, :4] * w).sum(1)
+```
+
+## 3. Evolve
+
+Evolution is performed about a base scenario which we seek to improve upon. The base scenario in this example is finetuning COCO128 for 10 epochs using pretrained YOLOv5s. The base scenario training command is:
+
+```bash
+python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache
+```
+
+To evolve hyperparameters **specific to this scenario**, starting from our initial values defined in **Section 1.**, and maximizing the fitness defined in **Section 2.**, append `--evolve`:
+
+```bash
+# Single-GPU
+python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --evolve
+
+# Multi-GPU
+for i in 0 1 2 3 4 5 6 7; do
+ sleep $(expr 30 \* $i) && # 30-second delay (optional)
+ echo 'Starting GPU '$i'...' &&
+ nohup python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --device $i --evolve > evolve_gpu_$i.log &
+done
+
+# Multi-GPU bash-while (not recommended)
+for i in 0 1 2 3 4 5 6 7; do
+ sleep $(expr 30 \* $i) && # 30-second delay (optional)
+ echo 'Starting GPU '$i'...' &&
+ "$(while true; do nohup python train.py... --device $i --evolve 1 > evolve_gpu_$i.log; done)" &
+done
+```
+
+The default evolution settings will run the base scenario 300 times, i.e. for 300 generations. You can modify generations via the `--evolve` argument, i.e. `python train.py --evolve 1000`.
+
+The main genetic operators are **crossover** and **mutation**. In this work mutation is used, with an 80% probability and a 0.04 variance to create new offspring based on a combination of the best parents from all previous generations. Results are logged to `runs/evolve/exp/evolve.csv`, and the highest fitness offspring is saved every generation as `runs/evolve/hyp_evolved.yaml`:
+
+```yaml
+# YOLOv5 Hyperparameter Evolution Results
+# Best generation: 287
+# Last generation: 300
+# metrics/precision, metrics/recall, metrics/mAP_0.5, metrics/mAP_0.5:0.95, val/box_loss, val/obj_loss, val/cls_loss
+# 0.54634, 0.55625, 0.58201, 0.33665, 0.056451, 0.042892, 0.013441
+
+lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
+lrf: 0.2 # final OneCycleLR learning rate (lr0 * lrf)
+momentum: 0.937 # SGD momentum/Adam beta1
+weight_decay: 0.0005 # optimizer weight decay 5e-4
+warmup_epochs: 3.0 # warmup epochs (fractions ok)
+warmup_momentum: 0.8 # warmup initial momentum
+warmup_bias_lr: 0.1 # warmup initial bias lr
+box: 0.05 # box loss gain
+cls: 0.5 # cls loss gain
+cls_pw: 1.0 # cls BCELoss positive_weight
+obj: 1.0 # obj loss gain (scale with pixels)
+obj_pw: 1.0 # obj BCELoss positive_weight
+iou_t: 0.20 # IoU training threshold
+anchor_t: 4.0 # anchor-multiple threshold
+# anchors: 3 # anchors per output layer (0 to ignore)
+fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
+hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
+hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
+hsv_v: 0.4 # image HSV-Value augmentation (fraction)
+degrees: 0.0 # image rotation (+/- deg)
+translate: 0.1 # image translation (+/- fraction)
+scale: 0.5 # image scale (+/- gain)
+shear: 0.0 # image shear (+/- deg)
+perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
+flipud: 0.0 # image flip up-down (probability)
+fliplr: 0.5 # image flip left-right (probability)
+mosaic: 1.0 # image mosaic (probability)
+mixup: 0.0 # image mixup (probability)
+copy_paste: 0.0 # segment copy-paste (probability)
+```
+
+We recommend a minimum of 300 generations of evolution for best results. Note that **evolution is generally expensive and time-consuming**, as the base scenario is trained hundreds of times, possibly requiring hundreds or thousands of GPU hours.
+
+## 4. Visualize
+
+`evolve.csv` is plotted as `evolve.png` by `utils.plots.plot_evolve()` after evolution finishes with one subplot per hyperparameter showing fitness (y-axis) vs hyperparameter values (x-axis). Yellow indicates higher concentrations. Vertical distributions indicate that a parameter has been disabled and does not mutate. This is user selectable in the `meta` dictionary in train.py, and is useful for fixing parameters and preventing them from evolving.
+
+
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/hyperparameter_evolution.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/hyperparameter_evolution.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/hyperparameter_evolution.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/model_ensembling.md b/ultralytics/docs/en/yolov5/tutorials/model_ensembling.md
new file mode 100755
index 0000000..767ed2a
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/model_ensembling.md
@@ -0,0 +1,146 @@
+---
+comments: true
+description: Learn how to ensemble YOLOv5 models for improved mAP and Recall! Clone the repo, install requirements, and start testing and inference.
+keywords: YOLOv5, object detection, ensemble learning, mAP, Recall
+---
+
+๐ This guide explains how to use YOLOv5 ๐ **model ensembling** during testing and inference for improved mAP and Recall.
+
+From [https://en.wikipedia.org/wiki/Ensemble_learning](https://en.wikipedia.org/wiki/Ensemble_learning):
+> Ensemble modeling is a process where multiple diverse models are created to predict an outcome, either by using many different modeling algorithms or using different training data sets. The ensemble model then aggregates the prediction of each base model and results in once final prediction for the unseen data. The motivation for using ensemble models is to reduce the generalization error of the prediction. As long as the base models are diverse and independent, the prediction error of the model decreases when the ensemble approach is used. The approach seeks the wisdom of crowds in making a prediction. Even though the ensemble model has multiple base models within the model, it acts and performs as a single model.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Test Normally
+
+Before ensembling we want to establish the baseline performance of a single model. This command tests YOLOv5x on COCO val2017 at image size 640 pixels. `yolov5x.pt` is the largest and most accurate model available. Other options are `yolov5s.pt`, `yolov5m.pt` and `yolov5l.pt`, or you own checkpoint from training a custom dataset `./weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```bash
+python val.py --weights yolov5x.pt --data coco.yaml --img 640 --half
+```
+
+Output:
+
+```shell
+val: data=./data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True
+YOLOv5 ๐ v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+Model Summary: 476 layers, 87730285 parameters, 0 gradients
+
+val: Scanning '../datasets/coco/val2017' images and labels...4952 found, 48 missing, 0 empty, 0 corrupted: 100% 5000/5000 [00:01<00:00, 2846.03it/s]
+val: New cache created: ../datasets/coco/val2017.cache
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [02:30<00:00, 1.05it/s]
+ all 5000 36335 0.746 0.626 0.68 0.49
+Speed: 0.1ms pre-process, 22.4ms inference, 1.4ms NMS per image at shape (32, 3, 640, 640) # <--- baseline speed
+
+Evaluating pycocotools mAP... saving runs/val/exp/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.504 # <--- baseline mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.688
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.546
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.351
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.551
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.644
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.382
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.628
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.681 # <--- baseline mAR
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.524
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.735
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.826
+```
+
+## Ensemble Test
+
+Multiple pretrained models may be ensembled together at test and inference time by simply appending extra models to the `--weights` argument in any existing val.py or detect.py command. This example tests an ensemble of 2 models together:
+
+- YOLOv5x
+- YOLOv5l6
+
+```bash
+python val.py --weights yolov5x.pt yolov5l6.pt --data coco.yaml --img 640 --half
+```
+
+Output:
+
+```shell
+val: data=./data/coco.yaml, weights=['yolov5x.pt', 'yolov5l6.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.6, task=val, device=, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True
+YOLOv5 ๐ v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+Model Summary: 476 layers, 87730285 parameters, 0 gradients # Model 1
+Fusing layers...
+Model Summary: 501 layers, 77218620 parameters, 0 gradients # Model 2
+Ensemble created with ['yolov5x.pt', 'yolov5l6.pt'] # Ensemble notice
+
+val: Scanning '../datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupted: 100% 5000/5000 [00:00<00:00, 49695545.02it/s]
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [03:58<00:00, 1.52s/it]
+ all 5000 36335 0.747 0.637 0.692 0.502
+Speed: 0.1ms pre-process, 39.5ms inference, 2.0ms NMS per image at shape (32, 3, 640, 640) # <--- ensemble speed
+
+Evaluating pycocotools mAP... saving runs/val/exp3/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.515 # <--- ensemble mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.699
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.557
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.356
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.563
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.668
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.387
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.638
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.689 # <--- ensemble mAR
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.526
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.743
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.844
+```
+
+## Ensemble Inference
+
+Append extra models to the `--weights` argument to run ensemble inference:
+
+```bash
+python detect.py --weights yolov5x.pt yolov5l6.pt --img 640 --source data/images
+```
+
+Output:
+
+```bash
+YOLOv5 ๐ v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+Model Summary: 476 layers, 87730285 parameters, 0 gradients
+Fusing layers...
+Model Summary: 501 layers, 77218620 parameters, 0 gradients
+Ensemble created with ['yolov5x.pt', 'yolov5l6.pt']
+
+image 1/2 /content/yolov5/data/images/bus.jpg: 640x512 4 persons, 1 bus, 1 tie, Done. (0.063s)
+image 2/2 /content/yolov5/data/images/zidane.jpg: 384x640 3 persons, 2 ties, Done. (0.056s)
+Results saved to runs/detect/exp2
+Done. (0.223s)
+```
+
+
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/model_ensembling.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/model_ensembling.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/model_ensembling.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/model_export.md b/ultralytics/docs/en/yolov5/tutorials/model_export.md
new file mode 100755
index 0000000..bb72f2e
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/model_export.md
@@ -0,0 +1,245 @@
+---
+comments: true
+description: Learn how to export a trained YOLOv5 model from PyTorch to different formats including TorchScript, ONNX, OpenVINO, TensorRT, and CoreML, and how to use these models.
+keywords: Ultralytics, YOLOv5, model export, PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, CoreML, TensorFlow
+---
+
+# TFLite, ONNX, CoreML, TensorRT Export
+
+๐ This guide explains how to export a trained YOLOv5 ๐ model from PyTorch to ONNX and TorchScript formats.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+For [TensorRT](https://developer.nvidia.com/tensorrt) export example (requires GPU) see our Colab [notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb#scrollTo=VTRwsvA9u7ln&line=2&uniqifier=1) appendix section.
+
+## Formats
+
+YOLOv5 inference is officially supported in 11 formats:
+
+๐ก ProTip: Export to ONNX or OpenVINO for up to 3x CPU speedup. See [CPU Benchmarks](https://github.com/ultralytics/yolov5/pull/6613). ๐ก ProTip: Export to TensorRT for up to 5x GPU speedup. See [GPU Benchmarks](https://github.com/ultralytics/yolov5/pull/6963).
+
+| Format | `export.py --include` | Model |
+|:---------------------------------------------------------------------------|:----------------------|:--------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov5s.pt` |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov5s.torchscript` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov5s.onnx` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov5s_openvino_model/` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov5s.engine` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov5s.mlmodel` |
+| [TensorFlow SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov5s_saved_model/` |
+| [TensorFlow GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov5s.pb` |
+| [TensorFlow Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov5s.tflite` |
+| [TensorFlow Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov5s_edgetpu.tflite` |
+| [TensorFlow.js](https://www.tensorflow.org/js) | `tfjs` | `yolov5s_web_model/` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov5s_paddle_model/` |
+
+## Benchmarks
+
+Benchmarks below run on a Colab Pro with the YOLOv5 tutorial notebook . To reproduce:
+
+```bash
+python benchmarks.py --weights yolov5s.pt --imgsz 640 --device 0
+```
+
+### Colab Pro V100 GPU
+
+```
+benchmarks: weights=/content/yolov5/yolov5s.pt, imgsz=640, batch_size=1, data=/content/yolov5/data/coco128.yaml, device=0, half=False, test=False
+Checking setup...
+YOLOv5 ๐ v6.1-135-g7926afc torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
+Setup complete โ (8 CPUs, 51.0 GB RAM, 46.7/166.8 GB disk)
+
+Benchmarks complete (458.07s)
+ Format mAP@0.5:0.95 Inference time (ms)
+0 PyTorch 0.4623 10.19
+1 TorchScript 0.4623 6.85
+2 ONNX 0.4623 14.63
+3 OpenVINO NaN NaN
+4 TensorRT 0.4617 1.89
+5 CoreML NaN NaN
+6 TensorFlow SavedModel 0.4623 21.28
+7 TensorFlow GraphDef 0.4623 21.22
+8 TensorFlow Lite NaN NaN
+9 TensorFlow Edge TPU NaN NaN
+10 TensorFlow.js NaN NaN
+```
+
+### Colab Pro CPU
+
+```
+benchmarks: weights=/content/yolov5/yolov5s.pt, imgsz=640, batch_size=1, data=/content/yolov5/data/coco128.yaml, device=cpu, half=False, test=False
+Checking setup...
+YOLOv5 ๐ v6.1-135-g7926afc torch 1.10.0+cu111 CPU
+Setup complete โ (8 CPUs, 51.0 GB RAM, 41.5/166.8 GB disk)
+
+Benchmarks complete (241.20s)
+ Format mAP@0.5:0.95 Inference time (ms)
+0 PyTorch 0.4623 127.61
+1 TorchScript 0.4623 131.23
+2 ONNX 0.4623 69.34
+3 OpenVINO 0.4623 66.52
+4 TensorRT NaN NaN
+5 CoreML NaN NaN
+6 TensorFlow SavedModel 0.4623 123.79
+7 TensorFlow GraphDef 0.4623 121.57
+8 TensorFlow Lite 0.4623 316.61
+9 TensorFlow Edge TPU NaN NaN
+10 TensorFlow.js NaN NaN
+```
+
+## Export a Trained YOLOv5 Model
+
+This command exports a pretrained YOLOv5s model to TorchScript and ONNX formats. `yolov5s.pt` is the 'small' model, the second-smallest model available. Other options are `yolov5n.pt`, `yolov5m.pt`, `yolov5l.pt` and `yolov5x.pt`, along with their P6 counterparts i.e. `yolov5s6.pt` or you own custom training checkpoint i.e. `runs/exp/weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```bash
+python export.py --weights yolov5s.pt --include torchscript onnx
+```
+
+๐ก ProTip: Add `--half` to export models at FP16 half precision for smaller file sizes
+
+Output:
+
+```bash
+export: data=data/coco128.yaml, weights=['yolov5s.pt'], imgsz=[640, 640], batch_size=1, device=cpu, half=False, inplace=False, train=False, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=12, verbose=False, workspace=4, nms=False, agnostic_nms=False, topk_per_class=100, topk_all=100, iou_thres=0.45, conf_thres=0.25, include=['torchscript', 'onnx']
+YOLOv5 ๐ v6.2-104-ge3e5122 Python-3.8.0 torch-1.12.1+cu113 CPU
+
+Downloading https://github.com/ultralytics/yolov5/releases/download/v6.2/yolov5s.pt to yolov5s.pt...
+100% 14.1M/14.1M [00:00<00:00, 274MB/s]
+
+Fusing layers...
+YOLOv5s summary: 213 layers, 7225885 parameters, 0 gradients
+
+PyTorch: starting from yolov5s.pt with output shape (1, 25200, 85) (14.1 MB)
+
+TorchScript: starting export with torch 1.12.1+cu113...
+TorchScript: export success โ 1.7s, saved as yolov5s.torchscript (28.1 MB)
+
+ONNX: starting export with onnx 1.12.0...
+ONNX: export success โ 2.3s, saved as yolov5s.onnx (28.0 MB)
+
+Export complete (5.5s)
+Results saved to /content/yolov5
+Detect: python detect.py --weights yolov5s.onnx
+Validate: python val.py --weights yolov5s.onnx
+PyTorch Hub: model = torch.hub.load('ultralytics/yolov5', 'custom', 'yolov5s.onnx')
+Visualize: https://netron.app/
+```
+
+The 3 exported models will be saved alongside the original PyTorch model:
+
+
+[Netron Viewer](https://github.com/lutzroeder/netron) is recommended for visualizing exported models:
+
+
+## Exported Model Usage Examples
+
+`detect.py` runs inference on exported models:
+
+```bash
+python detect.py --weights yolov5s.pt # PyTorch
+ yolov5s.torchscript # TorchScript
+ yolov5s.onnx # ONNX Runtime or OpenCV DNN with dnn=True
+ yolov5s_openvino_model # OpenVINO
+ yolov5s.engine # TensorRT
+ yolov5s.mlmodel # CoreML (macOS only)
+ yolov5s_saved_model # TensorFlow SavedModel
+ yolov5s.pb # TensorFlow GraphDef
+ yolov5s.tflite # TensorFlow Lite
+ yolov5s_edgetpu.tflite # TensorFlow Edge TPU
+ yolov5s_paddle_model # PaddlePaddle
+```
+
+`val.py` runs validation on exported models:
+
+```bash
+python val.py --weights yolov5s.pt # PyTorch
+ yolov5s.torchscript # TorchScript
+ yolov5s.onnx # ONNX Runtime or OpenCV DNN with dnn=True
+ yolov5s_openvino_model # OpenVINO
+ yolov5s.engine # TensorRT
+ yolov5s.mlmodel # CoreML (macOS Only)
+ yolov5s_saved_model # TensorFlow SavedModel
+ yolov5s.pb # TensorFlow GraphDef
+ yolov5s.tflite # TensorFlow Lite
+ yolov5s_edgetpu.tflite # TensorFlow Edge TPU
+ yolov5s_paddle_model # PaddlePaddle
+```
+
+Use PyTorch Hub with exported YOLOv5 models:
+
+``` python
+import torch
+
+# Model
+model = torch.hub.load('ultralytics/yolov5', 'custom', 'yolov5s.pt')
+ 'yolov5s.torchscript ') # TorchScript
+ 'yolov5s.onnx') # ONNX Runtime
+ 'yolov5s_openvino_model') # OpenVINO
+ 'yolov5s.engine') # TensorRT
+ 'yolov5s.mlmodel') # CoreML (macOS Only)
+ 'yolov5s_saved_model') # TensorFlow SavedModel
+ 'yolov5s.pb') # TensorFlow GraphDef
+ 'yolov5s.tflite') # TensorFlow Lite
+ 'yolov5s_edgetpu.tflite') # TensorFlow Edge TPU
+ 'yolov5s_paddle_model') # PaddlePaddle
+
+# Images
+img = 'https://ultralytics.com/images/zidane.jpg' # or file, Path, PIL, OpenCV, numpy, list
+
+# Inference
+results = model(img)
+
+# Results
+results.print() # or .show(), .save(), .crop(), .pandas(), etc.
+```
+
+## OpenCV DNN inference
+
+OpenCV inference with ONNX models:
+
+```bash
+python export.py --weights yolov5s.pt --include onnx
+
+python detect.py --weights yolov5s.onnx --dnn # detect
+python val.py --weights yolov5s.onnx --dnn # validate
+```
+
+## C++ Inference
+
+YOLOv5 OpenCV DNN C++ inference on exported ONNX model examples:
+
+- [https://github.com/Hexmagic/ONNX-yolov5/blob/master/src/test.cpp](https://github.com/Hexmagic/ONNX-yolov5/blob/master/src/test.cpp)
+- [https://github.com/doleron/yolov5-opencv-cpp-python](https://github.com/doleron/yolov5-opencv-cpp-python)
+
+YOLOv5 OpenVINO C++ inference examples:
+
+- [https://github.com/dacquaviva/yolov5-openvino-cpp-python](https://github.com/dacquaviva/yolov5-openvino-cpp-python)
+- [https://github.com/UNeedCryDear/yolov5-seg-opencv-dnn-cpp](https://github.com/UNeedCryDear/yolov5-seg-opencv-dnn-cpp)
+
+## TensorFlow.js Web Browser Inference
+
+- [https://aukerul-shuvo.github.io/YOLOv5_TensorFlow-JS/](https://aukerul-shuvo.github.io/YOLOv5_TensorFlow-JS/)
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/model_export.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/model_export.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/model_export.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/model_pruning_and_sparsity.md b/ultralytics/docs/en/yolov5/tutorials/model_pruning_and_sparsity.md
new file mode 100755
index 0000000..fddd1c6
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/model_pruning_and_sparsity.md
@@ -0,0 +1,110 @@
+---
+comments: true
+description: Improve YOLOv5 model efficiency by pruning with Ultralytics. Understand the process, conduct tests and view the impact on accuracy and sparsity. Test-maintained API environments.
+keywords: YOLOv5, YOLO, Ultralytics, model pruning, PyTorch, machine learning, deep learning, computer vision, object detection
+---
+
+๐ This guide explains how to apply **pruning** to YOLOv5 ๐ models.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Test Normally
+
+Before pruning we want to establish a baseline performance to compare to. This command tests YOLOv5x on COCO val2017 at image size 640 pixels. `yolov5x.pt` is the largest and most accurate model available. Other options are `yolov5s.pt`, `yolov5m.pt` and `yolov5l.pt`, or you own checkpoint from training a custom dataset `./weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```bash
+python val.py --weights yolov5x.pt --data coco.yaml --img 640 --half
+```
+
+Output:
+
+```shell
+val: data=/content/yolov5/data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, workers=8, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True, dnn=False
+YOLOv5 ๐ v6.0-224-g4c40933 torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
+
+Fusing layers...
+Model Summary: 444 layers, 86705005 parameters, 0 gradients
+val: Scanning '/content/datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupt: 100% 5000/5000 [00:00, ?it/s]
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [01:12<00:00, 2.16it/s]
+ all 5000 36335 0.732 0.628 0.683 0.496
+Speed: 0.1ms pre-process, 5.2ms inference, 1.7ms NMS per image at shape (32, 3, 640, 640) # <--- base speed
+
+Evaluating pycocotools mAP... saving runs/val/exp2/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.507 # <--- base mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.689
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.552
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.345
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.559
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.652
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.381
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.630
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.682
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.526
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.731
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.829
+Results saved to runs/val/exp
+```
+
+## Test YOLOv5x on COCO (0.30 sparsity)
+
+We repeat the above test with a pruned model by using the `torch_utils.prune()` command. We update `val.py` to prune YOLOv5x to 0.3 sparsity:
+
+
+
+30% pruned output:
+
+```bash
+val: data=/content/yolov5/data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, workers=8, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True, dnn=False
+YOLOv5 ๐ v6.0-224-g4c40933 torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
+
+Fusing layers...
+Model Summary: 444 layers, 86705005 parameters, 0 gradients
+Pruning model... 0.3 global sparsity
+val: Scanning '/content/datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupt: 100% 5000/5000 [00:00, ?it/s]
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [01:11<00:00, 2.19it/s]
+ all 5000 36335 0.724 0.614 0.671 0.478
+Speed: 0.1ms pre-process, 5.2ms inference, 1.7ms NMS per image at shape (32, 3, 640, 640) # <--- prune mAP
+
+Evaluating pycocotools mAP... saving runs/val/exp3/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.489 # <--- prune mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.677
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.537
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.334
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.542
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.635
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.370
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.612
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.664
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.496
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.722
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.803
+Results saved to runs/val/exp3
+```
+
+In the results we can observe that we have achieved a **sparsity of 30%** in our model after pruning, which means that 30% of the model's weight parameters in `nn.Conv2d` layers are equal to 0. **Inference time is essentially unchanged**, while the model's **AP and AR scores a slightly reduced**.
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/model_pruning_and_sparsity.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/model_pruning_and_sparsity.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/model_pruning_and_sparsity.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/multi_gpu_training.md b/ultralytics/docs/en/yolov5/tutorials/multi_gpu_training.md
new file mode 100755
index 0000000..35c17fd
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/multi_gpu_training.md
@@ -0,0 +1,190 @@
+---
+comments: true
+description: Learn how to train datasets on single or multiple GPUs using YOLOv5. Includes setup, training modes and result profiling for efficient leveraging of multiple GPUs.
+keywords: YOLOv5, multi-GPU Training, YOLOv5 training, deep learning, machine learning, object detection, Ultralytics
+---
+
+๐ This guide explains how to properly use **multiple** GPUs to train a dataset with YOLOv5 ๐ on single or multiple machine(s).
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+๐ก ProTip! **Docker Image** is recommended for all Multi-GPU trainings. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+๐ก ProTip! `torch.distributed.run` replaces `torch.distributed.launch` in **PyTorch>=1.9**. See [docs](https://pytorch.org/docs/stable/distributed.html) for details.
+
+## Training
+
+Select a pretrained model to start training from. Here we select [YOLOv5s](https://github.com/ultralytics/yolov5/blob/master/models/yolov5s.yaml), the smallest and fastest model available. See our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints) for a full comparison of all models. We will train this model with Multi-GPU on the [COCO](https://github.com/ultralytics/yolov5/blob/master/data/scripts/get_coco.sh) dataset.
+
+
+
+### Single GPU
+
+```bash
+python train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0
+```
+
+### Multi-GPU [DataParallel](https://pytorch.org/docs/stable/nn.html#torch.nn.DataParallel) Mode (โ ๏ธ not recommended)
+
+You can increase the `device` to use Multiple GPUs in DataParallel mode.
+
+```bash
+python train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0,1
+```
+
+This method is slow and barely speeds up training compared to using just 1 GPU.
+
+### Multi-GPU [DistributedDataParallel](https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel) Mode (โ recommended)
+
+You will have to pass `python -m torch.distributed.run --nproc_per_node`, followed by the usual arguments.
+
+```bash
+python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --weights yolov5s.pt --device 0,1
+```
+
+`--nproc_per_node` specifies how many GPUs you would like to use. In the example above, it is 2.
+`--batch ` is the total batch-size. It will be divided evenly to each GPU. In the example above, it is 64/2=32 per GPU.
+
+The code above will use GPUs `0... (N-1)`.
+
+
+ Use specific GPUs (click to expand)
+
+You can do so by simply passing `--device` followed by your specific GPUs. For example, in the code below, we will use GPUs `2,3`.
+
+```bash
+python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --device 2,3
+```
+
+
+
+
+ Use SyncBatchNorm (click to expand)
+
+[SyncBatchNorm](https://pytorch.org/docs/master/generated/torch.nn.SyncBatchNorm.html) could increase accuracy for multiple gpu training, however, it will slow down training by a significant factor. It is **only** available for Multiple GPU DistributedDataParallel training.
+
+It is best used when the batch-size on **each** GPU is small (<= 8).
+
+To use SyncBatchNorm, simple pass `--sync-bn` to the command like below,
+
+```bash
+python -m torch.distributed.run --nproc_per_node 2 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights '' --sync-bn
+```
+
+
+
+
+ Use Multiple machines (click to expand)
+
+This is **only** available for Multiple GPU DistributedDataParallel training.
+
+Before we continue, make sure the files on all machines are the same, dataset, codebase, etc. Afterward, make sure the machines can communicate to each other.
+
+You will have to choose a master machine(the machine that the others will talk to). Note down its address(`master_addr`) and choose a port(`master_port`). I will use `master_addr = 192.168.1.1` and `master_port = 1234` for the example below.
+
+To use it, you can do as the following,
+
+```bash
+# On master machine 0
+python -m torch.distributed.run --nproc_per_node G --nnodes N --node_rank 0 --master_addr "192.168.1.1" --master_port 1234 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights ''
+```
+
+```bash
+# On machine R
+python -m torch.distributed.run --nproc_per_node G --nnodes N --node_rank R --master_addr "192.168.1.1" --master_port 1234 train.py --batch 64 --data coco.yaml --cfg yolov5s.yaml --weights ''
+```
+
+where `G` is number of GPU per machine, `N` is the number of machines, and `R` is the machine number from `0...(N-1)`. Let's say I have two machines with two GPUs each, it would be `G = 2` , `N = 2`, and `R = 1` for the above.
+
+Training will not start until all `N` machines are connected. Output will only be shown on master machine!
+
+
+
+### Notes
+
+- Windows support is untested, Linux is recommended.
+- `--batch ` must be a multiple of the number of GPUs.
+- GPU 0 will take slightly more memory than the other GPUs as it maintains EMA and is responsible for checkpointing etc.
+- If you get `RuntimeError: Address already in use`, it could be because you are running multiple trainings at a time. To fix this, simply use a different port number by adding `--master_port` like below,
+
+```bash
+python -m torch.distributed.run --master_port 1234 --nproc_per_node 2 ...
+```
+
+## Results
+
+DDP profiling results on an [AWS EC2 P4d instance](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/) with 8x A100 SXM4-40GB for YOLOv5l for 1 COCO epoch.
+
+
+ Profiling code
+
+```bash
+# prepare
+t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/coco:/usr/src/coco $t
+pip3 install torch==1.9.0+cu111 torchvision==0.10.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html
+cd .. && rm -rf app && git clone https://github.com/ultralytics/yolov5 -b master app && cd app
+cp data/coco.yaml data/coco_profile.yaml
+
+# profile
+python train.py --batch-size 16 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0
+python -m torch.distributed.run --nproc_per_node 2 train.py --batch-size 32 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1
+python -m torch.distributed.run --nproc_per_node 4 train.py --batch-size 64 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1,2,3
+python -m torch.distributed.run --nproc_per_node 8 train.py --batch-size 128 --data coco_profile.yaml --weights yolov5l.pt --epochs 1 --device 0,1,2,3,4,5,6,7
+```
+
+
+
+| GPUs A100 | batch-size | CUDA_mem device0 (G) | COCO train | COCO val |
+|--------------|------------|------------------------------|--------------------|------------------|
+| 1x | 16 | 26GB | 20:39 | 0:55 |
+| 2x | 32 | 26GB | 11:43 | 0:57 |
+| 4x | 64 | 26GB | 5:57 | 0:55 |
+| 8x | 128 | 26GB | 3:09 | 0:57 |
+
+## FAQ
+
+If an error occurs, please read the checklist below first! (It could save your time)
+
+
+ Checklist (click to expand)
+
+
+
Have you properly read this post?
+
Have you tried to re-clone the codebase? The code changes daily.
+
Have you tried to search for your error? Someone may have already encountered it in this repo or in another and have the solution.
+
Have you installed all the requirements listed on top (including the correct Python and Pytorch versions)?
+
Have you tried in other environments listed in the "Environments" section below?
+
Have you tried with another dataset like coco128 or coco2017? It will make it easier to find the root cause.
+
+
+If you went through all the above, feel free to raise an Issue by giving as much detail as possible following the template.
+
+
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
+
+## Credits
+
+We would like to thank @MagicFrogSJTU, who did all the heavy lifting, and @glenn-jocher for guiding us along the way.
diff --git a/ultralytics/docs/en/yolov5/tutorials/multi_gpu_training.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/multi_gpu_training.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/multi_gpu_training.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/neural_magic_pruning_quantization.md b/ultralytics/docs/en/yolov5/tutorials/neural_magic_pruning_quantization.md
new file mode 100755
index 0000000..e0c2528
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/neural_magic_pruning_quantization.md
@@ -0,0 +1,264 @@
+---
+comments: true
+description: Explore how to achieve exceptional AI performance with DeepSparse's incredible inference speed. Discover how to deploy YOLOv5, and learn about model sparsification and fine-tuning with SparseML.
+keywords: YOLOv5, DeepSparse, Ultralytics, Neural Magic, sparsification, inference runtime, deep learning, deployment, model fine-tuning, SparseML, AI performance, GPU-class performance
+---
+
+
+
+Welcome to software-delivered AI.
+
+This guide explains how to deploy YOLOv5 with Neural Magic's DeepSparse.
+
+DeepSparse is an inference runtime with exceptional performance on CPUs. For instance, compared to the ONNX Runtime baseline, DeepSparse offers a 5.8x speed-up for YOLOv5s, running on the same machine!
+
+
+
+
+
+For the first time, your deep learning workloads can meet the performance demands of production without the complexity and costs of hardware accelerators. Put simply, DeepSparse gives you the performance of GPUs and the simplicity of software:
+
+- **Flexible Deployments**: Run consistently across cloud, data center, and edge with any hardware provider from Intel to AMD to ARM
+- **Infinite Scalability**: Scale vertically to 100s of cores, out with standard Kubernetes, or fully-abstracted with Serverless
+- **Easy Integration**: Clean APIs for integrating your model into an application and monitoring it in production
+
+### How Does DeepSparse Achieve GPU-Class Performance?
+
+DeepSparse takes advantage of model sparsity to gain its performance speedup.
+
+Sparsification through pruning and quantization is a broadly studied technique, allowing order-of-magnitude reductions in the size and compute needed to execute a network, while maintaining high accuracy. DeepSparse is sparsity-aware, meaning it skips the zeroed out parameters, shrinking amount of compute in a forward pass. Since the sparse computation is now memory bound, DeepSparse executes the network depth-wise, breaking the problem into Tensor Columns, vertical stripes of computation that fit in cache.
+
+
+
+
+
+Sparse networks with compressed computation, executed depth-wise in cache, allows DeepSparse to deliver GPU-class performance on CPUs!
+
+### How Do I Create A Sparse Version of YOLOv5 Trained on My Data?
+
+Neural Magic's open-source model repository, SparseZoo, contains pre-sparsified checkpoints of each YOLOv5 model. Using SparseML, which is integrated with Ultralytics, you can fine-tune a sparse checkpoint onto your data with a single CLI command.
+
+[Checkout Neural Magic's YOLOv5 documentation for more details](https://docs.neuralmagic.com/use-cases/object-detection/sparsifying).
+
+## DeepSparse Usage
+
+We will walk through an example benchmarking and deploying a sparse version of YOLOv5s with DeepSparse.
+
+### Install DeepSparse
+
+Run the following to install DeepSparse. We recommend you use a virtual environment with Python.
+
+```bash
+pip install "deepsparse[server,yolo,onnxruntime]"
+```
+
+### Collect an ONNX File
+
+DeepSparse accepts a model in the ONNX format, passed either as:
+
+- A SparseZoo stub which identifies an ONNX file in the SparseZoo
+- A local path to an ONNX model in a filesystem
+
+The examples below use the standard dense and pruned-quantized YOLOv5s checkpoints, identified by the following SparseZoo stubs:
+
+```bash
+zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
+zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
+```
+
+### Deploy a Model
+
+DeepSparse offers convenient APIs for integrating your model into an application.
+
+To try the deployment examples below, pull down a sample image and save it as `basilica.jpg` with the following:
+
+```bash
+wget -O basilica.jpg https://raw.githubusercontent.com/neuralmagic/deepsparse/main/src/deepsparse/yolo/sample_images/basilica.jpg
+```
+
+#### Python API
+
+`Pipelines` wrap pre-processing and output post-processing around the runtime, providing a clean interface for adding DeepSparse to an application. The DeepSparse-Ultralytics integration includes an out-of-the-box `Pipeline` that accepts raw images and outputs the bounding boxes.
+
+Create a `Pipeline` and run inference:
+
+```python
+from deepsparse import Pipeline
+
+# list of images in local filesystem
+images = ["basilica.jpg"]
+
+# create Pipeline
+model_stub = "zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none"
+yolo_pipeline = Pipeline.create(
+ task="yolo",
+ model_path=model_stub,
+)
+
+# run inference on images, receive bounding boxes + classes
+pipeline_outputs = yolo_pipeline(images=images, iou_thres=0.6, conf_thres=0.001)
+print(pipeline_outputs)
+```
+
+If you are running in the cloud, you may get an error that open-cv cannot find `libGL.so.1`. Running the following on Ubuntu installs it:
+
+```
+apt-get install libgl1
+```
+
+#### HTTP Server
+
+DeepSparse Server runs on top of the popular FastAPI web framework and Uvicorn web server. With just a single CLI command, you can easily setup a model service endpoint with DeepSparse. The Server supports any Pipeline from DeepSparse, including object detection with YOLOv5, enabling you to send raw images to the endpoint and receive the bounding boxes.
+
+Spin up the Server with the pruned-quantized YOLOv5s:
+
+```bash
+deepsparse.server \
+ --task yolo \
+ --model_path zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
+```
+
+An example request, using Python's `requests` package:
+
+```python
+import requests, json
+
+# list of images for inference (local files on client side)
+path = ['basilica.jpg']
+files = [('request', open(img, 'rb')) for img in path]
+
+# send request over HTTP to /predict/from_files endpoint
+url = 'http://0.0.0.0:5543/predict/from_files'
+resp = requests.post(url=url, files=files)
+
+# response is returned in JSON
+annotations = json.loads(resp.text) # dictionary of annotation results
+bounding_boxes = annotations["boxes"]
+labels = annotations["labels"]
+```
+
+#### Annotate CLI
+
+You can also use the annotate command to have the engine save an annotated photo on disk. Try --source 0 to annotate your live webcam feed!
+
+```bash
+deepsparse.object_detection.annotate --model_filepath zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none --source basilica.jpg
+```
+
+Running the above command will create an `annotation-results` folder and save the annotated image inside.
+
+
+
+
+
+## Benchmarking Performance
+
+We will compare DeepSparse's throughput to ONNX Runtime's throughput on YOLOv5s, using DeepSparse's benchmarking script.
+
+The benchmarks were run on an AWS `c6i.8xlarge` instance (16 cores).
+
+### Batch 32 Performance Comparison
+
+#### ONNX Runtime Baseline
+
+At batch 32, ONNX Runtime achieves 42 images/sec with the standard dense YOLOv5s:
+
+```bash
+deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 32 -nstreams 1 -e onnxruntime
+
+> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
+> Batch Size: 32
+> Scenario: sync
+> Throughput (items/sec): 41.9025
+```
+
+#### DeepSparse Dense Performance
+
+While DeepSparse offers its best performance with optimized sparse models, it also performs well with the standard dense YOLOv5s.
+
+At batch 32, DeepSparse achieves 70 images/sec with the standard dense YOLOv5s, a **1.7x performance improvement over ORT**!
+
+```bash
+deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 32 -nstreams 1
+
+> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
+> Batch Size: 32
+> Scenario: sync
+> Throughput (items/sec): 69.5546
+```
+
+#### DeepSparse Sparse Performance
+
+When sparsity is applied to the model, DeepSparse's performance gains over ONNX Runtime is even stronger.
+
+At batch 32, DeepSparse achieves 241 images/sec with the pruned-quantized YOLOv5s, a **5.8x performance improvement over ORT**!
+
+```bash
+deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 32 -nstreams 1
+
+> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
+> Batch Size: 32
+> Scenario: sync
+> Throughput (items/sec): 241.2452
+```
+
+### Batch 1 Performance Comparison
+
+DeepSparse is also able to gain a speed-up over ONNX Runtime for the latency-sensitive, batch 1 scenario.
+
+#### ONNX Runtime Baseline
+
+At batch 1, ONNX Runtime achieves 48 images/sec with the standard, dense YOLOv5s.
+
+```bash
+deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none -s sync -b 1 -nstreams 1 -e onnxruntime
+
+> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/base-none
+> Batch Size: 1
+> Scenario: sync
+> Throughput (items/sec): 48.0921
+```
+
+#### DeepSparse Sparse Performance
+
+At batch 1, DeepSparse achieves 135 items/sec with a pruned-quantized YOLOv5s, **a 2.8x performance gain over ONNX Runtime!**
+
+```bash
+deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none -s sync -b 1 -nstreams 1
+
+> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned65_quant-none
+> Batch Size: 1
+> Scenario: sync
+> Throughput (items/sec): 134.9468
+```
+
+Since `c6i.8xlarge` instances have VNNI instructions, DeepSparse's throughput can be pushed further if weights are pruned in blocks of 4.
+
+At batch 1, DeepSparse achieves 180 items/sec with a 4-block pruned-quantized YOLOv5s, a **3.7x performance gain over ONNX Runtime!**
+
+```bash
+deepsparse.benchmark zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni -s sync -b 1 -nstreams 1
+
+> Original Model Path: zoo:cv/detection/yolov5-s/pytorch/ultralytics/coco/pruned35_quant-none-vnni
+> Batch Size: 1
+> Scenario: sync
+> Throughput (items/sec): 179.7375
+```
+
+## Get Started With DeepSparse
+
+**Research or Testing?** DeepSparse Community is free for research and testing. Get started with our [Documentation](https://docs.neuralmagic.com/).
diff --git a/ultralytics/docs/en/yolov5/tutorials/neural_magic_pruning_quantization.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/neural_magic_pruning_quantization.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/neural_magic_pruning_quantization.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/pytorch_hub_model_loading.md b/ultralytics/docs/en/yolov5/tutorials/pytorch_hub_model_loading.md
new file mode 100755
index 0000000..4cc828d
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/pytorch_hub_model_loading.md
@@ -0,0 +1,372 @@
+---
+comments: true
+description: Detailed guide on loading YOLOv5 from PyTorch Hub. Includes examples & tips on inference settings, multi-GPU inference, training and more.
+keywords: Ultralytics, YOLOv5, PyTorch, loading YOLOv5, PyTorch Hub, inference, multi-GPU inference, training
+---
+
+๐ This guide explains how to load YOLOv5 ๐ from PyTorch Hub at [https://pytorch.org/hub/ultralytics_yolov5](https://pytorch.org/hub/ultralytics_yolov5).
+
+## Before You Start
+
+Install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+pip install -r https://raw.githubusercontent.com/ultralytics/yolov5/master/requirements.txt
+```
+
+๐ก ProTip: Cloning [https://github.com/ultralytics/yolov5](https://github.com/ultralytics/yolov5) is **not** required ๐
+
+## Load YOLOv5 with PyTorch Hub
+
+### Simple Example
+
+This example loads a pretrained YOLOv5s model from PyTorch Hub as `model` and passes an image for inference. `'yolov5s'` is the lightest and fastest YOLOv5 model. For details on all available models please see the [README](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```python
+import torch
+
+# Model
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
+
+# Image
+im = 'https://ultralytics.com/images/zidane.jpg'
+
+# Inference
+results = model(im)
+
+results.pandas().xyxy[0]
+# xmin ymin xmax ymax confidence class name
+# 0 749.50 43.50 1148.0 704.5 0.874023 0 person
+# 1 433.50 433.50 517.5 714.5 0.687988 27 tie
+# 2 114.75 195.75 1095.0 708.0 0.624512 0 person
+# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie
+```
+
+### Detailed Example
+
+This example shows **batched inference** with **PIL** and **OpenCV** image sources. `results` can be **printed** to console, **saved** to `runs/hub`, **showed** to screen on supported environments, and returned as **tensors** or **pandas** dataframes.
+
+```python
+import cv2
+import torch
+from PIL import Image
+
+# Model
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
+
+# Images
+for f in 'zidane.jpg', 'bus.jpg':
+ torch.hub.download_url_to_file('https://ultralytics.com/images/' + f, f) # download 2 images
+im1 = Image.open('zidane.jpg') # PIL image
+im2 = cv2.imread('bus.jpg')[..., ::-1] # OpenCV image (BGR to RGB)
+
+# Inference
+results = model([im1, im2], size=640) # batch of images
+
+# Results
+results.print()
+results.save() # or .show()
+
+results.xyxy[0] # im1 predictions (tensor)
+results.pandas().xyxy[0] # im1 predictions (pandas)
+# xmin ymin xmax ymax confidence class name
+# 0 749.50 43.50 1148.0 704.5 0.874023 0 person
+# 1 433.50 433.50 517.5 714.5 0.687988 27 tie
+# 2 114.75 195.75 1095.0 708.0 0.624512 0 person
+# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie
+```
+
+
+
+
+For all inference options see YOLOv5 `AutoShape()` forward [method](https://github.com/ultralytics/yolov5/blob/30e4c4f09297b67afedf8b2bcd851833ddc9dead/models/common.py#L243-L252).
+
+### Inference Settings
+
+YOLOv5 models contain various inference attributes such as **confidence threshold**, **IoU threshold**, etc. which can be set by:
+
+```python
+model.conf = 0.25 # NMS confidence threshold
+iou = 0.45 # NMS IoU threshold
+agnostic = False # NMS class-agnostic
+multi_label = False # NMS multiple labels per box
+classes = None # (optional list) filter by class, i.e. = [0, 15, 16] for COCO persons, cats and dogs
+max_det = 1000 # maximum number of detections per image
+amp = False # Automatic Mixed Precision (AMP) inference
+
+results = model(im, size=320) # custom inference size
+```
+
+### Device
+
+Models can be transferred to any device after creation:
+
+```python
+model.cpu() # CPU
+model.cuda() # GPU
+model.to(device) # i.e. device=torch.device(0)
+```
+
+Models can also be created directly on any `device`:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', device='cpu') # load on CPU
+```
+
+๐ก ProTip: Input images are automatically transferred to the correct model device before inference.
+
+### Silence Outputs
+
+Models can be loaded silently with `_verbose=False`:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', _verbose=False) # load silently
+```
+
+### Input Channels
+
+To load a pretrained YOLOv5s model with 4 input channels rather than the default 3:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', channels=4)
+```
+
+In this case the model will be composed of pretrained weights **except for** the very first input layer, which is no longer the same shape as the pretrained input layer. The input layer will remain initialized by random weights.
+
+### Number of Classes
+
+To load a pretrained YOLOv5s model with 10 output classes rather than the default 80:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', classes=10)
+```
+
+In this case the model will be composed of pretrained weights **except for** the output layers, which are no longer the same shape as the pretrained output layers. The output layers will remain initialized by random weights.
+
+### Force Reload
+
+If you run into problems with the above steps, setting `force_reload=True` may help by discarding the existing cache and force a fresh download of the latest YOLOv5 version from PyTorch Hub.
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', force_reload=True) # force reload
+```
+
+### Screenshot Inference
+
+To run inference on your desktop screen:
+
+```python
+import torch
+from PIL import ImageGrab
+
+# Model
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
+
+# Image
+im = ImageGrab.grab() # take a screenshot
+
+# Inference
+results = model(im)
+```
+
+### Multi-GPU Inference
+
+YOLOv5 models can be loaded to multiple GPUs in parallel with threaded inference:
+
+```python
+import torch
+import threading
+
+
+def run(model, im):
+ results = model(im)
+ results.save()
+
+
+# Models
+model0 = torch.hub.load('ultralytics/yolov5', 'yolov5s', device=0)
+model1 = torch.hub.load('ultralytics/yolov5', 'yolov5s', device=1)
+
+# Inference
+threading.Thread(target=run, args=[model0, 'https://ultralytics.com/images/zidane.jpg'], daemon=True).start()
+threading.Thread(target=run, args=[model1, 'https://ultralytics.com/images/bus.jpg'], daemon=True).start()
+```
+
+### Training
+
+To load a YOLOv5 model for training rather than inference, set `autoshape=False`. To load a model with randomly initialized weights (to train from scratch) use `pretrained=False`. You must provide your own training script in this case. Alternatively see our YOLOv5 [Train Custom Data Tutorial](https://docs.ultralytics.com/yolov5/tutorials/train_custom_data) for model training.
+
+```python
+import torch
+
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', autoshape=False) # load pretrained
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', autoshape=False, pretrained=False) # load scratch
+```
+
+### Base64 Results
+
+For use with API services. See https://github.com/ultralytics/yolov5/pull/2291 and [Flask REST API](https://github.com/ultralytics/yolov5/tree/master/utils/flask_rest_api) example for details.
+
+```python
+results = model(im) # inference
+
+results.ims # array of original images (as np array) passed to model for inference
+results.render() # updates results.ims with boxes and labels
+for im in results.ims:
+ buffered = BytesIO()
+ im_base64 = Image.fromarray(im)
+ im_base64.save(buffered, format="JPEG")
+ print(base64.b64encode(buffered.getvalue()).decode('utf-8')) # base64 encoded image with results
+```
+
+### Cropped Results
+
+Results can be returned and saved as detection crops:
+
+```python
+results = model(im) # inference
+crops = results.crop(save=True) # cropped detections dictionary
+```
+
+### Pandas Results
+
+Results can be returned as [Pandas DataFrames](https://pandas.pydata.org/):
+
+```python
+results = model(im) # inference
+results.pandas().xyxy[0] # Pandas DataFrame
+```
+
+
+ Pandas Output (click to expand)
+
+```python
+print(results.pandas().xyxy[0])
+# xmin ymin xmax ymax confidence class name
+# 0 749.50 43.50 1148.0 704.5 0.874023 0 person
+# 1 433.50 433.50 517.5 714.5 0.687988 27 tie
+# 2 114.75 195.75 1095.0 708.0 0.624512 0 person
+# 3 986.00 304.00 1028.0 420.0 0.286865 27 tie
+```
+
+
+
+### Sorted Results
+
+Results can be sorted by column, i.e. to sort license plate digit detection left-to-right (x-axis):
+
+```python
+results = model(im) # inference
+results.pandas().xyxy[0].sort_values('xmin') # sorted left-right
+```
+
+### Box-Cropped Results
+
+Results can be returned and saved as detection crops:
+
+```python
+results = model(im) # inference
+crops = results.crop(save=True) # cropped detections dictionary
+```
+
+### JSON Results
+
+Results can be returned in JSON format once converted to `.pandas()` dataframes using the `.to_json()` method. The JSON format can be modified using the `orient` argument. See pandas `.to_json()` [documentation](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html) for details.
+
+```python
+results = model(ims) # inference
+results.pandas().xyxy[0].to_json(orient="records") # JSON img1 predictions
+```
+
+
+ JSON Output (click to expand)
+
+```json
+[
+ {
+ "xmin": 749.5,
+ "ymin": 43.5,
+ "xmax": 1148.0,
+ "ymax": 704.5,
+ "confidence": 0.8740234375,
+ "class": 0,
+ "name": "person"
+ },
+ {
+ "xmin": 433.5,
+ "ymin": 433.5,
+ "xmax": 517.5,
+ "ymax": 714.5,
+ "confidence": 0.6879882812,
+ "class": 27,
+ "name": "tie"
+ },
+ {
+ "xmin": 115.25,
+ "ymin": 195.75,
+ "xmax": 1096.0,
+ "ymax": 708.0,
+ "confidence": 0.6254882812,
+ "class": 0,
+ "name": "person"
+ },
+ {
+ "xmin": 986.0,
+ "ymin": 304.0,
+ "xmax": 1028.0,
+ "ymax": 420.0,
+ "confidence": 0.2873535156,
+ "class": 27,
+ "name": "tie"
+ }
+]
+```
+
+
+
+## Custom Models
+
+This example loads a custom 20-class [VOC](https://github.com/ultralytics/yolov5/blob/master/data/VOC.yaml)-trained YOLOv5s model `'best.pt'` with PyTorch Hub.
+
+```python
+import torch
+
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='path/to/best.pt') # local model
+model = torch.hub.load('path/to/yolov5', 'custom', path='path/to/best.pt', source='local') # local repo
+```
+
+## TensorRT, ONNX and OpenVINO Models
+
+PyTorch Hub supports inference on most YOLOv5 export formats, including custom trained models. See [TFLite, ONNX, CoreML, TensorRT Export tutorial](https://docs.ultralytics.com/yolov5/tutorials/model_export) for details on exporting models.
+
+๐ก ProTip: **TensorRT** may be up to 2-5X faster than PyTorch on [**GPU benchmarks**](https://github.com/ultralytics/yolov5/pull/6963)
+๐ก ProTip: **ONNX** and **OpenVINO** may be up to 2-3X faster than PyTorch on [**CPU benchmarks**](https://github.com/ultralytics/yolov5/pull/6613)
+
+```python
+import torch
+
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s.pt') # PyTorch
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s.torchscript') # TorchScript
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s.onnx') # ONNX
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s_openvino_model/') # OpenVINO
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s.engine') # TensorRT
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s.mlmodel') # CoreML (macOS-only)
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s.tflite') # TFLite
+model = torch.hub.load('ultralytics/yolov5', 'custom', path='yolov5s_paddle_model/') # PaddlePaddle
+```
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/pytorch_hub_model_loading.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/pytorch_hub_model_loading.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/pytorch_hub_model_loading.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/roboflow_datasets_integration.md b/ultralytics/docs/en/yolov5/tutorials/roboflow_datasets_integration.md
new file mode 100755
index 0000000..a278ef2
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/roboflow_datasets_integration.md
@@ -0,0 +1,68 @@
+---
+comments: true
+description: Learn how to use Roboflow for organizing, labelling, preparing, and hosting your datasets for YOLOv5 models. Enhance your model deployments with our platform.
+keywords: Ultralytics, YOLOv5, Roboflow, data organization, data labelling, data preparation, model deployment, active learning, machine learning pipeline
+---
+
+# Roboflow Datasets
+
+You can now use Roboflow to organize, label, prepare, version, and host your datasets for training YOLOv5 ๐ models. Roboflow is free to use with YOLOv5 if you make your workspace public.
+
+!!! Warning
+
+ Roboflow users can use Ultralytics under the [AGPL license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) or procure an [Enterprise license](https://ultralytics.com/license) directly from Ultralytics. Be aware that Roboflow does **not** provide Ultralytics licenses, and it is the responsibility of the user to ensure appropriate licensing.
+
+## Upload
+
+You can upload your data to Roboflow via [web UI](https://docs.roboflow.com/adding-data), [REST API](https://docs.roboflow.com/adding-data/upload-api), or [Python](https://docs.roboflow.com/python).
+
+## Labeling
+
+After uploading data to Roboflow, you can label your data and review previous labels.
+
+[](https://roboflow.com/annotate)
+
+## Versioning
+
+You can make versions of your dataset with different preprocessing and offline augmentation options. YOLOv5 does online augmentations natively, so be intentional when layering Roboflow's offline augmentations on top.
+
+
+
+## Exporting Data
+
+You can download your data in YOLOv5 format to quickly begin training.
+
+```
+from roboflow import Roboflow
+rf = Roboflow(api_key="YOUR API KEY HERE")
+project = rf.workspace().project("YOUR PROJECT")
+dataset = project.version("YOUR VERSION").download("yolov5")
+```
+
+## Custom Training
+
+We have released a custom training tutorial demonstrating all of the above capabilities. You can access the code here:
+
+[](https://colab.research.google.com/github/roboflow-ai/yolov5-custom-training-tutorial/blob/main/yolov5-custom-training.ipynb)
+
+## Active Learning
+
+The real world is messy and your model will invariably encounter situations your dataset didn't anticipate. Using [active learning](https://blog.roboflow.com/what-is-active-learning/) is an important strategy to iteratively improve your dataset and model. With the Roboflow and YOLOv5 integration, you can quickly make improvements on your model deployments by using a battle tested machine learning pipeline.
+
+
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/roboflow_datasets_integration.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/roboflow_datasets_integration.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/roboflow_datasets_integration.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/running_on_jetson_nano.md b/ultralytics/docs/en/yolov5/tutorials/running_on_jetson_nano.md
new file mode 100755
index 0000000..58618c1
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/running_on_jetson_nano.md
@@ -0,0 +1,319 @@
+---
+comments: true
+description: Detailed guide on deploying trained models on NVIDIA Jetson using TensorRT and DeepStream SDK. Optimize the inference performance on Jetson with Ultralytics.
+keywords: TensorRT, NVIDIA Jetson, DeepStream SDK, deployment, Ultralytics, YOLO, Machine Learning, AI, Deep Learning, model optimization, inference performance
+---
+
+# Deploy on NVIDIA Jetson using TensorRT and DeepStream SDK
+
+๐ This guide explains how to deploy a trained model into NVIDIA Jetson Platform and perform inference using TensorRT and DeepStream SDK. Here we use TensorRT to maximize the inference performance on the Jetson platform.
+
+## Hardware Verification
+
+We have tested and verified this guide on the following Jetson devices
+
+- [Seeed reComputer J1010 built with Jetson Nano module](https://www.seeedstudio.com/Jetson-10-1-A0-p-5336.html)
+- [Seeed reComputer J2021 built with Jetson Xavier NX module](https://www.seeedstudio.com/reComputer-J2021-p-5438.html)
+
+## Before You Start
+
+Make sure you have properly installed **JetPack SDK** with all the **SDK Components** and **DeepStream SDK** on the Jetson device as this includes CUDA, TensorRT and DeepStream SDK which are needed for this guide.
+
+JetPack SDK provides a full development environment for hardware-accelerated AI-at-the-edge development. All Jetson modules and developer kits are supported by JetPack SDK.
+
+There are two major installation methods including,
+
+1. SD Card Image Method
+2. NVIDIA SDK Manager Method
+
+You can find a very detailed installation guide from NVIDIA [official website](https://developer.nvidia.com/jetpack-sdk-461). You can also find guides corresponding to the above-mentioned [reComputer J1010](https://wiki.seeedstudio.com/reComputer_J1010_J101_Flash_Jetpack) and [reComputer J2021](https://wiki.seeedstudio.com/reComputer_J2021_J202_Flash_Jetpack).
+
+## Install Necessary Packages
+
+- **Step 1.** Access the terminal of Jetson device, install pip and upgrade it
+
+```sh
+sudo apt update
+sudo apt install -y python3-pip
+pip3 install --upgrade pip
+```
+
+- **Step 2.** Clone the following repo
+
+```sh
+git clone https://github.com/ultralytics/yolov5
+```
+
+- **Step 3.** Open **requirements.txt**
+
+```sh
+cd yolov5
+vi requirements.txt
+```
+
+- **Step 5.** Edit the following lines. Here you need to press **i** first to enter editing mode. Press **ESC**, then type **:wq** to save and quit
+
+```sh
+# torch>=1.8.0
+# torchvision>=0.9.0
+```
+
+**Note:** torch and torchvision are excluded for now because they will be installed later.
+
+- **Step 6.** install the below dependency
+
+```sh
+sudo apt install -y libfreetype6-dev
+```
+
+- **Step 7.** Install the necessary packages
+
+```sh
+pip3 install -r requirements.txt
+```
+
+## Install PyTorch and Torchvision
+
+We cannot install PyTorch and Torchvision from pip because they are not compatible to run on Jetson platform which is based on **ARM aarch64 architecture**. Therefore, we need to manually install pre-built PyTorch pip wheel and compile/ install Torchvision from source.
+
+Visit [this page](https://forums.developer.nvidia.com/t/pytorch-for-jetson) to access all the PyTorch and Torchvision links.
+
+Here are some of the versions supported by JetPack 4.6 and above.
+
+**PyTorch v1.10.0**
+
+Supported by JetPack 4.4 (L4T R32.4.3) / JetPack 4.4.1 (L4T R32.4.4) / JetPack 4.5 (L4T R32.5.0) / JetPack 4.5.1 (L4T R32.5.1) / JetPack 4.6 (L4T R32.6.1) with Python 3.6
+
+**file_name:** torch-1.10.0-cp36-cp36m-linux_aarch64.whl
+**URL:** [https://nvidia.box.com/shared/static/fjtbno0vpo676a25cgvuqc1wty0fkkg6.whl](https://nvidia.box.com/shared/static/fjtbno0vpo676a25cgvuqc1wty0fkkg6.whl)
+
+**PyTorch v1.12.0**
+
+Supported by JetPack 5.0 (L4T R34.1.0) / JetPack 5.0.1 (L4T R34.1.1) / JetPack 5.0.2 (L4T R35.1.0) with Python 3.8
+
+**file_name:** torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl
+**URL:** [https://developer.download.nvidia.com/compute/redist/jp/v50/pytorch/torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl](https://developer.download.nvidia.com/compute/redist/jp/v50/pytorch/torch-1.12.0a0+2c916ef.nv22.3-cp38-cp38-linux_aarch64.whl)
+
+- **Step 1.** Install torch according to your JetPack version in the following format
+
+```sh
+wget -O
+pip3 install
+```
+
+For example, here we are running **JP4.6.1**, and therefore we choose **PyTorch v1.10.0**
+
+```sh
+cd ~
+sudo apt-get install -y libopenblas-base libopenmpi-dev
+wget https://nvidia.box.com/shared/static/fjtbno0vpo676a25cgvuqc1wty0fkkg6.whl -O torch-1.10.0-cp36-cp36m-linux_aarch64.whl
+pip3 install torch-1.10.0-cp36-cp36m-linux_aarch64.whl
+```
+
+- **Step 2.** Install torchvision depending on the version of PyTorch that you have installed. For example, we chose **PyTorch v1.10.0**, which means, we need to choose **Torchvision v0.11.1**
+
+```sh
+sudo apt install -y libjpeg-dev zlib1g-dev
+git clone --branch v0.11.1 https://github.com/pytorch/vision torchvision
+cd torchvision
+sudo python3 setup.py install
+```
+
+Here a list of the corresponding torchvision version that you need to install according to the PyTorch version:
+
+- PyTorch v1.10 - torchvision v0.11.1
+- PyTorch v1.12 - torchvision v0.13.0
+
+## DeepStream Configuration for YOLOv5
+
+- **Step 1.** Clone the following repo
+
+```sh
+cd ~
+git clone https://github.com/marcoslucianops/DeepStream-Yolo
+```
+
+- **Step 2.** Copy **gen_wts_yoloV5.py** from **DeepStream-Yolo/utils** into **yolov5** directory
+
+```sh
+cp DeepStream-Yolo/utils/gen_wts_yoloV5.py yolov5
+```
+
+- **Step 3.** Inside the yolov5 repo, download **pt file** from YOLOv5 releases (example for YOLOv5s 6.1)
+
+```sh
+cd yolov5
+wget https://github.com/ultralytics/yolov5/releases/download/v6.1/yolov5s.pt
+```
+
+- **Step 4.** Generate the **cfg** and **wts** files
+
+```sh
+python3 gen_wts_yoloV5.py -w yolov5s.pt
+```
+
+**Note**: To change the inference size (default: 640)
+
+```sh
+-s SIZE
+--size SIZE
+-s HEIGHT WIDTH
+--size HEIGHT WIDTH
+
+Example for 1280:
+
+-s 1280
+or
+-s 1280 1280
+```
+
+- **Step 5.** Copy the generated **cfg** and **wts** files into the **DeepStream-Yolo** folder
+
+```sh
+cp yolov5s.cfg ~/DeepStream-Yolo
+cp yolov5s.wts ~/DeepStream-Yolo
+```
+
+- **Step 6.** Open the **DeepStream-Yolo** folder and compile the library
+
+```sh
+cd ~/DeepStream-Yolo
+CUDA_VER=11.4 make -C nvdsinfer_custom_impl_Yolo # for DeepStream 6.1
+CUDA_VER=10.2 make -C nvdsinfer_custom_impl_Yolo # for DeepStream 6.0.1 / 6.0
+```
+
+- **Step 7.** Edit the **config_infer_primary_yoloV5.txt** file according to your model
+
+```sh
+[property]
+...
+custom-network-config=yolov5s.cfg
+model-file=yolov5s.wts
+...
+```
+
+- **Step 8.** Edit the **deepstream_app_config** file
+
+```sh
+...
+[primary-gie]
+...
+config-file=config_infer_primary_yoloV5.txt
+```
+
+- **Step 9.** Change the video source in **deepstream_app_config** file. Here a default video file is loaded as you can see below
+
+```sh
+...
+[source0]
+...
+uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4
+```
+
+## Run the Inference
+
+```sh
+deepstream-app -c deepstream_app_config.txt
+```
+
+
+
+The above result is running on **Jetson Xavier NX** with **FP32** and **YOLOv5s 640x640**. We can see that the **FPS** is around **30**.
+
+## INT8 Calibration
+
+If you want to use INT8 precision for inference, you need to follow the steps below
+
+- **Step 1.** Install OpenCV
+
+```sh
+sudo apt-get install libopencv-dev
+```
+
+- **Step 2.** Compile/recompile the **nvdsinfer_custom_impl_Yolo** library with OpenCV support
+
+```sh
+cd ~/DeepStream-Yolo
+CUDA_VER=11.4 OPENCV=1 make -C nvdsinfer_custom_impl_Yolo # for DeepStream 6.1
+CUDA_VER=10.2 OPENCV=1 make -C nvdsinfer_custom_impl_Yolo # for DeepStream 6.0.1 / 6.0
+```
+
+- **Step 3.** For COCO dataset, download the [val2017](https://drive.google.com/file/d/1gbvfn7mcsGDRZ_luJwtITL-ru2kK99aK/view?usp=sharing), extract, and move to **DeepStream-Yolo** folder
+
+- **Step 4.** Make a new directory for calibration images
+
+```sh
+mkdir calibration
+```
+
+- **Step 5.** Run the following to select 1000 random images from COCO dataset to run calibration
+
+```sh
+for jpg in $(ls -1 val2017/*.jpg | sort -R | head -1000); do \
+ cp ${jpg} calibration/; \
+done
+```
+
+**Note:** NVIDIA recommends at least 500 images to get a good accuracy. On this example, 1000 images are chosen to get better accuracy (more images = more accuracy). Higher INT8_CALIB_BATCH_SIZE values will result in more accuracy and faster calibration speed. Set it according to you GPU memory. You can set it from **head -1000**. For example, for 2000 images, **head -2000**. This process can take a long time.
+
+- **Step 6.** Create the **calibration.txt** file with all selected images
+
+```sh
+realpath calibration/*jpg > calibration.txt
+```
+
+- **Step 7.** Set environment variables
+
+```sh
+export INT8_CALIB_IMG_PATH=calibration.txt
+export INT8_CALIB_BATCH_SIZE=1
+```
+
+- **Step 8.** Update the **config_infer_primary_yoloV5.txt** file
+
+From
+
+```sh
+...
+model-engine-file=model_b1_gpu0_fp32.engine
+#int8-calib-file=calib.table
+...
+network-mode=0
+...
+```
+
+To
+
+```sh
+...
+model-engine-file=model_b1_gpu0_int8.engine
+int8-calib-file=calib.table
+...
+network-mode=1
+...
+```
+
+- **Step 9.** Run the inference
+
+```sh
+deepstream-app -c deepstream_app_config.txt
+```
+
+
+
+The above result is running on **Jetson Xavier NX** with **INT8** and **YOLOv5s 640x640**. We can see that the **FPS** is around **60**.
+
+## Benchmark results
+
+The following table summarizes how different models perform on **Jetson Xavier NX**.
+
+| Model Name | Precision | Inference Size | Inference Time (ms) | FPS |
+|------------|-----------|----------------|---------------------|-----|
+| YOLOv5s | FP32 | 320x320 | 16.66 | 60 |
+| | FP32 | 640x640 | 33.33 | 30 |
+| | INT8 | 640x640 | 16.66 | 60 |
+| YOLOv5n | FP32 | 640x640 | 16.66 | 60 |
+
+### Additional
+
+This tutorial is written by our friends at seeed @lakshanthad and Elaine
diff --git a/ultralytics/docs/en/yolov5/tutorials/running_on_jetson_nano.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/running_on_jetson_nano.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/running_on_jetson_nano.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/test_time_augmentation.md b/ultralytics/docs/en/yolov5/tutorials/test_time_augmentation.md
new file mode 100755
index 0000000..6a585ef
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/test_time_augmentation.md
@@ -0,0 +1,164 @@
+---
+comments: true
+description: Boost your YOLOv5 performance with our step-by-step guide on Test-Time Augmentation (TTA). Learn to enhance your model's mAP and Recall during testing and inference.
+keywords: YOLOv5, Ultralytics, Test-Time Augmentation, TTA, mAP, Recall, model performance, guide
+---
+
+# Test-Time Augmentation (TTA)
+
+๐ This guide explains how to use Test Time Augmentation (TTA) during testing and inference for improved mAP and Recall with YOLOv5 ๐.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Test Normally
+
+Before trying TTA we want to establish a baseline performance to compare to. This command tests YOLOv5x on COCO val2017 at image size 640 pixels. `yolov5x.pt` is the largest and most accurate model available. Other options are `yolov5s.pt`, `yolov5m.pt` and `yolov5l.pt`, or you own checkpoint from training a custom dataset `./weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```bash
+python val.py --weights yolov5x.pt --data coco.yaml --img 640 --half
+```
+
+Output:
+
+```shell
+val: data=./data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True
+YOLOv5 ๐ v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+Model Summary: 476 layers, 87730285 parameters, 0 gradients
+
+val: Scanning '../datasets/coco/val2017' images and labels...4952 found, 48 missing, 0 empty, 0 corrupted: 100% 5000/5000 [00:01<00:00, 2846.03it/s]
+val: New cache created: ../datasets/coco/val2017.cache
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [02:30<00:00, 1.05it/s]
+ all 5000 36335 0.746 0.626 0.68 0.49
+Speed: 0.1ms pre-process, 22.4ms inference, 1.4ms NMS per image at shape (32, 3, 640, 640) # <--- baseline speed
+
+Evaluating pycocotools mAP... saving runs/val/exp/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.504 # <--- baseline mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.688
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.546
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.351
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.551
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.644
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.382
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.628
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.681 # <--- baseline mAR
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.524
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.735
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.826
+```
+
+## Test with TTA
+
+Append `--augment` to any existing `val.py` command to enable TTA, and increase the image size by about 30% for improved results. Note that inference with TTA enabled will typically take about 2-3X the time of normal inference as the images are being left-right flipped and processed at 3 different resolutions, with the outputs merged before NMS. Part of the speed decrease is simply due to larger image sizes (832 vs 640), while part is due to the actual TTA operations.
+
+```bash
+python val.py --weights yolov5x.pt --data coco.yaml --img 832 --augment --half
+```
+
+Output:
+
+```shell
+val: data=./data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=832, conf_thres=0.001, iou_thres=0.6, task=val, device=, single_cls=False, augment=True, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True
+YOLOv5 ๐ v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:1156.)
+ return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)
+Model Summary: 476 layers, 87730285 parameters, 0 gradients
+val: Scanning '../datasets/coco/val2017' images and labels...4952 found, 48 missing, 0 empty, 0 corrupted: 100% 5000/5000 [00:01<00:00, 2885.61it/s]
+val: New cache created: ../datasets/coco/val2017.cache
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [07:29<00:00, 2.86s/it]
+ all 5000 36335 0.718 0.656 0.695 0.503
+Speed: 0.2ms pre-process, 80.6ms inference, 2.7ms NMS per image at shape (32, 3, 832, 832) # <--- TTA speed
+
+Evaluating pycocotools mAP... saving runs/val/exp2/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.516 # <--- TTA mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.701
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.562
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.361
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.564
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.656
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.388
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.640
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.696 # <--- TTA mAR
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.553
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.744
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.833
+```
+
+## Inference with TTA
+
+`detect.py` TTA inference operates identically to `val.py` TTA: simply append `--augment` to any existing `detect.py` command:
+
+```bash
+python detect.py --weights yolov5s.pt --img 832 --source data/images --augment
+```
+
+Output:
+
+```bash
+YOLOv5 ๐ v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Downloading https://github.com/ultralytics/yolov5/releases/download/v5.0/yolov5s.pt to yolov5s.pt...
+100% 14.1M/14.1M [00:00<00:00, 81.9MB/s]
+
+Fusing layers...
+Model Summary: 224 layers, 7266973 parameters, 0 gradients
+image 1/2 /content/yolov5/data/images/bus.jpg: 832x640 4 persons, 1 bus, 1 fire hydrant, Done. (0.029s)
+image 2/2 /content/yolov5/data/images/zidane.jpg: 480x832 3 persons, 3 ties, Done. (0.024s)
+Results saved to runs/detect/exp
+Done. (0.156s)
+```
+
+
+
+### PyTorch Hub TTA
+
+TTA is automatically integrated into all [YOLOv5 PyTorch Hub](https://pytorch.org/hub/ultralytics_yolov5) models, and can be accessed by passing `augment=True` at inference time.
+
+```python
+import torch
+
+# Model
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s') # or yolov5m, yolov5x, custom
+
+# Images
+img = 'https://ultralytics.com/images/zidane.jpg' # or file, PIL, OpenCV, numpy, multiple
+
+# Inference
+results = model(img, augment=True) # <--- TTA inference
+
+# Results
+results.print() # or .show(), .save(), .crop(), .pandas(), etc.
+```
+
+### Customize
+
+You can customize the TTA ops applied in the YOLOv5 `forward_augment()` method [here](https://github.com/ultralytics/yolov5/blob/8c6f9e15bfc0000d18b976a95b9d7c17d407ec91/models/yolo.py#L125-L137).
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/test_time_augmentation.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/test_time_augmentation.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/test_time_augmentation.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/tips_for_best_training_results.md b/ultralytics/docs/en/yolov5/tutorials/tips_for_best_training_results.md
new file mode 100755
index 0000000..22bfdb2
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/tips_for_best_training_results.md
@@ -0,0 +1,65 @@
+---
+comments: true
+description: Our comprehensive guide provides insights on how to train your YOLOv5 system to get the best mAP. Master dataset preparation, model selection, training settings, and more.
+keywords: Ultralytics, YOLOv5, Training guide, dataset preparation, model selection, training settings, mAP results, Machine Learning, Object Detection
+---
+
+๐ This guide explains how to produce the best mAP and training results with YOLOv5 ๐.
+
+Most of the time good results can be obtained with no changes to the models or training settings, **provided your dataset is sufficiently large and well labelled**. If at first you don't get good results, there are steps you might be able to take to improve, but we always recommend users **first train with all default settings** before considering any changes. This helps establish a performance baseline and spot areas for improvement.
+
+If you have questions about your training results **we recommend you provide the maximum amount of information possible** if you expect a helpful response, including results plots (train losses, val losses, P, R, mAP), PR curve, confusion matrix, training mosaics, test results and dataset statistics images such as labels.png. All of these are located in your `project/name` directory, typically `yolov5/runs/train/exp`.
+
+We've put together a full guide for users looking to get the best results on their YOLOv5 trainings below.
+
+## Dataset
+
+- **Images per class.** โฅ 1500 images per class recommended
+- **Instances per class.** โฅ 10000 instances (labeled objects) per class recommended
+- **Image variety.** Must be representative of deployed environment. For real-world use cases we recommend images from different times of day, different seasons, different weather, different lighting, different angles, different sources (scraped online, collected locally, different cameras) etc.
+- **Label consistency.** All instances of all classes in all images must be labelled. Partial labelling will not work.
+- **Label accuracy.** Labels must closely enclose each object. No space should exist between an object and it's bounding box. No objects should be missing a label.
+- **Label verification.** View `train_batch*.jpg` on train start to verify your labels appear correct, i.e. see [example](https://docs.ultralytics.com/yolov5/tutorials/train_custom_data#local-logging) mosaic.
+- **Background images.** Background images are images with no objects that are added to a dataset to reduce False Positives (FP). We recommend about 0-10% background images to help reduce FPs (COCO has 1000 background images for reference, 1% of the total). No labels are required for background images.
+
+
+
+## Model Selection
+
+Larger models like YOLOv5x and [YOLOv5x6](https://github.com/ultralytics/yolov5/releases/tag/v5.0) will produce better results in nearly all cases, but have more parameters, require more CUDA memory to train, and are slower to run. For **mobile** deployments we recommend YOLOv5s/m, for **cloud** deployments we recommend YOLOv5l/x. See our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints) for a full comparison of all models.
+
+
+
+- **Start from Pretrained weights.** Recommended for small to medium-sized datasets (i.e. [VOC](https://github.com/ultralytics/yolov5/blob/master/data/VOC.yaml), [VisDrone](https://github.com/ultralytics/yolov5/blob/master/data/VisDrone.yaml), [GlobalWheat](https://github.com/ultralytics/yolov5/blob/master/data/GlobalWheat2020.yaml)). Pass the name of the model to the `--weights` argument. Models download automatically from the [latest YOLOv5 release](https://github.com/ultralytics/yolov5/releases).
+
+```shell
+python train.py --data custom.yaml --weights yolov5s.pt
+ yolov5m.pt
+ yolov5l.pt
+ yolov5x.pt
+ custom_pretrained.pt
+```
+
+- **Start from Scratch.** Recommended for large datasets (i.e. [COCO](https://github.com/ultralytics/yolov5/blob/master/data/coco.yaml), [Objects365](https://github.com/ultralytics/yolov5/blob/master/data/Objects365.yaml), [OIv6](https://storage.googleapis.com/openimages/web/index.html)). Pass the model architecture YAML you are interested in, along with an empty `--weights ''` argument:
+
+```bash
+python train.py --data custom.yaml --weights '' --cfg yolov5s.yaml
+ yolov5m.yaml
+ yolov5l.yaml
+ yolov5x.yaml
+```
+
+## Training Settings
+
+Before modifying anything, **first train with default settings to establish a performance baseline**. A full list of train.py settings can be found in the [train.py](https://github.com/ultralytics/yolov5/blob/master/train.py) argparser.
+
+- **Epochs.** Start with 300 epochs. If this overfits early then you can reduce epochs. If overfitting does not occur after 300 epochs, train longer, i.e. 600, 1200 etc. epochs.
+- **Image size.** COCO trains at native resolution of `--img 640`, though due to the high amount of small objects in the dataset it can benefit from training at higher resolutions such as `--img 1280`. If there are many small objects then custom datasets will benefit from training at native or higher resolution. Best inference results are obtained at the same `--img` as the training was run at, i.e. if you train at `--img 1280` you should also test and detect at `--img 1280`.
+- **Batch size.** Use the largest `--batch-size` that your hardware allows for. Small batch sizes produce poor batchnorm statistics and should be avoided.
+- **Hyperparameters.** Default hyperparameters are in [hyp.scratch-low.yaml](https://github.com/ultralytics/yolov5/blob/master/data/hyps/hyp.scratch-low.yaml). We recommend you train with default hyperparameters first before thinking of modifying any. In general, increasing augmentation hyperparameters will reduce and delay overfitting, allowing for longer trainings and higher final mAP. Reduction in loss component gain hyperparameters like `hyp['obj']` will help reduce overfitting in those specific loss components. For an automated method of optimizing these hyperparameters, see our [Hyperparameter Evolution Tutorial](https://docs.ultralytics.com/yolov5/tutorials/hyperparameter_evolution).
+
+## Further Reading
+
+If you'd like to know more, a good place to start is Karpathy's 'Recipe for Training Neural Networks', which has great ideas for training that apply broadly across all ML domains: [http://karpathy.github.io/2019/04/25/recipe/](http://karpathy.github.io/2019/04/25/recipe/)
+
+Good luck ๐ and let us know if you have any other questions!
diff --git a/ultralytics/docs/en/yolov5/tutorials/tips_for_best_training_results.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/tips_for_best_training_results.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/tips_for_best_training_results.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/train_custom_data.md b/ultralytics/docs/en/yolov5/tutorials/train_custom_data.md
new file mode 100755
index 0000000..7f19e9d
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/train_custom_data.md
@@ -0,0 +1,229 @@
+---
+comments: true
+description: Learn how to train your data on custom datasets using YOLOv5. Simple and updated guide on collection and organization of images, labelling, model training and deployment.
+keywords: YOLOv5, train on custom dataset, image collection, model training, object detection, image labelling, Ultralytics, PyTorch, machine learning
+---
+
+๐ This guide explains how to train your own **custom dataset** with [YOLOv5](https://github.com/ultralytics/yolov5) ๐.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Train On Custom Data
+
+
+
+
+
+
+Creating a custom model to detect your objects is an iterative process of collecting and organizing images, labeling your objects of interest, training a model, deploying it into the wild to make predictions, and then using that deployed model to collect examples of edge cases to repeat and improve.
+
+### 1. Create Dataset
+
+YOLOv5 models must be trained on labelled data in order to learn classes of objects in that data. There are two options for creating your dataset before you start training:
+
+
+Use Roboflow to create your dataset in YOLO format ๐
+
+!!! Warning
+
+ Roboflow users can use Ultralytics under the [AGPL license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) or can request an [Enterprise license](https://ultralytics.com/license) directly from Ultralytics. Be aware that Roboflow does not provide Ultralytics licenses, and it is the responsibility of the user to ensure appropriate licensing.
+
+### 1.1 Collect Images
+
+Your model will learn by example. Training on images similar to the ones it will see in the wild is of the utmost importance. Ideally, you will collect a wide variety of images from the same configuration (camera, angle, lighting, etc.) as you will ultimately deploy your project.
+
+If this is not possible, you can start from [a public dataset](https://universe.roboflow.com/?ref=ultralytics) to train your initial model and then [sample images from the wild during inference](https://blog.roboflow.com/computer-vision-active-learning-tips/?ref=ultralytics) to improve your dataset and model iteratively.
+
+### 1.2 Create Labels
+
+Once you have collected images, you will need to annotate the objects of interest to create a ground truth for your model to learn from.
+
+
+
+[Roboflow Annotate](https://roboflow.com/annotate?ref=ultralytics) is a simple web-based tool for managing and labeling your images with your team and exporting them in [YOLOv5's annotation format](https://roboflow.com/formats/yolov5-pytorch-txt?ref=ultralytics).
+
+### 1.3 Prepare Dataset for YOLOv5
+
+Whether you [label your images with Roboflow](https://roboflow.com/annotate?ref=ultralytics) or not, you can use it to convert your dataset into YOLO format, create a YOLOv5 YAML configuration file, and host it for importing into your training script.
+
+[Create a free Roboflow account](https://app.roboflow.com/?model=yolov5&ref=ultralytics)
+and upload your dataset to a `Public` workspace, label any unannotated images, then generate and export a version of your dataset in `YOLOv5 Pytorch` format.
+
+Note: YOLOv5 does online augmentation during training, so we do not recommend applying any augmentation steps in Roboflow for training with YOLOv5. But we recommend applying the following preprocessing steps:
+
+
+
+* **Auto-Orient** - to strip EXIF orientation from your images.
+* **Resize (Stretch)** - to the square input size of your model (640x640 is the YOLOv5 default).
+
+Generating a version will give you a point in time snapshot of your dataset so you can always go back and compare your future model training runs against it, even if you add more images or change its configuration later.
+
+
+
+Export in `YOLOv5 Pytorch` format, then copy the snippet into your training script or notebook to download your dataset.
+
+
+
+Now continue with `2. Select a Model`.
+
+
+
+Or manually prepare your dataset
+
+### 1.1 Create dataset.yaml
+
+[COCO128](https://www.kaggle.com/ultralytics/coco128) is an example small tutorial dataset composed of the first 128 images in [COCO](http://cocodataset.org/#home) train2017. These same 128 images are used for both training and validation to verify our training pipeline is capable of overfitting. [data/coco128.yaml](https://github.com/ultralytics/yolov5/blob/master/data/coco128.yaml), shown below, is the dataset config file that defines 1) the dataset root directory `path` and relative paths to `train` / `val` / `test` image directories (or *.txt files with image paths) and 2) a class `names` dictionary:
+
+```yaml
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco128 # dataset root dir
+train: images/train2017 # train images (relative to 'path') 128 images
+val: images/train2017 # val images (relative to 'path') 128 images
+test: # test images (optional)
+
+# Classes (80 COCO classes)
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ # ...
+ 77: teddy bear
+ 78: hair drier
+ 79: toothbrush
+```
+
+### 1.2 Create Labels
+
+After using an annotation tool to label your images, export your labels to **YOLO format**, with one `*.txt` file per image (if no objects in image, no `*.txt` file is required). The `*.txt` file specifications are:
+
+- One row per object
+- Each row is `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, divide `x_center` and `width` by image width, and `y_center` and `height` by image height.
+- Class numbers are zero-indexed (start from 0).
+
+
+
+The label file corresponding to the above image contains 2 persons (class `0`) and a tie (class `27`):
+
+
+
+### 1.3 Organize Directories
+
+Organize your train and val images and labels according to the example below. YOLOv5 assumes `/coco128` is inside a `/datasets` directory **next to** the `/yolov5` directory. **YOLOv5 locates labels automatically for each image** by replacing the last instance of `/images/` in each image path with `/labels/`. For example:
+
+```bash
+../datasets/coco128/images/im0.jpg # image
+../datasets/coco128/labels/im0.txt # label
+```
+
+
+
+
+### 2. Select a Model
+
+Select a pretrained model to start training from. Here we select [YOLOv5s](https://github.com/ultralytics/yolov5/blob/master/models/yolov5s.yaml), the second-smallest and fastest model available. See our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints) for a full comparison of all models.
+
+
+
+### 3. Train
+
+Train a YOLOv5s model on COCO128 by specifying dataset, batch-size, image size and either pretrained `--weights yolov5s.pt` (recommended), or randomly initialized `--weights '' --cfg yolov5s.yaml` (not recommended). Pretrained weights are auto-downloaded from the [latest YOLOv5 release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt
+```
+
+!!! Tip "Tip"
+
+ ๐ก Add `--cache ram` or `--cache disk` to speed up training (requires significant RAM/disk resources).
+
+!!! Tip "Tip"
+
+ ๐ก Always train from a local dataset. Mounted or network drives like Google Drive will be very slow.
+
+All training results are saved to `runs/train/` with incrementing run directories, i.e. `runs/train/exp2`, `runs/train/exp3` etc. For more details see the Training section of our tutorial notebook.
+
+### 4. Visualize
+
+#### Comet Logging and Visualization ๐ NEW
+
+[Comet](https://bit.ly/yolov5-readme-comet) is now fully integrated with YOLOv5. Track and visualize model metrics in real time, save your hyperparameters, datasets, and model checkpoints, and visualize your model predictions with [Comet Custom Panels](https://bit.ly/yolov5-colab-comet-panels)! Comet makes sure you never lose track of your work and makes it easy to share results and collaborate across teams of all sizes!
+
+Getting started is easy:
+
+```shell
+pip install comet_ml # 1. install
+export COMET_API_KEY= # 2. paste API key
+python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt # 3. train
+```
+
+To learn more about all the supported Comet features for this integration, check out the [Comet Tutorial](https://docs.ultralytics.com/yolov5/tutorials/comet_logging_integration). If you'd like to learn more about Comet, head over to our [documentation](https://bit.ly/yolov5-colab-comet-docs). Get started by trying out the Comet Colab Notebook:
+[](https://colab.research.google.com/drive/1RG0WOQyxlDlo5Km8GogJpIEJlg_5lyYO?usp=sharing)
+
+
+
+#### ClearML Logging and Automation ๐ NEW
+
+[ClearML](https://cutt.ly/yolov5-notebook-clearml) is completely integrated into YOLOv5 to track your experimentation, manage dataset versions and even remotely execute training runs. To enable ClearML:
+
+- `pip install clearml`
+- run `clearml-init` to connect to a ClearML server (**deploy your own open-source server [here](https://github.com/allegroai/clearml-server)**, or use our free hosted server [here](https://cutt.ly/yolov5-notebook-clearml))
+
+You'll get all the great expected features from an experiment manager: live updates, model upload, experiment comparison etc. but ClearML also tracks uncommitted changes and installed packages for example. Thanks to that ClearML Tasks (which is what we call experiments) are also reproducible on different machines! With only 1 extra line, we can schedule a YOLOv5 training task on a queue to be executed by any number of ClearML Agents (workers).
+
+You can use ClearML Data to version your dataset and then pass it to YOLOv5 simply using its unique ID. This will help you keep track of your data without adding extra hassle. Explore the [ClearML Tutorial](https://docs.ultralytics.com/yolov5/tutorials/clearml_logging_integration) for details!
+
+
+
+
+#### Local Logging
+
+Training results are automatically logged with [Tensorboard](https://www.tensorflow.org/tensorboard) and [CSV](https://github.com/ultralytics/yolov5/pull/4148) loggers to `runs/train`, with a new experiment directory created for each new training as `runs/train/exp2`, `runs/train/exp3`, etc.
+
+This directory contains train and val statistics, mosaics, labels, predictions and augmented mosaics, as well as metrics and charts including precision-recall (PR) curves and confusion matrices.
+
+
+
+Results file `results.csv` is updated after each epoch, and then plotted as `results.png` (below) after training completes. You can also plot any `results.csv` file manually:
+
+```python
+from utils.plots import plot_results
+
+plot_results('path/to/results.csv') # plot 'results.csv' as 'results.png'
+```
+
+
+
+## Next Steps
+
+Once your model is trained you can use your best checkpoint `best.pt` to:
+
+* Run [CLI](https://github.com/ultralytics/yolov5#quick-start-examples) or [Python](https://docs.ultralytics.com/yolov5/tutorials/pytorch_hub_model_loading) inference on new images and videos
+* [Validate](https://github.com/ultralytics/yolov5/blob/master/val.py) accuracy on train, val and test splits
+* [Export](https://docs.ultralytics.com/yolov5/tutorials/model_export) to TensorFlow, Keras, ONNX, TFlite, TF.js, CoreML and TensorRT formats
+* [Evolve](https://docs.ultralytics.com/yolov5/tutorials/hyperparameter_evolution) hyperparameters to improve performance
+* [Improve](https://docs.roboflow.com/adding-data/upload-api?ref=ultralytics) your model by sampling real-world images and adding them to your dataset
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/train_custom_data.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/train_custom_data.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/train_custom_data.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/en/yolov5/tutorials/transfer_learning_with_frozen_layers.md b/ultralytics/docs/en/yolov5/tutorials/transfer_learning_with_frozen_layers.md
new file mode 100755
index 0000000..3d919a6
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/transfer_learning_with_frozen_layers.md
@@ -0,0 +1,156 @@
+---
+comments: true
+description: Learn to freeze YOLOv5 layers for efficient transfer learning. Optimize your model retraining with less resources and faster training times.
+keywords: YOLOv5, freeze layers, transfer learning, model retraining, Ultralytics
+---
+
+๐ This guide explains how to **freeze** YOLOv5 ๐ layers when **transfer learning**. Transfer learning is a useful way to quickly retrain a model on new data without having to retrain the entire network. Instead, part of the initial weights are frozen in place, and the rest of the weights are used to compute loss and are updated by the optimizer. This requires less resources than normal training and allows for faster training times, though it may also result in reductions to final trained accuracy.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Freeze Backbone
+
+All layers that match the train.py `freeze` list in train.py will be frozen by setting their gradients to zero before training starts.
+
+```python
+# Freeze
+freeze = [f'model.{x}.' for x in range(freeze)] # layers to freeze
+for k, v in model.named_parameters():
+ v.requires_grad = True # train all layers
+ if any(x in k for x in freeze):
+ print(f'freezing {k}')
+ v.requires_grad = False
+```
+
+To see a list of module names:
+
+```python
+for k, v in model.named_parameters():
+ print(k)
+
+"""Output:
+model.0.conv.conv.weight
+model.0.conv.bn.weight
+model.0.conv.bn.bias
+model.1.conv.weight
+model.1.bn.weight
+model.1.bn.bias
+model.2.cv1.conv.weight
+model.2.cv1.bn.weight
+...
+model.23.m.0.cv2.bn.weight
+model.23.m.0.cv2.bn.bias
+model.24.m.0.weight
+model.24.m.0.bias
+model.24.m.1.weight
+model.24.m.1.bias
+model.24.m.2.weight
+model.24.m.2.bias
+"""
+```
+
+Looking at the model architecture we can see that the model backbone is layers 0-9:
+
+```yaml
+# YOLOv5 backbone
+backbone:
+ # [from, number, module, args]
+ [[-1, 1, Focus, [64, 3]], # 0-P1/2
+ [-1, 1, Conv, [128, 3, 2]], # 1-P2/4
+ [-1, 3, BottleneckCSP, [128]],
+ [-1, 1, Conv, [256, 3, 2]], # 3-P3/8
+ [-1, 9, BottleneckCSP, [256]],
+ [-1, 1, Conv, [512, 3, 2]], # 5-P4/16
+ [-1, 9, BottleneckCSP, [512]],
+ [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32
+ [-1, 1, SPP, [1024, [5, 9, 13]]],
+ [-1, 3, BottleneckCSP, [1024, False]], # 9
+ ]
+
+# YOLOv5 head
+head:
+ [[-1, 1, Conv, [512, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 6], 1, Concat, [1]], # cat backbone P4
+ [-1, 3, BottleneckCSP, [512, False]], # 13
+
+ [-1, 1, Conv, [256, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 4], 1, Concat, [1]], # cat backbone P3
+ [-1, 3, BottleneckCSP, [256, False]], # 17 (P3/8-small)
+
+ [-1, 1, Conv, [256, 3, 2]],
+ [[-1, 14], 1, Concat, [1]], # cat head P4
+ [-1, 3, BottleneckCSP, [512, False]], # 20 (P4/16-medium)
+
+ [-1, 1, Conv, [512, 3, 2]],
+ [[-1, 10], 1, Concat, [1]], # cat head P5
+ [-1, 3, BottleneckCSP, [1024, False]], # 23 (P5/32-large)
+
+ [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)
+ ]
+```
+
+so we can define the freeze list to contain all modules with 'model.0.' - 'model.9.' in their names:
+
+```bash
+python train.py --freeze 10
+```
+
+## Freeze All Layers
+
+To freeze the full model except for the final output convolution layers in Detect(), we set freeze list to contain all modules with 'model.0.' - 'model.23.' in their names:
+
+```bash
+python train.py --freeze 24
+```
+
+## Results
+
+We train YOLOv5m on VOC on both of the above scenarios, along with a default model (no freezing), starting from the official COCO pretrained `--weights yolov5m.pt`:
+
+```bash
+train.py --batch 48 --weights yolov5m.pt --data voc.yaml --epochs 50 --cache --img 512 --hyp hyp.finetune.yaml
+```
+
+### Accuracy Comparison
+
+The results show that freezing speeds up training, but reduces final accuracy slightly.
+
+
+
+
+
+
+
+### GPU Utilization Comparison
+
+Interestingly, the more modules are frozen the less GPU memory is required to train, and the lower GPU utilization. This indicates that larger models, or models trained at larger --image-size may benefit from freezing in order to train faster.
+
+
+
+
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**:
+- **Google Cloud**: [GCP Quickstart Guide](../environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](../environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](../environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](../environments/docker_image_quickstart_tutorial.md)
+
+## Project Status
+
+
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
diff --git a/ultralytics/docs/en/yolov5/tutorials/transfer_learning_with_frozen_layers.md:Zone.Identifier b/ultralytics/docs/en/yolov5/tutorials/transfer_learning_with_frozen_layers.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/en/yolov5/tutorials/transfer_learning_with_frozen_layers.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/index.md b/ultralytics/docs/es/index.md
new file mode 100755
index 0000000..df84458
--- /dev/null
+++ b/ultralytics/docs/es/index.md
@@ -0,0 +1,83 @@
+---
+comments: true
+description: Explore una guรญa completa sobre Ultralytics YOLOv8, un modelo de alta velocidad y precisiรณn para detecciรณn de objetos y segmentaciรณn de imรกgenes. Tutoriales de instalaciรณn, predicciรณn, entrenamiento y mรกs.
+keywords: Ultralytics, YOLOv8, detecciรณn de objetos, segmentaciรณn de imรกgenes, aprendizaje automรกtico, aprendizaje profundo, visiรณn por computadora, instalaciรณn YOLOv8, predicciรณn YOLOv8, entrenamiento YOLOv8, historia de YOLO, licencias YOLO
+---
+
+
+
+Presentamos [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), la รบltima versiรณn del aclamado modelo para detecciรณn de objetos y segmentaciรณn de imรกgenes en tiempo real. YOLOv8 estรก construido sobre avances de vanguardia en aprendizaje profundo y visiรณn por computadora, ofreciendo un rendimiento sin paralelo en tรฉrminos de velocidad y precisiรณn. Su diseรฑo simplificado lo hace adecuado para varias aplicaciones y fรกcilmente adaptable a diferentes plataformas de hardware, desde dispositivos de borde hasta API en la nube.
+
+Explore los documentos de YOLOv8, un recurso integral diseรฑado para ayudarle a comprender y utilizar sus caracterรญsticas y capacidades. Independientemente de que sea un practicante experimentado en aprendizaje automรกtico o nuevo en el campo, este centro tiene como objetivo maximizar el potencial de YOLOv8 en sus proyectos.
+
+!!! Note "Nota"
+
+ ๐ง Nuestra documentaciรณn en varios idiomas estรก actualmente en construcciรณn y estamos trabajando duro para mejorarla. ยกGracias por su paciencia! ๐
+
+## Dรณnde empezar
+
+- **Instalar** `ultralytics` con pip y comenzar a funcionar en minutos [:material-clock-fast: Comenzar](quickstart.md){ .md-button }
+- **Predecir** nuevas imรกgenes y videos con YOLOv8 [:octicons-image-16: Predecir en Imรกgenes](modes/predict.md){ .md-button }
+- **Entrenar** un nuevo modelo YOLOv8 en su propio conjunto de datos personalizado [:fontawesome-solid-brain: Entrenar un Modelo](modes/train.md){ .md-button }
+- **Explorar** tareas de YOLOv8 como segmentar, clasificar, posar y seguir [:material-magnify-expand: Explorar Tareas](tasks/index.md){ .md-button }
+
+
+
+
+
+ Ver: Cรณmo entrenar un modelo YOLOv8 en Su Conjunto de Datos Personalizado en Google Colab.
+
+
+## YOLO: Una Breve Historia
+
+[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), un modelo popular de detecciรณn de objetos y segmentaciรณn de imรกgenes, fue desarrollado por Joseph Redmon y Ali Farhadi en la Universidad de Washington. Lanzado en 2015, YOLO rรกpidamente ganรณ popularidad por su alta velocidad y precisiรณn.
+
+- [YOLOv2](https://arxiv.org/abs/1612.08242), lanzado en 2016, mejorรณ el modelo original incorporando normalizaciรณn por lotes, cajas ancla y clรบsteres de dimensiones.
+- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lanzado en 2018, mejorรณ aรบn mรกs el rendimiento del modelo usando una red dorsal mรกs eficiente, mรบltiples anclas y agrupaciรณn piramidal espacial.
+- [YOLOv4](https://arxiv.org/abs/2004.10934) fue lanzado en 2020, introduciendo innovaciones como la ampliaciรณn de datos del mosaico, un nuevo cabezal de detecciรณn sin ancla y una nueva funciรณn de pรฉrdida.
+- [YOLOv5](https://github.com/ultralytics/yolov5) mejorรณ aรบn mรกs el rendimiento del modelo y agregรณ nuevas caracterรญsticas como la optimizaciรณn de hiperparรกmetros, seguimiento de experimentos integrados y exportaciรณn automรกtica a formatos de exportaciรณn populares.
+- [YOLOv6](https://github.com/meituan/YOLOv6) fue publicado en cรณdigo abierto por [Meituan](https://about.meituan.com/) en 2022 y se utiliza en muchos de los robots de entrega autรณnomos de la empresa.
+- [YOLOv7](https://github.com/WongKinYiu/yolov7) aรฑadiรณ tareas adicionales como la estimaciรณn de posturas en el conjunto de datos COCO keypoints.
+- [YOLOv8](https://github.com/ultralytics/ultralytics) es la รบltima versiรณn de YOLO de Ultralytics. Como un modelo de vanguardia y del estado del arte (SOTA), YOLOv8 se basa en el รฉxito de las versiones anteriores, introduciendo nuevas caracterรญsticas y mejoras para obtener un rendimiento mejorado, flexibilidad y eficiencia. YOLOv8 soporta una gama completa de tareas de IA de visiรณn, incluyendo [detecciรณn](tasks/detect.md), [segmentaciรณn](tasks/segment.md), [estimaciรณn de pose](tasks/pose.md), [seguimiento](modes/track.md) y [clasificaciรณn](tasks/classify.md). Esta versatilidad permite a los usuarios aprovechar las capacidades de YOLOv8 en una amplia gama de aplicaciones y dominios.
+
+## Licencias de YOLO: ยฟCรณmo estรกn licenciados los YOLO de Ultralytics?
+
+Ultralytics ofrece dos opciones de licencia para acomodar casos de uso diversos:
+
+- **Licencia AGPL-3.0**: Esta licencia de cรณdigo abierto aprobada por [OSI](https://opensource.org/licenses/) es ideal para estudiantes y entusiastas, promoviendo la colaboraciรณn abierta y el intercambio de conocimiento. Consulte el archivo [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) para obtener mรกs detalles.
+- **Licencia Empresarial**: Diseรฑada para uso comercial, esta licencia permite la integraciรณn sin problemas de software de Ultralytics y modelos de IA en bienes y servicios comerciales, eludiendo los requisitos de cรณdigo abierto de AGPL-3.0. Si su escenario implica la incorporaciรณn de nuestras soluciones en una oferta comercial, pรณngase en contacto a travรฉs de [Licencias de Ultralytics](https://ultralytics.com/license).
+
+Nuestra estrategia de licenciamiento estรก diseรฑada para asegurar que cualquier mejora a nuestros proyectos de cรณdigo abierto se devuelva a la comunidad. Mantenemos los principios del cรณdigo abierto cerca de nuestros corazones โค๏ธ, y nuestra misiรณn es garantizar que nuestras contribuciones puedan ser utilizadas y ampliadas de formas que sean beneficiosas para todos.
diff --git a/ultralytics/docs/es/index.md:Zone.Identifier b/ultralytics/docs/es/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/fast-sam.md b/ultralytics/docs/es/models/fast-sam.md
new file mode 100755
index 0000000..dfaee11
--- /dev/null
+++ b/ultralytics/docs/es/models/fast-sam.md
@@ -0,0 +1,193 @@
+---
+comments: true
+description: Explora FastSAM, una soluciรณn basada en CNN para la segmentaciรณn en tiempo real de objetos en imรกgenes. Ofrece una interacciรณn mejorada del usuario, eficiencia computacional y es adaptable a diversas tareas de visiรณn.
+keywords: FastSAM, aprendizaje automรกtico, soluciรณn basada en CNN, segmentaciรณn de objetos, soluciรณn en tiempo real, Ultralytics, tareas de visiรณn, procesamiento de imรกgenes, aplicaciones industriales, interacciรณn del usuario
+---
+
+# Modelo para Segmentar Cualquier Cosa Rรกpidamente (FastSAM)
+
+El Modelo para Segmentar Cualquier Cosa Rรกpidamente (FastSAM) es una soluciรณn novedosa basada en CNN que funciona en tiempo real para la tarea de Segmentar Cualquier Cosa. Esta tarea estรก diseรฑada para segmentar cualquier objeto dentro de una imagen basรกndose en diversas indicaciones posibles de interacciรณn del usuario. FastSAM reduce significativamente las demandas computacionales a la vez que mantiene un rendimiento competitivo, lo que lo convierte en una opciรณn prรกctica para una variedad de tareas de visiรณn.
+
+
+
+## Descripciรณn general
+
+FastSAM estรก diseรฑado para abordar las limitaciones del [Modelo para Segmentar Cualquier Cosa (SAM)](sam.md), un modelo Transformer pesado con requerimientos sustanciales de recursos computacionales. FastSAM divide la tarea de segmentar cualquier cosa en dos etapas secuenciales: segmentaciรณn de todas las instancias y selecciรณn basada en indicaciones. La primera etapa utiliza [YOLOv8-seg](../tasks/segment.md) para producir las mรกscaras de segmentaciรณn de todas las instancias en la imagen. En la segunda etapa, produce la regiรณn de interรฉs correspondiente a la indicaciรณn.
+
+## Caracterรญsticas principales
+
+1. **Soluciรณn en tiempo real:** Al aprovechar la eficiencia computacional de las CNN, FastSAM proporciona una soluciรณn en tiempo real para la tarea de segmentar cualquier cosa, lo que lo hace valioso para aplicaciones industriales que requieren resultados rรกpidos.
+
+2. **Eficiencia y rendimiento:** FastSAM ofrece una reducciรณn significativa en las demandas computacionales y de recursos sin comprometer la calidad del rendimiento. Alcanza un rendimiento comparable al de SAM, pero con recursos computacionales drรกsticamente reducidos, lo que permite su aplicaciรณn en tiempo real.
+
+3. **Segmentaciรณn guiada por indicaciones:** FastSAM puede segmentar cualquier objeto dentro de una imagen guiado por diversas indicaciones posibles de interacciรณn del usuario, lo que proporciona flexibilidad y adaptabilidad en diferentes escenarios.
+
+4. **Basado en YOLOv8-seg:** FastSAM se basa en [YOLOv8-seg](../tasks/segment.md), un detector de objetos equipado con una rama de segmentaciรณn de instancias. Esto le permite producir de manera efectiva las mรกscaras de segmentaciรณn de todas las instancias en una imagen.
+
+5. **Resultados competitivos en pruebas de referencia:** En la tarea de propuesta de objetos de MS COCO, FastSAM alcanza puntuaciones altas a una velocidad significativamente mรกs rรกpida que [SAM](sam.md) en una sola tarjeta NVIDIA RTX 3090, lo que demuestra su eficiencia y capacidad.
+
+6. **Aplicaciones prรกcticas:** El enfoque propuesto proporciona una soluciรณn nueva y prรกctica para un gran nรบmero de tareas de visiรณn a una velocidad muy alta, varias veces mรกs rรกpida que los mรฉtodos actuales.
+
+7. **Factibilidad de compresiรณn del modelo:** FastSAM demuestra la factibilidad de un camino que puede reducir significativamente el esfuerzo computacional al introducir una prioridad artificial en la estructura, abriendo asรญ nuevas posibilidades para la arquitectura de modelos grandes en tareas generales de visiรณn.
+
+## Modelos disponibles, tareas admitidas y modos de funcionamiento
+
+Esta tabla presenta los modelos disponibles con sus pesos pre-entrenados especรญficos, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento, como [Inference](../modes/predict.md) (inferencia), [Validation](../modes/val.md) (validaciรณn), [Training](../modes/train.md) (entrenamiento) y [Export](../modes/export.md) (exportaciรณn), indicados mediante emojis โ para los modos admitidos y emojis โ para los modos no admitidos.
+
+| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|----------------|----------------------|---------------------------------------------------|------------|------------|---------------|-------------|
+| FastSAM-s | `FastSAM-s.pt` | [Segmentaciรณn de Instancias](../tasks/segment.md) | โ | โ | โ | โ |
+| FastSAM-x | `FastSAM-x.pt` | [Segmentaciรณn de Instancias](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Ejemplos de uso
+
+Los modelos FastSAM son fรกciles de integrar en tus aplicaciones Python. Ultralytics proporciona una API y comandos de lรญnea de comandos (CLI) fรกciles de usar para agilizar el desarrollo.
+
+### Uso de predicciรณn
+
+Para realizar la detecciรณn de objetos en una imagen, utiliza el mรฉtodo `predict` de la siguiente manera:
+
+!!! Example "Ejemplo"
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM
+ from ultralytics.models.fastsam import FastSAMPrompt
+
+ # Define una fuente de inferencia
+ source = 'ruta/hacia/bus.jpg'
+
+ # Crea un modelo FastSAM
+ model = FastSAM('FastSAM-s.pt') # o FastSAM-x.pt
+
+ # Ejecuta la inferencia en una imagen
+ everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
+
+ # Prepara un objeto de procesamiento de indicaciones
+ prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
+
+ # Indicaciรณn Everything
+ ann = prompt_process.everything_prompt()
+
+ # Caja predeterminada [0,0,0,0] -> [x1,y1,x2,y2]
+ ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
+
+ # Indicaciรณn de texto
+ ann = prompt_process.text_prompt(text='una foto de un perro')
+
+ # Indicaciรณn de punto
+ # puntos predeterminados [[0,0]] [[x1,y1],[x2,y2]]
+ # etiqueta_predeterminada [0] [1,0] 0:fondo, 1:primer plano
+ ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
+ prompt_process.plot(annotations=ann, output='./')
+ ```
+
+ === "CLI"
+ ```bash
+ # Carga un modelo FastSAM y segmenta todo con รฉl
+ yolo segment predict model=FastSAM-s.pt source=ruta/hacia/bus.jpg imgsz=640
+ ```
+
+Este fragmento de cรณdigo demuestra la simplicidad de cargar un modelo pre-entrenado y realizar una predicciรณn en una imagen.
+
+### Uso de validaciรณn
+
+La validaciรณn del modelo en un conjunto de datos se puede realizar de la siguiente manera:
+
+!!! Example "Ejemplo"
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM
+
+ # Crea un modelo FastSAM
+ model = FastSAM('FastSAM-s.pt') # o FastSAM-x.pt
+
+ # Valida el modelo
+ results = model.val(data='coco8-seg.yaml')
+ ```
+
+ === "CLI"
+ ```bash
+ # Carga un modelo FastSAM y valida en el conjunto de datos de ejemplo COCO8 con un tamaรฑo de imagen de 640
+ yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
+ ```
+
+Ten en cuenta que FastSAM solo admite la detecciรณn y segmentaciรณn de una sola clase de objeto. Esto significa que reconocerรก y segmentarรก todos los objetos como si fueran de la misma clase. Por lo tanto, al preparar el conjunto de datos, debes convertir todos los IDs de categorรญa de objetos a 0.
+
+## Uso oficial de FastSAM
+
+FastSAM tambiรฉn estรก disponible directamente en el repositorio [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM). Aquรญ hay una descripciรณn general breve de los pasos tรญpicos que podrรญas seguir para usar FastSAM:
+
+### Instalaciรณn
+
+1. Clona el repositorio de FastSAM:
+ ```shell
+ git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
+ ```
+
+2. Crea y activa un entorno Conda con Python 3.9:
+ ```shell
+ conda create -n FastSAM python=3.9
+ conda activate FastSAM
+ ```
+
+3. Navega hasta el repositorio clonado e instala los paquetes requeridos:
+ ```shell
+ cd FastSAM
+ pip install -r requirements.txt
+ ```
+
+4. Instala el modelo CLIP:
+ ```shell
+ pip install git+https://github.com/openai/CLIP.git
+ ```
+
+### Ejemplo de uso
+
+1. Descarga un [punto de control del modelo](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing).
+
+2. Utiliza FastSAM para inferencia. Ejemplos de comandos:
+
+ - Segmentar todo en una imagen:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
+ ```
+
+ - Segmentar objetos especรญficos utilizando una indicaciรณn de texto:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "el perro amarillo"
+ ```
+
+ - Segmentar objetos dentro de una caja delimitadora (proporciona las coordenadas de la caja en formato xywh):
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
+ ```
+
+ - Segmentar objetos cerca de puntos especรญficos:
+ ```shell
+ python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
+ ```
+
+Ademรกs, puedes probar FastSAM a travรฉs de una [demostraciรณn en Colab](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) o en la [demostraciรณn web de HuggingFace](https://huggingface.co/spaces/An-619/FastSAM) para tener una experiencia visual.
+
+## Citas y agradecimientos
+
+Nos gustarรญa agradecer a los autores de FastSAM por sus importantes contribuciones en el campo de la segmentaciรณn de instancias en tiempo real:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{zhao2023fast,
+ title={Fast Segment Anything},
+ author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
+ year={2023},
+ eprint={2306.12156},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+El artรญculo original de FastSAM se puede encontrar en [arXiv](https://arxiv.org/abs/2306.12156). Los autores han puesto su trabajo a disposiciรณn del pรบblico, y el cรณdigo base se puede acceder en [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). Agradecemos sus esfuerzos para avanzar en el campo y hacer que su trabajo sea accesible a la comunidad en general.
diff --git a/ultralytics/docs/es/models/fast-sam.md:Zone.Identifier b/ultralytics/docs/es/models/fast-sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/fast-sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/index.md b/ultralytics/docs/es/models/index.md
new file mode 100755
index 0000000..a7137f9
--- /dev/null
+++ b/ultralytics/docs/es/models/index.md
@@ -0,0 +1,98 @@
+---
+comments: true
+description: Explore la amplia gama de modelos de la familia YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS y RT-DETR soportados por Ultralytics. Comienza con ejemplos para el uso tanto de CLI como de Python.
+keywords: Ultralytics, documentaciรณn, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modelos, arquitecturas, Python, CLI
+---
+
+# Modelos soportados por Ultralytics
+
+ยกBienvenido a la documentaciรณn de modelos de Ultralytics! Ofrecemos soporte para una amplia gama de modelos, cada uno adaptado a tareas especรญficas como [detecciรณn de objetos](../tasks/detect.md), [segmentaciรณn de instancias](../tasks/segment.md), [clasificaciรณn de imรกgenes](../tasks/classify.md), [estimaciรณn de posturas](../tasks/pose.md), y [seguimiento de mรบltiples objetos](../modes/track.md). Si estรกs interesado en contribuir con tu arquitectura de modelo a Ultralytics, consulta nuestra [Guรญa de Contribuciรณn](../../help/contributing.md).
+
+!!! Note "Nota"
+
+ ๐ง Estamos trabajando arduamente para mejorar nuestra documentaciรณn en varios idiomas actualmente en construcciรณn. ยกGracias por tu paciencia! ๐
+
+## Modelos destacados
+
+Aquรญ estรกn algunos de los modelos clave soportados:
+
+1. **[YOLOv3](yolov3.md)**: La tercera iteraciรณn de la familia de modelos YOLO, original de Joseph Redmon, conocida por su capacidad de detecciรณn de objetos en tiempo real eficientemente.
+2. **[YOLOv4](yolov4.md)**: Una actualizaciรณn nativa de darknet para YOLOv3, lanzada por Alexey Bochkovskiy en 2020.
+3. **[YOLOv5](yolov5.md)**: Una versiรณn mejorada de la arquitectura YOLO por Ultralytics, ofreciendo un mejor rendimiento y compromiso de velocidad comparado con versiones anteriores.
+4. **[YOLOv6](yolov6.md)**: Lanzado por [Meituan](https://about.meituan.com/) en 2022, y utilizado en muchos de los robots de entrega autรณnomos de la compaรฑรญa.
+5. **[YOLOv7](yolov7.md)**: Modelos YOLO actualizados lanzados en 2022 por los autores de YOLOv4.
+6. **[YOLOv8](yolov8.md) NUEVO ๐**: La รบltima versiรณn de la familia YOLO, con capacidades mejoradas como segmentaciรณn de instancias, estimaciรณn de posturas/puntos clave y clasificaciรณn.
+7. **[Modelo Segment Anything (SAM)](sam.md)**: Modelo Segment Anything (SAM) de Meta.
+8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM para aplicaciones mรณviles, por la Universidad de Kyung Hee.
+9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: FastSAM por el Grupo de Anรกlisis de Imagen y Video, Instituto de Automatizaciรณn, Academia China de Ciencias.
+10. **[YOLO-NAS](yolo-nas.md)**: Modelos YOLO de Bรบsqueda de Arquitectura Neural (NAS).
+11. **[Transformadores de Detecciรณn en Tiempo Real (RT-DETR)](rtdetr.md)**: Modelos de Transformador de Detecciรณn en Tiempo Real (RT-DETR) de Baidu's PaddlePaddle.
+
+
+
+
+
+ Mira: Ejecuta modelos YOLO de Ultralytics en solo unas pocas lรญneas de cรณdigo.
+
+
+## Empezando: Ejemplos de Uso
+
+Este ejemplo proporciona ejemplos simples de entrenamiento e inferencia YOLO. Para la documentaciรณn completa de estos y otros [modos](../modes/index.md), consulta las pรกginas de documentaciรณn de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
+
+Nota que el siguiente ejemplo es para los modelos YOLOv8 [Detect](../tasks/detect.md) para detecciรณn de objetos. Para tareas adicionales soportadas, consulta la documentaciรณn de [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) y [Pose](../tasks/pose.md).
+
+!!! Example "Ejemplo"
+
+ === "Python"
+
+ Los modelos pre-entrenados `*.pt` de PyTorch asรญ como los archivos de configuraciรณn `*.yaml` se pueden pasar a las clases `YOLO()`, `SAM()`, `NAS()` y `RTDETR()` para crear una instancia de modelo en Python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Cargar un modelo YOLOv8n preentrenado en COCO
+ model = YOLO('yolov8n.pt')
+
+ # Mostrar informaciรณn del modelo (opcional)
+ model.info()
+
+ # Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Ejecutar inferencia con el modelo YOLOv8n en la imagen 'bus.jpg'
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ Los comandos CLI estรกn disponibles para ejecutar directamente los modelos:
+
+ ```bash
+ # Cargar un modelo YOLOv8n preentrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Cargar un modelo YOLOv8n preentrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg'
+ yolo predict model=yolov8n.pt source=path/to/bus.jpg
+ ```
+
+## Contribuir con Nuevos Modelos
+
+ยฟInteresado en contribuir con tu modelo a Ultralytics? ยกGenial! Siempre estamos abiertos a expandir nuestro portafolio de modelos.
+
+1. **Haz un Fork del Repositorio**: Comienza haciendo un fork del [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics).
+
+2. **Clona tu Fork**: Clona tu fork a tu mรกquina local y crea una nueva rama para trabajar.
+
+3. **Implementa tu Modelo**: Aรฑade tu modelo siguiendo los estรกndares de codificaciรณn y directrices proporcionadas en nuestra [Guรญa de Contribuciรณn](../../help/contributing.md).
+
+4. **Prueba Rigurosamente**: Asegรบrate de probar tu modelo rigurosamente, tanto de forma aislada como parte del proceso.
+
+5. **Crea un Pull Request**: Una vez que estรฉs satisfecho con tu modelo, crea un pull request al repositorio principal para revisiรณn.
+
+6. **Revisiรณn de Cรณdigo y Fusiรณn**: Despuรฉs de la revisiรณn, si tu modelo cumple con nuestros criterios, serรก fusionado al repositorio principal.
+
+Para pasos detallados, consulta nuestra [Guรญa de Contribuciรณn](../../help/contributing.md).
diff --git a/ultralytics/docs/es/models/index.md:Zone.Identifier b/ultralytics/docs/es/models/index.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/index.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/mobile-sam.md b/ultralytics/docs/es/models/mobile-sam.md
new file mode 100755
index 0000000..bf68ab7
--- /dev/null
+++ b/ultralytics/docs/es/models/mobile-sam.md
@@ -0,0 +1,116 @@
+---
+comments: true
+description: Obtรฉn mรกs informaciรณn sobre MobileSAM, su implementaciรณn, comparaciรณn con SAM original y cรณmo descargarlo y probarlo en el framework de Ultralytics. ยกMejora tus aplicaciones mรณviles hoy mismo!
+keywords: MobileSAM, Ultralytics, SAM, aplicaciones mรณviles, Arxiv, GPU, API, codificador de imรกgenes, decodificador de mรกscaras, descarga de modelos, mรฉtodo de prueba
+---
+
+
+
+# Segmentaciรณn Mรณvil de Cualquier Cosa (MobileSAM)
+
+El artรญculo de MobileSAM ahora estรก disponible en [arXiv](https://arxiv.org/pdf/2306.14289.pdf).
+
+Una demostraciรณn de MobileSAM funcionando en una CPU se puede acceder en este [enlace de demostraciรณn](https://huggingface.co/spaces/dhkim2810/MobileSAM). El rendimiento en una CPU Mac i5 tarda aproximadamente 3 segundos. En la demostraciรณn de Hugging Face, la interfaz y las CPUs de menor rendimiento contribuyen a una respuesta mรกs lenta, pero sigue funcionando de manera efectiva.
+
+MobileSAM se implementa en varios proyectos, incluyendo [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling) y [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D).
+
+MobileSAM se entrena en una sola GPU con un conjunto de datos de 100k (1% de las imรกgenes originales) en menos de un dรญa. El cรณdigo para este entrenamiento estarรก disponible en el futuro.
+
+## Modelos Disponibles, Tareas Admitidas y Modos de Operaciรณn
+
+Esta tabla presenta los modelos disponibles con sus pesos pre-entrenados especรญficos, las tareas que admiten y su compatibilidad con diferentes modos de operaciรณn como [Inference (Inferencia)](../modes/predict.md), [Validation (Validaciรณn)](../modes/val.md), [Training (Entrenamiento)](../modes/train.md) y [Export (Exportaciรณn)](../modes/export.md), indicados por emojis โ para los modos admitidos y emojis โ para los modos no admitidos.
+
+| Tipo de Modelo | Pesos Pre-entrenados | Tareas Admitidas | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|----------------|----------------------|---------------------------------------------------|------------|------------|---------------|-------------|
+| MobileSAM | `mobile_sam.pt` | [Segmentaciรณn de Instancias](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Adaptaciรณn de SAM a MobileSAM
+
+Dado que MobileSAM mantiene el mismo pipeline que SAM original, hemos incorporado el pre-procesamiento, post-procesamiento y todas las demรกs interfaces del original. En consecuencia, aquellos que actualmente utilizan SAM original pueden hacer la transiciรณn a MobileSAM con un esfuerzo mรญnimo.
+
+MobileSAM tiene un rendimiento comparable a SAM original y mantiene el mismo pipeline excepto por un cambio en el codificador de imรกgenes. Especรญficamente, reemplazamos el codificador de imรกgenes original ViT-H pesado (632M) por uno mรกs pequeรฑo, Tiny-ViT (5M). En una sola GPU, MobileSAM funciona a aproximadamente 12ms por imagen: 8ms en el codificador de imรกgenes y 4ms en el decodificador de mรกscaras.
+
+La siguiente tabla proporciona una comparaciรณn de los codificadores de imรกgenes basados en ViT:
+
+| Codificador de Imรกgenes | SAM Original | MobileSAM |
+|-------------------------|--------------|-----------|
+| Parรกmetros | 611M | 5M |
+| Velocidad | 452ms | 8ms |
+
+Tanto SAM original como MobileSAM utilizan el mismo decodificador de mรกscaras guiado por instrucciones:
+
+| Decodificador de Mรกscaras | SAM Original | MobileSAM |
+|---------------------------|--------------|-----------|
+| Parรกmetros | 3.876M | 3.876M |
+| Velocidad | 4ms | 4ms |
+
+Aquรญ estรก la comparaciรณn de todo el pipeline:
+
+| Pipeline Completo (Enc+Dec) | SAM Original | MobileSAM |
+|-----------------------------|--------------|-----------|
+| Parรกmetros | 615M | 9.66M |
+| Velocidad | 456ms | 12ms |
+
+El rendimiento de MobileSAM y SAM original se demuestra utilizando tanto un punto como una caja como instrucciones.
+
+
+
+
+
+Con su rendimiento superior, MobileSAM es aproximadamente 5 veces mรกs pequeรฑo y 7 veces mรกs rรกpido que el actual FastSAM. Mรกs detalles estรกn disponibles en la [pรกgina del proyecto de MobileSAM](https://github.com/ChaoningZhang/MobileSAM).
+
+## Probando MobileSAM en Ultralytics
+
+Al igual que SAM original, ofrecemos un mรฉtodo sencillo de prueba en Ultralytics, que incluye modos tanto para instrucciones de Punto como para Caja.
+
+### Descarga del Modelo
+
+Puedes descargar el modelo [aquรญ](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt).
+
+### Instrucciรณn de Punto
+
+!!! Example "Ejemplo"
+
+ === "Python"
+ ```python
+ from ultralytics import SAM
+
+ # Carga el modelo
+ model = SAM('mobile_sam.pt')
+
+ # Predice un segmento basado en una instrucciรณn de punto
+ model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
+ ```
+
+### Instrucciรณn de Caja
+
+!!! Example "Ejemplo"
+
+ === "Python"
+ ```python
+ from ultralytics import SAM
+
+ # Carga el modelo
+ model = SAM('mobile_sam.pt')
+
+ # Predice un segmento basado en una instrucciรณn de caja
+ model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
+ ```
+
+Hemos implementado `MobileSAM` y `SAM` utilizando la misma API. Para obtener mรกs informaciรณn sobre cรณmo usarlo, consulta la [pรกgina de SAM](sam.md).
+
+## Citaciones y Reconocimientos
+
+Si encuentras รบtil MobileSAM en tu investigaciรณn o trabajo de desarrollo, considera citar nuestro artรญculo:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{mobile_sam,
+ title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications},
+ author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon},
+ journal={arXiv preprint arXiv:2306.14289},
+ year={2023}
+ }
diff --git a/ultralytics/docs/es/models/mobile-sam.md:Zone.Identifier b/ultralytics/docs/es/models/mobile-sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/mobile-sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/rtdetr.md b/ultralytics/docs/es/models/rtdetr.md
new file mode 100755
index 0000000..fada0ae
--- /dev/null
+++ b/ultralytics/docs/es/models/rtdetr.md
@@ -0,0 +1,93 @@
+---
+comments: true
+description: Descubre las caracterรญsticas y beneficios de RT-DETR, un eficiente y adaptable detector de objetos en tiempo real desarrollado por Baidu y potenciado por Vision Transformers, que incluye modelos pre-entrenados.
+keywords: RT-DETR, Baidu, Vision Transformers, detecciรณn de objetos, rendimiento en tiempo real, CUDA, TensorRT, selecciรณn de consultas IoU, Ultralytics, API de Python, PaddlePaddle
+---
+
+# RT-DETR de Baidu: Un Detector de Objetos en Tiempo Real Basado en Vision Transformers
+
+## Resumen
+
+Real-Time Detection Transformer (RT-DETR), desarrollado por Baidu, es un avanzado detector de objetos de extremo a extremo que proporciona un rendimiento en tiempo real manteniendo una alta precisiรณn. Utiliza la potencia de Vision Transformers (ViT) para procesar de manera eficiente caracterรญsticas de mรบltiples escalas mediante la descomposiciรณn de la interacciรณn intra-escala y la fusiรณn inter-escala. RT-DETR es altamente adaptable y permite ajustar de manera flexible la velocidad de inferencia utilizando diferentes capas de decodificador sin necesidad de volver a entrenar el modelo. El modelo se destaca en plataformas aceleradas como CUDA con TensorRT, superando a muchos otros detectores de objetos en tiempo real.
+
+
+**Resumen de RT-DETR de Baidu.** El diagrama de la arquitectura del modelo RT-DETR muestra las รบltimas tres etapas del canal (S3, S4, S5) como entrada al codificador. El eficiente codificador hรญbrido transforma caracterรญsticas de mรบltiples escalas en una secuencia de caracterรญsticas de imagen a travรฉs del mรณdulo de interacciรณn de caracterรญsticas intra-escala (AIFI) y el mรณdulo de fusiรณn de caracterรญsticas inter-escala (CCFM). Se utiliza la selecciรณn de consultas IoU-aware para seleccionar un nรบmero fijo de caracterรญsticas de imagen que servirรกn como consultas iniciales de objetos para el decodificador. Finalmente, el decodificador con cabeceras de predicciรณn auxiliares optimiza iterativamente las consultas de objetos para generar cajas y puntuaciones de confianza ([fuente](https://arxiv.org/pdf/2304.08069.pdf)).
+
+### Caracterรญsticas Clave
+
+- **Codificador Hรญbrido Eficiente:** RT-DETR de Baidu utiliza un codificador hรญbrido eficiente que procesa caracterรญsticas de mรบltiples escalas mediante la descomposiciรณn de la interacciรณn intra-escala y la fusiรณn inter-escala. Este diseรฑo รบnico basado en Vision Transformers reduce los costos computacionales y permite la detecciรณn de objetos en tiempo real.
+- **Selecciรณn de Consultas IoU-aware:** RT-DETR de Baidu mejora la inicializaciรณn de las consultas de objetos utilizando la selecciรณn de consultas IoU-aware. Esto permite que el modelo se enfoque en los objetos mรกs relevantes de la escena, mejorando la precisiรณn en la detecciรณn.
+- **Velocidad de Inferencia Adaptable:** RT-DETR de Baidu admite ajustes flexibles de la velocidad de inferencia utilizando diferentes capas de decodificador sin necesidad de volver a entrenar el modelo. Esta adaptabilidad facilita la aplicaciรณn prรกctica en diversos escenarios de detecciรณn de objetos en tiempo real.
+
+## Modelos Pre-entrenados
+
+La API de Python de Ultralytics proporciona modelos pre-entrenados de RT-DETR de PaddlePaddle en diferentes escalas:
+
+- RT-DETR-L: 53.0% AP en COCO val2017, 114 FPS en GPU T4
+- RT-DETR-X: 54.8% AP en COCO val2017, 74 FPS en GPU T4
+
+## Ejemplos de Uso
+
+Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de RT-DETRR. Para obtener una documentaciรณn completa sobre estos y otros [modos](../modes/index.md), consulta las pรกginas de documentaciรณn de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
+
+!!! Example "Ejemplo"
+
+ === "Python"
+
+ ```python
+ from ultralytics import RTDETR
+
+ # Cargar un modelo RT-DETR-l pre-entrenado en COCO
+ model = RTDETR('rtdetr-l.pt')
+
+ # Mostrar informaciรณn del modelo (opcional)
+ model.info()
+
+ # Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Realizar inferencia con el modelo RT-DETR-l en la imagen 'bus.jpg'
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Cargar un modelo RT-DETR-l pre-entrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Cargar un modelo RT-DETR-l pre-entrenado en COCO y realizar inferencia en la imagen 'bus.jpg'
+ yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
+ ```
+
+## Tareas y Modos Admitidos
+
+Esta tabla presenta los tipos de modelos, los pesos pre-entrenados especรญficos, las tareas admitidas por cada modelo y los diversos modos ([Train](../modes/train.md) , [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)) admitidos, indicados por los emojis โ .
+
+| Tipo de Modelo | Pesos Pre-entrenados | Tareas Admitidas | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|---------------------|----------------------|--------------------------------------------|------------|------------|---------------|-------------|
+| RT-DETR Large | `rtdetr-l.pt` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| RT-DETR Extra-Large | `rtdetr-x.pt` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+
+## Citaciones y Agradecimientos
+
+Si utilizas RT-DETR de Baidu en tu investigaciรณn o trabajo de desarrollo, por favor cita el [artรญculo original](https://arxiv.org/abs/2304.08069):
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{lv2023detrs,
+ title={DETRs Beat YOLOs on Real-time Object Detection},
+ author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu},
+ year={2023},
+ eprint={2304.08069},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+Nos gustarรญa agradecer a Baidu y al equipo de [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) por crear y mantener este valioso recurso para la comunidad de visiรณn por computadora. Apreciamos enormemente su contribuciรณn al campo con el desarrollo del detector de objetos en tiempo real basado en Vision Transformers, RT-DETR.
+
+*keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, detecciรณn de objetos en tiempo real, detecciรณn de objetos basada en Vision Transformers, modelos pre-entrenados PaddlePaddle RT-DETR, uso de RT-DETR de Baidu, API de Python de Ultralytics*
diff --git a/ultralytics/docs/es/models/rtdetr.md:Zone.Identifier b/ultralytics/docs/es/models/rtdetr.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/rtdetr.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/sam.md b/ultralytics/docs/es/models/sam.md
new file mode 100755
index 0000000..966c5be
--- /dev/null
+++ b/ultralytics/docs/es/models/sam.md
@@ -0,0 +1,226 @@
+---
+comments: true
+description: Explora el revolucionario Segment Anything Model (SAM) de Ultralytics que permite la segmentaciรณn de imรกgenes en tiempo real. Aprende sobre su segmentaciรณn por indicaciรณn, rendimiento en la transferencia sin entrenamiento y cรณmo usarlo.
+keywords: Ultralytics, segmentaciรณn de imรกgenes, Segment Anything Model, SAM, SA-1B dataset, rendimiento en tiempo real, transferencia sin entrenamiento, detecciรณn de objetos, anรกlisis de imรกgenes, aprendizaje automรกtico
+---
+
+# Segment Anything Model (SAM)
+
+Bienvenido al frontera de la segmentaciรณn de imรกgenes con el Segment Anything Model, o SAM. Este modelo revolucionario ha cambiado el juego al introducir la segmentaciรณn de imรกgenes por indicaciรณn con rendimiento en tiempo real, estableciendo nuevos estรกndares en el campo.
+
+## Introducciรณn a SAM: Segment Anything Model
+
+El Segment Anything Model, o SAM, es un modelo de segmentaciรณn de imรกgenes de vanguardia que permite la segmentaciรณn por indicaciรณn, ofreciendo una versatilidad sin igual en las tareas de anรกlisis de imรกgenes. SAM forma el corazรณn de la iniciativa Segment Anything, un proyecto innovador que presenta un modelo, una tarea y un conjunto de datos nuevos para la segmentaciรณn de imรกgenes.
+
+El diseรฑo avanzado de SAM le permite adaptarse a nuevas distribuciones y tareas de imรกgenes sin conocimientos previos, una caracterรญstica conocida como transferencia sin entrenamiento. Entrenado en el extenso [conjunto de datos SA-1B](https://ai.facebook.com/datasets/segment-anything/), que contiene mรกs de mil millones de mรกscaras distribuidas en once millones de imรกgenes seleccionadas cuidadosamente, SAM ha demostrado un impresionante rendimiento en la transferencia sin entrenamiento, superando en muchos casos los resultados de supervisiรณn completa anteriores.
+
+
+Imรกgenes de ejemplo con mรกscaras superpuestas de nuestro nuevo conjunto de datos, SA-1B. SA-1B contiene 11 millones de imรกgenes diversas de alta resoluciรณn, con licencia y protecciรณn de la privacidad, y 1.1 mil millones de mรกscaras de segmentaciรณn de alta calidad. Estas mรกscaras fueron anotadas completamente automรกticamente por SAM y, segรบn las calificaciones humanas y numerosos experimentos, tienen una alta calidad y diversidad. Las imรกgenes se agrupan por nรบmero de mรกscaras por imagen para su visualizaciรณn (hay aproximadamente 100 mรกscaras por imagen en promedio).
+
+## Caracterรญsticas clave del Segment Anything Model (SAM)
+
+- **Tarea de segmentaciรณn por indicaciรณn**: SAM fue diseรฑado teniendo en cuenta una tarea de segmentaciรณn por indicaciรณn, lo que le permite generar mรกscaras de segmentaciรณn vรกlidas a partir de cualquier indicaciรณn dada, como pistas espaciales o de texto que identifican un objeto.
+- **Arquitectura avanzada**: El Segment Anything Model utiliza un potente codificador de imรกgenes, un codificador de indicaciones y un decodificador de mรกscaras ligero. Esta arquitectura รบnica permite la indicaciรณn flexible, el cรกlculo de mรกscaras en tiempo real y la conciencia de ambigรผedades en las tareas de segmentaciรณn.
+- **El conjunto de datos SA-1B**: Introducido por el proyecto Segment Anything, el conjunto de datos SA-1B cuenta con mรกs de mil millones de mรกscaras en once millones de imรกgenes. Como el conjunto de datos de segmentaciรณn mรกs grande hasta la fecha, proporciona a SAM una fuente de datos de entrenamiento diversa y a gran escala.
+- **Rendimiento en la transferencia sin entrenamiento**: SAM muestra un destacado rendimiento en la transferencia sin entrenamiento en diversas tareas de segmentaciรณn, lo que lo convierte en una herramienta lista para usar en diversas aplicaciones con una necesidad mรญnima de ingenierรญa de indicaciรณn.
+
+Para obtener una visiรณn mรกs detallada del Segment Anything Model y el conjunto de datos SA-1B, visita el [sitio web de Segment Anything](https://segment-anything.com) y consulta el artรญculo de investigaciรณn [Segment Anything](https://arxiv.org/abs/2304.02643).
+
+## Modelos disponibles, tareas admitidas y modos de funcionamiento
+
+Esta tabla muestra los modelos disponibles con sus pesos pre-entrenados especรญficos, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento como [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) y [Export](../modes/export.md), indicados con emojis โ para los modos admitidos y emojis โ para los modos no admitidos.
+
+| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inference | Validation | Training | Export |
+|----------------|----------------------|---------------------------------------------------|-----------|------------|----------|--------|
+| SAM base | `sam_b.pt` | [Segmentaciรณn de instancias](../tasks/segment.md) | โ | โ | โ | โ |
+| SAM large | `sam_l.pt` | [Segmentaciรณn de instancias](../tasks/segment.md) | โ | โ | โ | โ |
+
+## Cรณmo usar SAM: Versatilidad y potencia en la segmentaciรณn de imรกgenes
+
+El Segment Anything Model se puede utilizar para una multitud de tareas posteriores que van mรกs allรก de sus datos de entrenamiento. Esto incluye detecciรณn de bordes, generaciรณn de propuestas de objetos, segmentaciรณn de instancias y predicciรณn preliminar de texto a mรกscara. Con la ingenierรญa de indicaciรณn, SAM puede adaptarse rรกpidamente a nuevas tareas y distribuciones de datos de manera sin entrenamiento, estableciรฉndolo como una herramienta versรกtil y potente para todas tus necesidades de segmentaciรณn de imรกgenes.
+
+### Ejemplo de predicciรณn con SAM
+
+!!! Example "Segmentar con indicaciones"
+
+ Segmenta la imagen con las indicaciones proporcionadas.
+
+ === "Python"
+
+ ```python
+ from ultralytics import SAM
+
+ # Cargar un modelo
+ modelo = SAM('sam_b.pt')
+
+ # Mostrar informaciรณn del modelo (opcional)
+ modelo.info()
+
+ # Ejecutar inferencia con indicaciones de bboxes
+ modelo('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
+
+ # Ejecutar inferencia con indicaciones de puntos
+ modelo('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
+ ```
+
+!!! Example "Segmentar todo"
+
+ Segmenta toda la imagen.
+
+ === "Python"
+
+ ```python
+ from ultralytics import SAM
+
+ # Cargar un modelo
+ modelo = SAM('sam_b.pt')
+
+ # Mostrar informaciรณn del modelo (opcional)
+ modelo.info()
+
+ # Ejecutar inferencia
+ modelo('ruta/hacia/imagen.jpg')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Ejecutar inferencia con un modelo SAM
+ yolo predict model=sam_b.pt source=ruta/hacia/imagen.jpg
+ ```
+
+- La lรณgica aquรญ es segmentar toda la imagen si no se proporcionan indicaciones (bboxes/puntos/mรกscaras).
+
+!!! Example "Ejemplo de SAMPredictor"
+
+ De esta manera, puedes configurar una imagen una vez y ejecutar inferencia con indicaciones mรบltiples sin ejecutar el codificador de imรกgenes mรบltiples veces.
+
+ === "Inferencia con indicaciones"
+
+ ```python
+ from ultralytics.models.sam import Predictor as SAMPredictor
+
+ # Crear SAMPredictor
+ opciones = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
+ predictor = SAMPredictor(opciones=opciones)
+
+ # Establecer imagen
+ predictor.set_image("ultralytics/assets/zidane.jpg") # establecer con archivo de imagen
+ predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # establecer con np.ndarray
+ resultados = predictor(bboxes=[439, 437, 524, 709])
+ resultados = predictor(points=[900, 370], labels=[1])
+
+ # Restablecer imagen
+ predictor.reset_image()
+ ```
+
+ Segmentar todo con argumentos adicionales.
+
+ === "Segmentar todo"
+
+ ```python
+ from ultralytics.models.sam import Predictor as SAMPredictor
+
+ # Crear SAMPredictor
+ opciones = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
+ predictor = SAMPredictor(opciones=opciones)
+
+ # Segmentar con argumentos adicionales
+ resultados = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
+ ```
+
+- Mรกs argumentos adicionales para `Segmentar todo` en [`Referencia de Predictor/generate`](../../../reference/models/sam/predict.md).
+
+## SAM comparado con YOLOv8
+
+Aquรญ comparamos el modelo SAM mรกs pequeรฑo de Meta, SAM-b, con el modelo de segmentaciรณn mรกs pequeรฑo de Ultralytics, [YOLOv8n-seg](../tasks/segment.md):
+
+| Modelo | Tamaรฑo | Parรกmetros | Velocidad (CPU) |
+|-------------------------------------------------|-------------------------------------|------------------------------|-------------------------------------|
+| SAM-b de Meta | 358 MB | 94.7 M | 51096 ms/im |
+| [MobileSAM](mobile-sam.md) | 40.7 MB | 10.1 M | 46122 ms/im |
+| [FastSAM-s](fast-sam.md) con respaldo de YOLOv8 | 23.7 MB | 11.8 M | 115 ms/im |
+| YOLOv8n-seg de Ultralytics | **6.7 MB** (53.4 veces mรกs pequeรฑo) | **3.4 M** (27.9 veces menos) | **59 ms/im** (866 veces mรกs rรกpido) |
+
+Esta comparaciรณn muestra las diferencias de รณrdenes de magnitud en los tamaรฑos y velocidades de los modelos. Si bien SAM presenta capacidades รบnicas para la segmentaciรณn automรกtica, no es un competidor directo de los modelos de segmentaciรณn YOLOv8, que son mรกs pequeรฑos, mรกs rรกpidos y mรกs eficientes.
+
+Las pruebas se realizaron en una MacBook Apple M2 de 2023 con 16 GB de RAM. Para reproducir esta prueba:
+
+!!! Example "Ejemplo"
+
+ === "Python"
+ ```python
+ from ultralytics import FastSAM, SAM, YOLO
+
+ # Perfil del modelo SAM-b
+ modelo = SAM('sam_b.pt')
+ modelo.info()
+ modelo('ultralytics/assets')
+
+ # Perfil de MobileSAM
+ modelo = SAM('mobile_sam.pt')
+ modelo.info()
+ modelo('ultralytics/assets')
+
+ # Perfil de FastSAM-s
+ modelo = FastSAM('FastSAM-s.pt')
+ modelo.info()
+ modelo('ultralytics/assets')
+
+ # Perfil de YOLOv8n-seg
+ modelo = YOLO('yolov8n-seg.pt')
+ modelo.info()
+ modelo('ultralytics/assets')
+ ```
+
+## Auto-anotaciรณn: un camino rรกpido hacia conjuntos de datos de segmentaciรณn
+
+La auto-anotaciรณn es una caracterรญstica clave de SAM que permite a los usuarios generar un [conjunto de datos de segmentaciรณn](https://docs.ultralytics.com/datasets/segment) utilizando un modelo de detecciรณn pre-entrenado. Esta funciรณn permite una anotaciรณn rรกpida y precisa de un gran nรบmero de imรกgenes, evitando la necesidad de una etiquetaciรณn manual que consume mucho tiempo.
+
+### Generar tu conjunto de datos de segmentaciรณn utilizando un modelo de detecciรณn
+
+Para auto-anotar tu conjunto de datos con el marco de trabajo de Ultralytics, utiliza la funciรณn `auto_annotate` como se muestra a continuaciรณn:
+
+!!! Example "Ejemplo"
+
+ === "Python"
+ ```python
+ from ultralytics.data.annotator import auto_annotate
+
+ auto_annotate(data="ruta/a/las/imagenes", det_model="yolov8x.pt", sam_model='sam_b.pt')
+ ```
+
+| Argumento | Tipo | Descripciรณn | Predeterminado |
+|------------|---------------------|-----------------------------------------------------------------------------------------------------------------------|----------------|
+| data | str | Ruta a una carpeta que contiene las imรกgenes a anotar. | |
+| det_model | str, opcional | Modelo de detecciรณn YOLO pre-entrenado. Por defecto, 'yolov8x.pt'. | 'yolov8x.pt' |
+| sam_model | str, opcional | Modelo de segmentaciรณn SAM pre-entrenado. Por defecto, 'sam_b.pt'. | 'sam_b.pt' |
+| device | str, opcional | Dispositivo en el que ejecutar los modelos. Por defecto, una cadena vacรญa (CPU o GPU, si estรก disponible). | |
+| output_dir | str, None, opcional | Directorio para guardar los resultados anotados. Por defecto, una carpeta 'labels' en el mismo directorio que 'data'. | None |
+
+La funciรณn `auto_annotate` toma la ruta de tus imรกgenes, con argumentos opcionales para especificar los modelos de detecciรณn y segmentaciรณn SAM pre-entrenados, el dispositivo en el que ejecutar los modelos, y el directorio de salida para guardar los resultados anotados.
+
+La auto-anotaciรณn con modelos pre-entrenados puede reducir drรกsticamente el tiempo y el esfuerzo requeridos para crear conjuntos de datos de segmentaciรณn de alta calidad. Esta caracterรญstica es especialmente beneficiosa para investigadores y desarrolladores que trabajan con grandes colecciones de imรกgenes, ya que les permite centrarse en el desarrollo y la evaluaciรณn de modelos en lugar de en la anotaciรณn manual.
+
+## Citas y agradecimientos
+
+Si encuentras รบtil SAM en tu trabajo de investigaciรณn o desarrollo, considera citar nuestro artรญculo:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{kirillov2023segment,
+ title={Segment Anything},
+ author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollรกr and Ross Girshick},
+ year={2023},
+ eprint={2304.02643},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+Nos gustarรญa expresar nuestro agradecimiento a Meta AI por crear y mantener este valioso recurso para la comunidad de visiรณn por computadora.
+
+*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, segmentaciรณn de imรกgenes, segmentaciรณn por indicaciรณn, rendimiento en la transferencia sin entrenamiento, conjunto de datos SA-1B, arquitectura avanzada, auto-anotaciรณn, Ultralytics, modelos pre-entrenados, SAM base, SAM large, segmentaciรณn de instancias, visiรณn por computadora, IA, inteligencia artificial, aprendizaje automรกtico, anotaciรณn de datos, mรกscaras de segmentaciรณn, modelo de detecciรณn, modelo de detecciรณn YOLO, bibtex, Meta AI.*
diff --git a/ultralytics/docs/es/models/sam.md:Zone.Identifier b/ultralytics/docs/es/models/sam.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/sam.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/yolo-nas.md b/ultralytics/docs/es/models/yolo-nas.md
new file mode 100755
index 0000000..3b25a60
--- /dev/null
+++ b/ultralytics/docs/es/models/yolo-nas.md
@@ -0,0 +1,121 @@
+---
+comments: true
+description: Explora la documentaciรณn detallada de YOLO-NAS, un modelo de detecciรณn de objetos superior. Aprende sobre sus caracterรญsticas, modelos pre-entrenados, uso con la API de Ultralytics Python, y mรกs.
+keywords: YOLO-NAS, Deci AI, detecciรณn de objetos, aprendizaje profundo, bรบsqueda de arquitectura neural, API de Ultralytics Python, modelo YOLO, modelos pre-entrenados, cuantizaciรณn, optimizaciรณn, COCO, Objects365, Roboflow 100
+---
+
+# YOLO-NAS
+
+## Visiรณn general
+
+Desarrollado por Deci AI, YOLO-NAS es un modelo revolucionario de detecciรณn de objetos. Es el producto de una tecnologรญa avanzada de Bรบsqueda de Arquitectura Neural, meticulosamente diseรฑada para abordar las limitaciones de los modelos YOLO anteriores. Con mejoras significativas en el soporte de cuantizaciรณn y el equilibrio entre precisiรณn y latencia, YOLO-NAS representa un gran avance en la detecciรณn de objetos.
+
+
+**Visiรณn general de YOLO-NAS.** YOLO-NAS utiliza bloques conscientes de cuantizaciรณn y cuantizaciรณn selectiva para un rendimiento รณptimo. El modelo, cuando se convierte en su versiรณn cuantizada INT8, experimenta una caรญda mรญnima de precisiรณn, una mejora significativa en comparaciรณn con otros modelos. Estos avances culminan en una arquitectura superior con capacidades de detecciรณn de objetos sin precedentes y un rendimiento sobresaliente.
+
+### Caracterรญsticas clave
+
+- **Bloque bรกsico compatible con cuantizaciรณn:** YOLO-NAS introduce un nuevo bloque bรกsico que es compatible con la cuantizaciรณn, abordando una de las limitaciones significativas de los modelos YOLO anteriores.
+- **Entrenamiento sofisticado y cuantizaciรณn:** YOLO-NAS utiliza esquemas avanzados de entrenamiento y cuantizaciรณn posterior para mejorar el rendimiento.
+- **Optimizaciรณn AutoNAC y pre-entrenamiento:** YOLO-NAS utiliza la optimizaciรณn AutoNAC y se pre-entrena en conjuntos de datos prominentes como COCO, Objects365 y Roboflow 100. Este pre-entrenamiento lo hace extremadamente adecuado para tareas de detecciรณn de objetos en entornos de producciรณn.
+
+## Modelos pre-entrenados
+
+Experimenta el poder de la detecciรณn de objetos de prรณxima generaciรณn con los modelos pre-entrenados de YOLO-NAS proporcionados por Ultralytics. Estos modelos estรกn diseรฑados para ofrecer un rendimiento de primera clase tanto en velocidad como en precisiรณn. Elige entre una variedad de opciones adaptadas a tus necesidades especรญficas:
+
+| Modelo | mAP | Latencia (ms) |
+|------------------|-------|---------------|
+| YOLO-NAS S | 47.5 | 3.21 |
+| YOLO-NAS M | 51.55 | 5.85 |
+| YOLO-NAS L | 52.22 | 7.87 |
+| YOLO-NAS S INT-8 | 47.03 | 2.36 |
+| YOLO-NAS M INT-8 | 51.0 | 3.78 |
+| YOLO-NAS L INT-8 | 52.1 | 4.78 |
+
+Cada variante del modelo estรก diseรฑada para ofrecer un equilibrio entre la Precisiรณn Promedio de las Areas (mAP, por sus siglas en inglรฉs) y la latencia, ayudรกndote a optimizar tus tareas de detecciรณn de objetos en tรฉrminos de rendimiento y velocidad.
+
+## Ejemplos de uso
+
+Ultralytics ha facilitado la integraciรณn de los modelos YOLO-NAS en tus aplicaciones de Python a travรฉs de nuestro paquete `ultralytics`. El paquete proporciona una API de Python fรกcil de usar para agilizar el proceso.
+
+Los siguientes ejemplos muestran cรณmo usar los modelos YOLO-NAS con el paquete `ultralytics` para inferencia y validaciรณn:
+
+### Ejemplos de inferencia y validaciรณn
+
+En este ejemplo validamos YOLO-NAS-s en el conjunto de datos COCO8.
+
+!!! Example "Ejemplo"
+
+ Este ejemplo proporciona un cรณdigo simple de inferencia y validaciรณn para YOLO-NAS. Para manejar los resultados de la inferencia, consulta el modo [Predict](../modes/predict.md). Para usar YOLO-NAS con modos adicionales, consulta [Val](../modes/val.md) y [Export](../modes/export.md). El paquete `ultralytics` para YOLO-NAS no admite entrenamiento.
+
+ === "Python"
+
+ Los archivos de modelos pre-entrenados `*.pt` de PyTorch se pueden pasar a la clase `NAS()` para crear una instancia del modelo en Python:
+
+ ```python
+ from ultralytics import NAS
+
+ # Carga un modelo YOLO-NAS-s pre-entrenado en COCO
+ modelo = NAS('yolo_nas_s.pt')
+
+ # Muestra informaciรณn del modelo (opcional)
+ modelo.info()
+
+ # Valida el modelo en el conjunto de datos de ejemplo COCO8
+ resultados = modelo.val(data='coco8.yaml')
+
+ # Ejecuta inferencia con el modelo YOLO-NAS-s en la imagen 'bus.jpg'
+ resultados = modelo('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ Los comandos CLI estรกn disponibles para ejecutar directamente los modelos:
+
+ ```bash
+ # Carga un modelo YOLO-NAS-s pre-entrenado en COCO y valida su rendimiento en el conjunto de datos de ejemplo COCO8
+ yolo val model=yolo_nas_s.pt data=coco8.yaml
+
+ # Carga un modelo YOLO-NAS-s pre-entrenado en COCO y ejecuta inferencia en la imagen 'bus.jpg'
+ yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
+ ```
+
+## Tareas y modos compatibles
+
+Ofrecemos tres variantes de los modelos YOLO-NAS: Small (s), Medium (m) y Large (l). Cada variante estรก diseรฑada para satisfacer diferentes necesidades computacionales y de rendimiento:
+
+- **YOLO-NAS-s**: Optimizado para entornos donde los recursos computacionales son limitados pero la eficiencia es clave.
+- **YOLO-NAS-m**: Ofrece un enfoque equilibrado, adecuado para la detecciรณn de objetos de propรณsito general con mayor precisiรณn.
+- **YOLO-NAS-l**: Adaptados para escenarios que requieren la mayor precisiรณn, donde los recursos computacionales son menos restrictivos.
+
+A continuaciรณn se muestra una descripciรณn detallada de cada modelo, incluyendo enlaces a sus pesos pre-entrenados, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento.
+
+| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|----------------|-----------------------------------------------------------------------------------------------|--------------------------------------------|------------|------------|---------------|-------------|
+| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_s.pt) | [Detecciรณn de objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_m.pt) | [Detecciรณn de objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_l.pt) | [Detecciรณn de objetos](../tasks/detect.md) | โ | โ | โ | โ |
+
+## Citaciones y agradecimientos
+
+Si utilizas YOLO-NAS en tu investigaciรณn o trabajo de desarrollo, por favor cita SuperGradients:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{supergradients,
+ doi = {10.5281/ZENODO.7789328},
+ url = {https://zenodo.org/record/7789328},
+ author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}},
+ title = {Super-Gradients},
+ publisher = {GitHub},
+ journal = {GitHub repository},
+ year = {2021},
+ }
+ ```
+
+Agradecemos al equipo de [SuperGradients](https://github.com/Deci-AI/super-gradients/) de Deci AI por sus esfuerzos en la creaciรณn y mantenimiento de este valioso recurso para la comunidad de visiรณn por computadora. Creemos que YOLO-NAS, con su arquitectura innovadora y sus capacidades de detecciรณn de objetos superiores, se convertirรก en una herramienta fundamental tanto para desarrolladores como para investigadores.
+
+*keywords: YOLO-NAS, Deci AI, detecciรณn de objetos, aprendizaje profundo, bรบsqueda de arquitectura neural, API de Ultralytics Python, modelo YOLO, SuperGradients, modelos pre-entrenados, bloque bรกsico compatible con cuantizaciรณn, esquemas avanzados de entrenamiento, cuantizaciรณn posterior, optimizaciรณn AutoNAC, COCO, Objects365, Roboflow 100*
diff --git a/ultralytics/docs/es/models/yolo-nas.md:Zone.Identifier b/ultralytics/docs/es/models/yolo-nas.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/yolo-nas.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/yolov3.md b/ultralytics/docs/es/models/yolov3.md
new file mode 100755
index 0000000..1990e5b
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov3.md
@@ -0,0 +1,98 @@
+---
+comments: true
+description: Obtรฉn una descripciรณn general de YOLOv3, YOLOv3-Ultralytics y YOLOv3u. Aprende sobre sus caracterรญsticas clave, uso y tareas admitidas para la detecciรณn de objetos.
+keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Detecciรณn de objetos, Inferencia, Entrenamiento, Ultralytics
+---
+
+# YOLOv3, YOLOv3-Ultralytics y YOLOv3u
+
+## Descripciรณn general
+
+Este documento presenta una descripciรณn general de tres modelos de detecciรณn de objetos estrechamente relacionados, conocidos como [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) y [YOLOv3u](https://github.com/ultralytics/ultralytics).
+
+1. **YOLOv3:** Esta es la tercera versiรณn del algoritmo de detecciรณn de objetos You Only Look Once (YOLO). Originalmente desarrollado por Joseph Redmon, YOLOv3 mejorรณ a sus predecesores al introducir caracterรญsticas como predicciones multiescala y tres tamaรฑos diferentes de nรบcleos de detecciรณn.
+
+2. **YOLOv3-Ultralytics:** Esta es la implementaciรณn de YOLOv3 realizada por Ultralytics. Reproduce la arquitectura original de YOLOv3 y ofrece funcionalidades adicionales, como soporte para mรกs modelos pre-entrenados y opciones de personalizaciรณn mรกs fรกciles.
+
+3. **YOLOv3u:** Esta es una versiรณn actualizada de YOLOv3-Ultralytics que incorpora la cabeza dividida sin anclaje y sin objeto utilizada en los modelos YOLOv8. YOLOv3u mantiene la misma arquitectura de columna vertebral y cuello que YOLOv3, pero con la cabeza de detecciรณn actualizada de YOLOv8.
+
+
+
+## Caracterรญsticas clave
+
+- **YOLOv3:** Introdujo el uso de tres escalas diferentes para la detecciรณn, aprovechando tres tamaรฑos diferentes de nรบcleos de detecciรณn: 13x13, 26x26 y 52x52. Esto mejorรณ significativamente la precisiรณn de detecciรณn para objetos de diferentes tamaรฑos. Ademรกs, YOLOv3 aรฑadiรณ caracterรญsticas como predicciones con mรบltiples etiquetas para cada cuadro delimitador y una mejor red extractora de caracterรญsticas.
+
+- **YOLOv3-Ultralytics:** La implementaciรณn de Ultralytics de YOLOv3 proporciona el mismo rendimiento que el modelo original, pero cuenta con soporte adicional para mรกs modelos pre-entrenados, mรฉtodos de entrenamiento adicionales y opciones de personalizaciรณn mรกs fรกciles. Esto lo hace mรกs versรกtil y fรกcil de usar para aplicaciones prรกcticas.
+
+- **YOLOv3u:** Este modelo actualizado incorpora la cabeza dividida sin anclaje y sin objeto de YOLOv8. Al eliminar la necesidad de cajas de anclaje predefinidas y puntuaciones de objeto, este diseรฑo de cabeza de detecciรณn puede mejorar la capacidad del modelo para detectar objetos de diferentes tamaรฑos y formas. Esto hace que YOLOv3u sea mรกs robusto y preciso para tareas de detecciรณn de objetos.
+
+## Tareas y modos admitidos
+
+La serie YOLOv3, que incluye YOLOv3, YOLOv3-Ultralytics y YOLOv3u, estรก diseรฑada especรญficamente para tareas de detecciรณn de objetos. Estos modelos son reconocidos por su eficacia en diversos escenarios del mundo real, equilibrando precisiรณn y velocidad. Cada variante ofrece caracterรญsticas y optimizaciones รบnicas, lo que los hace adecuados para una variedad de aplicaciones.
+
+Los tres modelos admiten un conjunto completo de modos, asegurando versatilidad en diversas etapas del despliegue y desarrollo del modelo. Estos modos incluyen [Inferencia](../modes/predict.md), [Validaciรณn](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportaciรณn](../modes/export.md), proporcionando a los usuarios un conjunto completo de herramientas para una detecciรณn de objetos efectiva.
+
+| Tipo de modelo | Tareas admitidas | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|--------------------|--------------------------------------------|------------|------------|---------------|-------------|
+| YOLOv3 | [Detecciรณn de objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv3-Ultralytics | [Detecciรณn de objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv3u | [Detecciรณn de objetos](../tasks/detect.md) | โ | โ | โ | โ |
+
+Esta tabla proporciona una visiรณn rรกpida de las capacidades de cada variante de YOLOv3, destacando su versatilidad y aptitud para diversas tareas y modos operativos en flujos de trabajo de detecciรณn de objetos.
+
+## Ejemplos de uso
+
+Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de YOLOv3. Para obtener documentaciรณn completa sobre estos y otros [modos](../modes/index.md), consulta las pรกginas de documentaciรณn de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
+
+!!! Example "Ejemplo"
+
+ === "Python"
+
+ Los modelos pre-entrenados de PyTorch en archivos `*.pt`, asรญ como los archivos de configuraciรณn `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Cargar un modelo YOLOv3n pre-entrenado en COCO
+ model = YOLO('yolov3n.pt')
+
+ # Mostrar informaciรณn del modelo (opcional)
+ model.info()
+
+ # Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Ejecutar inferencia con el modelo YOLOv3n en la imagen 'bus.jpg'
+ results = model('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ Hay comandos de CLI disponibles para ejecutar directamente los modelos:
+
+ ```bash
+ # Cargar un modelo YOLOv3n pre-entrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Cargar un modelo YOLOv3n pre-entrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg'
+ yolo predict model=yolov3n.pt source=path/to/bus.jpg
+ ```
+
+## Citaciones y agradecimientos
+
+Si utilizas YOLOv3 en tu investigaciรณn, por favor, cita los artรญculos originales de YOLO y el repositorio de YOLOv3 de Ultralytics:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{redmon2018yolov3,
+ title={YOLOv3: An Incremental Improvement},
+ author={Redmon, Joseph and Farhadi, Ali},
+ journal={arXiv preprint arXiv:1804.02767},
+ year={2018}
+ }
+ ```
+
+Gracias a Joseph Redmon y Ali Farhadi por desarrollar YOLOv3 original.
diff --git a/ultralytics/docs/es/models/yolov3.md:Zone.Identifier b/ultralytics/docs/es/models/yolov3.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov3.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/yolov4.md b/ultralytics/docs/es/models/yolov4.md
new file mode 100755
index 0000000..05bd43c
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov4.md
@@ -0,0 +1,71 @@
+---
+comments: true
+description: Explora nuestra detallada guรญa sobre YOLOv4, un detector de objetos en tiempo real de vanguardia. Comprende sus aspectos arquitectรณnicos destacados, caracterรญsticas innovadoras y ejemplos de aplicaciรณn.
+keywords: ultralytics, YOLOv4, detecciรณn de objetos, red neuronal, detecciรณn en tiempo real, detector de objetos, aprendizaje automรกtico
+---
+
+# YOLOv4: Detecciรณn de objetos rรกpida y precisa
+
+Bienvenido a la pรกgina de documentaciรณn de Ultralytics para YOLOv4, un detector de objetos en tiempo real de vanguardia lanzado en 2020 por Alexey Bochkovskiy en [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). YOLOv4 estรก diseรฑado para ofrecer un equilibrio รณptimo entre velocidad y precisiรณn, lo que lo convierte en una excelente opciรณn para muchas aplicaciones.
+
+
+**Diagrama de arquitectura de YOLOv4**. Muestra el intrincado diseรฑo de red de YOLOv4, incluyendo los componentes backbone, neck y head, y sus capas interconectadas para una detecciรณn de objetos en tiempo real รณptima.
+
+## Introducciรณn
+
+YOLOv4 significa You Only Look Once versiรณn 4. Es un modelo de detecciรณn de objetos en tiempo real desarrollado para abordar las limitaciones de versiones anteriores de YOLO como [YOLOv3](yolov3.md) y otros modelos de detecciรณn de objetos. A diferencia de otros detectores de objetos basados en redes neuronales convolucionales (CNN), YOLOv4 no solo es aplicable para sistemas de recomendaciรณn, sino tambiรฉn para la gestiรณn de procesos independientes y la reducciรณn de la entrada humana. Su funcionamiento en unidades de procesamiento de grรกficos (GPU) convencionales permite su uso masivo a un precio asequible, y estรก diseรฑado para funcionar en tiempo real en una GPU convencional, siendo necesario solo una GPU para el entrenamiento.
+
+## Arquitectura
+
+YOLOv4 utiliza varias caracterรญsticas innovadoras que trabajan juntas para optimizar su rendimiento. Estas incluyen Conexiones Residuales Ponderadas (WRC), Conexiones Parciales Cruzadas en Etapas (CSP), Normalizaciรณn Cruzada de Mini-Batch (CmBN), Entrenamiento Autoadversarial (SAT), Activaciรณn Mish, Aumento de Datos Mosaico, Regularizaciรณn DropBlock y Pรฉrdida CIoU. Estas caracterรญsticas se combinan para lograr resultados de vanguardia.
+
+Un detector de objetos tรญpico estรก compuesto por varias partes, incluyendo la entrada, el backbone (espinazo), el neck (cuello) y el head (cabeza). El backbone de YOLOv4 estรก pre-entrenado en ImageNet y se utiliza para predecir las clases y las cajas delimitadoras de los objetos. El backbone puede ser de varios modelos, incluyendo VGG, ResNet, ResNeXt o DenseNet. La parte del neck del detector se utiliza para recolectar mapas de caracterรญsticas de diferentes etapas y generalmente incluye varias rutas de abajo hacia arriba y varias rutas de arriba hacia abajo. La parte de la cabeza es la que se utiliza para realizar las detecciones y clasificaciones finales de objetos.
+
+## Bolsa de regalos
+
+YOLOv4 tambiรฉn utiliza mรฉtodos conocidos como "bolsa de regalos" (bag of freebies), que son tรฉcnicas que mejoran la precisiรณn del modelo durante el entrenamiento sin aumentar el costo de la inferencia. La ampliaciรณn de datos es una tรฉcnica comรบn de la bolsa de regalos utilizada en la detecciรณn de objetos, que aumenta la variabilidad de las imรกgenes de entrada para mejorar la robustez del modelo. Algunos ejemplos de ampliaciรณn de datos incluyen distorsiones fotomรฉtricas (ajuste del brillo, contraste, matiz, saturaciรณn y ruido de una imagen) y distorsiones geomรฉtricas (agregar escalado, recorte, volteo y rotaciรณn aleatorios). Estas tรฉcnicas ayudan al modelo a generalizar mejor para diferentes tipos de imรกgenes.
+
+## Caracterรญsticas y rendimiento
+
+YOLOv4 estรก diseรฑado para obtener una velocidad y precisiรณn รณptimas en la detecciรณn de objetos. La arquitectura de YOLOv4 incluye CSPDarknet53 como backbone, PANet como neck y YOLOv3 como cabeza de detecciรณn. Este diseรฑo permite que YOLOv4 realice la detecciรณn de objetos a una velocidad impresionante, lo que lo hace adecuado para aplicaciones en tiempo real. YOLOv4 tambiรฉn sobresale en precisiรณn, logrando resultados de vanguardia en los benchmarks de detecciรณn de objetos.
+
+## Ejemplos de uso
+
+Hasta el momento de escribir este documento, Ultralytics actualmente no admite modelos YOLOv4. Por lo tanto, cualquier usuario interesado en usar YOLOv4 deberรก consultar directamente el repositorio de YOLOv4 en GitHub para obtener instrucciones de instalaciรณn y uso.
+
+Aquรญ hay un resumen breve de los pasos tรญpicos que podrรญas seguir para usar YOLOv4:
+
+1. Visita el repositorio de YOLOv4 en GitHub: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
+
+2. Sigue las instrucciones proporcionadas en el archivo README para la instalaciรณn. Esto generalmente implica clonar el repositorio, instalar las dependencias necesarias y configurar las variables de entorno necesarias.
+
+3. Una vez que la instalaciรณn estรฉ completa, puedes entrenar y usar el modelo segรบn las instrucciones de uso proporcionadas en el repositorio. Esto normalmente implica preparar tu conjunto de datos, configurar los parรกmetros del modelo, entrenar el modelo y luego usar el modelo entrenado para realizar la detecciรณn de objetos.
+
+Ten en cuenta que los pasos especรญficos pueden variar dependiendo de tu caso de uso especรญfico y del estado actual del repositorio de YOLOv4. Por lo tanto, se recomienda encarecidamente consultar directamente las instrucciones proporcionadas en el repositorio de YOLOv4 en GitHub.
+
+Lamentamos cualquier inconveniente que esto pueda causar y nos esforzaremos por actualizar este documento con ejemplos de uso para Ultralytics una vez que se implemente el soporte para YOLOv4.
+
+## Conclusiรณn
+
+YOLOv4 es un modelo de detecciรณn de objetos potente y eficiente que logra un equilibrio entre velocidad y precisiรณn. Su uso de caracterรญsticas รบnicas y tรฉcnicas de bolsa de regalos durante el entrenamiento le permite realizar un excelente desempeรฑo en tareas de detecciรณn de objetos en tiempo real. YOLOv4 puede ser entrenado y utilizado por cualquier persona con una GPU convencional, lo que lo hace accesible y prรกctico para una amplia gama de aplicaciones.
+
+## Citaciones y agradecimientos
+
+Nos gustarรญa reconocer a los autores de YOLOv4 por sus importantes contribuciones en el campo de la detecciรณn de objetos en tiempo real:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{bochkovskiy2020yolov4,
+ title={YOLOv4: Optimal Speed and Accuracy of Object Detection},
+ author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao},
+ year={2020},
+ eprint={2004.10934},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+El artรญculo original de YOLOv4 se puede encontrar en [arXiv](https://arxiv.org/abs/2004.10934). Los autores han puesto su trabajo a disposiciรณn del pรบblico, y el cรณdigo se puede acceder en [GitHub](https://github.com/AlexeyAB/darknet). Apreciamos sus esfuerzos en el avance del campo y en hacer que su trabajo sea accesible para la comunidad en general.
diff --git a/ultralytics/docs/es/models/yolov4.md:Zone.Identifier b/ultralytics/docs/es/models/yolov4.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov4.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/yolov5.md b/ultralytics/docs/es/models/yolov5.md
new file mode 100755
index 0000000..66adf22
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov5.md
@@ -0,0 +1,113 @@
+---
+comments: true
+description: Descubra YOLOv5u, una versiรณn mejorada del modelo YOLOv5 con un mejor equilibrio entre precisiรณn y velocidad, y numerosos modelos pre-entrenados para diversas tareas de detecciรณn de objetos.
+keywords: YOLOv5u, detecciรณn de objetos, modelos pre-entrenados, Ultralytics, Inferencia, Validaciรณn, YOLOv5, YOLOv8, sin anclas, sin atenciรณn al objeto, aplicaciones en tiempo real, aprendizaje automรกtico
+---
+
+# YOLOv5
+
+## Resumen
+
+YOLOv5u representa un avance en las metodologรญas de detecciรณn de objetos. Originado a partir de la arquitectura fundamental del modelo [YOLOv5](https://github.com/ultralytics/yolov5) desarrollado por Ultralytics, YOLOv5u integra la divisiรณn de la cabeza Ultralytics sin anclas y sin atenciรณn al objeto, una caracterรญstica introducida previamente en los modelos [YOLOv8](yolov8.md). Esta adaptaciรณn perfecciona la arquitectura del modelo, resultando en un mejor equilibrio entre precisiรณn y velocidad en tareas de detecciรณn de objetos. Con base en los resultados empรญricos y sus caracterรญsticas derivadas, YOLOv5u proporciona una alternativa eficiente para aquellos que buscan soluciones robustas tanto en investigaciรณn como en aplicaciones prรกcticas.
+
+
+
+## Caracterรญsticas clave
+
+- **Cabeza dividida Ultralytics sin anclas:** Los modelos tradicionales de detecciรณn de objetos dependen de cajas de anclaje predefinidas para predecir la ubicaciรณn de los objetos. Sin embargo, YOLOv5u moderniza este enfoque. Al adoptar una cabeza Ultralytics dividida sin anclas, se garantiza un mecanismo de detecciรณn mรกs flexible y adaptable, lo que en consecuencia mejora el rendimiento en diversos escenarios.
+
+- **Equilibrio รณptimo entre precisiรณn y velocidad:** La velocidad y la precisiรณn suelen ser contrapuestas. Pero YOLOv5u desafรญa este equilibrio. Ofrece un balance calibrado, garantizando detecciones en tiempo real sin comprometer la precisiรณn. Esta caracterรญstica es especialmente valiosa para aplicaciones que requieren respuestas rรกpidas, como vehรญculos autรณnomos, robรณtica y anรกlisis de video en tiempo real.
+
+- **Variedad de modelos pre-entrenados:** Entendiendo que diferentes tareas requieren diferentes herramientas, YOLOv5u proporciona una gran cantidad de modelos pre-entrenados. Ya sea que te enfoques en Inferencia, Validaciรณn o Entrenamiento, hay un modelo a la medida esperรกndote. Esta variedad asegura que no estรฉs utilizando una soluciรณn genรฉrica, sino un modelo especรญficamente ajustado para tu desafรญo รบnico.
+
+## Tareas y Modos Soportados
+
+Los modelos YOLOv5u, con diferentes pesos pre-entrenados, sobresalen en las tareas de [Detecciรณn de Objetos](../tasks/detect.md). Soportan una amplia gama de modos que los hacen adecuados para diversas aplicaciones, desde el desarrollo hasta la implementaciรณn.
+
+| Tipo de Modelo | Pesos Pre-entrenados | Tarea | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|----------------|-----------------------------------------------------------------------------------------------------------------------------|--------------------------------------------|------------|------------|---------------|-------------|
+| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+
+Esta tabla proporciona una descripciรณn detallada de las variantes de modelos YOLOv5u, destacando su aplicabilidad en tareas de detecciรณn de objetos y el soporte para varios modos operativos como [Inferencia](../modes/predict.md), [Validaciรณn](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportaciรณn](../modes/export.md). Este soporte integral asegura que los usuarios puedan aprovechar al mรกximo las capacidades de los modelos YOLOv5u en una amplia gama de escenarios de detecciรณn de objetos.
+
+## Mรฉtricas de Rendimiento
+
+!!! Rendimiento
+
+ === "Detecciรณn"
+
+ Consulta la [Documentaciรณn de Detecciรณn](https://docs.ultralytics.com/tasks/detect/) para obtener ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/detect/coco/), los cuales incluyen 80 clases pre-entrenadas.
+
+ | Modelo | YAML | tamaรฑo (pรญxeles) | mAPval 50-95 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | parรกmetros (M) | FLOPs (B) |
+ |---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
+ | [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34.3 | 73.6 | 1.06 | 2.6 | 7.7 |
+ | [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43.0 | 120.7 | 1.27 | 9.1 | 24.0 |
+ | [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49.0 | 233.9 | 1.86 | 25.1 | 64.2 |
+ | [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52.2 | 408.4 | 2.50 | 53.2 | 135.0 |
+ | [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53.2 | 763.2 | 3.81 | 97.2 | 246.4 |
+ | | | | | | | | |
+ | [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42.1 | 211.0 | 1.83 | 4.3 | 7.8 |
+ | [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48.6 | 422.6 | 2.34 | 15.3 | 24.6 |
+ | [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53.6 | 810.9 | 4.36 | 41.2 | 65.7 |
+ | [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55.7 | 1470.9 | 5.47 | 86.1 | 137.4 |
+ | [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56.8 | 2436.5 | 8.98 | 155.4 | 250.7 |
+
+## Ejemplos de Uso
+
+Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de YOLOv5. Para obtener documentaciรณn completa sobre estos y otros [modos](../modes/index.md), consulta las pรกginas de documentaciรณn de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
+
+!!! Example "Ejemplo"
+
+ === "Python"
+
+ Los modelos pre-entrenados `*.pt` de PyTorch, asรญ como los archivos de configuraciรณn `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia de modelo en Python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Cargar un modelo YOLOv5n pre-entrenado en COCO
+ modelo = YOLO('yolov5n.pt')
+
+ # Mostrar informaciรณn del modelo (opcional)
+ modelo.info()
+
+ # Entrenar el modelo con el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Ejecutar inferencia con el modelo YOLOv5n en la imagen 'bus.jpg'
+ resultados = modelo('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ Hay comandos de CLI disponibles para ejecutar directamente los modelos:
+
+ ```bash
+ # Cargar un modelo YOLOv5n pre-entrenado en COCO y entrenarlo con el conjunto de datos de ejemplo COCO8 durante 100 รฉpocas
+ yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
+
+ # Cargar un modelo YOLOv5n pre-entrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg'
+ yolo predict model=yolov5n.pt source=path/to/bus.jpg
+ ```
+
+## Citaciones y Reconocimientos
+
+Si utilizas YOLOv5 o YOLOv5u en tu investigaciรณn, por favor cita el repositorio de Ultralytics YOLOv5 de la siguiente manera:
+
+!!! Quote ""
+
+ === "BibTeX"
+ ```bibtex
+ @software{yolov5,
+ title = {Ultralytics YOLOv5},
+ author = {Glenn Jocher},
+ year = {2020},
+ version = {7.0},
+ license = {AGPL-3.0},
+ url = {https://github.com/ultralytics/yolov5},
+ doi = {10.5281/zenodo.3908559},
+ orcid = {0000-0001-5950-6979}
+ }
+ ```
+
+Ten en cuenta que los modelos YOLOv5 se proporcionan bajo las licencias [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) y [Enterprise](https://ultralytics.com/license).
diff --git a/ultralytics/docs/es/models/yolov5.md:Zone.Identifier b/ultralytics/docs/es/models/yolov5.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov5.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/yolov6.md b/ultralytics/docs/es/models/yolov6.md
new file mode 100755
index 0000000..f65f37f
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov6.md
@@ -0,0 +1,107 @@
+---
+comments: true
+description: Explora Meituan YOLOv6, un modelo de detecciรณn de objetos de รบltima generaciรณn que logra un equilibrio entre velocidad y precisiรณn. Sumรฉrgete en caracterรญsticas, modelos pre-entrenados y el uso de Python.
+keywords: Meituan YOLOv6, detecciรณn de objetos, Ultralytics, documentaciรณn de YOLOv6, Concatenaciรณn Bidireccional, Entrenamiento con Anclas, modelos pre-entrenados, aplicaciones en tiempo real
+---
+
+# Meituan YOLOv6
+
+## Visiรณn general
+
+[Meituan](https://about.meituan.com/) YOLOv6 es un detector de objetos de รบltima generaciรณn que ofrece un notable equilibrio entre velocidad y precisiรณn, lo que lo convierte en una opciรณn popular para aplicaciones en tiempo real. Este modelo presenta varias mejoras notables en su arquitectura y esquema de entrenamiento, que incluyen la implementaciรณn de un mรณdulo de Concatenaciรณn Bidireccional (BiC), una estrategia de entrenamiento con anclas (AAT) y un diseรฑo de columna vertebral y cuello mejorado para lograr una precisiรณn de รบltima generaciรณn en el conjunto de datos COCO.
+
+
+
+**Visiรณn general de YOLOv6.** Diagrama de la arquitectura del modelo que muestra los componentes de la red redesdiseรฑados y las estrategias de entrenamiento que han llevado a mejoras significativas en el rendimiento. (a) El cuello de YOLOv6 (N y S se muestran). Seรฑalar que, en M/L, RepBlocks es reemplazado por CSPStackRep. (b) La estructura de un mรณdulo BiC. (c) Un bloque SimCSPSPPF. ([fuente](https://arxiv.org/pdf/2301.05586.pdf)).
+
+### Caracterรญsticas clave
+
+- **Mรณdulo de Concatenaciรณn Bidireccional (BiC):** YOLOv6 introduce un mรณdulo de BiC en el cuello del detector, mejorando las seรฑales de localizaciรณn y ofreciendo mejoras en el rendimiento con una degradaciรณn de velocidad despreciable.
+- **Estrategia de Entrenamiento con Anclas (AAT):** Este modelo propone AAT para disfrutar de los beneficios de los paradigmas basados en anclas y sin anclas sin comprometer la eficiencia de inferencia.
+- **Diseรฑo de Columna Vertebral y Cuello Mejorado:** Al profundizar en YOLOv6 para incluir otra etapa en la columna vertebral y el cuello, este modelo logra un rendimiento de รบltima generaciรณn en el conjunto de datos COCO con una entrada de alta resoluciรณn.
+- **Estrategia de Auto-Destilaciรณn:** Se implementa una nueva estrategia de auto-destilaciรณn para mejorar el rendimiento de los modelos mรกs pequeรฑos de YOLOv6, mejorando la rama de regresiรณn auxiliar durante el entrenamiento y eliminรกndola durante la inferencia para evitar una marcada disminuciรณn de velocidad.
+
+## Mรฉtricas de rendimiento
+
+YOLOv6 proporciona varios modelos pre-entrenados con diferentes escalas:
+
+- YOLOv6-N: 37.5% de precisiรณn promedio (AP) en COCO val2017 a 1187 FPS con la GPU NVIDIA Tesla T4.
+- YOLOv6-S: 45.0% de AP a 484 FPS.
+- YOLOv6-M: 50.0% de AP a 226 FPS.
+- YOLOv6-L: 52.8% de AP a 116 FPS.
+- YOLOv6-L6: Precisiรณn de รบltima generaciรณn en tiempo real.
+
+YOLOv6 tambiรฉn proporciona modelos cuantizados para diferentes precisiones y modelos optimizados para plataformas mรณviles.
+
+## Ejemplos de uso
+
+Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia con YOLOv6. Para obtener documentaciรณn completa sobre estos y otros [modos](../modes/index.md), consulta las pรกginas de documentaciรณn de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
+
+!!! Example "Ejemplo"
+
+ === "Python"
+
+ Los modelos pre-entrenados en `*.pt` de PyTorch, asรญ como los archivos de configuraciรณn `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python:
+
+ ```python
+ from ultralytics import YOLO
+
+ # Construir un modelo YOLOv6n desde cero
+ modelo = YOLO('yolov6n.yaml')
+
+ # Mostrar informaciรณn del modelo (opcional)
+ modelo.info()
+
+ # Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 epochs
+ resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640)
+
+ # Ejecutar inferencia con el modelo YOLOv6n en la imagen 'bus.jpg'
+ resultados = modelo('path/to/bus.jpg')
+ ```
+
+ === "CLI"
+
+ Se dispone de comandos de lรญnea de comandos (CLI) para ejecutar directamente los modelos:
+
+ ```bash
+ # Construir un modelo YOLOv6n desde cero y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 epochs
+ yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
+
+ # Construir un modelo YOLOv6n desde cero y ejecutar inferencia en la imagen 'bus.jpg'
+ yolo predict model=yolov6n.yaml source=path/to/bus.jpg
+ ```
+
+## Tareas y Modos Soportados
+
+La serie YOLOv6 ofrece una variedad de modelos, cada uno optimizado para [Detecciรณn de Objetos](../tasks/detect.md) de alto rendimiento. Estos modelos se adaptan a distintas necesidades computacionales y requisitos de precisiรณn, lo que los hace versรกtiles para una amplia gama de aplicaciones.
+
+| Tipo de Modelo | Pesos Pre-entrenados | Tareas Soportadas | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|----------------|----------------------|--------------------------------------------|------------|------------|---------------|-------------|
+| YOLOv6-N | `yolov6-n.pt` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-S | `yolov6-s.pt` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-M | `yolov6-m.pt` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-L | `yolov6-l.pt` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv6-L6 | `yolov6-l6.pt` | [Detecciรณn de Objetos](../tasks/detect.md) | โ | โ | โ | โ |
+
+Esta tabla proporciona una descripciรณn detallada de las variantes del modelo YOLOv6, destacando sus capacidades en tareas de detecciรณn de objetos y su compatibilidad con varios modos operativos como [Inferencia](../modes/predict.md), [Validaciรณn](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportaciรณn](../modes/export.md). Este soporte integral garantiza que los usuarios puedan aprovechar al mรกximo las capacidades de los modelos YOLOv6 en una amplia gama de escenarios de detecciรณn de objetos.
+
+## Citaciones y Agradecimientos
+
+Nos gustarรญa agradecer a los autores por sus importantes contribuciones en el campo de la detecciรณn de objetos en tiempo real:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{li2023yolov6,
+ title={YOLOv6 v3.0: A Full-Scale Reloading},
+ author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
+ year={2023},
+ eprint={2301.05586},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+ Se puede encontrar el artรญculo original de YOLOv6 en [arXiv](https://arxiv.org/abs/2301.05586). Los autores han puesto su trabajo a disposiciรณn del pรบblico y el cรณdigo fuente se puede acceder en [GitHub](https://github.com/meituan/YOLOv6). Agradecemos sus esfuerzos en avanzar en el campo y hacer que su trabajo sea accesible para la comunidad en general.
diff --git a/ultralytics/docs/es/models/yolov6.md:Zone.Identifier b/ultralytics/docs/es/models/yolov6.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov6.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/yolov7.md b/ultralytics/docs/es/models/yolov7.md
new file mode 100755
index 0000000..6452043
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov7.md
@@ -0,0 +1,66 @@
+---
+comments: true
+description: Explora el YOLOv7, un detector de objetos en tiempo real. Comprende su velocidad superior, precisiรณn impresionante y enfoque รบnico en la optimizaciรณn de entrenamiento de bolsas de caracterรญsticas entrenables.
+keywords: YOLOv7, detector de objetos en tiempo real, estado del arte, Ultralytics, conjunto de datos MS COCO, re-parametrizaciรณn del modelo, asignaciรณn dinรกmica de etiquetas, escalado extendido, escalado compuesto
+---
+
+# YOLOv7: Bolsa de Caracterรญsticas Entrenable
+
+YOLOv7 es un detector de objetos en tiempo real de รบltima generaciรณn que supera a todos los detectores de objetos conocidos tanto en velocidad como en precisiรณn en el rango de 5 FPS a 160 FPS. Tiene la mayor precisiรณn (56.8% AP) entre todos los detectores de objetos en tiempo real conocidos con una velocidad de 30 FPS o superior en la GPU V100. Ademรกs, YOLOv7 supera a otros detectores de objetos como YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 y muchos otros en cuanto a velocidad y precisiรณn. El modelo se entrena desde cero utilizando el conjunto de datos MS COCO sin utilizar ningรบn otro conjunto de datos o pesos pre-entrenados. El cรณdigo fuente de YOLOv7 estรก disponible en GitHub.
+
+
+**Comparaciรณn de los detectores de objetos de estado del arte.
+** Segรบn los resultados en la Tabla 2, sabemos que el mรฉtodo propuesto tiene el mejor equilibrio entre velocidad y precisiรณn de manera integral. Si comparamos YOLOv7-tiny-SiLU con YOLOv5-N (r6.1), nuestro mรฉtodo es 127 fps mรกs rรกpido y un 10.7% mรกs preciso en AP. Ademรกs, YOLOv7 tiene un AP del 51.4% a una velocidad de cuadro de 161 fps, mientras que PPYOLOE-L con el mismo AP tiene solo una velocidad de cuadro de 78 fps. En tรฉrminos de uso de parรกmetros, YOLOv7 utiliza un 41% menos que PPYOLOE-L. Si comparamos YOLOv7-X con una velocidad de inferencia de 114 fps con YOLOv5-L (r6.1) con una velocidad de inferencia de 99 fps, YOLOv7-X puede mejorar el AP en un 3.9%. Si se compara YOLOv7-X con YOLOv5-X (r6.1) de una escala similar, la velocidad de inferencia de YOLOv7-X es 31 fps mรกs rรกpida. Ademรกs, en tรฉrminos de cantidad de parรกmetros y cรกlculos, YOLOv7-X reduce un 22% de los parรกmetros y un 8% de los cรกlculos en comparaciรณn con YOLOv5-X (r6.1), pero mejora el AP en un 2.2% ([Fuente](https://arxiv.org/pdf/2207.02696.pdf)).
+
+## Descripciรณn general
+
+La detecciรณn de objetos en tiempo real es un componente importante en muchos sistemas de visiรณn por computadora, incluyendo el seguimiento de mรบltiples objetos, conducciรณn autรณnoma, robรณtica y anรกlisis de imรกgenes mรฉdicas. En los รบltimos aรฑos, el desarrollo de la detecciรณn de objetos en tiempo real se ha centrado en el diseรฑo de arquitecturas eficientes y en la mejora de la velocidad de inferencia de diversas CPUs, GPUs y unidades de procesamiento neural (NPUs). YOLOv7 es compatible tanto con GPU para dispositivos mรณviles como con GPU para dispositivos de escritorio, desde el borde hasta la nube.
+
+A diferencia de los detectores de objetos en tiempo real tradicionales que se centran en la optimizaciรณn de la arquitectura, YOLOv7 introduce un enfoque en la optimizaciรณn del proceso de entrenamiento. Esto incluye mรณdulos y mรฉtodos de optimizaciรณn diseรฑados para mejorar la precisiรณn de la detecciรณn de objetos sin aumentar el costo de inferencia, un concepto conocido como "bolsas de caracterรญsticas entrenables".
+
+## Caracterรญsticas clave
+
+YOLOv7 introduce varias caracterรญsticas clave:
+
+1. **Re-parametrizaciรณn del modelo**: YOLOv7 propone un modelo re-parametrizado planificado, que es una estrategia aplicable a capas en diferentes redes con el concepto de propagaciรณn del gradiente.
+
+2. **Asignaciรณn dinรกmica de etiquetas**: El entrenamiento del modelo con mรบltiples capas de salida presenta un nuevo problema: "ยฟCรณmo asignar objetivos dinรกmicos para las salidas de diferentes ramas?" Para resolver este problema, YOLOv7 introduce un nuevo mรฉtodo de asignaciรณn de etiquetas llamado asignaciรณn de etiquetas guiadas de manera gruesa a fina.
+
+3. **Escalado extendido y compuesto**: YOLOv7 propone mรฉtodos de "escalado extendido" y "escalado compuesto" para el detector de objetos en tiempo real que pueden utilizar eficazmente los parรกmetros y cรกlculos.
+
+4. **Eficiencia**: El mรฉtodo propuesto por YOLOv7 puede reducir eficazmente aproximadamente el 40% de los parรกmetros y el 50% de los cรกlculos del detector de objetos en tiempo real de รบltima generaciรณn y tiene una velocidad de inferencia mรกs rรกpida y una mayor precisiรณn de detecciรณn.
+
+## Ejemplos de uso
+
+Hasta la fecha de redacciรณn de este documento, Ultralytics no admite actualmente modelos YOLOv7. Por lo tanto, los usuarios interesados en utilizar YOLOv7 deberรกn consultar directamente el repositorio de GitHub de YOLOv7 para obtener instrucciones de instalaciรณn y uso.
+
+Aquรญ hay un resumen breve de los pasos tรญpicos que podrรญas seguir para usar YOLOv7:
+
+1. Visita el repositorio de GitHub de YOLOv7: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
+
+2. Sigue las instrucciones proporcionadas en el archivo README para la instalaciรณn. Esto generalmente implica clonar el repositorio, instalar las dependencias necesarias y configurar las variables de entorno necesarias.
+
+3. Una vez que la instalaciรณn estรฉ completa, puedes entrenar y utilizar el modelo segรบn las instrucciones de uso proporcionadas en el repositorio. Esto generalmente implica preparar tu conjunto de datos, configurar los parรกmetros del modelo, entrenar el modelo y luego utilizar el modelo entrenado para realizar la detecciรณn de objetos.
+
+Ten en cuenta que los pasos especรญficos pueden variar segรบn tu caso de uso especรญfico y el estado actual del repositorio YOLOv7. Por lo tanto, se recomienda encarecidamente consultar directamente las instrucciones proporcionadas en el repositorio de GitHub de YOLOv7.
+
+Lamentamos cualquier inconveniente que esto pueda causar y nos esforzaremos por actualizar este documento con ejemplos de uso para Ultralytics una vez que se implemente el soporte para YOLOv7.
+
+## Citaciones y Agradecimientos
+
+Nos gustarรญa agradecer a los autores de YOLOv7 por sus importantes contribuciones en el campo de la detecciรณn de objetos en tiempo real:
+
+!!! Quote ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{wang2022yolov7,
+ title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
+ author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
+ journal={arXiv preprint arXiv:2207.02696},
+ year={2022}
+ }
+ ```
+
+El artรญculo original de YOLOv7 se puede encontrar en [arXiv](https://arxiv.org/pdf/2207.02696.pdf). Los autores han hecho su trabajo pรบblicamente disponible y el cรณdigo se puede acceder en [GitHub](https://github.com/WongKinYiu/yolov7). Agradecemos sus esfuerzos en el avance del campo y en hacer su trabajo accesible a la comunidad en general.
diff --git a/ultralytics/docs/es/models/yolov7.md:Zone.Identifier b/ultralytics/docs/es/models/yolov7.md:Zone.Identifier
new file mode 100755
index 0000000..a45e1ac
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov7.md:Zone.Identifier
@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3
diff --git a/ultralytics/docs/es/models/yolov8.md b/ultralytics/docs/es/models/yolov8.md
new file mode 100755
index 0000000..7617460
--- /dev/null
+++ b/ultralytics/docs/es/models/yolov8.md
@@ -0,0 +1,162 @@
+---
+comments: true
+description: ยกExplora las emocionantes caracterรญsticas de YOLOv8, la รบltima versiรณn de nuestro detector de objetos en tiempo real! Aprende cรณmo las arquitecturas avanzadas, los modelos preentrenados y el equilibrio รณptimo entre precisiรณn y velocidad hacen de YOLOv8 la elecciรณn perfecta para tus tareas de detecciรณn de objetos.
+keywords: YOLOv8, Ultralytics, detector de objetos en tiempo real, modelos preentrenados, documentaciรณn, detecciรณn de objetos, serie YOLO, arquitecturas avanzadas, precisiรณn, velocidad
+---
+
+# YOLOv8
+
+## Descripciรณn general
+
+YOLOv8 es la รบltima versiรณn de la serie YOLO de detectores de objetos en tiempo real, ofreciendo un rendimiento de vanguardia en tรฉrminos de precisiรณn y velocidad. Basรกndose en los avances de las versiones anteriores de YOLO, YOLOv8 presenta nuevas caracterรญsticas y optimizaciones que lo convierten en una opciรณn ideal para diversas tareas de detecciรณn de objetos en una amplia gama de aplicaciones.
+
+
+
+## Caracterรญsticas principales
+
+- **Arquitecturas avanzadas de columna vertebral y cuello:** YOLOv8 utiliza arquitecturas de columna vertebral y cuello de รบltima generaciรณn, lo que resulta en una mejor extracciรณn de caracterรญsticas y rendimiento de detecciรณn de objetos.
+- **Cabeza Ultralytics dividida sin anclaje:** YOLOv8 adopta una cabeza Ultralytics dividida sin anclaje, lo que contribuye a una mejor precisiรณn y a un proceso de detecciรณn mรกs eficiente en comparaciรณn con los enfoques basados en anclaje.
+- **Equilibrio optimizado entre precisiรณn y velocidad:** Con un enfoque en mantener un equilibrio รณptimo entre precisiรณn y velocidad, YOLOv8 es adecuado para tareas de detecciรณn de objetos en tiempo real en diversas รกreas de aplicaciรณn.
+- **Variedad de modelos preentrenados:** YOLOv8 ofrece una variedad de modelos preentrenados para adaptarse a diversas tareas y requisitos de rendimiento, lo que facilita encontrar el modelo adecuado para tu caso de uso especรญfico.
+
+## Tareas y modos compatibles
+
+La serie YOLOv8 ofrece una amplia gama de modelos, cada uno especializado en tareas especรญficas en visiรณn por computadora. Estos modelos estรกn diseรฑados para adaptarse a diversos requisitos, desde la detecciรณn de objetos hasta tareas mรกs complejas como la segmentaciรณn de instancias, la detecciรณn de poses/puntos clave y la clasificaciรณn.
+
+Cada variante de la serie YOLOv8 estรก optimizada para su respectiva tarea, garantizando un alto rendimiento y precisiรณn. Ademรกs, estos modelos son compatibles con varios modos operativos, incluyendo [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) y [Export](../modes/export.md), lo que facilita su uso en diferentes etapas de implementaciรณn y desarrollo.
+
+| Modelo | Nombres de archivo | Tarea | Inferencia | Validaciรณn | Entrenamiento | Exportaciรณn |
+|-------------|----------------------------------------------------------------------------------------------------------------|---------------------------------------------------|------------|------------|---------------|-------------|
+| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Detecciรณn](../tasks/detect.md) | โ | โ | โ | โ |
+| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Segmentaciรณn de instancias](../tasks/segment.md) | โ | โ | โ | โ |
+| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Puntos clave](../tasks/pose.md) | โ | โ | โ | โ |
+| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Clasificaciรณn](../tasks/classify.md) | โ | โ | โ | โ |
+
+Esta tabla proporciona una descripciรณn general de las variantes de modelos YOLOv8, resaltando su aplicabilidad en tareas especรญficas y su compatibilidad con varios modos operativos como Inferencia, Validaciรณn, Entrenamiento y Exportaciรณn. Muestra la versatilidad y robustez de la serie YOLOv8, haciรฉndolos adecuados para una variedad de aplicaciones en visiรณn por computadora.
+
+## Mรฉtricas de rendimiento
+
+!!! Rendimiento
+
+ === "Detecciรณn (COCO)"
+
+ Consulta la [documentaciรณn de Detecciรณn](https://docs.ultralytics.com/tasks/detect/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/detect/coco/), que incluyen 80 clases preentrenadas.
+
+ | Modelo | tamaรฑo (pรญxeles) | mAPval 50-95 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | parรกmetros (M) | FLOPs (B) |
+ | ------------------------------------------------------------------------------------ | ----------------------- | --------------------- | ------------------------------ | --------------------------------------- | ---------------------- | ----------------- |
+ | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
+ | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
+ | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
+ | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
+ | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
+
+ === "Detecciรณn (Open Images V7)"
+
+ Consulta la [documentaciรณn de Detecciรณn](https://docs.ultralytics.com/tasks/detect/) para ejemplos de uso con estos modelos entrenados en [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), que incluyen 600 clases preentrenadas.
+
+ | Modelo | tamaรฑo (pรญxeles) | mAPval 50-95 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | parรกmetros (M) | FLOPs (B) |
+ | ----------------------------------------------------------------------------------------- | ----------------------- | --------------------- | -------------------------------- | --------------------------------------- | ---------------------- | ----------------- |
+ | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
+ | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
+ | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
+ | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
+ | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
+
+ === "Segmentaciรณn (COCO)"
+
+ Consulta la [documentaciรณn de Segmentaciรณn](https://docs.ultralytics.com/tasks/segment/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/segment/coco/), que incluyen 80 clases preentrenadas.
+
+ | Modelo | tamaรฑo (pรญxeles) | mAPcaja