From 59411288353b4a45731c58c17894f0c3a1f4ad8b Mon Sep 17 00:00:00 2001
From: Muhammad Rizwan Munawar
Date: Fri, 26 Jan 2024 21:33:57 +0500
Subject: [PATCH 001/171] Explorer API video https://youtu.be/3VryynorQeo
(#7838)
---
docs/en/datasets/explorer/api.md | 11 +++++++++++
docs/en/datasets/explorer/dashboard.md | 11 +++++++++++
docs/en/datasets/explorer/index.md | 11 +++++++++++
3 files changed, 33 insertions(+)
diff --git a/docs/en/datasets/explorer/api.md b/docs/en/datasets/explorer/api.md
index f7ea8d737c5..dc650e6b912 100644
--- a/docs/en/datasets/explorer/api.md
+++ b/docs/en/datasets/explorer/api.md
@@ -11,6 +11,17 @@ keywords: Ultralytics Explorer API, Dataset Exploration, SQL Queries, Vector Sim
The Explorer API is a Python API for exploring your datasets. It supports filtering and searching your dataset using SQL queries, vector similarity search and semantic search.
+
+
+
+
+ Watch: Ultralytics Explorer API Overview
+
+
## Installation
Explorer depends on external libraries for some of its functionality. These are automatically installed on usage. To manually install these dependencies, use the following command:
diff --git a/docs/en/datasets/explorer/dashboard.md b/docs/en/datasets/explorer/dashboard.md
index 450d01e5ada..7686646b7b3 100644
--- a/docs/en/datasets/explorer/dashboard.md
+++ b/docs/en/datasets/explorer/dashboard.md
@@ -12,6 +12,17 @@ Explorer GUI is like a playground build using [Ultralytics Explorer API](api.md)
+
+
+
+
+ Watch: Ultralytics Explorer Dashboard Overview
+
+
### Installation
```bash
diff --git a/docs/en/datasets/explorer/index.md b/docs/en/datasets/explorer/index.md
index ad331c0bcf9..a55a0f6b298 100644
--- a/docs/en/datasets/explorer/index.md
+++ b/docs/en/datasets/explorer/index.md
@@ -13,6 +13,17 @@ keywords: Ultralytics Explorer, CV Dataset Tools, Semantic Search, SQL Dataset Q
Ultralytics Explorer is a tool for exploring CV datasets using semantic search, SQL queries, vector similarity search and even using natural language. It is also a Python API for accessing the same functionality.
+
+
+
+
+ Watch: Ultralytics Explorer API | Semantic Search, SQL Queries & Ask AI Features
+
+
### Installation of optional dependencies
Explorer depends on external libraries for some of its functionality. These are automatically installed on usage. To manually install these dependencies, use the following command:
From ee8888287436b1125dcdc5c7957684e694bb90ea Mon Sep 17 00:00:00 2001
From: Glenn Jocher
Date: Sat, 27 Jan 2024 00:21:31 +0100
Subject: [PATCH 002/171] Add HUB-SDK Docs reference section (#7781)
Signed-off-by: Glenn Jocher
Co-authored-by: UltralyticsAssistant
Co-authored-by: Ayush Chaurasia
---
docs/build_docs.py | 34 ++++++++++++++++++++++---
docs/en/datasets/explorer/dashboard.md | 2 +-
docs/en/datasets/explorer/index.md | 2 +-
docs/mkdocs.yml | 19 ++++++++++++++
docs/mkdocs_github_authors.yaml | 22 ++++++++++++++++
ultralytics/cfg/__init__.py | 2 +-
ultralytics/data/dataset.py | 13 +++++++---
ultralytics/engine/results.py | 7 +++--
ultralytics/engine/trainer.py | 8 ++++--
ultralytics/hub/__init__.py | 9 ++++---
ultralytics/hub/auth.py | 4 +--
ultralytics/hub/session.py | 4 +--
ultralytics/models/sam/amg.py | 6 +++--
ultralytics/models/yolo/segment/val.py | 8 ++++--
ultralytics/nn/autobackend.py | 12 ++++-----
ultralytics/solutions/object_counter.py | 1 -
ultralytics/utils/__init__.py | 12 +++++----
ultralytics/utils/benchmarks.py | 3 +--
ultralytics/utils/checks.py | 4 +--
ultralytics/utils/loss.py | 9 +++++--
ultralytics/utils/metrics.py | 2 +-
ultralytics/utils/ops.py | 1 -
ultralytics/utils/plotting.py | 1 +
ultralytics/utils/triton.py | 2 +-
ultralytics/utils/tuner.py | 2 +-
25 files changed, 142 insertions(+), 47 deletions(-)
create mode 100644 docs/mkdocs_github_authors.yaml
diff --git a/docs/build_docs.py b/docs/build_docs.py
index 8db3f4a7c9f..1f0911b9f5b 100644
--- a/docs/build_docs.py
+++ b/docs/build_docs.py
@@ -49,8 +49,9 @@ def build_docs(use_languages=False, clone_repos=True):
os.system(f"git clone {repo} {local_dir}")
os.system(f"git -C {local_dir} pull") # update repo
shutil.rmtree(DOCS / "en/hub/sdk", ignore_errors=True) # delete if exists
- shutil.copytree(local_dir / "docs", DOCS / "en/hub/sdk")
- shutil.rmtree(DOCS / "en/hub/sdk/reference") # temporarily delete reference until we find a solution for this
+ shutil.copytree(local_dir / "docs", DOCS / "en/hub/sdk") # for docs
+ shutil.rmtree(DOCS.parent / "hub_sdk", ignore_errors=True) # delete if exists
+ shutil.copytree(local_dir / "hub_sdk", DOCS.parent / "hub_sdk") # for mkdocstrings
print(f"Cloned/Updated {repo} in {local_dir}")
# Build the main documentation
@@ -68,7 +69,7 @@ def build_docs(use_languages=False, clone_repos=True):
def update_html_links():
"""Update href links in HTML files to remove '.md' and '/index.md', excluding links starting with 'https://'."""
- html_files = Path(SITE).rglob("*.html")
+ html_files = SITE.rglob("*.html")
total_updated_links = 0
for html_file in html_files:
@@ -134,6 +135,27 @@ def update_html_head(script=""):
file.write(new_html_content)
+def update_subdir_edit_links(subdir="", docs_url=""):
+ """Update the HTML head section of each file."""
+ from bs4 import BeautifulSoup
+
+ if str(subdir[0]) == "/":
+ subdir = str(subdir[0])[1:]
+ html_files = (SITE / subdir).rglob("*.html")
+ for html_file in tqdm(html_files, desc="Processing subdir files"):
+ with html_file.open("r", encoding="utf-8") as file:
+ soup = BeautifulSoup(file, "html.parser")
+
+ # Find the anchor tag and update its href attribute
+ a_tag = soup.find("a", {"class": "md-content__button md-icon"})
+ if a_tag and a_tag["title"] == "Edit this page":
+ a_tag["href"] = f"{docs_url}{a_tag['href'].split(subdir)[-1]}"
+
+ # Write the updated HTML back to the file
+ with open(html_file, "w", encoding="utf-8") as file:
+ file.write(str(soup))
+
+
def main():
# Build the docs
build_docs()
@@ -141,6 +163,12 @@ def main():
# Update titles
update_page_title(SITE / "404.html", new_title="Ultralytics Docs - Not Found")
+ # Update edit links
+ update_subdir_edit_links(
+ subdir="hub/sdk/", # do not use leading slash
+ docs_url="https://github.com/ultralytics/hub-sdk/tree/develop/docs/",
+ )
+
# Update HTML file head section
# update_html_head("")
diff --git a/docs/en/datasets/explorer/dashboard.md b/docs/en/datasets/explorer/dashboard.md
index 7686646b7b3..85670d94598 100644
--- a/docs/en/datasets/explorer/dashboard.md
+++ b/docs/en/datasets/explorer/dashboard.md
@@ -9,7 +9,7 @@ keywords: Ultralytics, Explorer GUI, semantic search, vector similarity search,
Explorer GUI is like a playground build using [Ultralytics Explorer API](api.md). It allows you to run semantic/vector similarity search, SQL queries and even search using natural language using our ask AI feature powered by LLMs.
diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml
index 5b11259582b..ac08e208d67 100644
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -367,6 +367,25 @@ nav:
- Model: hub/sdk/model.md
- Dataset: hub/sdk/dataset.md
- Project: hub/sdk/project.md
+ - Reference:
+ - base:
+ - api_client: hub/sdk/reference/base/api_client.md
+ - auth: hub/sdk/reference/base/auth.md
+ - crud_client: hub/sdk/reference/base/crud_client.md
+ - paginated_list: hub/sdk/reference/base/paginated_list.md
+ - server_clients: hub/sdk/reference/base/server_clients.md
+ - helpers:
+ - error_handler: hub/sdk/reference/helpers/error_handler.md
+ - exceptions: hub/sdk/reference/helpers/exceptions.md
+ - logger: hub/sdk/reference/helpers/logger.md
+ - utils: hub/sdk/reference/helpers/utils.md
+ - hub_client: hub/sdk/reference/hub_client.md
+ - modules:
+ - datasets: hub/sdk/reference/modules/datasets.md
+ - models: hub/sdk/reference/modules/models.md
+ - projects: hub/sdk/reference/modules/projects.md
+ - teams: hub/sdk/reference/modules/teams.md
+ - users: hub/sdk/reference/modules/users.md
- REST API:
- hub/api/index.md
diff --git a/docs/mkdocs_github_authors.yaml b/docs/mkdocs_github_authors.yaml
new file mode 100644
index 00000000000..fb94ba758c2
--- /dev/null
+++ b/docs/mkdocs_github_authors.yaml
@@ -0,0 +1,22 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Author list used in docs publication actions
+
+1579093407@qq.com: null
+17216799+ouphi@users.noreply.github.com: ouphi
+17316848+maianumerosky@users.noreply.github.com: maianumerosky
+34196005+fcakyon@users.noreply.github.com: fcakyon
+37276661+capjamesg@users.noreply.github.com: capjamesg
+39910262+ChaoningZhang@users.noreply.github.com: ChaoningZhang
+40165666+berry-ding@users.noreply.github.com: berry-ding
+47978446+sergiuwaxmann@users.noreply.github.com: sergiuwaxmann
+61612323+Laughing-q@users.noreply.github.com: Laughing-q
+62214284+Burhan-Q@users.noreply.github.com: Burhan-Q
+75611662+tensorturtle@users.noreply.github.com: tensorturtle
+abirami.vina@gmail.com: abirami-vina
+ayush.chaurarsia@gmail.com: AyushExel
+chr043416@gmail.com: null
+glenn.jocher@ultralytics.com: glenn-jocher
+muhammadrizwanmunawar123@gmail.com: RizwanMunawar
+not.committed.yet: null
+shuizhuyuanluo@126.com: null
+xinwang614@gmail.com: GreatV
diff --git a/ultralytics/cfg/__init__.py b/ultralytics/cfg/__init__.py
index 6038baf0bb2..8a2de5941c5 100644
--- a/ultralytics/cfg/__init__.py
+++ b/ultralytics/cfg/__init__.py
@@ -317,7 +317,7 @@ def merge_equals_args(args: List[str]) -> List[str]:
args (List[str]): A list of strings where each element is an argument.
Returns:
- List[str]: A list of strings where the arguments around isolated '=' are merged.
+ (List[str]): A list of strings where the arguments around isolated '=' are merged.
"""
new_args = []
for i, arg in enumerate(args):
diff --git a/ultralytics/data/dataset.py b/ultralytics/data/dataset.py
index aecfc2a4ba7..4c4bcebfe70 100644
--- a/ultralytics/data/dataset.py
+++ b/ultralytics/data/dataset.py
@@ -46,7 +46,8 @@ def cache_labels(self, path=Path("./labels.cache")):
Cache dataset labels, check images and read shapes.
Args:
- path (Path): path where to save the cache file (default: Path('./labels.cache')).
+ path (Path): Path where to save the cache file. Default is Path('./labels.cache').
+
Returns:
(dict): labels.
"""
@@ -178,9 +179,13 @@ def close_mosaic(self, hyp):
self.transforms = self.build_transforms(hyp)
def update_labels_info(self, label):
- """Custom your label format here."""
- # NOTE: cls is not with bboxes now, classification and semantic segmentation need an independent cls label
- # We can make it also support classification and semantic segmentation by add or remove some dict keys there.
+ """
+ Custom your label format here.
+
+ Note:
+ cls is not with bboxes now, classification and semantic segmentation need an independent cls label
+ Can also support classification and semantic segmentation by adding or removing dict keys there.
+ """
bboxes = label.pop("bboxes")
segments = label.pop("segments", [])
keypoints = label.pop("keypoints", None)
diff --git a/ultralytics/engine/results.py b/ultralytics/engine/results.py
index 4faaeb99ab5..5338fe683dc 100644
--- a/ultralytics/engine/results.py
+++ b/ultralytics/engine/results.py
@@ -667,8 +667,11 @@ def xyxyxyxyn(self):
@property
@lru_cache(maxsize=2)
def xyxy(self):
- """Return the horizontal boxes in xyxy format, (N, 4)."""
- # This way to fit both torch and numpy version
+ """
+ Return the horizontal boxes in xyxy format, (N, 4).
+
+ Accepts both torch and numpy boxes.
+ """
x1 = self.xyxyxyxy[..., 0].min(1).values
x2 = self.xyxyxyxy[..., 0].max(1).values
y1 = self.xyxyxyxy[..., 1].min(1).values
diff --git a/ultralytics/engine/trainer.py b/ultralytics/engine/trainer.py
index 75b3ea3f10a..71ea5e84e1d 100644
--- a/ultralytics/engine/trainer.py
+++ b/ultralytics/engine/trainer.py
@@ -563,8 +563,12 @@ def build_dataset(self, img_path, mode="train", batch=None):
raise NotImplementedError("build_dataset function not implemented in trainer")
def label_loss_items(self, loss_items=None, prefix="train"):
- """Returns a loss dict with labelled training loss items tensor."""
- # Not needed for classification but necessary for segmentation & detection
+ """
+ Returns a loss dict with labelled training loss items tensor.
+
+ Note:
+ This is not needed for classification but necessary for segmentation & detection
+ """
return {"loss": loss_items} if loss_items is not None else ["loss"]
def set_model_attributes(self):
diff --git a/ultralytics/hub/__init__.py b/ultralytics/hub/__init__.py
index 745d4a9459d..6c8afc6f721 100644
--- a/ultralytics/hub/__init__.py
+++ b/ultralytics/hub/__init__.py
@@ -12,13 +12,16 @@ def login(api_key: str = None, save=True) -> bool:
"""
Log in to the Ultralytics HUB API using the provided API key.
- The session is not stored; a new session is created when needed using the saved SETTINGS or the HUB_API_KEY environment variable if successfully authenticated.
+ The session is not stored; a new session is created when needed using the saved SETTINGS or the HUB_API_KEY
+ environment variable if successfully authenticated.
Args:
- api_key (str, optional): The API key to use for authentication. If not provided, it will be retrieved from SETTINGS or HUB_API_KEY environment variable.
+ api_key (str, optional): API key to use for authentication.
+ If not provided, it will be retrieved from SETTINGS or HUB_API_KEY environment variable.
save (bool, optional): Whether to save the API key to SETTINGS if authentication is successful.
+
Returns:
- bool: True if authentication is successful, False otherwise.
+ (bool): True if authentication is successful, False otherwise.
"""
checks.check_requirements("hub-sdk>=0.0.2")
from hub_sdk import HUBClient
diff --git a/ultralytics/hub/auth.py b/ultralytics/hub/auth.py
index 17bb498677d..340f58413c2 100644
--- a/ultralytics/hub/auth.py
+++ b/ultralytics/hub/auth.py
@@ -87,7 +87,7 @@ def authenticate(self) -> bool:
Attempt to authenticate with the server using either id_token or API key.
Returns:
- bool: True if authentication is successful, False otherwise.
+ (bool): True if authentication is successful, False otherwise.
"""
try:
if header := self.get_auth_header():
@@ -107,7 +107,7 @@ def auth_with_cookies(self) -> bool:
supported browser.
Returns:
- bool: True if authentication is successful, False otherwise.
+ (bool): True if authentication is successful, False otherwise.
"""
if not is_colab():
return False # Currently only works with Colab
diff --git a/ultralytics/hub/session.py b/ultralytics/hub/session.py
index 8a4d8c59a4b..2d26b5a9bbb 100644
--- a/ultralytics/hub/session.py
+++ b/ultralytics/hub/session.py
@@ -277,7 +277,7 @@ def _get_failure_message(self, response: requests.Response, retry: int, timeout:
timeout: The maximum timeout duration.
Returns:
- str: The retry message.
+ (str): The retry message.
"""
if self._should_retry(response.status_code):
return f"Retrying {retry}x for {timeout}s." if retry else ""
@@ -341,7 +341,7 @@ def _show_upload_progress(self, content_length: int, response: requests.Response
response (requests.Response): The response object from the file download request.
Returns:
- (None)
+ None
"""
with TQDM(total=content_length, unit="B", unit_scale=True, unit_divisor=1024) as pbar:
for data in response.iter_content(chunk_size=1024):
diff --git a/ultralytics/models/sam/amg.py b/ultralytics/models/sam/amg.py
index c4bb6d1b6f2..128108fe9c9 100644
--- a/ultralytics/models/sam/amg.py
+++ b/ultralytics/models/sam/amg.py
@@ -35,9 +35,11 @@ def calculate_stability_score(masks: torch.Tensor, mask_threshold: float, thresh
The stability score is the IoU between the binary masks obtained by thresholding the predicted mask logits at high
and low values.
+
+ Notes:
+ - One mask is always contained inside the other.
+ - Save memory by preventing unnecessary cast to torch.int64
"""
- # One mask is always contained inside the other.
- # Save memory by preventing unnecessary cast to torch.int64
intersections = (masks > (mask_threshold + threshold_offset)).sum(-1, dtype=torch.int16).sum(-1, dtype=torch.int32)
unions = (masks > (mask_threshold - threshold_offset)).sum(-1, dtype=torch.int16).sum(-1, dtype=torch.int32)
return intersections / unions
diff --git a/ultralytics/models/yolo/segment/val.py b/ultralytics/models/yolo/segment/val.py
index 72c04b2c1f2..94757c4e065 100644
--- a/ultralytics/models/yolo/segment/val.py
+++ b/ultralytics/models/yolo/segment/val.py
@@ -215,8 +215,12 @@ def plot_predictions(self, batch, preds, ni):
self.plot_masks.clear()
def pred_to_json(self, predn, filename, pred_masks):
- """Save one JSON result."""
- # Example result = {"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}
+ """
+ Save one JSON result.
+
+ Examples:
+ >>> result = {"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}
+ """
from pycocotools.mask import encode # noqa
def single_encode(x):
diff --git a/ultralytics/nn/autobackend.py b/ultralytics/nn/autobackend.py
index 8f55c3baa9b..3fafbbd9c0a 100644
--- a/ultralytics/nn/autobackend.py
+++ b/ultralytics/nn/autobackend.py
@@ -508,9 +508,6 @@ def warmup(self, imgsz=(1, 3, 640, 640)):
Args:
imgsz (tuple): The shape of the dummy input tensor in the format (batch_size, channels, height, width)
-
- Returns:
- (None): This method runs the forward pass and don't return any value
"""
warmup_types = self.pt, self.jit, self.onnx, self.engine, self.saved_model, self.pb, self.triton, self.nn_module
if any(warmup_types) and (self.device.type != "cpu" or self.triton):
@@ -521,13 +518,16 @@ def warmup(self, imgsz=(1, 3, 640, 640)):
@staticmethod
def _model_type(p="path/to/model.pt"):
"""
- This function takes a path to a model file and returns the model type.
+ This function takes a path to a model file and returns the model type. Possibles types are pt, jit, onnx, xml,
+ engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, ncnn or paddle.
Args:
p: path to the model file. Defaults to path/to/model.pt
+
+ Examples:
+ >>> model = AutoBackend(weights="path/to/model.onnx")
+ >>> model_type = model._model_type() # returns "onnx"
"""
- # Return model type from model path, i.e. path='path/to/model.onnx' -> type=onnx
- # types = [pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle]
from ultralytics.engine.exporter import export_formats
sf = list(export_formats().Suffix) # export suffixes
diff --git a/ultralytics/solutions/object_counter.py b/ultralytics/solutions/object_counter.py
index 98231c3cd02..e06c5a25220 100644
--- a/ultralytics/solutions/object_counter.py
+++ b/ultralytics/solutions/object_counter.py
@@ -136,7 +136,6 @@ def mouse_event_for_region(self, event, x, y, flags, params):
cv2.EVENT_FLAG_SHIFTKEY, etc.).
params (dict): Additional parameters you may want to pass to the function.
"""
- # global is_drawing, selected_point
if event == cv2.EVENT_LBUTTONDOWN:
for i, point in enumerate(self.reg_pts):
if (
diff --git a/ultralytics/utils/__init__.py b/ultralytics/utils/__init__.py
index 07641c65802..d8cfccaac88 100644
--- a/ultralytics/utils/__init__.py
+++ b/ultralytics/utils/__init__.py
@@ -116,8 +116,11 @@ class TQDM(tqdm_original):
"""
def __init__(self, *args, **kwargs):
- """Initialize custom Ultralytics tqdm class with different default arguments."""
- # Set new default values (these can still be overridden when calling TQDM)
+ """
+ Initialize custom Ultralytics tqdm class with different default arguments.
+
+ Note these can still be overridden when calling TQDM.
+ """
kwargs["disable"] = not VERBOSE or kwargs.get("disable", False) # logical 'and' with default value if passed
kwargs.setdefault("bar_format", TQDM_BAR_FORMAT) # override default value if passed
super().__init__(*args, **kwargs)
@@ -377,7 +380,7 @@ def yaml_print(yaml_file: Union[str, Path, dict]) -> None:
yaml_file: The file path of the YAML file or a YAML-formatted dictionary.
Returns:
- None
+ (None)
"""
yaml_dict = yaml_load(yaml_file) if isinstance(yaml_file, (str, Path)) else yaml_file
dump = yaml.dump(yaml_dict, sort_keys=False, allow_unicode=True)
@@ -610,7 +613,7 @@ def get_ubuntu_version():
def get_user_config_dir(sub_dir="Ultralytics"):
"""
- Get the user config directory.
+ Return the appropriate config directory based on the environment operating system.
Args:
sub_dir (str): The name of the subdirectory to create.
@@ -618,7 +621,6 @@ def get_user_config_dir(sub_dir="Ultralytics"):
Returns:
(Path): The path to the user config directory.
"""
- # Return the appropriate config directory for each operating system
if WINDOWS:
path = Path.home() / "AppData" / "Roaming" / sub_dir
elif MACOS: # macOS
diff --git a/ultralytics/utils/benchmarks.py b/ultralytics/utils/benchmarks.py
index dbb95183032..6a3b1762e69 100644
--- a/ultralytics/utils/benchmarks.py
+++ b/ultralytics/utils/benchmarks.py
@@ -258,8 +258,7 @@ def get_onnx_model_info(self, onnx_file: str):
"""Retrieves the information including number of layers, parameters, gradients and FLOPs for an ONNX model
file.
"""
- # return (num_layers, num_params, num_gradients, num_flops)
- return 0.0, 0.0, 0.0, 0.0
+ return 0.0, 0.0, 0.0, 0.0 # return (num_layers, num_params, num_gradients, num_flops)
def iterative_sigma_clipping(self, data, sigma=2, max_iters=3):
"""Applies an iterative sigma clipping algorithm to the given data times number of iterations."""
diff --git a/ultralytics/utils/checks.py b/ultralytics/utils/checks.py
index ea4f757d613..0931f4cf391 100644
--- a/ultralytics/utils/checks.py
+++ b/ultralytics/utils/checks.py
@@ -109,7 +109,7 @@ def is_ascii(s) -> bool:
s (str): String to be checked.
Returns:
- bool: True if the string is composed only of ASCII characters, False otherwise.
+ (bool): True if the string is composed only of ASCII characters, False otherwise.
"""
# Convert list, tuple, None, etc. to string
s = str(s)
@@ -327,7 +327,7 @@ def check_python(minimum: str = "3.8.0") -> bool:
minimum (str): Required minimum version of python.
Returns:
- None
+ (bool): Whether the installed Python version meets the minimum constraints.
"""
return check_version(platform.python_version(), minimum, name="Python ", hard=True)
diff --git a/ultralytics/utils/loss.py b/ultralytics/utils/loss.py
index af3d240f46f..28dee2efbca 100644
--- a/ultralytics/utils/loss.py
+++ b/ultralytics/utils/loss.py
@@ -87,8 +87,12 @@ def forward(self, pred_dist, pred_bboxes, anchor_points, target_bboxes, target_s
@staticmethod
def _df_loss(pred_dist, target):
- """Return sum of left and right DFL losses."""
- # Distribution Focal Loss (DFL) proposed in Generalized Focal Loss https://ieeexplore.ieee.org/document/9792391
+ """
+ Return sum of left and right DFL losses.
+
+ Distribution Focal Loss (DFL) proposed in Generalized Focal Loss
+ https://ieeexplore.ieee.org/document/9792391
+ """
tl = target.long() # target left
tr = tl + 1 # target right
wl = tr - target # weight left
@@ -696,6 +700,7 @@ def bbox_decode(self, anchor_points, pred_dist, pred_angle):
anchor_points (torch.Tensor): Anchor points, (h*w, 2).
pred_dist (torch.Tensor): Predicted rotated distance, (bs, h*w, 4).
pred_angle (torch.Tensor): Predicted angle, (bs, h*w, 1).
+
Returns:
(torch.Tensor): Predicted rotated bounding boxes with angles, (bs, h*w, 5).
"""
diff --git a/ultralytics/utils/metrics.py b/ultralytics/utils/metrics.py
index f10ae329f46..7a3e9d32ba7 100644
--- a/ultralytics/utils/metrics.py
+++ b/ultralytics/utils/metrics.py
@@ -180,7 +180,7 @@ def _get_covariance_matrix(boxes):
Returns:
(torch.Tensor): Covariance metrixs corresponding to original rotated bounding boxes.
"""
- # Gaussian bounding boxes, ignored the center points(the first two columns) cause it's not needed here.
+ # Gaussian bounding boxes, ignore the center points (the first two columns) because they are not needed here.
gbbs = torch.cat((torch.pow(boxes[:, 2:4], 2) / 12, boxes[:, 4:]), dim=-1)
a, b, c = gbbs.split(1, dim=-1)
return (
diff --git a/ultralytics/utils/ops.py b/ultralytics/utils/ops.py
index 5f02dabc9b6..c569a3cb56b 100644
--- a/ultralytics/utils/ops.py
+++ b/ultralytics/utils/ops.py
@@ -75,7 +75,6 @@ def segment2box(segment, width=640, height=640):
Returns:
(np.ndarray): the minimum and maximum x and y values of the segment.
"""
- # Convert 1 segment label to 1 box label, applying inside-image constraint, i.e. (xy1, xy2, ...) to (xyxy)
x, y = segment.T # segment xy
inside = (x >= 0) & (y >= 0) & (x <= width) & (y <= height)
x = x[inside]
diff --git a/ultralytics/utils/plotting.py b/ultralytics/utils/plotting.py
index 3028ed144c0..629de701614 100644
--- a/ultralytics/utils/plotting.py
+++ b/ultralytics/utils/plotting.py
@@ -388,6 +388,7 @@ def estimate_pose_angle(a, b, c):
a (float) : The value of pose point a
b (float): The value of pose point b
c (float): The value o pose point c
+
Returns:
angle (degree): Degree value of angle between three points
"""
diff --git a/ultralytics/utils/triton.py b/ultralytics/utils/triton.py
index 98c4be207c6..3f873a6fafc 100644
--- a/ultralytics/utils/triton.py
+++ b/ultralytics/utils/triton.py
@@ -75,7 +75,7 @@ def __call__(self, *inputs: np.ndarray) -> List[np.ndarray]:
*inputs (List[np.ndarray]): Input data to the model.
Returns:
- List[np.ndarray]: Model outputs.
+ (List[np.ndarray]): Model outputs.
"""
infer_inputs = []
input_format = inputs[0].dtype
diff --git a/ultralytics/utils/tuner.py b/ultralytics/utils/tuner.py
index db7d4907944..20e3b7565eb 100644
--- a/ultralytics/utils/tuner.py
+++ b/ultralytics/utils/tuner.py
@@ -94,7 +94,7 @@ def _tune(config):
config (dict): A dictionary of hyperparameters to use for training.
Returns:
- None.
+ None
"""
model_to_train = ray.get(model_in_store) # get the model from ray store for tuning
model_to_train.reset_callbacks()
From 5f00fbd2279725f631bcfc91e11ea3c9f20ae74c Mon Sep 17 00:00:00 2001
From: Glenn Jocher
Date: Sat, 27 Jan 2024 18:48:24 +0100
Subject: [PATCH 003/171] Link checks SSL insecure robustness (#7853)
---
.github/workflows/links.yml | 8 ++++++--
pyproject.toml | 2 +-
2 files changed, 7 insertions(+), 3 deletions(-)
diff --git a/.github/workflows/links.yml b/.github/workflows/links.yml
index 7109800c9f4..e770a2d5473 100644
--- a/.github/workflows/links.yml
+++ b/.github/workflows/links.yml
@@ -36,8 +36,10 @@ jobs:
command: |
lychee \
--scheme https \
+ --timeout 60 \
+ --insecure \
--accept 403,429,500,502,999 \
- --exclude-loopback \
+ --exclude-all-private \
--exclude 'https?://(www\.)?(linkedin\.com|twitter\.com|instagram\.com|kaggle\.com|fonts\.gstatic\.com|url\.com)' \
--exclude-path docs/zh \
--exclude-path docs/es \
@@ -63,8 +65,10 @@ jobs:
command: |
lychee \
--scheme https \
+ --timeout 60 \
+ --insecure \
--accept 429,999 \
- --exclude-loopback \
+ --exclude-all-private \
--exclude 'https?://(www\.)?(linkedin\.com|twitter\.com|instagram\.com|kaggle\.com|fonts\.gstatic\.com|url\.com)' \
--exclude-path '**/ci.yaml' \
--exclude-path docs/zh \
diff --git a/pyproject.toml b/pyproject.toml
index 1afacc11f48..93e9078a841 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -93,7 +93,7 @@ dev = [
"mkdocstrings[python]",
"mkdocs-jupyter", # for notebooks
"mkdocs-redirects", # for 301 redirects
- "mkdocs-ultralytics-plugin>=0.0.40", # for meta descriptions and images, dates and authors
+ "mkdocs-ultralytics-plugin>=0.0.42", # for meta descriptions and images, dates and authors
]
export = [
"onnx>=1.12.0", # ONNX export
From 1435f0e9de9fe1f9d733163c3df7e73b1deb695e Mon Sep 17 00:00:00 2001
From: Glenn Jocher
Date: Sat, 27 Jan 2024 20:07:31 +0100
Subject: [PATCH 004/171] Add new @Retry() decorator (#7854)
Signed-off-by: Glenn Jocher
---
docs/en/reference/utils/__init__.md | 4 +
tests/conftest.py | 22 +--
tests/test_cli.py | 82 +++++-----
tests/test_cuda.py | 46 +++---
tests/test_engine.py | 90 +++++------
tests/test_explorer.py | 14 +-
tests/test_integrations.py | 80 +++++-----
tests/test_python.py | 230 ++++++++++++++++------------
ultralytics/utils/__init__.py | 73 ++++++++-
9 files changed, 372 insertions(+), 269 deletions(-)
diff --git a/docs/en/reference/utils/__init__.md b/docs/en/reference/utils/__init__.md
index 43b245f1130..fc4c9a79f7b 100644
--- a/docs/en/reference/utils/__init__.md
+++ b/docs/en/reference/utils/__init__.md
@@ -31,6 +31,10 @@ keywords: Ultralytics, Utils, utilitarian functions, colorstr, yaml_save, set_lo
+## ::: ultralytics.utils.Retry
+
+
+
## ::: ultralytics.utils.SettingsManager
diff --git a/tests/conftest.py b/tests/conftest.py
index 59955bd1cef..06c0d14075c 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -5,7 +5,7 @@
import pytest
-TMP = Path(__file__).resolve().parent / 'tmp' # temp directory for test files
+TMP = Path(__file__).resolve().parent / "tmp" # temp directory for test files
def pytest_addoption(parser):
@@ -15,7 +15,7 @@ def pytest_addoption(parser):
Args:
parser (pytest.config.Parser): The pytest parser object.
"""
- parser.addoption('--slow', action='store_true', default=False, help='Run slow tests')
+ parser.addoption("--slow", action="store_true", default=False, help="Run slow tests")
def pytest_configure(config):
@@ -25,7 +25,7 @@ def pytest_configure(config):
Args:
config (pytest.config.Config): The pytest config object.
"""
- config.addinivalue_line('markers', 'slow: mark test as slow to run')
+ config.addinivalue_line("markers", "slow: mark test as slow to run")
def pytest_runtest_setup(item):
@@ -35,8 +35,8 @@ def pytest_runtest_setup(item):
Args:
item (pytest.Item): The test item object.
"""
- if 'slow' in item.keywords and not item.config.getoption('--slow'):
- pytest.skip('skip slow tests unless --slow is set')
+ if "slow" in item.keywords and not item.config.getoption("--slow"):
+ pytest.skip("skip slow tests unless --slow is set")
def pytest_collection_modifyitems(config, items):
@@ -47,9 +47,9 @@ def pytest_collection_modifyitems(config, items):
config (pytest.config.Config): The pytest config object.
items (list): List of test items to be executed.
"""
- if not config.getoption('--slow'):
+ if not config.getoption("--slow"):
# Remove the item entirely from the list of test items if it's marked as 'slow'
- items[:] = [item for item in items if 'slow' not in item.keywords]
+ items[:] = [item for item in items if "slow" not in item.keywords]
def pytest_sessionstart(session):
@@ -84,11 +84,11 @@ def pytest_terminal_summary(terminalreporter, exitstatus, config):
from ultralytics.utils import WEIGHTS_DIR
# Remove files
- models = [path for x in ['*.onnx', '*.torchscript'] for path in WEIGHTS_DIR.rglob(x)]
- for file in ['bus.jpg', 'yolov8n.onnx', 'yolov8n.torchscript'] + models:
+ models = [path for x in ["*.onnx", "*.torchscript"] for path in WEIGHTS_DIR.rglob(x)]
+ for file in ["bus.jpg", "yolov8n.onnx", "yolov8n.torchscript"] + models:
Path(file).unlink(missing_ok=True)
# Remove directories
- models = [path for x in ['*.mlpackage', '*_openvino_model'] for path in WEIGHTS_DIR.rglob(x)]
- for directory in [TMP.parents[1] / '.pytest_cache', TMP] + models:
+ models = [path for x in ["*.mlpackage", "*_openvino_model"] for path in WEIGHTS_DIR.rglob(x)]
+ for directory in [TMP.parents[1] / ".pytest_cache", TMP] + models:
shutil.rmtree(directory, ignore_errors=True)
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 994ce5a28e9..ea07d764bc9 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -10,17 +10,19 @@
CUDA_IS_AVAILABLE = cuda_is_available()
CUDA_DEVICE_COUNT = cuda_device_count()
TASK_ARGS = [
- ('detect', 'yolov8n', 'coco8.yaml'),
- ('segment', 'yolov8n-seg', 'coco8-seg.yaml'),
- ('classify', 'yolov8n-cls', 'imagenet10'),
- ('pose', 'yolov8n-pose', 'coco8-pose.yaml'),
- ('obb', 'yolov8n-obb', 'dota8.yaml'), ] # (task, model, data)
+ ("detect", "yolov8n", "coco8.yaml"),
+ ("segment", "yolov8n-seg", "coco8-seg.yaml"),
+ ("classify", "yolov8n-cls", "imagenet10"),
+ ("pose", "yolov8n-pose", "coco8-pose.yaml"),
+ ("obb", "yolov8n-obb", "dota8.yaml"),
+] # (task, model, data)
EXPORT_ARGS = [
- ('yolov8n', 'torchscript'),
- ('yolov8n-seg', 'torchscript'),
- ('yolov8n-cls', 'torchscript'),
- ('yolov8n-pose', 'torchscript'),
- ('yolov8n-obb', 'torchscript'), ] # (model, format)
+ ("yolov8n", "torchscript"),
+ ("yolov8n-seg", "torchscript"),
+ ("yolov8n-cls", "torchscript"),
+ ("yolov8n-pose", "torchscript"),
+ ("yolov8n-obb", "torchscript"),
+] # (model, format)
def run(cmd):
@@ -30,50 +32,50 @@ def run(cmd):
def test_special_modes():
"""Test various special command modes of YOLO."""
- run('yolo help')
- run('yolo checks')
- run('yolo version')
- run('yolo settings reset')
- run('yolo cfg')
+ run("yolo help")
+ run("yolo checks")
+ run("yolo version")
+ run("yolo settings reset")
+ run("yolo cfg")
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
def test_train(task, model, data):
"""Test YOLO training for a given task, model, and data."""
- run(f'yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 cache=disk')
+ run(f"yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 cache=disk")
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
def test_val(task, model, data):
"""Test YOLO validation for a given task, model, and data."""
- run(f'yolo val {task} model={WEIGHTS_DIR / model}.pt data={data} imgsz=32 save_txt save_json')
+ run(f"yolo val {task} model={WEIGHTS_DIR / model}.pt data={data} imgsz=32 save_txt save_json")
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
def test_predict(task, model, data):
"""Test YOLO prediction on sample assets for a given task and model."""
- run(f'yolo predict model={WEIGHTS_DIR / model}.pt source={ASSETS} imgsz=32 save save_crop save_txt')
+ run(f"yolo predict model={WEIGHTS_DIR / model}.pt source={ASSETS} imgsz=32 save save_crop save_txt")
-@pytest.mark.parametrize('model,format', EXPORT_ARGS)
+@pytest.mark.parametrize("model,format", EXPORT_ARGS)
def test_export(model, format):
"""Test exporting a YOLO model to different formats."""
- run(f'yolo export model={WEIGHTS_DIR / model}.pt format={format} imgsz=32')
+ run(f"yolo export model={WEIGHTS_DIR / model}.pt format={format} imgsz=32")
-def test_rtdetr(task='detect', model='yolov8n-rtdetr.yaml', data='coco8.yaml'):
+def test_rtdetr(task="detect", model="yolov8n-rtdetr.yaml", data="coco8.yaml"):
"""Test the RTDETR functionality with the Ultralytics framework."""
# Warning: MUST use imgsz=640
- run(f'yolo train {task} model={model} data={data} --imgsz= 640 epochs =1, cache = disk') # add coma, spaces to args
+ run(f"yolo train {task} model={model} data={data} --imgsz= 640 epochs =1, cache = disk") # add coma, spaces to args
run(f"yolo predict {task} model={model} source={ASSETS / 'bus.jpg'} imgsz=640 save save_crop save_txt")
-def test_fastsam(task='segment', model=WEIGHTS_DIR / 'FastSAM-s.pt', data='coco8-seg.yaml'):
+def test_fastsam(task="segment", model=WEIGHTS_DIR / "FastSAM-s.pt", data="coco8-seg.yaml"):
"""Test FastSAM segmentation functionality within Ultralytics."""
- source = ASSETS / 'bus.jpg'
+ source = ASSETS / "bus.jpg"
- run(f'yolo segment val {task} model={model} data={data} imgsz=32')
- run(f'yolo segment predict model={model} source={source} imgsz=32 save save_crop save_txt')
+ run(f"yolo segment val {task} model={model} data={data} imgsz=32")
+ run(f"yolo segment predict model={model} source={source} imgsz=32 save save_crop save_txt")
from ultralytics import FastSAM
from ultralytics.models.fastsam import FastSAMPrompt
@@ -83,26 +85,26 @@ def test_fastsam(task='segment', model=WEIGHTS_DIR / 'FastSAM-s.pt', data='coco8
sam_model = FastSAM(model) # or FastSAM-x.pt
# Run inference on an image
- everything_results = sam_model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
+ everything_results = sam_model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
# Remove small regions
new_masks, _ = Predictor.remove_small_regions(everything_results[0].masks.data, min_area=20)
# Everything prompt
- prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
+ prompt_process = FastSAMPrompt(source, everything_results, device="cpu")
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')
+ 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='./')
+ prompt_process.plot(annotations=ann, output="./")
def test_mobilesam():
@@ -110,10 +112,10 @@ def test_mobilesam():
from ultralytics import SAM
# Load the model
- model = SAM(WEIGHTS_DIR / 'mobile_sam.pt')
+ model = SAM(WEIGHTS_DIR / "mobile_sam.pt")
# Source
- source = ASSETS / 'zidane.jpg'
+ source = ASSETS / "zidane.jpg"
# Predict a segment based on a point prompt
model.predict(source, points=[900, 370], labels=[1])
@@ -127,10 +129,10 @@ def test_mobilesam():
# Slow Tests -----------------------------------------------------------------------------------------------------------
@pytest.mark.slow
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
-@pytest.mark.skipif(CUDA_DEVICE_COUNT < 2, reason='DDP is not available')
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(CUDA_DEVICE_COUNT < 2, reason="DDP is not available")
def test_train_gpu(task, model, data):
"""Test YOLO training on GPU(s) for various tasks and models."""
- run(f'yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 device=0') # single GPU
- run(f'yolo train {task} model={model}.pt data={data} imgsz=32 epochs=1 device=0,1') # multi GPU
+ run(f"yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 device=0") # single GPU
+ run(f"yolo train {task} model={model}.pt data={data} imgsz=32 epochs=1 device=0,1") # multi GPU
diff --git a/tests/test_cuda.py b/tests/test_cuda.py
index eb49a08f561..ed08f700703 100644
--- a/tests/test_cuda.py
+++ b/tests/test_cuda.py
@@ -9,9 +9,9 @@
CUDA_IS_AVAILABLE = checks.cuda_is_available()
CUDA_DEVICE_COUNT = checks.cuda_device_count()
-MODEL = WEIGHTS_DIR / 'path with spaces' / 'yolov8n.pt' # test spaces in path
-DATA = 'coco8.yaml'
-BUS = ASSETS / 'bus.jpg'
+MODEL = WEIGHTS_DIR / "path with spaces" / "yolov8n.pt" # test spaces in path
+DATA = "coco8.yaml"
+BUS = ASSETS / "bus.jpg"
def test_checks():
@@ -20,7 +20,7 @@ def test_checks():
assert torch.cuda.device_count() == CUDA_DEVICE_COUNT
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
def test_train():
"""Test model training on a minimal dataset."""
device = 0 if CUDA_DEVICE_COUNT == 1 else [0, 1]
@@ -28,32 +28,32 @@ def test_train():
@pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
def test_predict_multiple_devices():
"""Validate model prediction on multiple devices."""
- model = YOLO('yolov8n.pt')
+ model = YOLO("yolov8n.pt")
model = model.cpu()
- assert str(model.device) == 'cpu'
+ assert str(model.device) == "cpu"
_ = model(BUS) # CPU inference
- assert str(model.device) == 'cpu'
+ assert str(model.device) == "cpu"
- model = model.to('cuda:0')
- assert str(model.device) == 'cuda:0'
+ model = model.to("cuda:0")
+ assert str(model.device) == "cuda:0"
_ = model(BUS) # CUDA inference
- assert str(model.device) == 'cuda:0'
+ assert str(model.device) == "cuda:0"
model = model.cpu()
- assert str(model.device) == 'cpu'
+ assert str(model.device) == "cpu"
_ = model(BUS) # CPU inference
- assert str(model.device) == 'cpu'
+ assert str(model.device) == "cpu"
model = model.cuda()
- assert str(model.device) == 'cuda:0'
+ assert str(model.device) == "cuda:0"
_ = model(BUS) # CUDA inference
- assert str(model.device) == 'cuda:0'
+ assert str(model.device) == "cuda:0"
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
def test_autobatch():
"""Check batch size for YOLO model using autobatch."""
from ultralytics.utils.autobatch import check_train_batch_size
@@ -62,24 +62,24 @@ def test_autobatch():
@pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
def test_utils_benchmarks():
"""Profile YOLO models for performance benchmarks."""
from ultralytics.utils.benchmarks import ProfileModels
# Pre-export a dynamic engine model to use dynamic inference
- YOLO(MODEL).export(format='engine', imgsz=32, dynamic=True, batch=1)
+ YOLO(MODEL).export(format="engine", imgsz=32, dynamic=True, batch=1)
ProfileModels([MODEL], imgsz=32, half=False, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
def test_predict_sam():
"""Test SAM model prediction with various prompts."""
from ultralytics import SAM
from ultralytics.models.sam import Predictor as SAMPredictor
# Load a model
- model = SAM(WEIGHTS_DIR / 'sam_b.pt')
+ model = SAM(WEIGHTS_DIR / "sam_b.pt")
# Display model information (optional)
model.info()
@@ -91,14 +91,14 @@ def test_predict_sam():
model(BUS, bboxes=[439, 437, 524, 709], device=0)
# Run inference with points prompt
- model(ASSETS / 'zidane.jpg', points=[900, 370], labels=[1], device=0)
+ model(ASSETS / "zidane.jpg", points=[900, 370], labels=[1], device=0)
# Create SAMPredictor
- overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model=WEIGHTS_DIR / 'mobile_sam.pt')
+ overrides = dict(conf=0.25, task="segment", mode="predict", imgsz=1024, model=WEIGHTS_DIR / "mobile_sam.pt")
predictor = SAMPredictor(overrides=overrides)
# Set image
- predictor.set_image(ASSETS / 'zidane.jpg') # set with image file
+ predictor.set_image(ASSETS / "zidane.jpg") # set with image file
# predictor(bboxes=[439, 437, 524, 709])
# predictor(points=[900, 370], labels=[1])
diff --git a/tests/test_engine.py b/tests/test_engine.py
index ce328efca4d..bd528a8d833 100644
--- a/tests/test_engine.py
+++ b/tests/test_engine.py
@@ -6,123 +6,123 @@
from ultralytics.models.yolo import classify, detect, segment
from ultralytics.utils import ASSETS, DEFAULT_CFG, WEIGHTS_DIR
-CFG_DET = 'yolov8n.yaml'
-CFG_SEG = 'yolov8n-seg.yaml'
-CFG_CLS = 'yolov8n-cls.yaml' # or 'squeezenet1_0'
+CFG_DET = "yolov8n.yaml"
+CFG_SEG = "yolov8n-seg.yaml"
+CFG_CLS = "yolov8n-cls.yaml" # or 'squeezenet1_0'
CFG = get_cfg(DEFAULT_CFG)
-MODEL = WEIGHTS_DIR / 'yolov8n'
+MODEL = WEIGHTS_DIR / "yolov8n"
def test_func(*args): # noqa
"""Test function callback."""
- print('callback test passed')
+ print("callback test passed")
def test_export():
"""Test model exporting functionality."""
exporter = Exporter()
- exporter.add_callback('on_export_start', test_func)
- assert test_func in exporter.callbacks['on_export_start'], 'callback test failed'
+ exporter.add_callback("on_export_start", test_func)
+ assert test_func in exporter.callbacks["on_export_start"], "callback test failed"
f = exporter(model=YOLO(CFG_DET).model)
YOLO(f)(ASSETS) # exported model inference
def test_detect():
"""Test object detection functionality."""
- overrides = {'data': 'coco8.yaml', 'model': CFG_DET, 'imgsz': 32, 'epochs': 1, 'save': False}
- CFG.data = 'coco8.yaml'
+ overrides = {"data": "coco8.yaml", "model": CFG_DET, "imgsz": 32, "epochs": 1, "save": False}
+ CFG.data = "coco8.yaml"
CFG.imgsz = 32
# Trainer
trainer = detect.DetectionTrainer(overrides=overrides)
- trainer.add_callback('on_train_start', test_func)
- assert test_func in trainer.callbacks['on_train_start'], 'callback test failed'
+ trainer.add_callback("on_train_start", test_func)
+ assert test_func in trainer.callbacks["on_train_start"], "callback test failed"
trainer.train()
# Validator
val = detect.DetectionValidator(args=CFG)
- val.add_callback('on_val_start', test_func)
- assert test_func in val.callbacks['on_val_start'], 'callback test failed'
+ val.add_callback("on_val_start", test_func)
+ assert test_func in val.callbacks["on_val_start"], "callback test failed"
val(model=trainer.best) # validate best.pt
# Predictor
- pred = detect.DetectionPredictor(overrides={'imgsz': [64, 64]})
- pred.add_callback('on_predict_start', test_func)
- assert test_func in pred.callbacks['on_predict_start'], 'callback test failed'
- result = pred(source=ASSETS, model=f'{MODEL}.pt')
- assert len(result), 'predictor test failed'
+ pred = detect.DetectionPredictor(overrides={"imgsz": [64, 64]})
+ pred.add_callback("on_predict_start", test_func)
+ assert test_func in pred.callbacks["on_predict_start"], "callback test failed"
+ result = pred(source=ASSETS, model=f"{MODEL}.pt")
+ assert len(result), "predictor test failed"
- overrides['resume'] = trainer.last
+ overrides["resume"] = trainer.last
trainer = detect.DetectionTrainer(overrides=overrides)
try:
trainer.train()
except Exception as e:
- print(f'Expected exception caught: {e}')
+ print(f"Expected exception caught: {e}")
return
- Exception('Resume test failed!')
+ Exception("Resume test failed!")
def test_segment():
"""Test image segmentation functionality."""
- overrides = {'data': 'coco8-seg.yaml', 'model': CFG_SEG, 'imgsz': 32, 'epochs': 1, 'save': False}
- CFG.data = 'coco8-seg.yaml'
+ overrides = {"data": "coco8-seg.yaml", "model": CFG_SEG, "imgsz": 32, "epochs": 1, "save": False}
+ CFG.data = "coco8-seg.yaml"
CFG.imgsz = 32
# YOLO(CFG_SEG).train(**overrides) # works
# Trainer
trainer = segment.SegmentationTrainer(overrides=overrides)
- trainer.add_callback('on_train_start', test_func)
- assert test_func in trainer.callbacks['on_train_start'], 'callback test failed'
+ trainer.add_callback("on_train_start", test_func)
+ assert test_func in trainer.callbacks["on_train_start"], "callback test failed"
trainer.train()
# Validator
val = segment.SegmentationValidator(args=CFG)
- val.add_callback('on_val_start', test_func)
- assert test_func in val.callbacks['on_val_start'], 'callback test failed'
+ val.add_callback("on_val_start", test_func)
+ assert test_func in val.callbacks["on_val_start"], "callback test failed"
val(model=trainer.best) # validate best.pt
# Predictor
- pred = segment.SegmentationPredictor(overrides={'imgsz': [64, 64]})
- pred.add_callback('on_predict_start', test_func)
- assert test_func in pred.callbacks['on_predict_start'], 'callback test failed'
- result = pred(source=ASSETS, model=f'{MODEL}-seg.pt')
- assert len(result), 'predictor test failed'
+ pred = segment.SegmentationPredictor(overrides={"imgsz": [64, 64]})
+ pred.add_callback("on_predict_start", test_func)
+ assert test_func in pred.callbacks["on_predict_start"], "callback test failed"
+ result = pred(source=ASSETS, model=f"{MODEL}-seg.pt")
+ assert len(result), "predictor test failed"
# Test resume
- overrides['resume'] = trainer.last
+ overrides["resume"] = trainer.last
trainer = segment.SegmentationTrainer(overrides=overrides)
try:
trainer.train()
except Exception as e:
- print(f'Expected exception caught: {e}')
+ print(f"Expected exception caught: {e}")
return
- Exception('Resume test failed!')
+ Exception("Resume test failed!")
def test_classify():
"""Test image classification functionality."""
- overrides = {'data': 'imagenet10', 'model': CFG_CLS, 'imgsz': 32, 'epochs': 1, 'save': False}
- CFG.data = 'imagenet10'
+ overrides = {"data": "imagenet10", "model": CFG_CLS, "imgsz": 32, "epochs": 1, "save": False}
+ CFG.data = "imagenet10"
CFG.imgsz = 32
# YOLO(CFG_SEG).train(**overrides) # works
# Trainer
trainer = classify.ClassificationTrainer(overrides=overrides)
- trainer.add_callback('on_train_start', test_func)
- assert test_func in trainer.callbacks['on_train_start'], 'callback test failed'
+ trainer.add_callback("on_train_start", test_func)
+ assert test_func in trainer.callbacks["on_train_start"], "callback test failed"
trainer.train()
# Validator
val = classify.ClassificationValidator(args=CFG)
- val.add_callback('on_val_start', test_func)
- assert test_func in val.callbacks['on_val_start'], 'callback test failed'
+ val.add_callback("on_val_start", test_func)
+ assert test_func in val.callbacks["on_val_start"], "callback test failed"
val(model=trainer.best)
# Predictor
- pred = classify.ClassificationPredictor(overrides={'imgsz': [64, 64]})
- pred.add_callback('on_predict_start', test_func)
- assert test_func in pred.callbacks['on_predict_start'], 'callback test failed'
+ pred = classify.ClassificationPredictor(overrides={"imgsz": [64, 64]})
+ pred.add_callback("on_predict_start", test_func)
+ assert test_func in pred.callbacks["on_predict_start"], "callback test failed"
result = pred(source=ASSETS, model=trainer.best)
- assert len(result), 'predictor test failed'
+ assert len(result), "predictor test failed"
diff --git a/tests/test_explorer.py b/tests/test_explorer.py
index eed02ae5ebf..12960dd2b32 100644
--- a/tests/test_explorer.py
+++ b/tests/test_explorer.py
@@ -12,7 +12,7 @@ def test_similarity():
exp.create_embeddings_table()
similar = exp.get_similar(idx=1)
assert len(similar) == 25
- similar = exp.get_similar(img=ASSETS / 'zidane.jpg')
+ similar = exp.get_similar(img=ASSETS / "zidane.jpg")
assert len(similar) == 25
similar = exp.get_similar(idx=[1, 2], limit=10)
assert len(similar) == 10
@@ -24,9 +24,9 @@ def test_similarity():
def test_det():
"""Test detection functionalities and ensure the embedding table has bounding boxes."""
- exp = Explorer(data='coco8.yaml', model='yolov8n.pt')
+ exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
exp.create_embeddings_table(force=True)
- assert len(exp.table.head()['bboxes']) > 0
+ assert len(exp.table.head()["bboxes"]) > 0
similar = exp.get_similar(idx=[1, 2], limit=10)
assert len(similar) > 0
# This is a loose test, just checks errors not correctness
@@ -36,9 +36,9 @@ def test_det():
def test_seg():
"""Test segmentation functionalities and verify the embedding table includes masks."""
- exp = Explorer(data='coco8-seg.yaml', model='yolov8n-seg.pt')
+ exp = Explorer(data="coco8-seg.yaml", model="yolov8n-seg.pt")
exp.create_embeddings_table(force=True)
- assert len(exp.table.head()['masks']) > 0
+ assert len(exp.table.head()["masks"]) > 0
similar = exp.get_similar(idx=[1, 2], limit=10)
assert len(similar) > 0
similar = exp.plot_similar(idx=[1, 2], limit=10)
@@ -47,9 +47,9 @@ def test_seg():
def test_pose():
"""Test pose estimation functionalities and check the embedding table for keypoints."""
- exp = Explorer(data='coco8-pose.yaml', model='yolov8n-pose.pt')
+ exp = Explorer(data="coco8-pose.yaml", model="yolov8n-pose.pt")
exp.create_embeddings_table(force=True)
- assert len(exp.table.head()['keypoints']) > 0
+ assert len(exp.table.head()["keypoints"]) > 0
similar = exp.get_similar(idx=[1, 2], limit=10)
assert len(similar) > 0
similar = exp.plot_similar(idx=[1, 2], limit=10)
diff --git a/tests/test_integrations.py b/tests/test_integrations.py
index 0831f716079..af8f507a7b1 100644
--- a/tests/test_integrations.py
+++ b/tests/test_integrations.py
@@ -9,67 +9,67 @@
from ultralytics.utils import ASSETS, DATASETS_DIR, ROOT, SETTINGS, WEIGHTS_DIR
from ultralytics.utils.checks import check_requirements
-MODEL = WEIGHTS_DIR / 'path with spaces' / 'yolov8n.pt' # test spaces in path
-CFG = 'yolov8n.yaml'
-SOURCE = ASSETS / 'bus.jpg'
-TMP = (ROOT / '../tests/tmp').resolve() # temp directory for test files
+MODEL = WEIGHTS_DIR / "path with spaces" / "yolov8n.pt" # test spaces in path
+CFG = "yolov8n.yaml"
+SOURCE = ASSETS / "bus.jpg"
+TMP = (ROOT / "../tests/tmp").resolve() # temp directory for test files
-@pytest.mark.skipif(not check_requirements('ray', install=False), reason='ray[tune] not installed')
+@pytest.mark.skipif(not check_requirements("ray", install=False), reason="ray[tune] not installed")
def test_model_ray_tune():
"""Tune YOLO model with Ray optimization library."""
- YOLO('yolov8n-cls.yaml').tune(use_ray=True,
- data='imagenet10',
- grace_period=1,
- iterations=1,
- imgsz=32,
- epochs=1,
- plots=False,
- device='cpu')
+ YOLO("yolov8n-cls.yaml").tune(
+ use_ray=True, data="imagenet10", grace_period=1, iterations=1, imgsz=32, epochs=1, plots=False, device="cpu"
+ )
-@pytest.mark.skipif(not check_requirements('mlflow', install=False), reason='mlflow not installed')
+@pytest.mark.skipif(not check_requirements("mlflow", install=False), reason="mlflow not installed")
def test_mlflow():
"""Test training with MLflow tracking enabled."""
- SETTINGS['mlflow'] = True
- YOLO('yolov8n-cls.yaml').train(data='imagenet10', imgsz=32, epochs=3, plots=False, device='cpu')
+ SETTINGS["mlflow"] = True
+ YOLO("yolov8n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=3, plots=False, device="cpu")
-@pytest.mark.skipif(not check_requirements('tritonclient', install=False), reason='tritonclient[all] not installed')
+@pytest.mark.skipif(not check_requirements("tritonclient", install=False), reason="tritonclient[all] not installed")
def test_triton():
"""Test NVIDIA Triton Server functionalities."""
- check_requirements('tritonclient[all]')
+ check_requirements("tritonclient[all]")
import subprocess
import time
from tritonclient.http import InferenceServerClient # noqa
# Create variables
- model_name = 'yolo'
- triton_repo_path = TMP / 'triton_repo'
+ model_name = "yolo"
+ triton_repo_path = TMP / "triton_repo"
triton_model_path = triton_repo_path / model_name
# Export model to ONNX
- f = YOLO(MODEL).export(format='onnx', dynamic=True)
+ f = YOLO(MODEL).export(format="onnx", dynamic=True)
# Prepare Triton repo
- (triton_model_path / '1').mkdir(parents=True, exist_ok=True)
- Path(f).rename(triton_model_path / '1' / 'model.onnx')
- (triton_model_path / 'config.pbtxt').touch()
+ (triton_model_path / "1").mkdir(parents=True, exist_ok=True)
+ Path(f).rename(triton_model_path / "1" / "model.onnx")
+ (triton_model_path / "config.pbtxt").touch()
# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
- tag = 'nvcr.io/nvidia/tritonserver:23.09-py3' # 6.4 GB
+ tag = "nvcr.io/nvidia/tritonserver:23.09-py3" # 6.4 GB
# Pull the image
- subprocess.call(f'docker pull {tag}', shell=True)
+ 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()
+ 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)
+ triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)
# Wait until model is ready
for _ in range(10):
@@ -79,13 +79,13 @@ def test_triton():
time.sleep(1)
# Check Triton inference
- YOLO(f'http://localhost:8000/{model_name}', 'detect')(SOURCE) # exported model inference
+ YOLO(f"http://localhost:8000/{model_name}", "detect")(SOURCE) # exported model inference
# Kill and remove the container at the end of the test
- subprocess.call(f'docker kill {container_id}', shell=True)
+ subprocess.call(f"docker kill {container_id}", shell=True)
-@pytest.mark.skipif(not check_requirements('pycocotools', install=False), reason='pycocotools not installed')
+@pytest.mark.skipif(not check_requirements("pycocotools", install=False), reason="pycocotools not installed")
def test_pycocotools():
"""Validate model predictions using pycocotools."""
from ultralytics.models.yolo.detect import DetectionValidator
@@ -93,25 +93,25 @@ def test_pycocotools():
from ultralytics.models.yolo.segment import SegmentationValidator
# Download annotations after each dataset downloads first
- url = 'https://github.com/ultralytics/assets/releases/download/v8.1.0/'
+ url = "https://github.com/ultralytics/assets/releases/download/v8.1.0/"
- args = {'model': 'yolov8n.pt', 'data': 'coco8.yaml', 'save_json': True, 'imgsz': 64}
+ args = {"model": "yolov8n.pt", "data": "coco8.yaml", "save_json": True, "imgsz": 64}
validator = DetectionValidator(args=args)
validator()
validator.is_coco = True
- download(f'{url}instances_val2017.json', dir=DATASETS_DIR / 'coco8/annotations')
+ download(f"{url}instances_val2017.json", dir=DATASETS_DIR / "coco8/annotations")
_ = validator.eval_json(validator.stats)
- args = {'model': 'yolov8n-seg.pt', 'data': 'coco8-seg.yaml', 'save_json': True, 'imgsz': 64}
+ args = {"model": "yolov8n-seg.pt", "data": "coco8-seg.yaml", "save_json": True, "imgsz": 64}
validator = SegmentationValidator(args=args)
validator()
validator.is_coco = True
- download(f'{url}instances_val2017.json', dir=DATASETS_DIR / 'coco8-seg/annotations')
+ download(f"{url}instances_val2017.json", dir=DATASETS_DIR / "coco8-seg/annotations")
_ = validator.eval_json(validator.stats)
- args = {'model': 'yolov8n-pose.pt', 'data': 'coco8-pose.yaml', 'save_json': True, 'imgsz': 64}
+ args = {"model": "yolov8n-pose.pt", "data": "coco8-pose.yaml", "save_json": True, "imgsz": 64}
validator = PoseValidator(args=args)
validator()
validator.is_coco = True
- download(f'{url}person_keypoints_val2017.json', dir=DATASETS_DIR / 'coco8-pose/annotations')
+ download(f"{url}person_keypoints_val2017.json", dir=DATASETS_DIR / "coco8-pose/annotations")
_ = validator.eval_json(validator.stats)
diff --git a/tests/test_python.py b/tests/test_python.py
index 46d28762860..61f43034045 100644
--- a/tests/test_python.py
+++ b/tests/test_python.py
@@ -14,15 +14,27 @@
from ultralytics import RTDETR, YOLO
from ultralytics.cfg import TASK2DATA
from ultralytics.data.build import load_inference_source
-from ultralytics.utils import (ASSETS, DEFAULT_CFG, DEFAULT_CFG_PATH, LINUX, MACOS, ONLINE, ROOT, WEIGHTS_DIR, WINDOWS,
- checks, is_dir_writeable)
+from ultralytics.utils import (
+ ASSETS,
+ DEFAULT_CFG,
+ DEFAULT_CFG_PATH,
+ LINUX,
+ MACOS,
+ ONLINE,
+ ROOT,
+ WEIGHTS_DIR,
+ WINDOWS,
+ Retry,
+ checks,
+ is_dir_writeable,
+)
from ultralytics.utils.downloads import download
from ultralytics.utils.torch_utils import TORCH_1_9
-MODEL = WEIGHTS_DIR / 'path with spaces' / 'yolov8n.pt' # test spaces in path
-CFG = 'yolov8n.yaml'
-SOURCE = ASSETS / 'bus.jpg'
-TMP = (ROOT / '../tests/tmp').resolve() # temp directory for test files
+MODEL = WEIGHTS_DIR / "path with spaces" / "yolov8n.pt" # test spaces in path
+CFG = "yolov8n.yaml"
+SOURCE = ASSETS / "bus.jpg"
+TMP = (ROOT / "../tests/tmp").resolve() # temp directory for test files
IS_TMP_WRITEABLE = is_dir_writeable(TMP)
@@ -40,9 +52,9 @@ def test_model_methods():
model.info(verbose=True, detailed=True)
model = model.reset_weights()
model = model.load(MODEL)
- model.to('cpu')
+ model.to("cpu")
model.fuse()
- model.clear_callback('on_train_start')
+ model.clear_callback("on_train_start")
model.reset_callbacks()
# Model properties
@@ -61,23 +73,23 @@ def test_model_profile():
_ = model.predict(im, profile=True)
-@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason='directory is not writeable')
+@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason="directory is not writeable")
def test_predict_txt():
"""Test YOLO predictions with sources (file, dir, glob, recursive glob) specified in a text file."""
- txt_file = TMP / 'sources.txt'
- with open(txt_file, 'w') as f:
- for x in [ASSETS / 'bus.jpg', ASSETS, ASSETS / '*', ASSETS / '**/*.jpg']:
- f.write(f'{x}\n')
+ txt_file = TMP / "sources.txt"
+ with open(txt_file, "w") as f:
+ for x in [ASSETS / "bus.jpg", ASSETS, ASSETS / "*", ASSETS / "**/*.jpg"]:
+ f.write(f"{x}\n")
_ = YOLO(MODEL)(source=txt_file, imgsz=32)
def test_predict_img():
"""Test YOLO prediction on various types of image sources."""
model = YOLO(MODEL)
- seg_model = YOLO(WEIGHTS_DIR / 'yolov8n-seg.pt')
- cls_model = YOLO(WEIGHTS_DIR / 'yolov8n-cls.pt')
- pose_model = YOLO(WEIGHTS_DIR / 'yolov8n-pose.pt')
- obb_model = YOLO(WEIGHTS_DIR / 'yolov8n-obb.pt')
+ seg_model = YOLO(WEIGHTS_DIR / "yolov8n-seg.pt")
+ cls_model = YOLO(WEIGHTS_DIR / "yolov8n-cls.pt")
+ pose_model = YOLO(WEIGHTS_DIR / "yolov8n-pose.pt")
+ obb_model = YOLO(WEIGHTS_DIR / "yolov8n-obb.pt")
im = cv2.imread(str(SOURCE))
assert len(model(source=Image.open(SOURCE), save=True, verbose=True, imgsz=32)) == 1 # PIL
assert len(model(source=im, save=True, save_txt=True, imgsz=32)) == 1 # ndarray
@@ -87,10 +99,11 @@ def test_predict_img():
batch = [
str(SOURCE), # filename
Path(SOURCE), # Path
- 'https://ultralytics.com/images/zidane.jpg' if ONLINE else SOURCE, # URI
+ "https://ultralytics.com/images/zidane.jpg" if ONLINE else SOURCE, # URI
cv2.imread(str(SOURCE)), # OpenCV
Image.open(SOURCE), # PIL
- np.zeros((320, 640, 3))] # numpy
+ np.zeros((320, 640, 3)),
+ ] # numpy
assert len(model(batch, imgsz=32)) == len(batch) # multiple sources in a batch
# Test tensor inference
@@ -113,16 +126,16 @@ def test_predict_img():
def test_predict_grey_and_4ch():
"""Test YOLO prediction on SOURCE converted to greyscale and 4-channel images."""
im = Image.open(SOURCE)
- directory = TMP / 'im4'
+ directory = TMP / "im4"
directory.mkdir(parents=True, exist_ok=True)
- source_greyscale = directory / 'greyscale.jpg'
- source_rgba = directory / '4ch.png'
- source_non_utf = directory / 'non_UTF_测试文件_tést_image.jpg'
- source_spaces = directory / 'image with spaces.jpg'
+ source_greyscale = directory / "greyscale.jpg"
+ source_rgba = directory / "4ch.png"
+ source_non_utf = directory / "non_UTF_测试文件_tést_image.jpg"
+ source_spaces = directory / "image with spaces.jpg"
- im.convert('L').save(source_greyscale) # greyscale
- im.convert('RGBA').save(source_rgba) # 4-ch PNG with alpha
+ im.convert("L").save(source_greyscale) # greyscale
+ im.convert("RGBA").save(source_rgba) # 4-ch PNG with alpha
im.save(source_non_utf) # non-UTF characters in filename
im.save(source_spaces) # spaces in filename
@@ -136,7 +149,8 @@ def test_predict_grey_and_4ch():
@pytest.mark.slow
-@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
+@Retry(times=3, delay=10)
def test_youtube():
"""
Test YouTube inference.
@@ -144,11 +158,11 @@ def test_youtube():
Marked --slow to reduce YouTube API rate limits risk.
"""
model = YOLO(MODEL)
- model.predict('https://youtu.be/G17sBkb38XQ', imgsz=96, save=True)
+ model.predict("https://youtu.be/G17sBkb38XQ", imgsz=96, save=True)
-@pytest.mark.skipif(not ONLINE, reason='environment is offline')
-@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason='directory is not writeable')
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
+@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason="directory is not writeable")
def test_track_stream():
"""
Test streaming tracking (short 10 frame video) with non-default ByteTrack tracker.
@@ -157,56 +171,56 @@ def test_track_stream():
"""
import yaml
- video_url = 'https://ultralytics.com/assets/decelera_portrait_min.mov'
+ video_url = "https://ultralytics.com/assets/decelera_portrait_min.mov"
model = YOLO(MODEL)
- model.track(video_url, imgsz=160, tracker='bytetrack.yaml')
- model.track(video_url, imgsz=160, tracker='botsort.yaml', save_frames=True) # test frame saving also
+ model.track(video_url, imgsz=160, tracker="bytetrack.yaml")
+ model.track(video_url, imgsz=160, tracker="botsort.yaml", save_frames=True) # test frame saving also
# Test Global Motion Compensation (GMC) methods
- for gmc in 'orb', 'sift', 'ecc':
- with open(ROOT / 'cfg/trackers/botsort.yaml', encoding='utf-8') as f:
+ for gmc in "orb", "sift", "ecc":
+ with open(ROOT / "cfg/trackers/botsort.yaml", encoding="utf-8") as f:
data = yaml.safe_load(f)
- tracker = TMP / f'botsort-{gmc}.yaml'
- data['gmc_method'] = gmc
- with open(tracker, 'w', encoding='utf-8') as f:
+ tracker = TMP / f"botsort-{gmc}.yaml"
+ data["gmc_method"] = gmc
+ with open(tracker, "w", encoding="utf-8") as f:
yaml.safe_dump(data, f)
model.track(video_url, imgsz=160, tracker=tracker)
def test_val():
"""Test the validation mode of the YOLO model."""
- YOLO(MODEL).val(data='coco8.yaml', imgsz=32, save_hybrid=True)
+ YOLO(MODEL).val(data="coco8.yaml", imgsz=32, save_hybrid=True)
def test_train_scratch():
"""Test training the YOLO model from scratch."""
model = YOLO(CFG)
- model.train(data='coco8.yaml', epochs=2, imgsz=32, cache='disk', batch=-1, close_mosaic=1, name='model')
+ model.train(data="coco8.yaml", epochs=2, imgsz=32, cache="disk", batch=-1, close_mosaic=1, name="model")
model(SOURCE)
def test_train_pretrained():
"""Test training the YOLO model from a pre-trained state."""
- model = YOLO(WEIGHTS_DIR / 'yolov8n-seg.pt')
- model.train(data='coco8-seg.yaml', epochs=1, imgsz=32, cache='ram', copy_paste=0.5, mixup=0.5, name=0)
+ model = YOLO(WEIGHTS_DIR / "yolov8n-seg.pt")
+ model.train(data="coco8-seg.yaml", epochs=1, imgsz=32, cache="ram", copy_paste=0.5, mixup=0.5, name=0)
model(SOURCE)
def test_export_torchscript():
"""Test exporting the YOLO model to TorchScript format."""
- f = YOLO(MODEL).export(format='torchscript', optimize=False)
+ f = YOLO(MODEL).export(format="torchscript", optimize=False)
YOLO(f)(SOURCE) # exported model inference
def test_export_onnx():
"""Test exporting the YOLO model to ONNX format."""
- f = YOLO(MODEL).export(format='onnx', dynamic=True)
+ f = YOLO(MODEL).export(format="onnx", dynamic=True)
YOLO(f)(SOURCE) # exported model inference
def test_export_openvino():
"""Test exporting the YOLO model to OpenVINO format."""
- f = YOLO(MODEL).export(format='openvino')
+ f = YOLO(MODEL).export(format="openvino")
YOLO(f)(SOURCE) # exported model inference
@@ -214,10 +228,10 @@ def test_export_coreml():
"""Test exporting the YOLO model to CoreML format."""
if not WINDOWS: # RuntimeError: BlobWriter not loaded with coremltools 7.0 on windows
if MACOS:
- f = YOLO(MODEL).export(format='coreml')
+ f = YOLO(MODEL).export(format="coreml")
YOLO(f)(SOURCE) # model prediction only supported on macOS for nms=False models
else:
- YOLO(MODEL).export(format='coreml', nms=True)
+ YOLO(MODEL).export(format="coreml", nms=True)
def test_export_tflite(enabled=False):
@@ -228,7 +242,7 @@ def test_export_tflite(enabled=False):
"""
if enabled and LINUX:
model = YOLO(MODEL)
- f = model.export(format='tflite')
+ f = model.export(format="tflite")
YOLO(f)(SOURCE)
@@ -240,7 +254,7 @@ def test_export_pb(enabled=False):
"""
if enabled and LINUX:
model = YOLO(MODEL)
- f = model.export(format='pb')
+ f = model.export(format="pb")
YOLO(f)(SOURCE)
@@ -251,20 +265,20 @@ def test_export_paddle(enabled=False):
Note Paddle protobuf requirements conflicting with onnx protobuf requirements.
"""
if enabled:
- YOLO(MODEL).export(format='paddle')
+ YOLO(MODEL).export(format="paddle")
@pytest.mark.slow
def test_export_ncnn():
"""Test exporting the YOLO model to NCNN format."""
- f = YOLO(MODEL).export(format='ncnn')
+ f = YOLO(MODEL).export(format="ncnn")
YOLO(f)(SOURCE) # exported model inference
def test_all_model_yamls():
"""Test YOLO model creation for all available YAML configurations."""
- for m in (ROOT / 'cfg' / 'models').rglob('*.yaml'):
- if 'rtdetr' in m.name:
+ for m in (ROOT / "cfg" / "models").rglob("*.yaml"):
+ if "rtdetr" in m.name:
if TORCH_1_9: # torch<=1.8 issue - TypeError: __init__() got an unexpected keyword argument 'batch_first'
_ = RTDETR(m.name)(SOURCE, imgsz=640) # must be 640
else:
@@ -274,10 +288,10 @@ def test_all_model_yamls():
def test_workflow():
"""Test the complete workflow including training, validation, prediction, and exporting."""
model = YOLO(MODEL)
- model.train(data='coco8.yaml', epochs=1, imgsz=32, optimizer='SGD')
+ model.train(data="coco8.yaml", epochs=1, imgsz=32, optimizer="SGD")
model.val(imgsz=32)
model.predict(SOURCE, imgsz=32)
- model.export(format='onnx') # export a model to ONNX format
+ model.export(format="onnx") # export a model to ONNX format
def test_predict_callback_and_setup():
@@ -291,34 +305,34 @@ def on_predict_batch_end(predictor):
predictor.results = zip(predictor.results, im0s, bs) # results is List[batch_size]
model = YOLO(MODEL)
- model.add_callback('on_predict_batch_end', on_predict_batch_end)
+ model.add_callback("on_predict_batch_end", on_predict_batch_end)
dataset = load_inference_source(source=SOURCE)
bs = dataset.bs # noqa access predictor properties
results = model.predict(dataset, stream=True, imgsz=160) # source already setup
for r, im0, bs in results:
- print('test_callback', im0.shape)
- print('test_callback', bs)
+ print("test_callback", im0.shape)
+ print("test_callback", bs)
boxes = r.boxes # Boxes object for bbox outputs
print(boxes)
def test_results():
"""Test various result formats for the YOLO model."""
- for m in 'yolov8n-pose.pt', 'yolov8n-seg.pt', 'yolov8n.pt', 'yolov8n-cls.pt':
+ for m in "yolov8n-pose.pt", "yolov8n-seg.pt", "yolov8n.pt", "yolov8n-cls.pt":
results = YOLO(WEIGHTS_DIR / m)([SOURCE, SOURCE], imgsz=160)
for r in results:
r = r.cpu().numpy()
- r = r.to(device='cpu', dtype=torch.float32)
- r.save_txt(txt_file=TMP / 'runs/tests/label.txt', save_conf=True)
- r.save_crop(save_dir=TMP / 'runs/tests/crops/')
+ r = r.to(device="cpu", dtype=torch.float32)
+ r.save_txt(txt_file=TMP / "runs/tests/label.txt", save_conf=True)
+ r.save_crop(save_dir=TMP / "runs/tests/crops/")
r.tojson(normalize=True)
r.plot(pil=True)
r.plot(conf=True, boxes=True)
print(r, len(r), r.path)
-@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
def test_data_utils():
"""Test utility functions in ultralytics/data/utils.py."""
from ultralytics.data.utils import HUBDatasetStats, autosplit
@@ -327,25 +341,25 @@ def test_data_utils():
# from ultralytics.utils.files import WorkingDirectory
# with WorkingDirectory(ROOT.parent / 'tests'):
- for task in 'detect', 'segment', 'pose', 'classify':
- file = Path(TASK2DATA[task]).with_suffix('.zip') # i.e. coco8.zip
- download(f'https://github.com/ultralytics/hub/raw/main/example_datasets/{file}', unzip=False, dir=TMP)
+ for task in "detect", "segment", "pose", "classify":
+ file = Path(TASK2DATA[task]).with_suffix(".zip") # i.e. coco8.zip
+ download(f"https://github.com/ultralytics/hub/raw/main/example_datasets/{file}", unzip=False, dir=TMP)
stats = HUBDatasetStats(TMP / file, task=task)
stats.get_json(save=True)
stats.process_images()
- autosplit(TMP / 'coco8')
- zip_directory(TMP / 'coco8/images/val') # zip
+ autosplit(TMP / "coco8")
+ zip_directory(TMP / "coco8/images/val") # zip
-@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
def test_data_converter():
"""Test dataset converters."""
from ultralytics.data.converter import coco80_to_coco91_class, convert_coco
- file = 'instances_val2017.json'
- download(f'https://github.com/ultralytics/yolov5/releases/download/v1.0/{file}', dir=TMP)
- convert_coco(labels_dir=TMP, save_dir=TMP / 'yolo_labels', use_segments=True, use_keypoints=False, cls91to80=True)
+ file = "instances_val2017.json"
+ download(f"https://github.com/ultralytics/yolov5/releases/download/v1.0/{file}", dir=TMP)
+ convert_coco(labels_dir=TMP, save_dir=TMP / "yolo_labels", use_segments=True, use_keypoints=False, cls91to80=True)
coco80_to_coco91_class()
@@ -353,10 +367,12 @@ def test_data_annotator():
"""Test automatic data annotation."""
from ultralytics.data.annotator import auto_annotate
- auto_annotate(ASSETS,
- det_model=WEIGHTS_DIR / 'yolov8n.pt',
- sam_model=WEIGHTS_DIR / 'mobile_sam.pt',
- output_dir=TMP / 'auto_annotate_labels')
+ auto_annotate(
+ ASSETS,
+ det_model=WEIGHTS_DIR / "yolov8n.pt",
+ sam_model=WEIGHTS_DIR / "mobile_sam.pt",
+ output_dir=TMP / "auto_annotate_labels",
+ )
def test_events():
@@ -366,7 +382,7 @@ def test_events():
events = Events()
events.enabled = True
cfg = copy(DEFAULT_CFG) # does not require deepcopy
- cfg.mode = 'test'
+ cfg.mode = "test"
events(cfg)
@@ -375,10 +391,10 @@ def test_cfg_init():
from ultralytics.cfg import check_dict_alignment, copy_default_cfg, smart_value
with contextlib.suppress(SyntaxError):
- check_dict_alignment({'a': 1}, {'b': 2})
+ check_dict_alignment({"a": 1}, {"b": 2})
copy_default_cfg()
- (Path.cwd() / DEFAULT_CFG_PATH.name.replace('.yaml', '_copy.yaml')).unlink(missing_ok=False)
- [smart_value(x) for x in ['none', 'true', 'false']]
+ (Path.cwd() / DEFAULT_CFG_PATH.name.replace(".yaml", "_copy.yaml")).unlink(missing_ok=False)
+ [smart_value(x) for x in ["none", "true", "false"]]
def test_utils_init():
@@ -393,12 +409,12 @@ def test_utils_init():
def test_utils_checks():
"""Test various utility checks."""
- checks.check_yolov5u_filename('yolov5n.pt')
+ checks.check_yolov5u_filename("yolov5n.pt")
checks.git_describe(ROOT)
checks.check_requirements() # check requirements.txt
checks.check_imgsz([600, 600], max_dim=1)
checks.check_imshow()
- checks.check_version('ultralytics', '8.0.0')
+ checks.check_version("ultralytics", "8.0.0")
checks.print_args()
# checks.check_imshow(warn=True)
@@ -407,7 +423,7 @@ def test_utils_benchmarks():
"""Test model benchmarking."""
from ultralytics.utils.benchmarks import ProfileModels
- ProfileModels(['yolov8n.yaml'], imgsz=32, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
+ ProfileModels(["yolov8n.yaml"], imgsz=32, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
def test_utils_torchutils():
@@ -423,18 +439,29 @@ def test_utils_torchutils():
time_sync()
-@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
def test_utils_downloads():
"""Test file download utilities."""
from ultralytics.utils.downloads import get_google_drive_file_info
- get_google_drive_file_info('https://drive.google.com/file/d/1cqT-cJgANNrhIHCrEufUYhQ4RqiWG_lJ/view?usp=drive_link')
+ get_google_drive_file_info("https://drive.google.com/file/d/1cqT-cJgANNrhIHCrEufUYhQ4RqiWG_lJ/view?usp=drive_link")
def test_utils_ops():
"""Test various operations utilities."""
- from ultralytics.utils.ops import (ltwh2xywh, ltwh2xyxy, make_divisible, xywh2ltwh, xywh2xyxy, xywhn2xyxy,
- xywhr2xyxyxyxy, xyxy2ltwh, xyxy2xywh, xyxy2xywhn, xyxyxyxy2xywhr)
+ from ultralytics.utils.ops import (
+ ltwh2xywh,
+ ltwh2xyxy,
+ make_divisible,
+ xywh2ltwh,
+ xywh2xyxy,
+ xywhn2xyxy,
+ xywhr2xyxyxyxy,
+ xyxy2ltwh,
+ xyxy2xywh,
+ xyxy2xywhn,
+ xyxyxyxy2xywhr,
+ )
make_divisible(17, torch.tensor([8]))
@@ -455,9 +482,9 @@ def test_utils_files():
file_age(SOURCE)
file_date(SOURCE)
- get_latest_run(ROOT / 'runs')
+ get_latest_run(ROOT / "runs")
- path = TMP / 'path/with spaces'
+ path = TMP / "path/with spaces"
path.mkdir(parents=True, exist_ok=True)
with spaces_in_path(path) as new_path:
print(new_path)
@@ -471,9 +498,9 @@ def test_utils_patches_torch_save():
mock = MagicMock(side_effect=RuntimeError)
- with patch('ultralytics.utils.patches._torch_save', new=mock):
+ with patch("ultralytics.utils.patches._torch_save", new=mock):
with pytest.raises(RuntimeError):
- torch_save(torch.zeros(1), TMP / 'test.pt')
+ torch_save(torch.zeros(1), TMP / "test.pt")
assert mock.call_count == 4, "torch_save was not attempted the expected number of times"
@@ -512,7 +539,7 @@ def test_nn_modules_block():
BottleneckCSP(c1, c2)(x)
-@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
def test_hub():
"""Test Ultralytics HUB functionalities."""
from ultralytics.hub import export_fmts_hub, logout
@@ -520,7 +547,7 @@ def test_hub():
export_fmts_hub()
logout()
- smart_request('GET', 'https://github.com', progress=True)
+ smart_request("GET", "https://github.com", progress=True)
@pytest.fixture
@@ -529,12 +556,13 @@ def image():
@pytest.mark.parametrize(
- 'auto_augment, erasing, force_color_jitter',
+ "auto_augment, erasing, force_color_jitter",
[
(None, 0.0, False),
- ('randaugment', 0.5, True),
- ('augmix', 0.2, False),
- ('autoaugment', 0.0, True), ],
+ ("randaugment", 0.5, True),
+ ("augmix", 0.2, False),
+ ("autoaugment", 0.0, True),
+ ],
)
def test_classify_transforms_train(image, auto_augment, erasing, force_color_jitter):
import torchvision.transforms as T
@@ -566,17 +594,17 @@ def test_classify_transforms_train(image, auto_augment, erasing, force_color_jit
@pytest.mark.slow
-@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
def test_model_tune():
"""Tune YOLO model for performance."""
- YOLO('yolov8n-pose.pt').tune(data='coco8-pose.yaml', plots=False, imgsz=32, epochs=1, iterations=2, device='cpu')
- YOLO('yolov8n-cls.pt').tune(data='imagenet10', plots=False, imgsz=32, epochs=1, iterations=2, device='cpu')
+ YOLO("yolov8n-pose.pt").tune(data="coco8-pose.yaml", plots=False, imgsz=32, epochs=1, iterations=2, device="cpu")
+ YOLO("yolov8n-cls.pt").tune(data="imagenet10", plots=False, imgsz=32, epochs=1, iterations=2, device="cpu")
def test_model_embeddings():
"""Test YOLO model embeddings."""
model_detect = YOLO(MODEL)
- model_segment = YOLO(WEIGHTS_DIR / 'yolov8n-seg.pt')
+ model_segment = YOLO(WEIGHTS_DIR / "yolov8n-seg.pt")
for batch in [SOURCE], [SOURCE, SOURCE]: # test batch size 1 and 2
assert len(model_detect.embed(source=batch, imgsz=32)) == len(batch)
diff --git a/ultralytics/utils/__init__.py b/ultralytics/utils/__init__.py
index d8cfccaac88..2efa70bbcbb 100644
--- a/ultralytics/utils/__init__.py
+++ b/ultralytics/utils/__init__.py
@@ -9,6 +9,7 @@
import subprocess
import sys
import threading
+import time
import urllib
import uuid
from pathlib import Path
@@ -721,9 +722,19 @@ def remove_colorstr(input_string):
class TryExcept(contextlib.ContextDecorator):
"""
- YOLOv8 TryExcept class.
+ Ultralytics TryExcept class. Use as @TryExcept() decorator or 'with TryExcept():' context manager.
- Use as @TryExcept() decorator or 'with TryExcept():' context manager.
+ Examples:
+ As a decorator:
+ >>> @TryExcept(msg="Error occurred in func", verbose=True)
+ >>> def func():
+ >>> # Function logic here
+ >>> pass
+
+ As a context manager:
+ >>> with TryExcept(msg="Error occurred in block", verbose=True):
+ >>> # Code block here
+ >>> pass
"""
def __init__(self, msg="", verbose=True):
@@ -742,6 +753,64 @@ def __exit__(self, exc_type, value, traceback):
return True
+class Retry(contextlib.ContextDecorator):
+ """
+ Retry class for function execution with exponential backoff.
+
+ Can be used as a decorator or a context manager to retry a function or block of code on exceptions, up to a
+ specified number of times with an exponentially increasing delay between retries.
+
+ Examples:
+ Example usage as a decorator:
+ >>> @Retry(times=3, delay=2)
+ >>> def test_func():
+ >>> # Replace with function logic that may raise exceptions
+ >>> return True
+
+ Example usage as a context manager:
+ >>> with Retry(times=3, delay=2):
+ >>> # Replace with code block that may raise exceptions
+ >>> pass
+ """
+
+ def __init__(self, times=3, delay=2):
+ """Initialize Retry class with specified number of retries and delay."""
+ self.times = times
+ self.delay = delay
+ self._attempts = 0
+
+ def __call__(self, func):
+ """Decorator implementation for Retry with exponential backoff."""
+
+ def wrapped_func(*args, **kwargs):
+ self._attempts = 0
+ while self._attempts < self.times:
+ try:
+ return func(*args, **kwargs)
+ except Exception as e:
+ self._attempts += 1
+ print(f"Retry {self._attempts}/{self.times} failed: {e}")
+ if self._attempts >= self.times:
+ raise e
+ time.sleep(self.delay * (2**self._attempts)) # exponential backoff delay
+
+ return wrapped_func
+
+ def __enter__(self):
+ """Enter the runtime context related to this object."""
+ self._attempts = 0
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ """Exit the runtime context related to this object with exponential backoff."""
+ if exc_type is not None:
+ self._attempts += 1
+ if self._attempts < self.times:
+ print(f"Retry {self._attempts}/{self.times} failed: {exc_value}")
+ time.sleep(self.delay * (2**self._attempts)) # exponential backoff delay
+ return True # Suppresses the exception and retries
+ return False # Re-raises the exception if retries are exhausted
+
+
def threaded(func):
"""
Multi-threads a target function by default and returns the thread or function result.
From 6183b59d8a1c3fe67ed1a6fab093799a8a85cbe7 Mon Sep 17 00:00:00 2001
From: Abirami Vina
Date: Sun, 28 Jan 2024 04:48:47 +0300
Subject: [PATCH 005/171] Add TensorRT Docs Integrations Page (#7855)
---
docs/en/integrations/index.md | 2 +
docs/en/integrations/tensorrt.md | 128 +++++++++++++++++++++++++++++++
docs/mkdocs.yml | 1 +
3 files changed, 131 insertions(+)
create mode 100644 docs/en/integrations/tensorrt.md
diff --git a/docs/en/integrations/index.md b/docs/en/integrations/index.md
index 6d9b791a695..afb7d1c6247 100644
--- a/docs/en/integrations/index.md
+++ b/docs/en/integrations/index.md
@@ -44,6 +44,8 @@ Welcome to the Ultralytics Integrations page! This page provides an overview of
- [ONNX](onnx.md): An open-source format created by [Microsoft](https://www.microsoft.com) for facilitating the transfer of AI models between various frameworks, enhancing the versatility and deployment flexibility of Ultralytics models.
+- [TensorRT](tensorrt.md): Developed by [NVIDIA](https://www.nvidia.com/), this high-performance deep learning inference framework and model format optimizes AI models for accelerated speed and efficiency on NVIDIA GPUs, ensuring streamlined deployment.
+
### Export Formats
We also support a variety of model export formats for deployment in different environments. Here are the available formats:
diff --git a/docs/en/integrations/tensorrt.md b/docs/en/integrations/tensorrt.md
new file mode 100644
index 00000000000..88b3bf46fb9
--- /dev/null
+++ b/docs/en/integrations/tensorrt.md
@@ -0,0 +1,128 @@
+---
+comments: true
+description: Discover the power and flexibility of exporting Ultralytics YOLOv8 models to TensorRT format for enhanced performance and efficiency on NVIDIA GPUs.
+keywords: Ultralytics, YOLOv8, TensorRT Export, Model Deployment, GPU Acceleration, NVIDIA Support, CUDA Deployment
+---
+
+# TensorRT Export for YOLOv8 Models
+
+Deploying computer vision models in high-performance environments can require a format that maximizes speed and efficiency. This is especially true when you are deploying your model on NVIDIA GPUs.
+
+By using the TensorRT export format, you can enhance your [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models for swift and efficient inference on NVIDIA hardware. This guide will give you easy-to-follow steps for the conversion process and help you make the most of NVIDIA's advanced technology in your deep learning projects.
+
+## TensorRT
+
+
+
+
+
+[TensorRT](https://developer.nvidia.com/tensorrt#:~:text=NVIDIA%20TensorRT%2DLLM%20is%20an,knowledge%20of%20C%2B%2B%20or%20CUDA.), developed by NVIDIA, is an advanced software development kit (SDK) designed for high-speed deep learning inference. It’s well-suited for real-time applications like object detection.
+
+This toolkit optimizes deep learning models for NVIDIA GPUs and results in faster and more efficient operations. TensorRT models undergo TensorRT optimization, which includes techniques like layer fusion, precision calibration (INT8 and FP16), dynamic tensor memory management, and kernel auto-tuning. Converting deep learning models into the TensorRT format allows developers to realize the potential of NVIDIA GPUs fully.
+
+TensorRT is known for its compatibility with various model formats, including TensorFlow, PyTorch, and ONNX, providing developers with a flexible solution for integrating and optimizing models from different frameworks. This versatility enables efficient model deployment across diverse hardware and software environments.
+
+## Key Features of TensorRT Models
+
+TensorRT models offer a range of key features that contribute to their efficiency and effectiveness in high-speed deep learning inference:
+
+- **Precision Calibration**: TensorRT supports precision calibration, allowing models to be fine-tuned for specific accuracy requirements. This includes support for reduced precision formats like INT8 and FP16, which can further boost inference speed while maintaining acceptable accuracy levels.
+
+- **Layer Fusion**: The TensorRT optimization process includes layer fusion, where multiple layers of a neural network are combined into a single operation. This reduces computational overhead and improves inference speed by minimizing memory access and computation.
+
+
+
+
+
+- **Dynamic Tensor Memory Management**: TensorRT efficiently manages tensor memory usage during inference, reducing memory overhead and optimizing memory allocation. This results in more efficient GPU memory utilization.
+
+- **Automatic Kernel Tuning**: TensorRT applies automatic kernel tuning to select the most optimized GPU kernel for each layer of the model. This adaptive approach ensures that the model takes full advantage of the GPU's computational power.
+
+## Deployment Options in TensorRT
+
+Before we look at the code for exporting YOLOv8 models to the TensorRT format, let’s understand where TensorRT models are normally used.
+
+TensorRT offers several deployment options, and each option balances ease of integration, performance optimization, and flexibility differently:
+
+- **Deploying within TensorFlow**: This method integrates TensorRT into TensorFlow, allowing optimized models to run in a familiar TensorFlow environment. It's useful for models with a mix of supported and unsupported layers, as TF-TRT can handle these efficiently.
+
+
+
+
+
+- **Standalone TensorRT Runtime API**: Offers granular control, ideal for performance-critical applications. It's more complex but allows for custom implementation of unsupported operators.
+
+- **NVIDIA Triton Inference Server**: An option that supports models from various frameworks. Particularly suited for cloud or edge inferencing, it provides features like concurrent model execution and model analysis.
+
+## Exporting YOLOv8 Models to TensorRT
+
+You can improve execution efficiency and optimize performance by converting YOLOv8 models to TensorRT format.
+
+### Installation
+
+To install the required package, run:
+
+!!! Tip "Installation"
+
+ === "CLI"
+
+ ```bash
+ # Install the required package for YOLOv8
+ pip install ultralytics
+ ```
+
+For detailed instructions and best practices related to the installation process, 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.
+
+### 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 the YOLOv8 model
+ model = YOLO('yolov8n.pt')
+
+ # Export the model to TensorRT format
+ model.export(format='engine') # creates 'yolov8n.engine'
+
+ # Load the exported TensorRT model
+ tensorrt_model = YOLO('yolov8n.engine')
+
+ # Run inference
+ results = tensorrt_model('https://ultralytics.com/images/bus.jpg')
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Export a YOLOv8n PyTorch model to TensorRT format
+ yolo export model=yolov8n.pt format=engine # creates 'yolov8n.engine''
+
+ # Run inference with the exported model
+ yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'
+ ```
+
+For more details about the export process, visit the [Ultralytics documentation page on exporting](../modes/export.md).
+
+## Deploying Exported YOLOv8 TensorRT Models
+
+Having successfully exported your Ultralytics YOLOv8 models to TensorRT format, you're now ready to deploy them. For in-depth instructions on deploying your TensorRT models in various settings, take a look at the following resources:
+
+- **[Deploying Deep Neural Networks with NVIDIA TensorRT](https://developer.nvidia.com/blog/deploying-deep-learning-nvidia-tensorrt/)**: This article explains how to use NVIDIA TensorRT to deploy deep neural networks on GPU-based deployment platforms efficiently.
+
+- **[End-to-End AI for NVIDIA-Based PCs: NVIDIA TensorRT Deployment](https://developer.nvidia.com/blog/end-to-end-ai-for-nvidia-based-pcs-nvidia-tensorrt-deployment/)**: This blog post explains the use of NVIDIA TensorRT for optimizing and deploying AI models on NVIDIA-based PCs.
+
+- **[GitHub Repository for NVIDIA TensorRT:](https://github.com/NVIDIA/TensorRT)**: This is the official GitHub repository that contains the source code and documentation for NVIDIA TensorRT.
+
+## Summary
+
+In this guide, we focused on converting Ultralytics YOLOv8 models to NVIDIA's TensorRT model format. This conversion step is crucial for improving the efficiency and speed of YOLOv8 models, making them more effective and suitable for diverse deployment environments.
+
+For more information on usage details, take a look at the [TensorRT official documentation](https://docs.nvidia.com/deeplearning/tensorrt/).
+
+If you're curious about additional Ultralytics YOLOv8 integrations, our [integration guide page](../integrations/index.md) provides an extensive selection of informative resources and insights.
diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml
index ac08e208d67..d7eaad2b629 100644
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -337,6 +337,7 @@ nav:
- Comet ML: integrations/comet.md
- OpenVINO: integrations/openvino.md
- ONNX: integrations/onnx.md
+ - TensorRT: integrations/tensorrt.md
- Ray Tune: integrations/ray-tune.md
- Roboflow: integrations/roboflow.md
- MLflow: integrations/mlflow.md
From afb0cb10576b49b3725373bc4ab0dc3eb611502f Mon Sep 17 00:00:00 2001
From: Glenn Jocher
Date: Sun, 28 Jan 2024 19:40:29 +0100
Subject: [PATCH 006/171] Cleanup Docs languages (#7865)
Signed-off-by: Glenn Jocher
---
docs/ar/datasets/index.md | 127 ------
docs/ar/index.md | 83 ----
docs/ar/models/fast-sam.md | 191 ---------
docs/ar/models/index.md | 98 -----
docs/ar/models/mobile-sam.md | 116 ------
docs/ar/models/rtdetr.md | 93 -----
docs/ar/models/sam.md | 225 ----------
docs/ar/models/yolo-nas.md | 121 ------
docs/ar/models/yolov3.md | 98 -----
docs/ar/models/yolov4.md | 72 ----
docs/ar/models/yolov5.md | 107 -----
docs/ar/models/yolov6.md | 107 -----
docs/ar/models/yolov7.md | 66 ---
docs/ar/models/yolov8.md | 166 --------
docs/ar/modes/benchmark.md | 94 -----
docs/ar/modes/export.md | 108 -----
docs/ar/modes/index.md | 77 ----
docs/ar/modes/predict.md | 217 ----------
docs/ar/modes/track.md | 360 ----------------
docs/ar/modes/train.md | 286 -------------
docs/ar/modes/val.md | 86 ----
docs/ar/quickstart.md | 326 ---------------
docs/ar/tasks/classify.md | 172 --------
docs/ar/tasks/detect.md | 185 ---------
docs/ar/tasks/index.md | 55 ---
docs/ar/tasks/pose.md | 186 ---------
docs/ar/tasks/segment.md | 189 ---------
docs/build_docs.py | 50 +--
docs/de/datasets/index.md | 127 ------
docs/de/index.md | 83 ----
docs/de/models/fast-sam.md | 193 ---------
docs/de/models/index.md | 98 -----
docs/de/models/mobile-sam.md | 116 ------
docs/de/models/rtdetr.md | 93 -----
docs/de/models/sam.md | 226 ----------
docs/de/models/yolo-nas.md | 121 ------
docs/de/models/yolov3.md | 98 -----
docs/de/models/yolov4.md | 71 ----
docs/de/models/yolov5.md | 113 -----
docs/de/models/yolov6.md | 107 -----
docs/de/models/yolov7.md | 66 ---
docs/de/models/yolov8.md | 162 --------
docs/de/modes/benchmark.md | 94 -----
docs/de/modes/export.md | 108 -----
docs/de/modes/index.md | 74 ----
docs/de/modes/predict.md | 227 ----------
docs/de/modes/track.md | 200 ---------
docs/de/modes/train.md | 206 ---------
docs/de/modes/val.md | 86 ----
docs/de/quickstart.md | 198 ---------
docs/de/tasks/classify.md | 172 --------
docs/de/tasks/detect.md | 184 --------
docs/de/tasks/index.md | 55 ---
docs/de/tasks/pose.md | 185 ---------
docs/de/tasks/segment.md | 188 ---------
docs/es/datasets/index.md | 127 ------
docs/es/index.md | 83 ----
docs/es/models/fast-sam.md | 193 ---------
docs/es/models/index.md | 98 -----
docs/es/models/mobile-sam.md | 116 ------
docs/es/models/rtdetr.md | 93 -----
docs/es/models/sam.md | 226 ----------
docs/es/models/yolo-nas.md | 121 ------
docs/es/models/yolov3.md | 98 -----
docs/es/models/yolov4.md | 71 ----
docs/es/models/yolov5.md | 113 -----
docs/es/models/yolov6.md | 107 -----
docs/es/models/yolov7.md | 66 ---
docs/es/models/yolov8.md | 162 --------
docs/es/modes/benchmark.md | 94 -----
docs/es/modes/export.md | 108 -----
docs/es/modes/index.md | 73 ----
docs/es/modes/predict.md | 227 ----------
docs/es/modes/track.md | 200 ---------
docs/es/modes/train.md | 206 ---------
docs/es/modes/val.md | 86 ----
docs/es/quickstart.md | 198 ---------
docs/es/tasks/classify.md | 172 --------
docs/es/tasks/detect.md | 184 --------
docs/es/tasks/index.md | 55 ---
docs/es/tasks/pose.md | 185 ---------
docs/es/tasks/segment.md | 188 ---------
docs/fr/datasets/index.md | 127 ------
docs/fr/index.md | 83 ----
docs/fr/models/fast-sam.md | 193 ---------
docs/fr/models/index.md | 98 -----
docs/fr/models/mobile-sam.md | 116 ------
docs/fr/models/rtdetr.md | 93 -----
docs/fr/models/sam.md | 226 ----------
docs/fr/models/yolo-nas.md | 121 ------
docs/fr/models/yolov3.md | 98 -----
docs/fr/models/yolov4.md | 71 ----
docs/fr/models/yolov5.md | 113 -----
docs/fr/models/yolov6.md | 107 -----
docs/fr/models/yolov7.md | 66 ---
docs/fr/models/yolov8.md | 162 --------
docs/fr/modes/benchmark.md | 94 -----
docs/fr/modes/export.md | 108 -----
docs/fr/modes/index.md | 73 ----
docs/fr/modes/predict.md | 227 ----------
docs/fr/modes/track.md | 200 ---------
docs/fr/modes/train.md | 206 ---------
docs/fr/modes/val.md | 86 ----
docs/fr/quickstart.md | 198 ---------
docs/fr/tasks/classify.md | 172 --------
docs/fr/tasks/detect.md | 184 --------
docs/fr/tasks/index.md | 55 ---
docs/fr/tasks/pose.md | 176 --------
docs/fr/tasks/segment.md | 189 ---------
docs/hi/datasets/index.md | 134 ------
docs/hi/index.md | 84 ----
docs/hi/models/fast-sam.md | 193 ---------
docs/hi/models/index.md | 98 -----
docs/hi/models/mobile-sam.md | 115 -----
docs/hi/models/rtdetr.md | 93 -----
docs/hi/models/sam.md | 226 ----------
docs/hi/models/yolo-nas.md | 119 ------
docs/hi/models/yolov3.md | 98 -----
docs/hi/models/yolov4.md | 69 ---
docs/hi/models/yolov5.md | 113 -----
docs/hi/models/yolov6.md | 90 ----
docs/hi/models/yolov7.md | 65 ---
docs/hi/models/yolov8.md | 162 --------
docs/hi/modes/benchmark.md | 94 -----
docs/hi/modes/export.md | 108 -----
docs/hi/modes/index.md | 78 ----
docs/hi/modes/predict.md | 226 ----------
docs/hi/modes/track.md | 358 ----------------
docs/hi/modes/train.md | 293 -------------
docs/hi/modes/val.md | 86 ----
docs/hi/quickstart.md | 327 ---------------
docs/hi/tasks/classify.md | 172 --------
docs/hi/tasks/detect.md | 186 ---------
docs/hi/tasks/index.md | 55 ---
docs/hi/tasks/pose.md | 183 --------
docs/hi/tasks/segment.md | 187 ---------
docs/ja/datasets/index.md | 127 ------
docs/ja/index.md | 83 ----
docs/ja/models/fast-sam.md | 193 ---------
docs/ja/models/index.md | 98 -----
docs/ja/models/mobile-sam.md | 116 ------
docs/ja/models/rtdetr.md | 93 -----
docs/ja/models/sam.md | 226 ----------
docs/ja/models/yolo-nas.md | 121 ------
docs/ja/models/yolov3.md | 98 -----
docs/ja/models/yolov4.md | 71 ----
docs/ja/models/yolov5.md | 113 -----
docs/ja/models/yolov6.md | 107 -----
docs/ja/models/yolov7.md | 65 ---
docs/ja/models/yolov8.md | 162 --------
docs/ja/modes/benchmark.md | 94 -----
docs/ja/modes/export.md | 76 ----
docs/ja/modes/index.md | 53 ---
docs/ja/modes/predict.md | 211 ----------
docs/ja/modes/track.md | 200 ---------
docs/ja/modes/train.md | 206 ---------
docs/ja/modes/val.md | 86 ----
docs/ja/quickstart.md | 198 ---------
docs/ja/tasks/classify.md | 172 --------
docs/ja/tasks/detect.md | 184 --------
docs/ja/tasks/index.md | 55 ---
docs/ja/tasks/pose.md | 185 ---------
docs/ja/tasks/segment.md | 186 ---------
docs/ko/datasets/index.md | 127 ------
docs/ko/index.md | 83 ----
docs/ko/models/fast-sam.md | 193 ---------
docs/ko/models/index.md | 98 -----
docs/ko/models/mobile-sam.md | 116 ------
docs/ko/models/rtdetr.md | 93 -----
docs/ko/models/sam.md | 226 ----------
docs/ko/models/yolo-nas.md | 119 ------
docs/ko/models/yolov3.md | 98 -----
docs/ko/models/yolov4.md | 71 ----
docs/ko/models/yolov5.md | 113 -----
docs/ko/models/yolov6.md | 107 -----
docs/ko/models/yolov7.md | 65 ---
docs/ko/models/yolov8.md | 162 --------
docs/ko/modes/benchmark.md | 94 -----
docs/ko/modes/export.md | 108 -----
docs/ko/modes/index.md | 73 ----
docs/ko/modes/predict.md | 227 ----------
docs/ko/modes/track.md | 256 ------------
docs/ko/modes/train.md | 145 -------
docs/ko/modes/val.md | 86 ----
docs/ko/quickstart.md | 207 ---------
docs/ko/tasks/classify.md | 172 --------
docs/ko/tasks/detect.md | 184 --------
docs/ko/tasks/index.md | 55 ---
docs/ko/tasks/pose.md | 185 ---------
docs/ko/tasks/segment.md | 188 ---------
docs/mkdocs_ar.yml | 212 ----------
docs/mkdocs_de.yml | 212 ----------
docs/mkdocs_es.yml | 212 ----------
docs/mkdocs_fr.yml | 212 ----------
docs/mkdocs_github_authors.yaml | 3 -
docs/mkdocs_hi.yml | 212 ----------
docs/mkdocs_ja.yml | 212 ----------
docs/mkdocs_ko.yml | 212 ----------
docs/mkdocs_pt.yml | 212 ----------
docs/mkdocs_ru.yml | 212 ----------
docs/mkdocs_zh.yml | 212 ----------
docs/pt/datasets/index.md | 127 ------
docs/pt/index.md | 83 ----
docs/pt/models/fast-sam.md | 193 ---------
docs/pt/models/index.md | 98 -----
docs/pt/models/mobile-sam.md | 116 ------
docs/pt/models/rtdetr.md | 93 -----
docs/pt/models/sam.md | 226 ----------
docs/pt/models/yolo-nas.md | 121 ------
docs/pt/models/yolov3.md | 98 -----
docs/pt/models/yolov4.md | 71 ----
docs/pt/models/yolov5.md | 113 -----
docs/pt/models/yolov6.md | 107 -----
docs/pt/models/yolov7.md | 66 ---
docs/pt/models/yolov8.md | 162 --------
docs/pt/modes/benchmark.md | 94 -----
docs/pt/modes/export.md | 108 -----
docs/pt/modes/index.md | 73 ----
docs/pt/modes/predict.md | 227 ----------
docs/pt/modes/track.md | 200 ---------
docs/pt/modes/train.md | 206 ---------
docs/pt/modes/val.md | 86 ----
docs/pt/quickstart.md | 198 ---------
docs/pt/tasks/classify.md | 172 --------
docs/pt/tasks/detect.md | 185 ---------
docs/pt/tasks/index.md | 55 ---
docs/pt/tasks/pose.md | 188 ---------
docs/pt/tasks/segment.md | 188 ---------
docs/ru/datasets/index.md | 127 ------
docs/ru/index.md | 83 ----
docs/ru/models/fast-sam.md | 193 ---------
docs/ru/models/index.md | 98 -----
docs/ru/models/mobile-sam.md | 116 ------
docs/ru/models/rtdetr.md | 93 -----
docs/ru/models/sam.md | 226 ----------
docs/ru/models/yolo-nas.md | 121 ------
docs/ru/models/yolov3.md | 98 -----
docs/ru/models/yolov4.md | 71 ----
docs/ru/models/yolov5.md | 113 -----
docs/ru/models/yolov6.md | 107 -----
docs/ru/models/yolov7.md | 65 ---
docs/ru/models/yolov8.md | 162 --------
docs/ru/modes/benchmark.md | 94 -----
docs/ru/modes/export.md | 108 -----
docs/ru/modes/index.md | 73 ----
docs/ru/modes/predict.md | 227 ----------
docs/ru/modes/track.md | 200 ---------
docs/ru/modes/train.md | 206 ---------
docs/ru/modes/val.md | 86 ----
docs/ru/quickstart.md | 198 ---------
docs/ru/tasks/classify.md | 172 --------
docs/ru/tasks/detect.md | 184 --------
docs/ru/tasks/index.md | 55 ---
docs/ru/tasks/pose.md | 176 --------
docs/ru/tasks/segment.md | 189 ---------
docs/update_translations.py | 345 ---------------
docs/zh/datasets/index.md | 127 ------
docs/zh/index.md | 85 ----
docs/zh/models/fast-sam.md | 193 ---------
docs/zh/models/index.md | 98 -----
docs/zh/models/mobile-sam.md | 116 ------
docs/zh/models/rtdetr.md | 93 -----
docs/zh/models/sam.md | 226 ----------
docs/zh/models/yolo-nas.md | 121 ------
docs/zh/models/yolov3.md | 98 -----
docs/zh/models/yolov4.md | 71 ----
docs/zh/models/yolov5.md | 113 -----
docs/zh/models/yolov6.md | 107 -----
docs/zh/models/yolov7.md | 65 ---
docs/zh/models/yolov8.md | 162 --------
docs/zh/modes/benchmark.md | 94 -----
docs/zh/modes/export.md | 108 -----
docs/zh/modes/index.md | 73 ----
docs/zh/modes/predict.md | 714 --------------------------------
docs/zh/modes/track.md | 273 ------------
docs/zh/modes/train.md | 294 -------------
docs/zh/modes/val.md | 86 ----
docs/zh/quickstart.md | 325 ---------------
docs/zh/tasks/classify.md | 172 --------
docs/zh/tasks/detect.md | 184 --------
docs/zh/tasks/index.md | 51 ---
docs/zh/tasks/pose.md | 185 ---------
docs/zh/tasks/segment.md | 188 ---------
docs/mkdocs.yml => mkdocs.yml | 6 +-
284 files changed, 8 insertions(+), 40429 deletions(-)
delete mode 100644 docs/ar/datasets/index.md
delete mode 100644 docs/ar/index.md
delete mode 100644 docs/ar/models/fast-sam.md
delete mode 100644 docs/ar/models/index.md
delete mode 100644 docs/ar/models/mobile-sam.md
delete mode 100644 docs/ar/models/rtdetr.md
delete mode 100644 docs/ar/models/sam.md
delete mode 100644 docs/ar/models/yolo-nas.md
delete mode 100644 docs/ar/models/yolov3.md
delete mode 100644 docs/ar/models/yolov4.md
delete mode 100644 docs/ar/models/yolov5.md
delete mode 100644 docs/ar/models/yolov6.md
delete mode 100644 docs/ar/models/yolov7.md
delete mode 100644 docs/ar/models/yolov8.md
delete mode 100644 docs/ar/modes/benchmark.md
delete mode 100644 docs/ar/modes/export.md
delete mode 100644 docs/ar/modes/index.md
delete mode 100644 docs/ar/modes/predict.md
delete mode 100644 docs/ar/modes/track.md
delete mode 100644 docs/ar/modes/train.md
delete mode 100644 docs/ar/modes/val.md
delete mode 100644 docs/ar/quickstart.md
delete mode 100644 docs/ar/tasks/classify.md
delete mode 100644 docs/ar/tasks/detect.md
delete mode 100644 docs/ar/tasks/index.md
delete mode 100644 docs/ar/tasks/pose.md
delete mode 100644 docs/ar/tasks/segment.md
delete mode 100644 docs/de/datasets/index.md
delete mode 100644 docs/de/index.md
delete mode 100644 docs/de/models/fast-sam.md
delete mode 100644 docs/de/models/index.md
delete mode 100644 docs/de/models/mobile-sam.md
delete mode 100644 docs/de/models/rtdetr.md
delete mode 100644 docs/de/models/sam.md
delete mode 100644 docs/de/models/yolo-nas.md
delete mode 100644 docs/de/models/yolov3.md
delete mode 100644 docs/de/models/yolov4.md
delete mode 100644 docs/de/models/yolov5.md
delete mode 100644 docs/de/models/yolov6.md
delete mode 100644 docs/de/models/yolov7.md
delete mode 100644 docs/de/models/yolov8.md
delete mode 100644 docs/de/modes/benchmark.md
delete mode 100644 docs/de/modes/export.md
delete mode 100644 docs/de/modes/index.md
delete mode 100644 docs/de/modes/predict.md
delete mode 100644 docs/de/modes/track.md
delete mode 100644 docs/de/modes/train.md
delete mode 100644 docs/de/modes/val.md
delete mode 100644 docs/de/quickstart.md
delete mode 100644 docs/de/tasks/classify.md
delete mode 100644 docs/de/tasks/detect.md
delete mode 100644 docs/de/tasks/index.md
delete mode 100644 docs/de/tasks/pose.md
delete mode 100644 docs/de/tasks/segment.md
delete mode 100644 docs/es/datasets/index.md
delete mode 100644 docs/es/index.md
delete mode 100644 docs/es/models/fast-sam.md
delete mode 100644 docs/es/models/index.md
delete mode 100644 docs/es/models/mobile-sam.md
delete mode 100644 docs/es/models/rtdetr.md
delete mode 100644 docs/es/models/sam.md
delete mode 100644 docs/es/models/yolo-nas.md
delete mode 100644 docs/es/models/yolov3.md
delete mode 100644 docs/es/models/yolov4.md
delete mode 100644 docs/es/models/yolov5.md
delete mode 100644 docs/es/models/yolov6.md
delete mode 100644 docs/es/models/yolov7.md
delete mode 100644 docs/es/models/yolov8.md
delete mode 100644 docs/es/modes/benchmark.md
delete mode 100644 docs/es/modes/export.md
delete mode 100644 docs/es/modes/index.md
delete mode 100644 docs/es/modes/predict.md
delete mode 100644 docs/es/modes/track.md
delete mode 100644 docs/es/modes/train.md
delete mode 100644 docs/es/modes/val.md
delete mode 100644 docs/es/quickstart.md
delete mode 100644 docs/es/tasks/classify.md
delete mode 100644 docs/es/tasks/detect.md
delete mode 100644 docs/es/tasks/index.md
delete mode 100644 docs/es/tasks/pose.md
delete mode 100644 docs/es/tasks/segment.md
delete mode 100644 docs/fr/datasets/index.md
delete mode 100644 docs/fr/index.md
delete mode 100644 docs/fr/models/fast-sam.md
delete mode 100644 docs/fr/models/index.md
delete mode 100644 docs/fr/models/mobile-sam.md
delete mode 100644 docs/fr/models/rtdetr.md
delete mode 100644 docs/fr/models/sam.md
delete mode 100644 docs/fr/models/yolo-nas.md
delete mode 100644 docs/fr/models/yolov3.md
delete mode 100644 docs/fr/models/yolov4.md
delete mode 100644 docs/fr/models/yolov5.md
delete mode 100644 docs/fr/models/yolov6.md
delete mode 100644 docs/fr/models/yolov7.md
delete mode 100644 docs/fr/models/yolov8.md
delete mode 100644 docs/fr/modes/benchmark.md
delete mode 100644 docs/fr/modes/export.md
delete mode 100644 docs/fr/modes/index.md
delete mode 100644 docs/fr/modes/predict.md
delete mode 100644 docs/fr/modes/track.md
delete mode 100644 docs/fr/modes/train.md
delete mode 100644 docs/fr/modes/val.md
delete mode 100644 docs/fr/quickstart.md
delete mode 100644 docs/fr/tasks/classify.md
delete mode 100644 docs/fr/tasks/detect.md
delete mode 100644 docs/fr/tasks/index.md
delete mode 100644 docs/fr/tasks/pose.md
delete mode 100644 docs/fr/tasks/segment.md
delete mode 100644 docs/hi/datasets/index.md
delete mode 100644 docs/hi/index.md
delete mode 100644 docs/hi/models/fast-sam.md
delete mode 100644 docs/hi/models/index.md
delete mode 100644 docs/hi/models/mobile-sam.md
delete mode 100644 docs/hi/models/rtdetr.md
delete mode 100644 docs/hi/models/sam.md
delete mode 100644 docs/hi/models/yolo-nas.md
delete mode 100644 docs/hi/models/yolov3.md
delete mode 100644 docs/hi/models/yolov4.md
delete mode 100644 docs/hi/models/yolov5.md
delete mode 100644 docs/hi/models/yolov6.md
delete mode 100644 docs/hi/models/yolov7.md
delete mode 100644 docs/hi/models/yolov8.md
delete mode 100644 docs/hi/modes/benchmark.md
delete mode 100644 docs/hi/modes/export.md
delete mode 100644 docs/hi/modes/index.md
delete mode 100644 docs/hi/modes/predict.md
delete mode 100644 docs/hi/modes/track.md
delete mode 100644 docs/hi/modes/train.md
delete mode 100644 docs/hi/modes/val.md
delete mode 100644 docs/hi/quickstart.md
delete mode 100644 docs/hi/tasks/classify.md
delete mode 100644 docs/hi/tasks/detect.md
delete mode 100644 docs/hi/tasks/index.md
delete mode 100644 docs/hi/tasks/pose.md
delete mode 100644 docs/hi/tasks/segment.md
delete mode 100644 docs/ja/datasets/index.md
delete mode 100644 docs/ja/index.md
delete mode 100644 docs/ja/models/fast-sam.md
delete mode 100644 docs/ja/models/index.md
delete mode 100644 docs/ja/models/mobile-sam.md
delete mode 100644 docs/ja/models/rtdetr.md
delete mode 100644 docs/ja/models/sam.md
delete mode 100644 docs/ja/models/yolo-nas.md
delete mode 100644 docs/ja/models/yolov3.md
delete mode 100644 docs/ja/models/yolov4.md
delete mode 100644 docs/ja/models/yolov5.md
delete mode 100644 docs/ja/models/yolov6.md
delete mode 100644 docs/ja/models/yolov7.md
delete mode 100644 docs/ja/models/yolov8.md
delete mode 100644 docs/ja/modes/benchmark.md
delete mode 100644 docs/ja/modes/export.md
delete mode 100644 docs/ja/modes/index.md
delete mode 100644 docs/ja/modes/predict.md
delete mode 100644 docs/ja/modes/track.md
delete mode 100644 docs/ja/modes/train.md
delete mode 100644 docs/ja/modes/val.md
delete mode 100644 docs/ja/quickstart.md
delete mode 100644 docs/ja/tasks/classify.md
delete mode 100644 docs/ja/tasks/detect.md
delete mode 100644 docs/ja/tasks/index.md
delete mode 100644 docs/ja/tasks/pose.md
delete mode 100644 docs/ja/tasks/segment.md
delete mode 100644 docs/ko/datasets/index.md
delete mode 100644 docs/ko/index.md
delete mode 100644 docs/ko/models/fast-sam.md
delete mode 100644 docs/ko/models/index.md
delete mode 100644 docs/ko/models/mobile-sam.md
delete mode 100644 docs/ko/models/rtdetr.md
delete mode 100644 docs/ko/models/sam.md
delete mode 100644 docs/ko/models/yolo-nas.md
delete mode 100644 docs/ko/models/yolov3.md
delete mode 100644 docs/ko/models/yolov4.md
delete mode 100644 docs/ko/models/yolov5.md
delete mode 100644 docs/ko/models/yolov6.md
delete mode 100644 docs/ko/models/yolov7.md
delete mode 100644 docs/ko/models/yolov8.md
delete mode 100644 docs/ko/modes/benchmark.md
delete mode 100644 docs/ko/modes/export.md
delete mode 100644 docs/ko/modes/index.md
delete mode 100644 docs/ko/modes/predict.md
delete mode 100644 docs/ko/modes/track.md
delete mode 100644 docs/ko/modes/train.md
delete mode 100644 docs/ko/modes/val.md
delete mode 100644 docs/ko/quickstart.md
delete mode 100644 docs/ko/tasks/classify.md
delete mode 100644 docs/ko/tasks/detect.md
delete mode 100644 docs/ko/tasks/index.md
delete mode 100644 docs/ko/tasks/pose.md
delete mode 100644 docs/ko/tasks/segment.md
delete mode 100644 docs/mkdocs_ar.yml
delete mode 100644 docs/mkdocs_de.yml
delete mode 100644 docs/mkdocs_es.yml
delete mode 100644 docs/mkdocs_fr.yml
delete mode 100644 docs/mkdocs_hi.yml
delete mode 100644 docs/mkdocs_ja.yml
delete mode 100644 docs/mkdocs_ko.yml
delete mode 100644 docs/mkdocs_pt.yml
delete mode 100644 docs/mkdocs_ru.yml
delete mode 100644 docs/mkdocs_zh.yml
delete mode 100644 docs/pt/datasets/index.md
delete mode 100644 docs/pt/index.md
delete mode 100644 docs/pt/models/fast-sam.md
delete mode 100644 docs/pt/models/index.md
delete mode 100644 docs/pt/models/mobile-sam.md
delete mode 100644 docs/pt/models/rtdetr.md
delete mode 100644 docs/pt/models/sam.md
delete mode 100644 docs/pt/models/yolo-nas.md
delete mode 100644 docs/pt/models/yolov3.md
delete mode 100644 docs/pt/models/yolov4.md
delete mode 100644 docs/pt/models/yolov5.md
delete mode 100644 docs/pt/models/yolov6.md
delete mode 100644 docs/pt/models/yolov7.md
delete mode 100644 docs/pt/models/yolov8.md
delete mode 100644 docs/pt/modes/benchmark.md
delete mode 100644 docs/pt/modes/export.md
delete mode 100644 docs/pt/modes/index.md
delete mode 100644 docs/pt/modes/predict.md
delete mode 100644 docs/pt/modes/track.md
delete mode 100644 docs/pt/modes/train.md
delete mode 100644 docs/pt/modes/val.md
delete mode 100644 docs/pt/quickstart.md
delete mode 100644 docs/pt/tasks/classify.md
delete mode 100644 docs/pt/tasks/detect.md
delete mode 100644 docs/pt/tasks/index.md
delete mode 100644 docs/pt/tasks/pose.md
delete mode 100644 docs/pt/tasks/segment.md
delete mode 100644 docs/ru/datasets/index.md
delete mode 100644 docs/ru/index.md
delete mode 100644 docs/ru/models/fast-sam.md
delete mode 100644 docs/ru/models/index.md
delete mode 100644 docs/ru/models/mobile-sam.md
delete mode 100644 docs/ru/models/rtdetr.md
delete mode 100644 docs/ru/models/sam.md
delete mode 100644 docs/ru/models/yolo-nas.md
delete mode 100644 docs/ru/models/yolov3.md
delete mode 100644 docs/ru/models/yolov4.md
delete mode 100644 docs/ru/models/yolov5.md
delete mode 100644 docs/ru/models/yolov6.md
delete mode 100644 docs/ru/models/yolov7.md
delete mode 100644 docs/ru/models/yolov8.md
delete mode 100644 docs/ru/modes/benchmark.md
delete mode 100644 docs/ru/modes/export.md
delete mode 100644 docs/ru/modes/index.md
delete mode 100644 docs/ru/modes/predict.md
delete mode 100644 docs/ru/modes/track.md
delete mode 100644 docs/ru/modes/train.md
delete mode 100644 docs/ru/modes/val.md
delete mode 100644 docs/ru/quickstart.md
delete mode 100644 docs/ru/tasks/classify.md
delete mode 100644 docs/ru/tasks/detect.md
delete mode 100644 docs/ru/tasks/index.md
delete mode 100644 docs/ru/tasks/pose.md
delete mode 100644 docs/ru/tasks/segment.md
delete mode 100644 docs/update_translations.py
delete mode 100644 docs/zh/datasets/index.md
delete mode 100644 docs/zh/index.md
delete mode 100644 docs/zh/models/fast-sam.md
delete mode 100644 docs/zh/models/index.md
delete mode 100644 docs/zh/models/mobile-sam.md
delete mode 100644 docs/zh/models/rtdetr.md
delete mode 100644 docs/zh/models/sam.md
delete mode 100644 docs/zh/models/yolo-nas.md
delete mode 100644 docs/zh/models/yolov3.md
delete mode 100644 docs/zh/models/yolov4.md
delete mode 100644 docs/zh/models/yolov5.md
delete mode 100644 docs/zh/models/yolov6.md
delete mode 100644 docs/zh/models/yolov7.md
delete mode 100644 docs/zh/models/yolov8.md
delete mode 100644 docs/zh/modes/benchmark.md
delete mode 100644 docs/zh/modes/export.md
delete mode 100644 docs/zh/modes/index.md
delete mode 100644 docs/zh/modes/predict.md
delete mode 100644 docs/zh/modes/track.md
delete mode 100644 docs/zh/modes/train.md
delete mode 100644 docs/zh/modes/val.md
delete mode 100644 docs/zh/quickstart.md
delete mode 100644 docs/zh/tasks/classify.md
delete mode 100644 docs/zh/tasks/detect.md
delete mode 100644 docs/zh/tasks/index.md
delete mode 100644 docs/zh/tasks/pose.md
delete mode 100644 docs/zh/tasks/segment.md
rename docs/mkdocs.yml => mkdocs.yml (99%)
diff --git a/docs/ar/datasets/index.md b/docs/ar/datasets/index.md
deleted file mode 100644
index 4ee98954276..00000000000
--- a/docs/ar/datasets/index.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-comments: true
-description: استكشف مجموعات بيانات الرؤية الحاسوبية المدعومة بواسطة Ultralytics لكشف الكائنات وتجزئة الصور وتقدير الركض وتصنيف الصور وتعقب الأجسام المتعددة.
-keywords: الرؤية الحاسوبية ، مجموعات البيانات ، Ultralytics ، يوه ، كشف الكائنات ، تجزئة النموذج ، تقدير الركض ، تصنيف الصور ، تعقب الأجسام المتعددة
----
-
-# نظرة عامة على مجموعات البيانات
-
-توفر Ultralytics الدعم لمجموعة متنوعة من مجموعات البيانات لتسهيل المهام الخاصة بالرؤية الحاسوبية مثل الكشف وتجزئة الكائنات وتقدير الركض وتصنيف الصور وتعقب الأجسام المتعددة. فيما يلي قائمة بالمجموعات الرئيسية التي يدعمها Ultralytics ، تليها ملخص لكل مهمة في الرؤية الحاسوبية ومجموعات البيانات المتعلقة بها.
-
-!!! Note "ملاحظة"
-
- 🚧 قسم الوثائق ذو اللغات المتعددة قيد الإنشاء حاليًا ، ونعمل بجد لتحسينه. نشكرك على صبرك! 🙏
-
-## [مجموعات بيانات الكشف](../../datasets/detect/index.md)
-
-يعد كشف الكائنات بواسطة صندوق محيط هو تقنية في الرؤية الحاسوبية تتضمن كشف الكائنات وتمييزها في الصورة عن طريق رسم صندوق محيط حول كل كائن.
-
-- [Argoverse](../../datasets/detect/argoverse.md): مجموعة بيانات تحتوي على بيانات تتبع ثلاثية الأبعاد وتنبؤ الحركة من البيئات الحضرية مع توجيه البيانات بشكل جيد.
-- [COCO](../../datasets/detect/coco.md): مجموعة بيانات كبيرة مصممة للكشف والتجزئة والتسمية تحتوي على أكثر من 200 ألف صورة معتمدة.
-- [COCO8](../../datasets/detect/coco8.md): يحتوي على أول 4 صور من COCO التدريب و COCO val ، مناسب للاختبار السريع.
-- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): مجموعة بيانات من صور رؤوس القمح جمعت من جميع أنحاء العالم لمهام الكشف والتحديد الموضعي.
-- [Objects365](../../datasets/detect/objects365.md): مجموعة بيانات كبيرة وعالية الجودة لاكتشاف الكائنات بتصنيفات 365 وأكثر من 600 ألف صورة مرتبطة.
-- [OpenImagesV7](../../datasets/detect/open-images-v7.md): مجموعة بيانات شاملة من جوجل تحتوي على 1.7 مليون صورة للتدريب و 42 ألف صورة للتحقق.
-- [SKU-110K](../../datasets/detect/sku-110k.md): مجموعة بيانات تتضمن الكشف المكثف للكائنات في بيئات البيع بالتجزئة مع أكثر من 11 ألف صورة و 1.7 مليون صندوق بيانات محيط.
-- [VisDrone](../../datasets/detect/visdrone.md): مجموعة بيانات تحتوي على كشف الكائنات ونماذج تعقب لأجسام متعددة من الصور الملتقطة بواسطة طائرات بدون طيار بأكثر من 10 ألف صورة وتسلسلات فيديو.
-- [VOC](../../datasets/detect/voc.md): مجموعة بيانات Pascal Visual Object Classes (VOC) لكشف الكائنات والتجزئة بـ20 فئة من الكائنات وأكثر من 11 ألف صورة.
-- [xView](../../datasets/detect/xview.md): مجموعة بيانات لكشف الكائنات في الصور الملتقطة من الأعلى بـ 60 فئة من الكائنات وأكثر من مليون كائن محدد ملحوظ.
-
-## [مجموعات بيانات التجزئة النمطية](../../datasets/segment/index.md)
-
-تعتبر التجزئة النمطية تقنية في الرؤية الحاسوبية تتطلب تحديد أجسام وتحديد مكانها في مستوى البكسل في الصورة.
-
-- [COCO](../../datasets/segment/coco.md): مجموعة بيانات كبيرة مصممة للكشف والتجزئة والتسمية تحتوي على أكثر من 200 ألف صورة معتمدة.
-- [COCO8-seg](../../datasets/segment/coco8-seg.md): مجموعة بيانات أصغر لمهام التجزئة النمطية ، تحتوي على مجموعة فرعية من 8 صور COCO مع تسميات التجزئة.
-
-## [تقدير الركض](../../datasets/pose/index.md)
-
-تقدير الركض هو تقنية تُستخدم لتحديد وضع الكائن مقارنةً بالكاميرا أو نظام الإحداثيات العالمية.
-
-- [COCO](../../datasets/pose/coco.md): مجموعة بيانات كبيرة بتعليقات وضع الإنسان المصممة لمهام تقدير الركض.
-- [COCO8-pose](../../datasets/pose/coco8-pose.md): مجموعة بيانات أصغر لمهام تقدير الركض ، تحتوي على مجموعة فرعية من 8 صور COCO مع تغييرات في وضع الإنسان.
-- [تقدير الركض النمر](../../datasets/pose/tiger-pose.md): مجموعة بيانات مدمجة تتكون من 263 صورة مركزة على النمور ، مع 12 نقطة مرجعية لكل نمر لمهام تقدير الركض.
-
-## [التصنيف](../../datasets/classify/index.md)
-
-تصنيف الصورة هو مهمة في الرؤية الحاسوبية تتضمن تصنيف صورة في فئة أو أكثر محددة مسبقًا بناءً على محتواها البصري.
-
-- [كالتك 101](../../datasets/classify/caltech101.md): مجموعة بيانات تحتوي على صور لـ 101 فئة من الكائنات لمهام تصنيف الصور.
-- [كالتك 256](../../datasets/classify/caltech256.md): نسخة موسعة من Caltech 101 بـ 256 فئة من الكائنات وصور أكثر تحديًا.
-- [CIFAR-10](../../datasets/classify/cifar10.md): مجموعة بيانات تحتوي على 60 ألف صورة ملونة بحجم 32x32 بكسل في 10 فئات ، مع 6 آلاف صورة لكل فئة.
-- [CIFAR-100](../../datasets/classify/cifar100.md): نسخة موسعة من CIFAR-10 بـ 100 فئة من الكائنات و 600 صورة لكل فئة.
-- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): مجموعة بيانات تتكون من 70,000 صورة رمادية لـ 10 فئات من الملابس لمهام تصنيف الصور.
-- [ImageNet](../../datasets/classify/imagenet.md): مجموعة بيانات بمقياس كبير لكشف الكائنات وتصنيف الصور بأكثر من 14 مليون صورة و 20,000 فئة.
-- [ImageNet-10](../../datasets/classify/imagenet10.md): نسخة أصغر من ImageNet مع 10 فئات للاختبار والتجربة الأسرع.
-- [Imagenette](../../datasets/classify/imagenette.md): مجموعة فرعية أصغر لـ ImageNet تحتوي على 10 فئات يمكن التمييز بينها بسهولة للتدريب والاختبار الأسرع.
-- [Imagewoof](../../datasets/classify/imagewoof.md): نسخة أكثر تحديًا من ImageNet تحتوي على 10 فئات من فئات كلاب العنبر لمهام تصنيف الصور.
-- [MNIST](../../datasets/classify/mnist.md): مجموعة بيانات تتكون من 70,000 صورة رمادية للأرقام المكتوبة يدويًا لمهام تصنيف الصور.
-
-## [صناديق الحدود الموجهة (OBB)](../../datasets/obb/index.md)
-
-صناديق الحدود الموجهة (OBB) هي طريقة في الرؤية الحاسوبية لاكتشاف الكائنات ذات زوايا في الصور باستخدام صناديق حدود مدورة تمت تدويرها ، وغالبًا ما يتم تطبيقها على صور الأقمار الصناعية والطائرات بدون طيار.
-
-- [DOTAv2](../../datasets/obb/dota-v2.md): مجموعة بيانات OBB الجوية الشهيرة بـ 1.7 مليون حالة و 11,268 صورة.
-
-## [تتبع الكائنات المتعددة](../../datasets/track/index.md)
-
-تعتبر تتبع الكائنات المتعددة تقنية في الرؤية الحاسوبية تتضمن كشف وتتبع عدة كائنات معًا عبر الزمن في سلسلة فيديو.
-
-- [Argoverse](../../datasets/detect/argoverse.md): مجموعة بيانات تحتوي على بيانات تتبع ثلاثية الأبعاد وتنبؤ الحركة من البيئات الحضرية مع توجيه البيانات بشكل جيد لمهام تتبع الكائنات المتعددة.
-- [VisDrone](../../datasets/detect/visdrone.md): مجموعة بيانات تحتوي على كشف الكائنات ونماذج تتبع لأجسام متعددة من الصور الملتقطة بواسطة طائرات بدون طيار بأكثر من 10 ألف صورة وتسلسلات فيديو.
-
-## المساهمة في مجموعات بيانات جديدة
-
-تشمل المساهمة في مجموعة بيانات جديدة عدة خطوات لضمان توافقها مع البنية القائمة. فيما يلي الخطوات اللازمة:
-
-### الخطوات المطلوبة للمساهمة في مجموعة بيانات جديدة
-
-1. **جمع الصور**: اجمع الصور التي تنتمي إلى مجموعة البيانات. يمكن جمع هذه الصور من مصادر مختلفة مثل قواعد البيانات العامة أو مجموعتك الخاصة.
-
-2. **وضع تعليقات على الصور**: قم بإضافة تعليقات على هذه الصور مع صناديق الحدود أو الشرائح أو النقاط التي تعتمد على المهمة.
-
-3. **تصدير التعليقات**: قم بتحويل هذه التعليقات إلى تنسيق الملف `*.txt` `*.txt` المدعوم من Ultralytics.
-
-4. **تنظيم مجموعة البيانات**: قم بترتيب مجموعة البيانات الخاصة بك في البنية المجلدات الصحيحة. يجب أن تحتوي على مجلدات أعلى المستوى `train/` و `val/` ، وداخل كل منهما ، مجلدات فرعية للـ `images/` و `labels/`.
-
- ```
- dataset/
- ├── train/
- │ ├── images/
- │ └── labels/
- └── val/
- ├── images/
- └── labels/
- ```
-
-5. **إنشاء ملف `data.yaml`**: في المجلد الجذري لمجموعة البيانات الخاصة بك ، قم بإنشاء ملف `data.yaml` يصف المجموعة البيانات والفئات وغيرها من المعلومات الضرورية.
-
-6. **تحسين الصور (اختياري)**: إذا كنت ترغب في تقليل حجم مجموعة البيانات لمزيد من الكفاءة في المعالجة ، فيمكنك تحسين الصور باستخدام الكود أدناه. لا يلزم ذلك ، ولكنه موصى به لأحجام مجموعات البيانات الأصغر وسرعات التنزيل الأسرعة.
-
-7. **ضغط مجموعة البيانات**: قم بضغط مجلد مجموعة البيانات بالكامل وضعه في ملف zip.
-
-8. **الوثائق وإرسال طلب السحب (PR)**: قم بإنشاء صفحة وثائق تصف مجموعة البيانات الخاصة بك وكيف تتوافق مع الإطار القائم. بعد ذلك ، قدم طلب سحب (PR). راجع [مبادئ المساهمة في Ultralytics](https://docs.ultralytics.com/help/contributing) لمزيد من التفاصيل حول كيفية تقديم طلب السحب (PR).
-
-### كود مثال لتحسين وضغط مجموعة البيانات
-
-!!! Example "تحسين وضغط مجموعة البيانات"
-
- === "Python"
-
- ```python
- from pathlib import Path
- from ultralytics.data.utils import compress_one_image
- from ultralytics.utils.downloads import zip_directory
-
- # تعيين مسار مجلد مجموعة البيانات
- path = Path('path/to/dataset')
-
- # تحسين الصور في مجموعة البيانات (اختياري)
- for f in path.rglob('*.jpg'):
- compress_one_image(f)
-
- # ضغط مجلد مجموعة البيانات في ملف زيب
- zip_directory(path)
- ```
-
-باتباع هذه الخطوات ، يمكنك المساهمة في مجموعة بيانات جديدة تتكامل بشكل جيد مع البنية القائمة لـ Ultralytics.
diff --git a/docs/ar/index.md b/docs/ar/index.md
deleted file mode 100644
index fb4b4a7bd95..00000000000
--- a/docs/ar/index.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-comments: true
-description: استكشف دليل كامل لـ Ultralytics YOLOv8 ، نموذج كشف الكائنات وتجزئة الصور ذو السرعة العالية والدقة العالية. تثبيت المحررة ، والتنبؤ ، والتدريب والمزيد.
-keywords: Ultralytics، YOLOv8، كشف الكائنات، تجزئة الصور، التعلم الآلي، التعلم العميق، الرؤية الحاسوبية، YOLOv8 installation، YOLOv8 prediction، YOLOv8 training، تاريخ YOLO، تراخيص YOLO
----
-
-
-
-يتم تقديم [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics) ، أحدث إصدار من نموذج كشف الكائنات وتجزئة الصور المشهورة للوقت الفعلي. يعتمد YOLOv8 على التطورات المتقدمة في التعلم العميق والرؤية الحاسوبية ، ويقدم أداءً فائقًا من حيث السرعة والدقة. يجعل التصميم البسيط له مناسبًا لمختلف التطبيقات وقابلًا للتكيف بسهولة مع منصات الأجهزة المختلفة ، من الأجهزة الحافة إلى واجهات برمجة التطبيقات في السحابة.
-
-استكشف أدلة YOLOv8 ، وهي مورد شامل يهدف إلى مساعدتك في فهم واستخدام ميزاته وقدراته. سواء كنت ممارسًا في مجال التعلم الآلي من ذوي الخبرة أو جديدًا في هذا المجال ، فإن الهدف من هذا المركز هو تحقيق الحد الأقصى لإمكانات YOLOv8 في مشاريعك.
-
-!!! Note "ملاحظة"
-
- 🚧 تم تطوير وثائقنا متعددة اللغات حاليًا ، ونعمل بجد لتحسينها. شكراً لصبرك! 🙏
-
-## من أين أبدأ
-
-- **تثبيت** `ultralytics` بواسطة pip والبدء في العمل في دقائق [:material-clock-fast: ابدأ الآن](quickstart.md){ .md-button }
-- **توقع** الصور ومقاطع الفيديو الجديدة بواسطة YOLOv8 [:octicons-image-16: توقع على الصور](modes/predict.md){ .md-button }
-- **تدريب** نموذج YOLOv8 الجديد على مجموعة البيانات المخصصة الخاصة بك [:fontawesome-solid-brain: قم بتدريب نموذج](modes/train.md){ .md-button }
-- **استكشاف** مهام YOLOv8 مثل التجزئة والتصنيف والوضع والتتبع [:material-magnify-expand: استكشاف المهام](tasks/index.md){ .md-button }
-
-
-
-
-
- مشاهدة: كيفية تدريب نموذج YOLOv8 على مجموعة بيانات مخصصة في جوجل كولاب.
-
-
-## YOLO: نبذة تاريخية
-
-تم تطوير [YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once) ، نموذج شهير لكشف الكائنات وتجزئة الصور ، من قبل جوزيف ريدمون وعلي فرهادي في جامعة واشنطن. في عام 2015 ، حققت YOLO شهرة سريعة بفضل سرعتها العالية ودقتها.
-
-- [YOLOv2](https://arxiv.org/abs/1612.08242) ، الذي تم إصداره في عام 2016 ، قام بتحسين النموذج الأصلي من خلال دمج التطبيع التشغيلي ، ومربعات الربط ، ومجموعات الأبعاد.
-- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf) ، الذي تم إطلاقه في عام 2018 ، قدم تحسينات إضافية لأداء النموذج باستخدام شبكة ظهر أكثر كفاءة ومرشحات متعددة وتجميع هرم المساحة.
-- تم إصدار [YOLOv4](https://arxiv.org/abs/2004.10934) في عام 2020 ، وقدم ابتكارات مثل زيادة المساعدات في البيانات ، ورأس جديد للكشف غير المرتبط بالمرابط ، ووظيفة فقدان جديدة.
-- [YOLOv5](https://github.com/ultralytics/yolov5) قام بتحسين أداء النموذج وأضاف ميزات جديدة مثل تحسين ثوابت النموذج ، وتعقب التجارب المتكامل والتصدير التلقائي إلى تنسيقات التصدير الشهيرة.
-- [YOLOv6](https://github.com/meituan/YOLOv6) تم تَوْزيعه على [Meituan](https://about.meituan.com/) في عام 2022 وهو قيد الاستخدام في العديد من روبوتات التسليم الذاتي للشركة.
-- [YOLOv7](https://github.com/WongKinYiu/yolov7) أضاف مهمات إضافية مثل تقدير الوضع على مجموعة بيانات نقاط COCO الرئيسية.
-- [YOLOv8](https://github.com/ultralytics/ultralytics) هو أحدث إصدار من YOLO بواسطة Ultralytics. باعتباره نموذجًا حديثًا وفريدًا من نوعه ، فإن YOLOv8 يبني على نجاح الإصدارات السابقة ، ويقدم ميزات وتحسينات جديدة لتحسين الأداء والمرونة والكفاءة. يدعم YOLOv8 مجموعة كاملة من مهام الذكاء الصناعي للرؤية ، بما في ذلك [الكشف](tasks/detect.md) ، [التجزئة](tasks/segment.md) ، [تقدير الوضع](tasks/pose.md) ، [التتبع](modes/track.md) ، و [التصنيف](tasks/classify.md). تتيح هذه القابلية للتكيف للمستخدمين استغلال قدرات YOLOv8 في تطبيقات ومجالات متنوعة.
-
-## تراخيص YOLO: كيف يتم ترخيص Ultralytics YOLO؟
-
-يوفر Ultralytics خيارين للترخيص لاستيعاب الحالات الاستخدام المتنوعة:
-
-- **ترخيص AGPL-3.0**: هذا الترخيص مفتوح المصدر والمعتمد من [OSI](https://opensource.org/licenses/) وهو مثالي للطلاب والهواة ، ويشجع على التعاون المفتوح ومشاركة المعرفة. راجع ملف [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) لمزيد من التفاصيل.
-- **ترخيص المؤسسة**: صمم للاستخدام التجاري ، يسمح هذا الترخيص بدمج سلس للبرمجيات ونماذج AI الخاصة بشركة Ultralytics في السلع والخدمات التجارية ، وتفادي متطلبات المصدر المفتوح لـ AGPL-3.0. إذا تشمل سيناريو الخاص بك تضمين حلولنا في عرض تجاري ، فيرجى التواصل من خلال [Ultralytics Licensing](https://ultralytics.com/license).
-
-تم تصميم استراتيجية الترخيص الخاصة بنا لضمان أن أي تحسينات على مشاريعنا مفتوحة المصدر يتم إرجاعها إلى المجتمع. نحمل مبادئ المصدر المفتوح قريبة من قلوبنا ❤️ ، ومهمتنا هي ضمان أن يمكن استخدام وتوسيع مساهماتنا بطرق تعود بالنفع على الجميع.
diff --git a/docs/ar/models/fast-sam.md b/docs/ar/models/fast-sam.md
deleted file mode 100644
index 68b39fcde28..00000000000
--- a/docs/ar/models/fast-sam.md
+++ /dev/null
@@ -1,191 +0,0 @@
----
-comments: true
-description: استكشف FastSAM ، وهو حلاً مبنيًا على الشبكات العصبية السريعة لتجزئة الكائنات في الوقت الحقيقي في الصور. تفاعل المستخدم المحسّن ، والكفاءة الحسابية ، والقابلية للتكيف في مهام الرؤية المختلفة.
-keywords: FastSAM ، التعلم الآلي ، حلاً مبنيًا على الشبكات العصبية السريعة ، قسيمة الكائنات ، حلاً في الوقت الحقيقي ، Ultralytics ، مهام الرؤية ، معالجة الصور ، تطبيقات صناعية ، تفاعل المستخدم
----
-
-# نموذج تجزئة أي شيء بسرعة عالية (FastSAM)
-
-نموذج تجزئة أي شيء بسرعة عالية (FastSAM) هو حلاً مبتكرًا للعصب الشبكي يعمل بالزمن الحقيقي لمهمة تجزئة أي كائن داخل صورة ما. تم تصميم هذه المهمة لتجزئة أي كائن داخل صورة بناءً على إشارات تفاعل المستخدم المختلفة الممكنة. يقلل الـ FastSAM من الاحتياجات الحسابية بشكل كبير مع الحفاظ على أداء تنافسي ، مما يجعله خيارًا عمليًا لمجموعة متنوعة من مهام الرؤية.
-
-![نظرة عامة على تصميم نموذج تجزئة أي شيء بسرعة عالية (FastSAM)](https://user-images.githubusercontent.com/26833433/248551984-d98f0f6d-7535-45d0-b380-2e1440b52ad7.jpg)
-
-## نظرة عامة
-
-تم تصميم FastSAM للتغلب على القيود الموجودة في [نموذج تجزئة ما شيء (SAM)](sam.md) ، وهو نموذج تحويل ثقيل يتطلب موارد حسابية كبيرة. يفصل FastSAM عملية تجزئة أي شيء إلى مرحلتين متسلسلتين: تجزئة جميع الأمثلة واختيار موجه بناءً على التعليمات. تستخدم المرحلة الأولى [YOLOv8-seg](../tasks/segment.md) لإنتاج قناع التجزئة لجميع الأمثلة في الصورة. في المرحلة الثانية ، يتم إخراج منطقة الاهتمام المتعلقة بالتعليمة.
-
-## المميزات الرئيسية
-
-1. **حلاً في الوقت الحقيقي**: من خلال استغلال كفاءة الشبكات العصبية الحاسوبية ، يوفر FastSAM حلاً في الوقت الحقيقي لمهمة تجزئة أي شيء ، مما يجعله قيمًا للتطبيقات الصناعية التي تتطلب نتائج سريعة.
-
-2. **كفاءة وأداء**: يقدم FastSAM تقليل كبير في الاحتياجات الحسابية واستخدام الموارد دون التنازل عن جودة الأداء. يحقق أداءً قابلاً للمقارنة مع SAM ولكن بموارد حسابية مخفضة بشكل كبير ، مما يمكن من تطبيقه في الوقت الحقيقي.
-
-3. **تجزئة يستند إلى الموجه**: يمكن لـ FastSAM تجزئة أي كائن داخل صورة ترشده مختلف إشارات تفاعل المستخدم الممكنة ، مما يوفر مرونة وقابلية للتكيف في سيناريوهات مختلفة.
-
-4. **يستند إلى YOLOv8-seg**: يستند FastSAM إلى [YOLOv8-seg](../tasks/segment.md) ، وهو كاشف كائنات مجهز بفرع تجزئة المثيلات. يمكنه بشكل فعال إنتاج قناع التجزئة لجميع الأمثلة في صورة.
-
-5. **نتائج تنافسية في الاختبارات التحضيرية**: في مهمة اقتراح الكائن على MS COCO ، يحقق FastSAM درجات عالية بسرعة أسرع بكثير من [SAM](sam.md) على بطاقة NVIDIA RTX 3090 واحدة ، مما يدل على كفاءته وقدرته.
-
-6. **تطبيقات عملية**: توفر الطريقة المقترحة حلاً جديدًا وعمليًا لعدد كبير من مهام الرؤية بسرعة عالية حقًا ، بمعدلات سرعة عشرات أو مئات المرات أسرع من الطرق الحالية.
-
-7. **جدوى ضغط النموذج**: يظهر FastSAM إمكانية تقليل الجهد الحسابي بشكل كبير من خلال إدخال سابق اصطناعي للهيكل ، مما يفتح إمكانيات جديدة لهندسة هيكل النموذج الكبير لمهام الرؤية العامة.
-
-## النماذج المتاحة ، المهام المدعومة ، وأوضاع التشغيل
-
-يعرض هذا الجدول النماذج المتاحة مع أوزانها المحددة ، والمهام التي تدعمها ، ومدى توافقها مع أوضاع التشغيل المختلفة مثل [الاستنتاج](../modes/predict.md) ، [التحقق](../modes/val.md) ، [التدريب](../modes/train.md) ، و[التصدير](../modes/export.md) ، مشار إليها برموز الـ✅ للأوضاع المدعومة والرموز ❌ للأوضاع غير المدعومة.
-
-| نوع النموذج | أوزان تم تدريبها مسبقًا | المهام المدعومة | الاستنتاج | التحقق | التدريب | التصدير |
-|-------------|-------------------------|---------------------------------------|-----------|--------|---------|---------|
-| FastSAM-s | `FastSAM-s.pt` | [تجزئة المثيلات](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-| FastSAM-x | `FastSAM-x.pt` | [تجزئة المثيلات](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-
-## أمثلة الاستخدام
-
-يسهل دمج نماذج FastSAM في تطبيقات Python الخاصة بك. يوفر Ultralytics واجهة برمجة تطبيقات Python سهلة الاستخدام وأوامر CLI لتسهيل التطوير.
-
-### استخدام التوقعات
-
-للقيام بكشف الكائنات في صورة ، استخدم طريقة `predict` كما هو موضح أدناه:
-
-!!! Example "مثال"
-
- === "بايثون"
- ```python
- from ultralytics import FastSAM
- from ultralytics.models.fastsam import FastSAMPrompt
-
- # حدد مصدر التوقع
- source = 'path/to/bus.jpg'
-
- # قم بإنشاء نموذج FastSAM
- model = FastSAM('FastSAM-s.pt') # or FastSAM-x.pt
-
- # تنفيذ توقعات على صورة
- everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
-
- # قم بتجهيز كائن معالج مع قواعد التوقع
- prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
-
- # التوقع باستخدام كل شيء
- ann = prompt_process.everything_prompt()
-
- # bbox الشكل الافتراضي [0،0،0،0] -> [x1،y1،x2،y2]
- ann = prompt_process.box_prompt(bbox=[200، 200، 300، 300])
-
- # التوقع النصي
- ann = prompt_process.text_prompt(text='صورة لكلب')
-
- # التوقع النقطي
- ann = prompt_process.point_prompt(points=[[200، 200]]، pointlabel=[1])
- prompt_process.plot(annotations=ann، output='./')
- ```
-
- === "CLI"
- ```bash
- # قم بتحميل نموذج FastSAM وتجزئة كل شيء به
- yolo segment predict model=FastSAM-s.pt source=path/to/bus.jpg imgsz=640
- ```
-
-توضح هذه المقاطع البساطة في تحميل نموذج مدرب مسبقًا وتنفيذ توقع على صورة.
-
-### استخدام مهام التحقق
-
-يمكن تنفيذ التحقق من النموذج على مجموعة بيانات على النحو التالي:
-
-!!! Example "مثال"
-
- === "بايثون"
- ```python
- from ultralytics import FastSAM
-
- # قم بإنشاء نموذج FastSAM
- model = FastSAM('FastSAM-s.pt') # or FastSAM-x.pt
-
- # قم بتنفيذ التحقق من النموذج
- results = model.val(data='coco8-seg.yaml')
- ```
-
- === "CLI"
- ```bash
- # قم بتحميل نموذج FastSAM وأجرِ التحقق منه بخصوص مجموعة البيانات مثال كوكو 8 بحجم صورة 640
- yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
- ```
-
-يرجى ملاحظة أن الـ FastSAM يدعم فقط الكشف والتجزئة لفئة واحدة من الكائن. هذا يعني أنه سيتعرف ويجزء جميع الكائنات على أنها نفس الفئة. لذلك ، عند إعداد مجموعة البيانات ، يجب تحويل جميع معرفات فئة الكائن إلى 0.
-
-## استخدام FastSAM الرسمي
-
-يتوفر نموذج FastSAM مباشرةً من مستودع [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM). فيما يلي نظرة عامة موجزة على الخطوات التقليدية التي قد تتخذها لاستخدام FastSAM:
-
-### التثبيت
-
-1. استنسخ مستودع FastSAM:
- ```shell
- git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
- ```
-
-2. أنشئ بيئة Conda وفعّلها بـ Python 3.9:
- ```shell
- conda create -n FastSAM python=3.9
- conda activate FastSAM
- ```
-
-3. انتقل إلى المستودع المنسخ وقم بتثبيت الحزم المطلوبة:
- ```shell
- cd FastSAM
- pip install -r requirements.txt
- ```
-
-4. قم بتثبيت نموذج CLIP:
- ```shell
- pip install git+https://github.com/openai/CLIP.git
- ```
-
-### مثال الاستخدام
-
-1. قم بتنزيل [تفويض نموذج](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing).
-
-2. استخدم FastSAM للتوقع. أمثلة الأوامر:
-
- - تجزئة كل شيء في صورة:
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
- ```
-
- - تجزئة كائنات محددة باستخدام تعليمات النص:
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "الكلب الأصفر"
- ```
-
- - تجزئة كائنات داخل مربع محدد (تقديم إحداثيات الصندوق في تنسيق xywh):
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
- ```
-
- - تجزئة كائنات قرب النقاط المحددة:
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
- ```
-
-بالإضافة إلى ذلك ، يمكنك تجربة FastSAM من خلال [Colab demo](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) أو على [HuggingFace web demo](https://huggingface.co/spaces/An-619/FastSAM) لتجربة بصرية.
-
-## الاقتباسات والشكر
-
-نود أن نشكر أباء FastSAM على مساهماتهم الهامة في مجال تجزئة المثيلات في الوقت الحقيقي:
-
-!!! Quote ""
-
- === "بيب تيكس"
-
- ```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}
- }
- ```
-
-يمكن العثور على ورقة FastSAM الأصلية على [arXiv](https://arxiv.org/abs/2306.12156). قام الأباء بجعل أعمالهم متاحة للجمهور ، ويمكن الوصول إلى قاعدة الكود على [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). نقدر جهودهم في تطوير المجال وجعل أعمالهم متاحة للمجتمع الأوسع.
diff --git a/docs/ar/models/index.md b/docs/ar/models/index.md
deleted file mode 100644
index a399f0df862..00000000000
--- a/docs/ar/models/index.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-comments: true
-description: استكشف مجموعة متنوعة من عائلة YOLO، ونماذج SAM وMobileSAM وFastSAM وYOLO-NAS وRT-DETR المدعومة من Ultralytics. ابدأ بأمثلة لكل من استخدام واجهة الأوامر وPython.
-keywords: Ultralytics, documentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, models, architectures, Python, CLI
----
-
-# النماذج المدعومة من Ultralytics
-
-أهلاً بك في وثائق نماذج Ultralytics! نحن نقدم الدعم لمجموعة واسعة من النماذج، كل منها مُصمم لمهام محددة مثل [الكشف عن الأجسام](../tasks/detect.md)، [تقطيع الحالات](../tasks/segment.md)، [تصنيف الصور](../tasks/classify.md)، [تقدير الوضعيات](../tasks/pose.md)، و[تتبع الأجسام المتعددة](../modes/track.md). إذا كنت مهتمًا بالمساهمة في هندسة نموذجك مع Ultralytics، راجع دليل [المساهمة](../../help/contributing.md).
-
-!!! Note "ملاحظة"
-
- 🚧 تحت الإنشاء: وثائقنا بلغات متعددة قيد الإنشاء حاليًا، ونحن نعمل بجد لتحسينها. شكرًا لصبرك! 🙏
-
-## النماذج المميزة
-
-إليك بعض النماذج الرئيسية المدعومة:
-
-1. **[YOLOv3](yolov3.md)**: الإصدار الثالث من عائلة نموذج YOLO، الذي أنشأه أصلاً Joseph Redmon، والمعروف بقدراته الفعالة في الكشف عن الأجسام في الوقت الفعلي.
-2. **[YOLOv4](yolov4.md)**: تحديث محلي لـ YOLOv3، تم إصداره بواسطة Alexey Bochkovskiy في 2020.
-3. **[YOLOv5](yolov5.md)**: نسخة مُحسنة من هندسة YOLO من قبل Ultralytics، توفر أداءً أفضل وتوازن في السرعة مقارنة بالإصدارات السابقة.
-4. **[YOLOv6](yolov6.md)**: أُصدرت بواسطة [Meituan](https://about.meituan.com/) في 2022، ويُستخدم في العديد من روبوتات التوصيل الذاتية للشركة.
-5. **[YOLOv7](yolov7.md)**: تم إصدار نماذج YOLO المحدثة في 2022 بواسطة مؤلفي YOLOv4.
-6. **[YOLOv8](yolov8.md) جديد 🚀**: الإصدار الأحدث من عائلة YOLO، يتميز بقدرات مُعززة مثل تقطيع الحالات، تقدير الوضعيات/النقاط الرئيسية، والتصنيف.
-7. **[Segment Anything Model (SAM)](sam.md)**: نموذج Segment Anything Model (SAM) من Meta.
-8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: نموذج MobileSAM للتطبيقات المحمولة، من جامعة Kyung Hee.
-9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: نموذج FastSAM من مجموعة تحليل الصور والفيديو، والمعهد الصيني للأتمتة، وأكاديمية العلوم الصينية.
-10. **[YOLO-NAS](yolo-nas.md)**: نماذج YOLO Neural Architecture Search (NAS).
-11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)**: نماذج Realtime Detection Transformer (RT-DETR) من PaddlePaddle التابعة لشركة Baidu.
-
-
-
-
-
- شاهد: تشغيل نماذج YOLO من Ultralytics في بضعة أسطر من الكود فقط.
-
-
-## البدء في الاستخدام: أمثلة على الاستخدام
-
-يوفر هذا المثال أمثلة مبسطة على التدريب والاستدلال باستخدام YOLO. للحصول على الوثائق الكاملة عن هذه وغيرها من [الأوضاع](../modes/index.md), انظر صفحات وثائق [التنبؤ](../modes/predict.md)، و[التدريب](../modes/train.md)، و[التقييم](../modes/val.md) و[التصدير](../modes/export.md).
-
-لاحظ أن المثال أدناه هو لنماذج [Detect](../tasks/detect.md) YOLOv8 لكشف الأجسام. للاطلاع على المهام الإضافية المدعومة، راجع وثائق [Segment](../tasks/segment.md)، و[Classify](../tasks/classify.md) و[Pose](../tasks/pose.md).
-
-!!! Example "مثال"
-
- === "Python"
-
- نماذج `*.pt` المُدربة مسبقًا وملفات الإعداد `*.yaml` يمكن أن تُمرر إلى فئات `YOLO()`, `SAM()`, `NAS()` و `RTDETR()` لإنشاء مثال نموذج في Python:
-
- ```python
- من ultralytics استيراد YOLO
-
- # تحميل نموذج YOLOv8n المُدرب مسبقًا على COCO
- النموذج = YOLO('yolov8n.pt')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # تدريب النموذج على مجموعة البيانات المثالية COCO8 لمدة 100 عصر
- النتائج = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # تشغيل الاستدلال بنموذج YOLOv8n على صورة 'bus.jpg'
- النتائج = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- الأوامر CLI متاحة لتشغيل النماذج مباشرة:
-
- ```bash
- # تحميل نموذج YOLOv8n المُدرب مسبقًا على COCO وتدريبه على مجموعة البيانات المثالية COCO8 لمدة 100 عصر
- yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # تحميل نموذج YOLOv8n المُدرب مسبقًا على COCO وتشغيل الاستدلال على صورة 'bus.jpg'
- yolo predict model=yolov8n.pt source=path/to/bus.jpg
- ```
-
-## المساهمة بنماذج جديدة
-
-هل أنت مهتم بالمساهمة بنموذجك في Ultralytics؟ رائع! نحن دائمًا منفتحون على توسيع محفظة النماذج لدينا.
-
-1. **احفظ نسخة عن المستودع**: ابدأ بحفظ نسخة عن [مستودع Ultralytics على GitHub](https://github.com/ultralytics/ultralytics).
-
-2. **استنسخ نسختك**: انسخ نسختك إلى جهازك المحلي وأنشئ فرعًا جديدًا للعمل عليه.
-
-3. **طبق نموذجك**: أضف نموذجك متبعًا معايير وإرشادات البرمجة الموفرة في دليل [المساهمة](../../help/contributing.md) لدينا.
-
-4. **اختبر بدقة**: تأكد من اختبار نموذجك بشكل مكثف، سواء بشكل منفصل أو كجزء من المسار البرمجي.
-
-5. **أنشئ Pull Request**: بمجرد أن تكون راضًيا عن نموذجك، قم بإنشاء طلب سحب إلى المستودع الرئيسي للمراجعة.
-
-6. **مراجعة الكود والدمج**: بعد المراجعة، إذا كان نموذجك يلبي معاييرنا، سيتم دمجه في المستودع الرئيسي.
-
-للخطوات التفصيلية، يرجى الرجوع إلى دليل [المساهمة](../../help/contributing.md).
diff --git a/docs/ar/models/mobile-sam.md b/docs/ar/models/mobile-sam.md
deleted file mode 100644
index ec671da1b55..00000000000
--- a/docs/ar/models/mobile-sam.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-comments: true
-description: تعرّف على MobileSAM وتطبيقه، وقارنه مع SAM الأصلي، وكيفية تنزيله واختباره في إطار Ultralytics. قم بتحسين تطبيقاتك المحمولة اليوم.
-keywords: MobileSAM، Ultralytics، SAM، التطبيقات المحمولة، Arxiv، GPU، API، مُشفّر الصورة، فك تشفير القناع، تنزيل النموذج، طريقة الاختبار
----
-
-![شعار MobileSAM](https://github.com/ChaoningZhang/MobileSAM/blob/master/assets/logo2.png?raw=true)
-
-# التمييز المحمول لأي شيء (MobileSAM)
-
-الآن يمكنك الاطّلاع على ورقة MobileSAM في [arXiv](https://arxiv.org/pdf/2306.14289.pdf).
-
-يمكن الوصول إلى عرض مباشر لـ MobileSAM يعمل على وحدة المعالجة المركزية CPU من [هنا](https://huggingface.co/spaces/dhkim2810/MobileSAM). يستغرق الأداء على وحدة المعالجة المركزية Mac i5 تقريبًا 3 ثوانٍ. في عرض الواجهة التفاعلية الخاص بهنغ فيس، تؤدي واجهة المستخدم ووحدات المعالجة المركزية ذات الأداء المنخفض إلى استجابة أبطأ، لكنها تواصل العمل بفعالية.
-
-تم تنفيذ MobileSAM في عدة مشاريع بما في ذلك [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything) و [AnyLabeling](https://github.com/vietanhdev/anylabeling) و [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D).
-
-تم تدريب MobileSAM على وحدة المعالجة الرسومية (GPU) الواحدة باستخدام مجموعة بيانات تحتوي على 100000 صورة (1% من الصور الأصلية) في أقل من يوم واحد. سيتم توفير الشفرة المصدرية لعملية التدريب هذه في المستقبل.
-
-## النماذج المتاحة، المهام المدعومة، وأوضاع التشغيل
-
-يُعرض في هذا الجدول النماذج المتاحة مع وزنها المدرب مسبقًا، والمهام التي تدعمها، وتوافقها مع أوضاع التشغيل المختلفة مثل [الاستدلال](../modes/predict.md)، [التحقق](../modes/val.md)، [التدريب](../modes/train.md)، و [التصدير](../modes/export.md)، حيث يُشير إيموجي ✅ للأوضاع المدعومة وإيموجي ❌ للأوضاع غير المدعومة.
-
-| نوع النموذج | الأوزان المدربة مسبقًا | المهام المدعومة | الاستدلال | التحقق | التدريب | التصدير |
-|-------------|------------------------|--------------------------------------|-----------|--------|---------|---------|
-| MobileSAM | `mobile_sam.pt` | [تجزئة العناصر](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-
-## التحويل من SAM إلى MobileSAM
-
-نظرًا لأن MobileSAM يحتفظ بنفس سير العمل لـ SAM الأصلي، قمنا بدمج التجهيزات المسبقة والتجهيزات اللاحقة للنموذج الأصلي وجميع الواجهات الأخرى. نتيجة لذلك، يمكن لأولئك الذين يستخدمون حاليًا SAM الأصلي الانتقال إلى MobileSAM بقدر أدنى من الجهد.
-
-يؤدي MobileSAM بشكل مقارب لـ SAM الأصلي ويحتفظ بنفس سير العمل باستثناء تغيير في مُشفر الصورة. على وحدة المعالجة الرسومية (GPU) الواحدة، يعمل MobileSAM بمعدل 12 مللي ثانية لكل صورة: 8 مللي ثانية لمُشفر الصورة و4 مللي ثانية لفك تشفير القناع.
-
-يوفر الجدول التالي مقارنة بين مُشفرات الصور القائمة على ViT:
-
-| مُشفّر الصورة | SAM الأصلي | MobileSAM |
-|---------------|----------------|--------------|
-| العوامل | 611 مليون | 5 مليون |
-| السرعة | 452 مللي ثانية | 8 مللي ثانية |
-
-يستخدم SَM الأصلي و MobileSAM نفس فك تشفير القناع الذي يعتمد على التوجيه بواسطة الرموز:
-
-| فك تشفير القناع | SAM الأصلي | MobileSAM |
-|-----------------|--------------|--------------|
-| العوامل | 3.876 مليون | 3.876 مليون |
-| السرعة | 4 مللي ثانية | 4 مللي ثانية |
-
-فيما يلي مقارنة لكامل سير العمل:
-
-| السير الكامل (التشفير+الفك) | SAM الأصلي | MobileSAM |
-|-----------------------------|----------------|---------------|
-| العوامل | 615 مليون | 9.66 مليون |
-| السرعة | 456 مللي ثانية | 12 مللي ثانية |
-
-يتم عرض أداء MobileSAM و SAM الأصلي باستخدام كل من النقطة ومربع كلمة المحفز.
-
-![صورة بالنقطة ككلمة محفز](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-![صورة بالمربع ككلمة محفز](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-بفضل أدائه المتفوق، يكون MobileSAM أصغر بحوالي 5 أضعاف وأسرع بحوالي 7 أضعاف من FastSAM الحالي. يتوفر مزيد من التفاصيل على [صفحة مشروع MobileSAM](https://github.com/ChaoningZhang/MobileSAM).
-
-## اختبار MobileSAM في Ultralytics
-
-مثل SAM الأصلي، نقدم طريقة اختبار مبسّطة في Ultralytics، بما في ذلك وضعي النقطة والصندوق.
-
-### تنزيل النموذج
-
-يمكنك تنزيل النموذج [هنا](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt).
-
-### النقطة ككلمة محفز
-
-!!! Example "مثال"
-
- === "Python"
- ```python
- from ultralytics import SAM
-
- # تحميل النموذج
- model = SAM('mobile_sam.pt')
-
- # توقع جزء بناءً على نقطة محفز
- model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
- ```
-
-### الصندوق ككلمة محفز
-
-!!! Example "مثال"
-
- === "Python"
- ```python
- from ultralytics import SAM
-
- # تحميل النموذج
- model = SAM('mobile_sam.pt')
-
- # توقع جزء بناءً على صندوق محفز
- model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
- ```
-
-لقد قمنا بتنفيذ "MobileSAM" و "SAM" باستخدام نفس API. لمزيد من معلومات الاستخدام، يُرجى الاطّلاع على [صفحة SAM](sam.md).
-
-## الاقتباس والشكر
-
-إذا وجدت MobileSAM مفيدًا في أبحاثك أو عملك التطويري، يُرجى النظر في استشهاد ورقتنا:
-
-!!! 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/docs/ar/models/rtdetr.md b/docs/ar/models/rtdetr.md
deleted file mode 100644
index f60d049839e..00000000000
--- a/docs/ar/models/rtdetr.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-comments: true
-description: اكتشف ميزات وفوائد RT-DETR من Baidu، وهو كاشف كائنات فعال وقابل للتكيف في الوقت الفعلي يعتمد على Vision Transformers، بما في ذلك النماذج المدربة مسبقًا.
-keywords: RT-DETR, Baidu, Vision Transformers, كشف كائنات, أداء فوري, CUDA, TensorRT, اختيار الاستعلام المرتبط بـ IoU, Ultralytics, واجهة برمجة التطبيقات الخاصة بلغة Python, PaddlePaddle
----
-
-# RT-DETR من Baidu: اكتشاف كائنات في الوقت الفعلي يعتمد على Vision Transformer
-
-## النظرة العامة
-
-Real-Time Detection Transformer (RT-DETR)، المطور من قبل Baidu، هو كاشف حديث الطراز يوفر أداءً فعليًا في الوقت الفعلي مع الحفاظ على دقة عالية. يستفيد من قوة Vision Transformers (ViT) في معالجة الميزات متعددة المقياس عن طريق فصل التفاعلات داخل المقياس ودمج التفاعلات بين المقاييس المختلفة. يتكيف RT-DETR بشكل كبير ويدعم ضبط سرعة الاستعلام باستخدام طبقات مختلفة في المفكرة بدون إعادة التدريب. يتفوق هذا النموذج على العديد من كاشفات الكائنات في الوقت الفعلي الأخرى، ويستفيد من المنصات القوية مثل CUDA مع TensorRT.
-
-![نموذج مثال](https://user-images.githubusercontent.com/26833433/238963168-90e8483f-90aa-4eb6-a5e1-0d408b23dd33.png)
-**نظرة عامة على RT-DETR من Baidu.** يعرض مخطط معمارية نموذج RT-DETR مراحل الظهر الثلاث الأخيرة {S3، S4، S5} كإدخال للمشفر. يحول المشفر الهجين الفعال الميزات متعددة المقياس إلى تسلسل من ميزات الصورة من خلال تفاعل الميزات داخل المقياس (AIFI) ووحدة دمج الميزات بين المقاييس المختلفة (CCFM). يتم استخدام اختيار الاستعلام المرتبط بـ IoU لاختيار عدد ثابت من ميزات الصورة لتكون استعلامات الكائن الأولية لفك الترميز. أخيرًا، يحسن فك الترميز مع رؤوس التنبؤ الإضافية الاستعلامات الكائنية لتوليد المربعات وتقييمات الثقة ([المصدر](https://arxiv.org/pdf/2304.08069.pdf)).
-
-### الميزات الرئيسية
-
-- **مشفر هجين فعال:** يستخدم RT-DETR من Baidu مشفر هجين فعال يعمل على معالجة الميزات متعددة المقياس من خلال فصل التفاعلات داخل المقياس ودمج التفاعلات بين المقاييس المختلفة. يقلل هذا التصميم الفريد القائم على Vision Transformers من تكاليف الحسابات ويتيح الكشف عن الكائنات في الوقت الفعلي.
-- **اختيار الاستعلام المرتبط بـ IoU:** يعمل RT-DETR من Baidu على تحسين بدء استعلام الكائنات من خلال استخدام اختيار الاستعلام المرتبط بـ IoU. يتيح هذا للنموذج التركيز على الكائنات الأكثر صلة في السيناريو، مما يعزز دقة الكشف.
-- **سرعة الاستنتاج قابلة للتكيف:** يدعم RT-DETR من Baidu ضبط سرعة الاستنتاج بشكل مرن باستخدام طبقات مختلفة في المفكرة دون الحاجة لإعادة التدريب. يسهل هذا التكيف التطبيق العملي في العديد من سيناريوهات كشف الكائنات في الوقت الفعلي.
-
-## النماذج المدربة مسبقًا
-
-تقدم واجهة برمجة التطبيقات الخاصة بلغة Python في Ultralytics نماذج PaddlePaddle RT-DETR مدربة مسبقًا بمقاييس مختلفة:
-
-- RT-DETR-L: 53.0% AP على COCO val2017، 114 FPS على GPU T4
-- RT-DETR-X: 54.8% AP على COCO val2017، 74 FPS على GPU T4
-
-## أمثلة الاستخدام
-
-يوفر هذا المثال أمثلة بسيطة لتدريب واختبار RT-DETRR. للحصول على وثائق كاملة حول هذه الأمثلة وأوضاع أخرى [انقر هنا](../modes/index.md) للاطلاع على صفحات الوثائق [التنبؤ](../modes/predict.md)، [التدريب](../modes/train.md)، [التصحيح](../modes/val.md) و [التصدير](../modes/export.md).
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import RTDETR
-
- # تحميل نموذج RT-DETR-l محمي بواسطة COCO مسبقًا
- model = RTDETR('rtdetr-l.pt')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # تدريب النموذج على مجموعة بيانات المثال COCO8 لـ 100 دورة
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # تشغيل الاستدلال باستخدام النموذج RT-DETR-l على صورة 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- ```bash
- # تحميل نموذج RT-DETR-l محمي بواسطة COCO مسبقًا وتدريبه على مجموعة بيانات المثال COCO8 لـ 100 دورة
- yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
-
- # تحميل نموذج RT-DETR-l محمي بواسطة COCO مسبقًا وتشغيل الاستدلال على صورة 'bus.jpg'
- yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
- ```
-
-## المهام والأوضاع المدعومة
-
-يقدم هذا الجدول أنواع النماذج والأوزان المدربة مسبقًا المحددة والمهام المدعومة بواسطة كل نموذج، والأوضاع المختلفة ([التدريب](../modes/train.md)، [التصحيح](../modes/val.md)، [التنبؤ](../modes/predict.md)، [التصدير](../modes/export.md)) التي يتم دعمها، ممثلة برموز الـ ✅.
-
-| نوع النموذج | الأوزان المدربة مسبقًا | المهام المدعومة | استنتاج | تحقق صحة | تدريب | استيراد |
-|-----------------------|------------------------|----------------------------------|---------|----------|-------|---------|
-| RT-DETR الكبير | `rtdetr-l.pt` | [كشف كائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| RT-DETR الكبير الزائد | `rtdetr-x.pt` | [كشف كائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-## الاستشهادات والتقديرات
-
-إذا استخدمت RT-DETR من Baidu في أعمال البحث أو التطوير الخاصة بك، يرجى الاستشهاد بـ [الورقة الأصلية](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}
- }
- ```
-
-نحن نود أن نعرب عن امتناننا لـ Baidu وفريق [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) لإنشاء وصيانة هذ المورد القيم لمجتمع الرؤية الحاسوبية. نقدر تفاعلهم مع المجال من خلال تطوير كاشف الكائنات الحقيقي في الوقت الفعلي القائم على Vision Transformers، RT-DETR.
-
-*keywords: RT-DETR، الناقل، Vision Transformers، Baidu RT-DETR، PaddlePaddle، Paddle Paddle RT-DETR، كشف كائنات في الوقت الفعلي، كشف كائنات قائم على Vision Transformers، نماذج PaddlePaddle RT-DETR مدربة مسبقًا، استخدام Baidu's RT-DETR، واجهة برمجة التطبيقات الخاصة بلغة Python في Ultralytics*
diff --git a/docs/ar/models/sam.md b/docs/ar/models/sam.md
deleted file mode 100644
index b47d5ec6b5f..00000000000
--- a/docs/ar/models/sam.md
+++ /dev/null
@@ -1,225 +0,0 @@
----
-comments: true
-description: استكشف النموذج القاطع للشيء أيا كان (SAM) الحديث من Ultralytics الذي يتيح الت segment تشفير صور الوقت الحقيقي. تعرف على مرونته في مجال الت segment، وأداء نقل انيفورم زيرو شوت، وكيفية استخدامه.
-keywords: Ultralytics, قسيمة الصور, Segment Anything Model, SAM, سلسلة بيانات SA-1B, مرونة الصور في الوقت الحقيقي, نقل الانيفورم زيرو شوت, الكشف عن الكائنات, تحليل الصور, التعلم الآلي
----
-
-# نموذج القطعة شيء ما (SAM)
-
-مرحبًا بك في الجبهة الأولى لقطع الصور مع نموذج القطعة شيء ما ، أو SAM. هذا النموذج الثوري قد غير اللعبة من خلال إدخال التشفير القراءة للصور مع أداء في الوقت الحقيقي، وتحديد معايير جديدة في هذا المجال.
-
-## مقدمة إلى SAM: القطعة شيء ما نموذج
-
-نموذج القطعة شيء ما ، أو SAM، هو نموذج شفاف اول في فصل الصور الرقمية التي تتيح قدرة شهير على التشفير، توفر مرونة فريدة من نوعها في مهام التحليل اللازمة للصور. نموذج SAM هو أساس مشروع 'أي شيء في شيء' الابتكاري و هو مشروع يقدم نموذجا جديدا ، مهمة وسلسلة بيانات مبتكرة للفصل البصري.
-
-يتيح تصميم SAM المتقدم له التكيف مع توزيعات صور جديدة ومهام جديدة دون الحاجة إلى معرفة مسبقة، وهذه الميزة تعرف بالكفاءة المطلوبة. حيث يتم تدريبه على سلسلة البيانات الواسعة [سلسلة SA-1B](https://ai.facebook.com/datasets/segment-anything/)، التي تحتوي على أكثر من ملياري قناع معروض على 11 مليون صورة تمت المحافظة عليها بعناية، وقد عرض SAM أداء مثير للإعجاب مع نقل انيفورم زيرو شوت فاق النتائج المراقبة السابقة بالتدريب الكامل في العديد من الحالات.
-
-![صورة مثالية لسلسة البيانات](https://user-images.githubusercontent.com/26833433/238056229-0e8ffbeb-f81a-477e-a490-aff3d82fd8ce.jpg)
-صور مثالية مع قناع محاط بها من سلسلة البيانات التي قدمناها حديثًا ، SA-1B. يحتوي سلسلة SA-1B على 11 مليون صورة متنوعة ، عالية الدقة ، مرخصة وتحمي الخصوصية و 1.1 مليار قناع فصل جودة عالية. تم توجيه هذه القناع تمامًا بتقويم آلي من قبل SAM وتم التحقق من جودتها وتنوعها من خلال تصنيفات بشرية وتجارب عديدة. يتم تجميع الصور حسب عدد الأقنعة في كل صورة للتصوير (هناك حوالي 100 قناع في الصورة في المتوسط).
-
-## السمات الرئيسية لنموذج القطعة شيء ما (SAM)
-
-- **مهمة التشفير القضائية:** تم تصميم SAM بهدف مهمة التشفير القابلة للتشفير ، مما يتيح له إنشاء قناع تشفير صالح من أي تلميح معين ، مثل الدلائل المكانية أو النصية التي تحدد الكائن.
-- **بنية متقدمة:** يستخدم نموذج القطعة شيء ما مُشفر صورة قوي ، مشفر تشفير ومُشفر بسهولة الويغورة. تمكن هذه البنية الفريدة من فتح المجال للتشفير المرن ، وحساب القناع في الوقت الحقيقي ، والاستعداد للغموض في مهام التشفير.
-- **سلسلة البيانات SA-1B:** التي قدمها مشروع أي شيء في شيء، تعرض سلسلة البيانات SA-1B أكثر من ملياري قناع على 11 مليون صورة. كأكبر سلسلة بيانات للفصل حتى الآن، توفر نموذج SAM مصدر تدريب ضخم ومتنوع.
-- **أداء نقل الانيفورم زيرو شوت:** يعرض نموذج SAM أداء رائع في نقل الانيفورم زيرو شوت في مهام القطع المختلفة، مما يجعله أداة قوية جاهزة للاستخدام في تطبيقات متنوعة مع حاجة قليلة جدًا لهندسة التشفير الخاصة.
-
-للحصول على نظرة شاملة على نموذج القطعة شيء ما وسلسلة SA-1B، يرجى زيارة [موقع أي شيء في شيء](https://segment-anything.com) واطلع على بحث [أي شيء في شيء](https://arxiv.org/abs/2304.02643).
-
-## النماذج المتاحة والمهام المدعومة ووضعيات العمل
-
-تقدم هذه الجدول النماذج المتاحة مع أوزان محددة مسبقًا والمهام التي يدعمونها وتوافقهم مع وضعيات العمل المختلفة مثل [قراءة الصورة](../modes/predict.md)، [التحقق](../modes/val.md)، [التدريب](../modes/train.md)، و [التصدير](../modes/export.md) ، مما يشير إلى ✅ رموز الدعم و ❌ للوضعيات غير المدعومة.
-
-| نوع النموذج | الأوزان المدربة مسبقًا | المهام المدعومة | قراءة الصورة | التحقق | التدريب | التصدير |
-|-------------|------------------------|------------------------------------|--------------|--------|---------|---------|
-| SAM الأساسي | `sam_b.pt` | [تجزئة النسخ](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-| SAM الكبير | `sam_l.pt` | [تجزئة النسخ](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-
-## كيفية استخدام SAM: مرونة وقوة في تجزئة الصورة
-
-يمكن استخدام نموذج القطعة شيء من أجل العديد من المهام التابعة إلى تدريبه. يشمل ذلك الكشف عن الحافة، إنشاء ترشيح للكائنات، تجزئة نسخة وتوقع نص مبدئي للتشفير. مع التشفير المهني ، يمكن لـ SAM التكيف بسرعة مع المهمات وتوزيعات البيانات الجديدة بطريقة transfer zero-shot، وبالتالي يعتبر أداة متعددة الاستخدامات وفعالة لجميع احتياجات تجزئة الصورة.
-
-### مثال لدمج SAM
-
-!!! Example "القسم بالاشارات"
-
- تقسيم الصورة مع الإشارات المعطاة.
-
- === "البايثون"
-
- ```python
- from ultralytics import SAM
-
- # تحميل النموذج
- model = SAM('sam_b.pt')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # تشغيل التنبوء بواسطة الدلائل
- model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
-
- # تشغيل التنبوء بواسطة نقاط الإشارة
- model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
- ```
-
-!!! Example "قطع كل الشيء"
-
- قم بتجزئة الصورة بأكملها.
-
- === "البايثون"
-
- ```python
- from ultralytics import SAM
-
- # تحميل النموذج
- model = SAM('sam_b.pt')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # تشغيل التنبوء
- model('مسار/إلى/صورة.jpg')
- ```
-
- === "صفيحة"
-
- ```البايش
- # تشغيل التنبوء بنموذج SAM
- yolo predict model=sam_b.pt source=path/to/image.jpg
- ```
-
-- المنطق هنا هو تجزئة الصورة كلها إذا لم تمر عبر أي إشارات (bboxes/ points / masks).
-
-!!! Example "مثال على SAMPredictor"
-
- بواسطة هذا الطريق ، يمكنك تعيين الصورة مرة واحدة وتشغيل الإشارات مرارًا وتكرارًا دون تشغيل مشفر الصورة مرة أخرى.
-
- === "التنبؤ بالإشارة"
-
- ```البايثون
- from ultralytics.models.sam import Predictor as SAMPredictor
-
- # إنشاء SAMPredictor
- الأعلى = dict (الثقة = 0.25، task ='segment'، النمط = 'تنبؤ'، imgsz = 1024، نموذج = "mobile_sam.pt")
- predictor = SAMPredictor (overrides = التجاوز الأعلى)
-
- # تعيين الصورة
- predictor.set_image("ultralytics/assets/zidane.jpg") # تعيين بواسطة ملف صورة
- predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # تعيين مع np.ndarray
- results = predictor(bboxes=[439, 437, 524, 709])
- results = predictor(points=[900, 370], labels=[1])
-
- # إعادة تعيين الصورة
- predictor.reset_image()
- ```
-
- قطع كل شيء مع وجود معطيات اختيارية.
-
- === "تقطيع كل شيء"
-
- ```البايثون
- from ultralytics.models.sam import Predictor as SAMPredictor
-
- # إنشاء SAMPredictor
- الأعلى = dict (الثقة = 0.25، task ='segment'، النمط = 'تنبؤ'، imgsz = 1024، نموذج = "mobile_sam.pt")
- predictor = SAMPredictor (overrides = التجاوز الأعلى)
-
- # تجزئة مع بيانات إضافية
- results = predictor(source="ultralytics/assets/zidane.jpg"، crop_n_layers=1، points_stride=64)
- ```
-
-- المزيد args إضافي للتقطيع كل شيء شاهد التوثيق مرجع [`السلبي/تقديم` مرجع](../../../reference/models/sam/predict.md).
-
-## مقارنة SAM مقابل YOLOv8
-
-في هذا المكان نقارن نموذج SAM الأصغر سام، SAM-b ، مع نموذج التجزئة YOLOv8 الصغيرة Ultralytics، [YOLOv8n-seg](../tasks/segment.md):
-
-| النموذج | الحجم | المعلمات | السرعة (المعالج) |
-|----------------------------------------------|----------------------------|-----------------------|--------------------------|
-| سام SAM-b | 358 م.بايت | 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 حافظة | 23.7 MB | 11.8 M | 115 ms/im |
-| [YOLOv8n-seg](../tasks/segment.md) ل Ultraly | **6.7 MB** (53.4 مرة أصغر) | **3.4 M** (27.9x أقل) | **59 ms/im** (866x أسرع) |
-
-هذه المقارنة تظهر الاختلافات في أمر المقدار والسرعة بين النماذج. في حين يقدم SAM قدرات فريدة للتجزئة التلقائية ، إلا أنه ليس منافسًا مباشرًا لنماذج التجزئة YOLOv8 ، حيث تكون أصغر وأسرع وأكثر كفاءة.
-
-اكتنزات التجريب على ماكينة Apple M2 Macbook 2023 مع 16GB من الذاكرة. لإعادة إنتاج هذا الاختبار:
-
-!!! Example "مثال"
-
- === "البايثون"
- ```البايثون
- from ultralytics import FastSAM, SAM, YOLO
-
- # تحليل يام-b
- model = SAM('sam_b.pt')
- model.info()
- model('ultralytics/assets')
-
- # تحليل MobileSAM
- model = SAM('mobile_sam.pt')
- model.info()
- model('ultralytics/assets')
-
- # تحليل FastSAM-s
- model = FastSAM('FastSAM-s.pt')
- model.info()
- model('ultralytics/assets')
-
- # تحليل YOLOv8n-seg
- model = YOLO('yolov8n-seg.pt')
- model.info()
- model('ultralytics/assets')
- ```
-
-## تعلم تلقائي: مسار سريع إلى سلاسل البيانات الخاصة بالتجزئة
-
-التعلم التلقائي هو ميزة رئيسية لـ SAM، حيث يسمح للمستخدمين بإنشاء [سلاسل بيانات تجزئة](https://docs.ultralytics.com/datasets/segment) باستخدام نموذج الكشف الجاهز. يتيح هذا الميزة إنشاء وتحديث سريع ودقيق لعدد كبير من الصور بدون الحاجة إلى عملية التسمية اليدوية البطيئة.
-
-### إنشاء سلاسل البيانات الخاصة بالتجزئة باستخدام نموذج الكشف
-
-للتعليم التلقائي لسلاسل البيانات الخاصة بالتجزئة باستخدام إطار العمل Ultralytics ، استخدم وظيفة 'auto_annotate' كما هو موضح أدناه:
-
-!!! Example "مثال"
-
- === "البايثون"
- ```البايثون
- from ultralytics.data.annotator import auto_annotate
-
- auto_annotate(data="مسار/إلى/صور", det_model="yolov8x.pt", sam_model='sam_b.pt')
- ```
-
-| الوسيطة | النوع | الوصف | الافتراضي |
-|------------|------------------------|---------------------------------------------------------------------------------------------------------------------------|--------------|
-| البيانات | سلسلة | المسار إلى المجلد الذي يحتوي على الصور التي سيتم الإشارة إليها. | |
-| det_model | سلسلة، اختياري | نموذج الكشف المدرب المسبق لـ YOLO. الافتراضي هو 'yolov8x.pt'. | 'yolov8x.pt' |
-| sam_model | سلسلة، اختياري | نموذج القطعة أيا شيء من Ultralytics. الافتراضي هو 'sam_b.pt'. | 'sam_b.pt' |
-| device | سلسلة، اختياري | الجهاز الذي يتم تشغيل النماذج عليه. الافتراضي هو سلسلة فارغة (وحدة المعالجة المركزية أو وحدة معالجة الرسومات إذا توافرت). | |
-| output_dir | سلسلة، لا شيء، اختياري | الدليل لحفظ النتائج المرئية. الافتراضي هو مجلد 'التسميات' في نفس دليل 'البيانات'. | لا شيء |
-
-يأخذ تابع 'auto_annotate' المسار إلى الصور الخاصة بك مع وسيطات اختيارية لتحديد نموذج الكشف المدرب مسبقًا ونموذج التجزئة SAM والجهاز الذي سيتم تشغيل النماذج به والدليل الخروج لحفظ النتائج المرئية.
-
-تعلم تلقائيًا باستخدام نماذج مدربة مسبقًا يمكن أن يقلل بشكل كبير من الوقت والجهد المطلوب لإنشاء سلاسل بيانات تجزئة عالية الجودة. يكون هذا الأمر مفيدًا خصوصًا للباحثين والمطورين الذين يتعاملون مع مجموعات صور كبيرة ، حيث يتيح لهم التركيز على تطوير النماذج وتقييمها بدلاً من التسمية اليدوية البطيئة.
-
-## الاقتباسات والتقديرات
-
-إذا وجدت SAM مفيدًا في البحث أو العمل التطويري الخاص بك ، يرجى النظر في استشهاد بحثنا:
-
-!!! Quote ""
-
- === "البيبتيكس"
- ```البيبتيكس
- @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}
- }
- ```
-
-نود أن نعبر عن امتناننا لـ Meta AI لإنشاء وصيانة هذا المورد القيم لمجتمع البصريات الحواسيبية.
-
-*أكلمات دالة: سلسلة المفعولة, نموذج القطعة شيء ما, SAM, Meta SAM, التجزئة, التشفير المميز, آلة آي, segment, Ultralytics, نماذج مدربة مسبقا, SAM الاساسي, SAM الكبير, تجزئة الكيانات, الرؤية الكمبيوترية, آي الاصطناعية, التعلم الآلي, تسمية بيانات, قناع التجزئة, نموذج الكشف, نموذج الكشف YOLO, البيبتكس, Meta AI.*
diff --git a/docs/ar/models/yolo-nas.md b/docs/ar/models/yolo-nas.md
deleted file mode 100644
index 5cffdbe120e..00000000000
--- a/docs/ar/models/yolo-nas.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-comments: true
-description: استكشف التوثيق المفصل لـ YOLO-NAS ، وهو نموذج كشف الكائنات المتطور. تعلم المزيد عن ميزاته والطرز المدربة مسبقًا واستخدامه مع واجهة برمجة Ultralytics Python وأكثر من ذلك.
-keywords: YOLO-NAS, Deci AI, كشف الكائنات, deep learning, البحث في الهندسة العصبية, واجهة برمجة Ultralytics Python, نموذج YOLO, الطرز المدربة مسبقًا, كمّية, التحسين, COCO, Objects365, Roboflow 100
----
-
-# YOLO-NAS
-
-## نظرة عامة
-
-تم تطوير YOLO-NAS بواسطة ديسي ايه اي ، وهو نموذج استشعار الكائنات الطائرة للأمام الذي يقدم تطورًا مبتكرًا. إنه منتج تكنولوجيا بحث الهندسة العصبية المتقدمة ، المصممة بعناية لمعالجة القيود التي كانت تعاني منها النماذج السابقة YOLO. مع تحسينات كبيرة في دعم التمثيل الكموني وتنازلات الدقة والتأخير ، يمثل YOLO-NAS قفزة كبيرة في كشف الكائنات.
-
-![نموذج صورة مثال](https://learnopencv.com/wp-content/uploads/2023/05/yolo-nas_COCO_map_metrics.png)
-**نظرة عامة على YOLO-NAS.** يستخدم YOLO-NAS كتلًا تفاعلية للتمثيل الكموني وتمثيل كمي للحصول على أداء مثلى. يواجه النموذج ، عند تحويله إلى الإصدار المكون من 8 بت ، انخفاضًا طفيفًا في الدقة ، وهو تحسين كبير على النماذج الأخرى. تتوج هذه التطورات بتصميم متفوق ذي قدرات استشعار للكائنات لا مثيل لها وأداء متميز.
-
-### المزايا الرئيسية
-
-- **كتلة أساسية ودية للتمثيل الكموني:** يقدم YOLO-NAS كتلة أساسية جديدة ودية للتمثيل الكموني ، مما يعالج أحد القيود الرئيسية للنماذج السابقة YOLO.
-- **تدريب متطور وتمثيل كمي:** يستخدم YOLO-NAS نظم تدريب متقدمة وتمثيلًا للكم بعد التدريب لتعزيز الأداء.
-- **تحسين AutoNAC والتدريب المسبق:** يستخدم YOLO-NAS تحسين AutoNAC ويتم تدريبه مسبقًا على مجموعات بيانات بارزة مثل COCO و Objects365 و Roboflow 100. يجعل هذا التدريب المسبق مناسبًا لمهام استشعار الكائنات الفرعية في بيئات الإنتاج.
-
-## الطرز المدربة مسبقًا
-
-استمتع بقوة كشف الكائنات من الجيل القادم مع الطرز المدربة مسبقًا لـ YOLO-NAS التي يوفرها Ultralytics. تم تصميم هذه الطرز لتقديم أداء متفوق من حيث السرعة والدقة. اختر من بين مجموعة متنوعة من الخيارات المصممة وفقًا لاحتياجاتك الخاصة:
-
-| الطراز | مؤشر التقدير المتوسط (mAP) | تأخر الوقت (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 |
-
-تم تصميم كل نسخة من النموذج لتقديم توازن بين متوسط الدقة (mAP) وتأخير الوقت ، مما يساعدك في تحسين مهام كشف الكائنات الخاصة بك من حيث الأداء والسرعة.
-
-## أمثلة الاستخدام
-
-قام Ultralytics بجعل طرز YOLO-NAS سهلة الدمج في تطبيقات Python الخاصة بك عبر حزمة `ultralytics` الخاصة بنا. توفر الحزمة واجهة برمجة التطبيقات بسيطة الاستخدام لتسهيل العملية.
-
-توضح الأمثلة التالية كيفية استخدام طرز YOLO-NAS مع حزمة `ultralytics` للكشف والتحقق:
-
-### أمثلة الكشف والتحقق
-
-في هذا المثال ، نقوم بالتحقق من صحة YOLO-NAS-s على مجموعة بيانات COCO8.
-
-!!! Example "مثال"
-
- يوفر هذا المثال رمز بسيط لعملية الكشف والتحقق لـ YOLO-NAS. لمعالجة نتائج الاستدلال ، انظر وضع [توقع](../modes/predict.md). لاستخدام YOLO-NAS مع وضعيات إضافية ، انظر [توصيف](../modes/val.md) و[تصدير](../modes/export.md). لا يدعم نظام YOLO-NAS على حزمة `ultralytics` عملية التدريب.
-
- === "Python"
-
- يمكن تمرير نماذج PyTorch المدربة مسبقًا `*.pt` إلى فئة `NAS()` لإنشاء نموذج في Python:
-
- ```python
- from ultralytics import NAS
-
- # تحميل نموذج YOLO-NAS-s المدرب مسبقًا على COCO
- model = NAS('yolo_nas_s.pt')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # التحقق من صحة النموذج على مجموعة بيانات مثال COCO8
- results = model.val(data='coco8.yaml')
-
- # تشغيل استدلال باستخدام نموذج YOLO-NAS-s على صورة 'bus.jpg'
- results = model('path/to/bus.jpg'))
- ```
-
- === "CLI"
-
- تتوفر أوامر CLI لتشغيل النماذج مباشرة:
-
- ```bash
- # تحميل نموذج YOLO-NAS-s المدرب مسبقًا على COCO والتحقق من أدائه على مجموعة بيانات مثال COCO8
- yolo val model=yolo_nas_s.pt data=coco8.yaml
-
- # تحميل نموذج YOLO-NAS-s المدرب مسبقًا على COCO والتنبؤ بالاستدلال على صورة 'bus.jpg'
- yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
- ```
-
-## المهام والأوضاع المدعومة
-
-نحن نقدم ثلاثة أنواع من نماذج YOLO-NAS: الصغير (s) ، المتوسط (m) ، والكبير (l). يتم تصميم كل نسخة لتلبية احتياجات الحوسبة والأداء المختلفة:
-
-- **YOLO-NAS-s**: محسنة للبيئات التي تكون فيها الموارد الحسابية محدودة والكفاءة هي الأهم.
-- **YOLO-NAS-m**: يقدم نهجًا متوازنًا ، مناسبًا لكشف الكائنات العامة بدقة أعلى.
-- **YOLO-NAS-l**: مصممة للسيناريوهات التي تتطلب أعلى درجة من الدقة ، حيث الموارد الحسابية أقل قيدًا.
-
-أدناه نظرة عامة مفصلة عن كل نموذج ، بما في ذلك روابط أوزانهم المدربين مسبقًا ، والمهام التي يدعمونها ، وتوافقهم مع وضعيات التشغيل المختلفة.
-
-| نوع النموذج | أوزان مدربة مسبقًا | المهام المدعومة | الاستدلال | التحقق | التدريب | التصدير |
-|-------------|-----------------------------------------------------------------------------------------------|------------------------------------|-----------|--------|---------|---------|
-| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_s.pt) | [كشف الكائنات](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_m.pt) | [كشف الكائنات](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_l.pt) | [كشف الكائنات](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-
-## الاقتباسات والشكر
-
-إذا استخدمت YOLO-NAS في أعمالك البحثية أو التطويرية ، يرجى الاستشهاد بمشروع 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},
- }
- ```
-
-نعبر عن امتناننا لفريق [SuperGradients](https://github.com/Deci-AI/super-gradients/) في Deci AI لجهودهم في إنشاء وصيانة هذة الموارد القيمة لمجتمع رؤية الحاسوب. نعتقد أن YOLO-NAS ، بتصميمه المبتكر وقدرته الاستشعار المتفوقة للكائنات ، سيصبح أداة حاسمة للمطورين والباحثين على حد سواء.
-
-*keywords: YOLO-NAS, Deci AI, كشف الكائنات, deep learning, البحث في الهندسة العصبية, واجهة برمجة Ultralytics Python, نموذج YOLO, SuperGradients, الطرز المدربة مسبقًا, كتلة أساسية ودية للتمثيل الكموني, أنظمة تدريب متطورة, تمثيل كمي بعد التدريب, تحسين AutoNAC, COCO, Objects365, Roboflow 100*
diff --git a/docs/ar/models/yolov3.md b/docs/ar/models/yolov3.md
deleted file mode 100644
index d34e91519f6..00000000000
--- a/docs/ar/models/yolov3.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-comments: true
-description: احصل على نظرة عامة حول YOLOv3 و YOLOv3-Ultralytics و YOLOv3u. تعرف على ميزاتها الرئيسية واستخدامها والمهام المدعومة للكشف عن الكائنات.
-keywords: YOLOv3، YOLOv3-Ultralytics، YOLOv3u، الكشف عن الكائنات، إجراء، التدريب، Ultralytics
----
-
-# YOLOv3 و YOLOv3-Ultralytics و YOLOv3u
-
-## النظرة العامة
-
-يقدم هذا الوثيقة نظرة عامة على ثلاث نماذج مرتبطة بكشف الكائنات ، وهي [YOLOv3](https://pjreddie.com/darknet/yolo/) و [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) و [YOLOv3u](https://github.com/ultralytics/ultralytics).
-
-1. **YOLOv3:** هذه هي الإصدار الثالث من خوارزمية You Only Look Once (YOLO) للكشف عن الكائنات. قام جوزيف ريدمون بتطويرها بالأصل ، وقد قامت YOLOv3 بتحسين سابقيها من خلال إدخال ميزات مثل التنبؤات متعددة المقياس وثلاثة أحجام مختلفة من نوى الكشف.
-
-2. **YOLOv3-Ultralytics:** هذه هي تنفيذ Ultralytics لنموذج YOLOv3. يقوم بإعادة إنتاج بنية YOLOv3 الأصلية ويقدم وظائف إضافية ، مثل دعم المزيد من النماذج المدربة مسبقًا وخيارات تخصيص أسهل.
-
-3. **YOLOv3u:** هذا هو الإصدار المُحدّث لـ YOLOv3-Ultralytics الذي يدمج رأس الكشف بدون مشتركات وبدون مستخدم الكائن الذي يستخدم في نماذج YOLOv8. يحتفظ YOLOv3u بنفس بنية العمود الفقري والعنق مثل YOLOv3 ولكن برأس الكشف المُحدث من YOLOv8.
-
-![Ultralytics YOLOv3](https://raw.githubusercontent.com/ultralytics/assets/main/yolov3/banner-yolov3.png)
-
-## الميزات الرئيسية
-
-- **YOLOv3:** قدم استخدام ثلاث مقياسات مختلفة للكشف ، باستخدام ثلاثة أحجام مختلفة من نوى الكشف: 13x13 ، 26x26 و 52x52. هذا يحسن بشكل كبير دقة الكشف للكائنات ذات الأحجام المختلفة. بالإضافة إلى ذلك ، أضاف YOLOv3 ميزات مثل التنبؤات متعددة العلامات لكل مربع محاذاة وشبكة استخراج سمات أفضل.
-
-- **YOLOv3-Ultralytics:** توفر تنفيذ Ultralytics لـ YOLOv3 نفس الأداء مثل النموذج الأصلي ولكنه يأتي مع دعم إضافي للمزيد من النماذج المدربة مسبقًا وطرق تدريب إضافية وخيارات أسهل للتخصيص. هذا يجعلها أكثر مرونة وسهولة استخداماً للتطبيقات العملية.
-
-- **YOLOv3u:** يدمج هذا النموذج المُحدّث رأس الكشف بدون مشتركات وبدون مستخدم الكائن من YOLOv8. من خلال إزالة الحاجة إلى صناديق المرجع المحددة مسبقًا ودرجات تكون الكائن ، يمكن أن يحسن تصميم رأس الكشف هذا قدرة النموذج على كشف الكائنات ذات الأحجام والأشكال المتنوعة. هذا يجعل YOLOv3u أكثر مرونة ودقة لمهام كشف الكائنات.
-
-## المهام المدعومة والأوضاع
-
-تم تصميم سلسلة YOLOv3 ، بما في ذلك YOLOv3 و YOLOv3-Ultralytics و YOLOv3u ، خصيصًا لمهام الكشف عن الكائنات. يشتهر هذه النماذج بفعاليتها في سيناريوهات العالم الحقيقي المختلفة ، مع توازن دقة الكشف والسرعة. يوفر كل طراز ميزات وتحسينات فريدة ، مما يجعلها مناسبة لمجموعة متنوعة من التطبيقات.
-
-يدعم النماذج الثلاثة وضعًا شاملاً من الأوضاع ، مما يضمن مرونة في مراحل مختلفة من نموذج النشر والتطوير. هذه الأوضاع تشمل [التمييز](../modes/predict.md) ، [التحقق](../modes/val.md) ، [التدريب](../modes/train.md) و [التصدير](../modes/export.md) ، مما يوفر للمستخدمين مجموعة كاملة من أدوات فعالة للكشف عن الكائنات.
-
-| نوع النموذج | المهام المدعومة | التمييز | التحقق | التدريب | التصدير |
-|--------------------|------------------------------------|---------|--------|---------|---------|
-| YOLOv3 | [كشف الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv3-Ultralytics | [كشف الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv3u | [كشف الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-توفر هذه الجدولة نظرة فورية على إمكانات كل نسخة من YOLOv3 ، مما يسلط الضوء على مرونتها وملاءمتها لمختلف المهام وأوضاع العمل العملية في سير العمل لكشف الكائنات.
-
-## أمثلة الاستخدام
-
-يقدم هذا المثال أمثلة بسيطة للتدريب والتنبؤ باستخدام YOLOv3. للحصول على وثائق كاملة حول هذه وغيرها من [الأوضاع](../modes/index.md) انظر صفحات الوثائق: [التنبؤ](../modes/predict.md) ، (../modes/train.md) [Val](../modes/val.md) و [التصدير](../modes/export.md) docs.
-
-!!! Example "مثال"
-
- === "بيثون"
-
- يمكن تمرير نماذج PyTorch المدربة مسبقًا `*.pt` وملفات التكوين `*.yaml` إلى فئة `YOLO()` لإنشاء نموذج في Python:
-
- ```python
- من ultralytics استيراد YOLO
-
- # تحميل نموذج YOLOv3n المدرب مسبقًا على COCO
- model = YOLO('yolov3n.pt')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # تدريب النموذج على مجموعة البيانات المثالية Coco8 لمدة 100 دورة تدريب
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # قم بتشغيل التنبؤ باستخدام نموذج YOLOv3n على صورة 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- تتوفر أوامر CLI لتشغيل النماذج مباشرة:
-
- ```bash
- # تحميل نموذج YOLOv3n المدرب مسبقًا على COCO وقم بتدريبه على مجموعة البيانات المثالية Coco8 لمدة 100 دورة تدريب
- yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # تحميل نموذج YOLOv3n المدرب مسبقًا على COCO وتشغيل التنبؤ على صورة 'bus.jpg'
- yolo predict model=yolov3n.pt source=path/to/bus.jpg
- ```
-
-## الاقتباسات والشكر
-
-إذا قمت باستخدام YOLOv3 في بحثك ، فيرجى الاقتباس لأوراق YOLO الأصلية ومستودع Ultralytics YOLOv3:
-
-!!! Quote ""
-
- === "بيب تيكس"
-
- ```bibtex
- @article{redmon2018yolov3,
- title={YOLOv3: An Incremental Improvement},
- author={Redmon, Joseph and Farhadi, Ali},
- journal={arXiv preprint arXiv:1804.02767},
- year={2018}
- }
- ```
-
-شكراً لجوزيف ريدمون وعلي فرهادي على تطوير YOLOv3 الأصلي.
diff --git a/docs/ar/models/yolov4.md b/docs/ar/models/yolov4.md
deleted file mode 100644
index 1cf50689fb4..00000000000
--- a/docs/ar/models/yolov4.md
+++ /dev/null
@@ -1,72 +0,0 @@
----
-comments: true
-description: استكشف دليلنا التفصيلي على YOLOv4 ، وهو جهاز كشف الكائنات الحديثة في الوقت الحقيقي. فهم أبرز معالم التصميم المعماري الخاصة به ، والميزات المبتكرة ، وأمثلة التطبيق.
-keywords: ultralytics ، yolo v4 ، كشف الكائنات ، شبكة عصبية ، كشف في الوقت الحقيقي ، كاشف الكائنات ، تعلم الآلة
-
----
-
-# YOLOv4: الكشف العالي السرعة والدقة للكائنات
-
-أهلاً بك في صفحة وثائق Ultralytics لـ YOLOv4 ، جهاز كشف الكائنات الحديث في الوقت الحقيقي الذي تم إطلاقه في عام 2020 من قبل Alexey Bochkovskiy على [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). تم تصميم YOLOv4 لتوفير التوازن المثالي بين السرعة والدقة ، مما يجعله خيارًا ممتازًا للعديد من التطبيقات.
-
-![رسم توضيحي لهندسة YOLOv4](https://user-images.githubusercontent.com/26833433/246185689-530b7fe8-737b-4bb0-b5dd-de10ef5aface.png)
-**رسم توضيحي لهندسة YOLOv4**. يعرض التصميم المعماري المعقد لشبكة YOLOv4 ، بما في ذلك المكونات الرئيسية والرقبة والرأس ، والطبقات المترابطة للكشف الفعال في الوقت الحقيقي.
-
-## مقدمة
-
-تعني YOLOv4 "فقط تنظر مرة واحدة النسخة 4". هو نموذج كشف الكائنات الحقيقي الزمني الذي تم تطويره لمعالجة قيود الإصدارات السابقة لـ YOLO مثل [YOLOv3](yolov3.md) ونماذج كشف الكائنات الأخرى. على عكس كاشفات الكائنات الأخرى القائمة على الشبكات العصبية المتزاحمة المستخدمة للكشف عن الكائنات ، يمكن تطبيق YOLOv4 لأنظمة الوصية النصحية وكذلك لإدارة العملية المستقلة وتقليل الإدخالات البشرية. يتيح تشغيله على وحدات معالجة الرسومات القياسية (GPUs) الاستخدام الشامل بتكلفة معقولة ، وتم تصميمه للعمل في الوقت الفعلي على وحدة معالجة الرسومات التقليدية مع الحاجة إلى وحدة واحدة فقط من هذا النوع للتدريب.
-
-## الهندسة
-
-تستغل YOLOv4 العديد من الميزات المبتكرة التي تعمل معًا لتحسين أدائها. تشمل هذه الميزات الاتصالات المتبقية المرجحة (WRC) ، والاتصالات الجزئية عبر المرحلة المتقاطعة (CSP) ، والتطبيع المتقاطع المصغر لدُفع (CmBN) ، والتدريب المتنازع لنفسه (SAT) ، وتنشيط Mish ، وزيادة بيانات الزخم ، وتنظيم DropBlock ، وخسارة CIoU. يتم دمج هذه الميزات لتحقيق أحدث النتائج.
-
-يتألف كاشف الكائنات النموذجي من عدة أجزاء بما في ذلك المدخل والظهر والرقبة والرأس. يتم تدريب الظهرية لـ YOLOv4 سلفًا على ImageNet ويستخدم لتوقع فئات ومربعات محيطة للكائنات. يمكن أن يكون الظهرية من عدة نماذج بما في ذلك VGG و ResNet و ResNeXt أو DenseNet. يتم استخدام جزء الرقبة من الكاشف لجمع خرائط الميزات من مراحل مختلفة وعادة ما يتضمن عدة مسارات لأسفل وعدة مسارات للأعلى. جزء الرأس هو ما يستخدم لإجراء اكتشاف الكائنات والتصنيف النهائي.
-
-## الحقيبة المجانية
-
-يستخدم YOLOv4 أيضًا طرقًا تعرف باسم "حقيبة المجانيات" وهي تقنيات تحسِّن دقة النموذج أثناء التدريب دون زيادة تكلفة الاستنتاج. تعد التعديلات في البيانات تقنية شائعة في كشف الكائنات ، والتي تزيد من تنوع صور الإدخال لتحسين قوة الموديل. بعض أمثلة التعديل في البيانات تشمل التشويهات البصرية (ضبط السطوع والتباين والدرجة والتشبع والضوضاء في الصورة) والتشويهات الهندسية (إضافة توزيع عشوائي للتغيير المقياسي والاقتصاص والانعكاس والتدوير). تساعد هذه التقنيات الموديل في التعميم على أنواع مختلفة من الصور.
-
-## الميزات والأداء
-
-تم تصميم YOLOv4 لتحقيق سرعة ودقة مثلى في كشف الكائنات. يتضمن تصميم YOLOv4 CSPDarknet53 كظهر ، PANet كرقبة ، و YOLOv3 كرأس كشف. يسمح هذا التصميم لـ YOLOv4 بأداء كشف الكائنات بسرعة مذهلة ، مما يجعله مناسبًا لتطبيقات الوقت الحقيقي. يتفوق YOLOv4 أيضًا في الدقة ، ويحقق نتائج عالية في مقاييس كشف الكائنات.
-
-## أمثلة الاستخدام
-
-في وقت كتابة هذا النص ، لا يدعم Ultralytics حاليًا نماذج YOLOv4. لذلك ، سيحتاج أي مستخدمين مهتمين باستخدام YOLOv4 إلى الرجوع مباشرة إلى مستودع YOLOv4 على GitHub للحصول على تعليمات التثبيت والاستخدام.
-
-إليك نظرة عامة موجزة على الخطوات النموذجية التي يمكن أن تتخذها لاستخدام YOLOv4:
-
-1. قم بزيارة مستودع YOLOv4 على GitHub: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
-
-2. اتبع التعليمات المقدمة في ملف README لعملية التثبيت. ينطوي هذا عادة على استنساخ المستودع ، وتثبيت التبعيات اللازمة ، وإعداد أي متغيرات بيئة ضرورية.
-
-3. بمجرد الانتهاء من التثبيت ، يمكنك تدريب واستخدام النموذج وفقًا لتعليمات الاستخدام المقدمة في المستودع. يتضمن ذلك عادة إعداد مجموعة البيانات الخاصة بك ، وتكوين معاملات النموذج ، وتدريب النموذج ، ثم استخدام النموذج المدرب لأداء اكتشاف الكائنات.
-
-يرجى ملاحظة أن الخطوات النموذجية قد تختلف اعتمادًا على حالة الاستخدام الخاصة بك وحالة مستودع YOLOv4 الحالي. لذلك ، يُنصح بشدة بالرجوع مباشرة إلى التعليمات المقدمة في مستودع YOLOv4 على GitHub.
-
-نؤسف على أي إزعاج ، وسنسعى لتحديث هذا المستند بأمثلة استخدام لـ Ultralytics بمجرد تنفيذ الدعم لـ YOLOv4.
-
-## الاستنتاج
-
-YOLOv4 هو نموذج قوي وفعال لكشف الكائنات يجمع بين السرعة والدقة. يستخدم الميزات الفريدة وتقنيات الزخم في التدريب للأداء بشكل ممتاز في مهام اكتشاف الكائنات في الوقت الفعلي. يمكن لأي شخص يمتلك وحدة معالجة رسومية تقليدية تدريب YOLOv4 واستخدامها ، مما يجعلها سهلة الوصول وعملية لمجموعة واسعة من التطبيقات.
-
-## التنويه والتقديرات
-
-نود أن نعترف بمساهمة أصحاب YOLOv4 في مجال كشف الكائنات الحقيقية الزمنية:
-
-!!! Quote ""
-
- === "بيب تكس"
-
- ```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}
- }
- ```
-
-يمكن العثور على ورقة YOLOv4 الأصلية على [arXiv](https://arxiv.org/abs/2004.10934). قام المؤلفون بتوفير عملهم بشكل عام ، ويمكن الوصول إلى قاعدة الشفرات على [GitHub](https://github.com/AlexeyAB/darknet). نقدر جهودهم في تعزيز الميدان وتوفير عملهم للمجتمع العريض.
diff --git a/docs/ar/models/yolov5.md b/docs/ar/models/yolov5.md
deleted file mode 100644
index c922faa60c6..00000000000
--- a/docs/ar/models/yolov5.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-comments: true
-description: اكتشف YOLOv5u، وهو إصدار معزز لنموذج YOLOv5 يوفر توازنًا محسنًا بين الدقة والسرعة والعديد من النماذج المدربة مسبقًا لمهام كشف الكائنات المختلفة.
-keywords: YOLOv5u، كشف الكائنات، النماذج المدربة مسبقًا، Ultralytics، التشخيص، التحقق، YOLOv5، YOLOv8، بدون قاعدة تثبيت العقدة الرئيسية، بدون قيمة الكائن، التطبيقات الفعلية، تعلم الآلة
----
-
-# YOLOv5
-
-## نظرة عامة
-
-يمثل YOLOv5u تقدمًا في منهجيات كشف الكائنات. يندرج YOLOv5u تحت البنية المعمارية الأساسية لنموذج [YOLOv5](https://github.com/ultralytics/yolov5) الذي طورته شركة Ultralytics، و يدمج نموذج YOLOv5u ميزة القسمة على جزئين للكائنات المستقلة عن القاعدة التي تم تقديمها في نماذج [YOLOv8](yolov8.md). تحسين هذا النمط يحسن نمط النموذج، مما يؤدي إلى تحسين التوازن بين الدقة والسرعة في مهام كشف الكائنات. بناءً على النتائج التجريبية والمزايا المشتقة منها، يقدم YOLOv5u بديلاً فعالًا لأولئك الذين يسعون لإيجاد حلول قوية في الأبحاث والتطبيقات العملية.
-
-![Ultralytics YOLOv5](https://raw.githubusercontent.com/ultralytics/assets/main/yolov5/v70/splash.png)
-
-## المزايا الرئيسية
-
-- **رأس Ultralytics للقسمة بدون قاعدة تثبيت العقدة:** يعتمد نماذج كشف الكائنات التقليدية على صناديق قاعدة محددة مسبقًا لتوقع مواقع الكائنات. ومع ذلك، يحدث تحديث في نهج YOLOv5u هذا. من خلال اعتماد رأس Ultralytics المُقسم بدون قاعدة تثبيت العقدة، يضمن هذا النمط آلية كشف أكثر مرونة واندفاعًا، مما يعزز الأداء في سيناريوهات متنوعة.
-
-- **توازن محسن بين الدقة والسرعة:** تتصارع السرعة والدقة في العديد من الأحيان. ولكن YOLOv5u يتحدى هذا التوازن. يقدم توازنًا معايرًا، ويضمن كشفًا في الوقت الفعلي دون المساومة على الدقة. تعد هذه الميزة ذات قيمة خاصة للتطبيقات التي تتطلب استجابة سريعة، مثل المركبات المستقلة والروبوتات وتحليل الفيديو في الوقت الفعلي.
-
-- **مجموعة متنوعة من النماذج المدربة مسبقًا:** على فهم الأمور التي تحتاج إلى مجموعات أدوات مختلفة YOLOv5u يوفر العديد من النماذج المدربة مسبقًا. سواء كنت تركز على التشخيص أو التحقق أو التدريب، هناك نموذج مصمم خصيصًا ينتظرك. يضمن هذا التنوع أنك لا تستخدم حلاً من نوع واحد يناسب الجميع، ولكن نموذج موازن حسب حاجتك الفريدة.
-
-## المهام والأوضاع المدعومة
-
-تتفوق نماذج YOLOv5u، مع مجموعة متنوعة من الأوزان المدربة مسبقًا، في مهام [كشف الكائنات](../tasks/detect.md). تدعم هذه النماذج مجموعة شاملة من الأوضاع، مما يجعلها مناسبة لتطبيقات متنوعة، من التطوير إلى التنفيذ.
-
-| نوع النموذج | الأوزان المدربة مسبقًا | المهمة | التشخيص | التحقق | التدريب | التصدير |
-|-------------|-----------------------------------------------------------------------------------------------------------------------------|------------------------------------|---------|--------|---------|---------|
-| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [كشف الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-يوفر هذا الجدول نظرة عامة مفصلة عن البدائل من نماذج نموذج YOLOv5u، ويسلط الضوء على تطبيقاتها في مهام كشف الكائنات ودعمها لأوضاع تشغيل متنوعة مثل [التشخيص](../modes/predict.md)، [التحقق](../modes/val.md)، [التدريب](../modes/train.md)، و[التصدير](../modes/export.md). يضمن هذا الدعم الشامل أن يمكن للمستخدمين استغلال قدرات نماذج YOLOv5u بشكل كامل في مجموعة واسعة من سيناريوهات كشف الكائنات.
-
-## الأداء
-
-!!! الأداء
-
- === "كشف"
-
- راجع [وثائق الكشف](https://docs.ultralytics.com/tasks/detect/) للحصول على أمثلة استخدام مع هذه النماذج المدربة على [COCO](https://docs.ultralytics.com/datasets/detect/coco/)، التي تشمل 80 فئة مدربة مسبقًا.
-
- | النموذج | يامل | حجم (بكسل) | mAPval 50-95 | سرعة معالج الجهاز ONNX (مللي ثانية) | سرعة حويصلة A100 TensorRT (مللي ثانية) | المعلمات (مليون) | FLOPs (بليون) |
- |---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
- | [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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 |
-
-## أمثلة للاستخدام
-
-يقدم هذا المثال أمثلة بسيطة للغاية للتدريب والتشخيص باستخدام YOLOv5. يُمكن إنشاء نموذج مثيل في البرمجة باستخدام نماذج PyTorch المدربة مسبقًا في صيغة `*.pt` وملفات التكوين `*.yaml`:
-
-```python
-from ultralytics import YOLO
-
-# قم بتحميل نموذج YOLOv5n المدرب مسبقًا على مجموعة بيانات COCO
-model = YOLO('yolov5n.pt')
-
-# قم بعرض معلومات النموذج (اختياري)
-model.info()
-
-# قم بتدريب النموذج على مجموعة البيانات COCO8 لمدة 100 دورة
-results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
-# قم بتشغيل التشخيص بنموذج YOLOv5n على صورة 'bus.jpg'
-results = model('path/to/bus.jpg')
-```
-
-=== "سطر الأوامر"
-
- يتاح سطر الأوامر لتشغيل النماذج مباشرة:
-
- ```bash
- # قم بتحميل نموذج YOLOv5n المدرب مسبقًا على مجموعة بيانات COCO8 وقم بتدريبه لمدة 100 دورة
- yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # قم بتحميل نموذج YOLOv5n المدرب مسبقًا على مجموعة بيانات COCO8 وتشغيل حالة التشخيص على صورة 'bus.jpg'
- yolo predict model=yolov5n.pt source=path/to/bus.jpg
- ```
-
-## الاستشهادات والتقدير
-
-إذا قمت باستخدام YOLOv5 أو YOLOv5u في بحثك، يرجى استشهاد نموذج Ultralytics YOLOv5 بطريقة الاقتباس التالية:
-
-!!! 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}
- }
- ```
-
-يرجى ملاحظة أن نماذج YOLOv5 متاحة بترخيص [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) و[Enterprise](https://ultralytics.com/license).
diff --git a/docs/ar/models/yolov6.md b/docs/ar/models/yolov6.md
deleted file mode 100644
index 12dd557216d..00000000000
--- a/docs/ar/models/yolov6.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-comments: true
-description: استكشف نموذج Meituan YOLOv6 للكشف عن الكائنات الحديثة، والذي يوفر توازنًا مذهلاً بين السرعة والدقة، مما يجعله الخيار الأمثل لتطبيقات الوقت الحقيقي. تعرّف على الميزات والنماذج المُدربة مسبقًا واستخدام Python.
-keywords: Meituan YOLOv6، الكشف عن الكائنات، Ultralytics، YOLOv6 docs، Bi-directional Concatenation، تدريب بمساعدة العناصر، النماذج المدربة مسبقا، تطبيقات الوقت الحقيقي
----
-
-# Meituan YOLOv6
-
-## نظرة عامة
-
-[Meituan](https://about.meituan.com/) YOLOv6 هو منظّف الكائنات الحديثة الحديثة الذي يُقدم توازنًا ملحوظًا بين السرعة والدقة، مما يجعله خيارًا شائعًا لتطبيقات الوقت الحقيقي. يُقدم هذا النموذج العديد من التحسينات الملحوظة في بنيته ونظام التدريب، بما في ذلك تطبيق وحدة Bi-directional Concatenation (BiC)، واستراتيجية AAT (anchor-aided training) التي تعتمد على العناصر، وتصميم محسّن للأساس والرقبة لتحقيق أداء على مجموعة بيانات COCO يفوق جميع النماذج الأخرى.
-
-![Meituan YOLOv6](https://user-images.githubusercontent.com/26833433/240750495-4da954ce-8b3b-41c4-8afd-ddb74361d3c2.png)
-![Model example image](https://user-images.githubusercontent.com/26833433/240750557-3e9ec4f0-0598-49a8-83ea-f33c91eb6d68.png)
-**نظرة عامة على YOLOv6.** مخطط بنية النموذج يوضح المكونات المعاد تصميمها واستراتيجيات التدريب التي أدت إلى تحسينات أداء كبيرة. (أ) الرقبة الخاصة بـ YOLOv6 (N و S معروضان). لاحظ أنه بالنسبة لم/n، يتم استبدال RepBlocks بـ CSPStackRep. (ب) هيكل وحدة BiC. (ج) مكون SimCSPSPPF. ([المصدر](https://arxiv.org/pdf/2301.05586.pdf)).
-
-### ميزات رئيسية
-
-- **وحدة Bi-directional Concatenation (BiC):** يقدم YOLOv6 وحدة BiC في الرقبة التابعة للكاشف، مما يعزز إشارات التحديد المحلية ويؤدي إلى زيادة الأداء دون التأثير على السرعة.
-- **استراتيجية التدريب بمساعدة العناصر (AAT):** يقدم هذا النموذج استراتيجية AAT للاستفادة من فوائد النماذج المستندة إلى العناصر وغير المستندة إليها دون التضحية في كفاءة الاستدلال.
-- **تصميم أساس ورقبة محسّن:** من خلال تعميق YOLOv6 لتشمل مرحلة أخرى في الأساس والرقبة، يحقق هذا النموذج أداءً يفوق جميع النماذج الأخرى على مجموعة بيانات COCO لإدخال عالي الدقة.
-- **استراتيجية الاستنباط الذاتي:** يتم تنفيذ استراتيجية استنتاج ذاتي جديدة لتعزيز أداء النماذج الصغيرة من YOLOv6، وذلك عن طريق تعزيز فرع الانحدار المساعد خلال التدريب وإزالته في الاستنتاج لتجنب انخفاض السرعة الواضح.
-
-## معايير الأداء
-
-يوفر YOLOv6 مجموعة متنوعة من النماذج المدرّبة مسبقًا بمقاييس مختلفة:
-
-- YOLOv6-N: ٣٧.٥٪ AP في COCO val2017 عندما يتم استخدام بطاقة NVIDIA Tesla T4 GPU وسرعة ١١٨٧ إطار في الثانية.
-- YOLOv6-S: ٤٥.٠٪ AP وسرعة ٤٨٤ إطار في الثانية.
-- YOLOv6-M: ٥٠.٠٪ AP وسرعة ٢٢٦ إطار في الثانية.
-- YOLOv6-L: ٥٢.٨٪ AP وسرعة ١١٦ إطار في الثانية.
-- YOLOv6-L6: دقة حديثة في الزمن الحقيقي.
-
-كما يوفر YOLOv6 نماذج مؤنقة (quantized models) بدقات مختلفة ونماذج محسنة للمنصات المحمولة.
-
-## أمثلة عن الاستخدام
-
-يقدم هذا المثال أمثلة بسيطة لتدريب YOLOv6 واستنتاجه. للحصول على وثائق كاملة حول هذه وأوضاع أخرى [انظر](../modes/index.md) الى الصفحات التوضيحية لتوسعة الوثائق الفائقة ، [توقع](../modes/predict.md) ، [تدريب](../modes/train.md) ، [التحقق](../modes/val.md) و [التصدير](../modes/export.md).
-
-!!! Example "مثال"
-
- === "Python"
-
- يمكن تمرير النماذج المدرّبة مسبقًا بتنسيق `*.pt` في PyTorch وملفات التكوين `*.yaml` لفئة `YOLO()` لإنشاء نموذج في Python:
-
- ```python
- from ultralytics import YOLO
-
- # إنشاء نموذج YOLOv6n من البداية
- model = YOLO('yolov6n.yaml')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # تدريب النموذج على مجموعة بيانات مثال COCO8 لمدة 100 دورة تدريب
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # تشغيل الاستنتاج بنموذج YOLOv6n على صورة 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- يمكن استخدام أوامر CLI لتشغيل النماذج مباشرةً:
-
- ```bash
- # إنشاء نموذج YOLOv6n من البداية وتدريبه باستخدام مجموعة بيانات مثال COCO8 لمدة 100 دورة تدريب
- yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
-
- # إنشاء نموذج YOLOv6n من البداية وتشغيل الاستنتاج على صورة 'bus.jpg'
- yolo predict model=yolov6n.yaml source=path/to/bus.jpg
- ```
-
-## المهام والأوضاع المدعومة
-
-تقدم سلسلة YOLOv6 مجموعة من النماذج، والتي تم تحسينها للكشف عن الكائنات عالي الأداء. تلبي هذه النماذج احتياجات الكمبيوتيشن المتنوعة ومتطلبات الدقة، مما يجعلها متعددة الاستخدامات في مجموعة واسعة من التطبيقات.
-
-| نوع النموذج | الأوزان المدربة مسبقًا | المهام المدعومة | الاستنتاج | التحقق | التدريب | التصدير |
-|-------------|------------------------|-----------------------------------------|-----------|--------|---------|---------|
-| YOLOv6-N | `yolov6-n.pt` | [الكشف عن الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-S | `yolov6-s.pt` | [الكشف عن الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-M | `yolov6-m.pt` | [الكشف عن الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-L | `yolov6-l.pt` | [الكشف عن الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-L6 | `yolov6-l6.pt` | [الكشف عن الكائنات](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-توفر هذه الجدول نظرة عامة مفصلة على النماذج المختلفة لـ YOLOv6، مع تسليط الضوء على قدراتها في مهام الكشف عن الكائنات وتوافقها مع الأوضاع التشغيلية المختلفة مثل [الاستنتاج](../modes/predict.md) و [التحقق](../modes/val.md) و [التدريب](../modes/train.md) و [التصدير](../modes/export.md). هذا الدعم الشامل يضمن أن يمكن للمستخدمين الاستفادة الكاملة من قدرات نماذج YOLOv6 في مجموعة واسعة من سيناريوهات الكشف عن الكائنات.
-
-## الاقتباسات والتقديرات
-
-نحن نود أن نقدّم الشكر للمؤلفين على مساهماتهم الهامة في مجال كشف الكائنات في الوقت الحقيقي:
-
-!!! 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}
- }
- ```
-
-يمكن العثور على الورقة الأصلية لـ YOLOv6 على [arXiv](https://arxiv.org/abs/2301.05586). نشر المؤلفون عملهم بشكل عام، ويمكن الوصول إلى الشيفرة المصدرية على [GitHub](https://github.com/meituan/YOLOv6). نحن نقدّر جهودهم في تطوير هذا المجال وجعل عملهم متاحًا للمجتمع بأسره.
diff --git a/docs/ar/models/yolov7.md b/docs/ar/models/yolov7.md
deleted file mode 100644
index 1cdcc639eaa..00000000000
--- a/docs/ar/models/yolov7.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-comments: true
-description: استكشف YOLOv7 ، جهاز كشف الكائنات في الوقت الحقيقي. تعرف على سرعته الفائقة، ودقته المذهلة، وتركيزه الفريد على تحسين الأمتعة التدريبية تدريبياً.
-keywords: YOLOv7، كاشف الكائنات في الوقت الحقيقي، الحالة الفنية، Ultralytics، مجموعة بيانات MS COCO، المعيار المعاد تعريفه للنموذج، التسمية الديناميكية، التحجيم الموسع، التحجيم المركب
----
-
-# YOLOv7: حقيبة مجانية قابلة للتدريب
-
-YOLOv7 هو كاشف الكائنات في الوقت الحقيقي الحديث الحالي الذي يتفوق على جميع كاشفات الكائنات المعروفة من حيث السرعة والدقة في النطاق من 5 إطارات في الثانية إلى 160 إطارًا في الثانية. إنه يتمتع بأعلى دقة (٥٦.٨٪ AP) بين جميع كاشفات الكائنات الحالية في الوقت الحقيقي بسرعة ٣٠ إطارًا في الثانية أو أعلى على GPU V100. علاوة على ذلك, يتفوق YOLOv7 على كاشفات الكائنات الأخرى مثل YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 والعديد من الآخرين من حيث السرعة والدقة. النموذج مدرب على مجموعة بيانات MS COCO من البداية دون استخدام أي مجموعات بيانات أخرى أو وزن مُعين مُسبقًا. رمز المصدر لـ YOLOv7 متاح على GitHub.
-
-![مقارنة YOLOv7 مع كاشفات الكائنات الأعلى الفنية](https://github.com/ultralytics/ultralytics/assets/26833433/5e1e0420-8122-4c79-b8d0-2860aa79af92)
-
-**مقارنة بين كاشفات الكائنات الأعلى الفنية.** من النتائج في الجدول 2 نتعرف على أن الطريقة المقترحة لديها أفضل توازن بين السرعة والدقة بشكل شامل. إذا قارنا بين YOLOv7-tiny-SiLU و YOLOv5-N (r6.1) ، يكون الطريقة الحالية أسرع بـ ١٢٧ إطارًا في الثانية وأكثر دقة بنسبة ١٠.٧٪ من حيث AP. بالإضافة إلى ذلك ، YOLOv7 لديها AP بنسبة ٥١.٤٪ في معدل إطار ١٦١ في الثانية ، في حين يكون لـ PPYOLOE-L نفس AP فقط بمعدل إطار ٧٨ في الثانية. من حيث استخدام العوامل ، يكون YOLOv7 أقل بنسبة ٤١٪ من العوامل مقارنةً بـ PPYOLOE-L. إذا قارنا YOLOv7-X بسرعة تواصل بيانات ١١٤ إطارًا في الثانية مع YOLOv5-L (r6.1) مع سرعة تحليل ٩٩ إطارًا في الثانية ، يمكن أن يحسن YOLOv7-X AP بمقدار ٣.٩٪. إذا قورن YOLOv7-X بــ YOLOv5-X (r6.1) بنفس الحجم ، فإن سرعة تواصل البيانات في YOLOv7-X تكون أسرع بـ ٣١ إطارًا في الثانية. بالإضافة إلى ذلك ، من حيث كمية المعاملات والحسابات ، يقلل YOLOv7-X بنسبة ٢٢٪ من المعاملات و٨٪ من الحساب مقارنةً بـ YOLOv5-X (r6.1) ، ولكنه يحسن AP بنسبة ٢.٢٪ ([المصدر](https://arxiv.org/pdf/2207.02696.pdf)).
-
-## النظرة العامة
-
-كاشف الكائنات في الوقت الحقيقي هو جزء مهم في العديد من أنظمة رؤية الحاسوب ، بما في ذلك التتبع متعدد الكائنات والقيادة التلقائية والروبوتات وتحليل صور الأعضاء. في السنوات الأخيرة ، تركز تطوير كاشفات الكائنات في الوقت الحقيقي على تصميم هياكل فعالة وتحسين سرعة التحليل لمعالجات الكمبيوتر المركزية ومعالجات الرسومات ووحدات معالجة الأعصاب (NPUs). يدعم YOLOv7 كلاً من GPU المحمول وأجهزة الـ GPU ، من الحواف إلى السحابة.
-
-على عكس كاشفات الكائنات في الوقت الحقيقي التقليدية التي تركز على تحسين الهياكل ، يُقدم YOLOv7 تركيزًا على تحسين عملية التدريب. يتضمن ذلك وحدات وطرق تحسين تُصمم لتحسين دقة كشف الكائنات دون زيادة تكلفة التحليل ، وهو مفهوم يُعرف بـ "الحقيبة القابلة للتدريب للمجانيات".
-
-## الميزات الرئيسية
-
-تُقدم YOLOv7 عدة ميزات رئيسية:
-
-1. **إعادة تعيين نموذج المعاملات**: يقترح YOLOv7 نموذج معاملات معين مخطط له ، وهو استراتيجية قابلة للتطبيق على الطبقات في شبكات مختلفة باستخدام مفهوم مسار انتشار التدرج.
-
-2. **التسمية الديناميكية**: تدريب النموذج مع عدة طبقات إخراج يبرز قضية جديدة: "كيفية تعيين أهداف ديناميكية لإخراج الفروع المختلفة؟" لحل هذه المشكلة ، يقدم YOLOv7 طريقة تسمية جديدة تسمى تسمية الهدف المرشدة من الخشن إلى الدقيقة.
-
-3. **التحجيم الموسع والمركب**: يقترح YOLOv7 طرق "التحجيم الموسع" و "التحجيم المركب" لكاشف الكائنات في الوقت الحقيقي التي يمكن أن تستخدم بشكل فعال في المعاملات والحسابات.
-
-4. **الكفاءة**: يمكن للطريقة المقترحة بواسطة YOLOv7 تقليل بشكل فعال حوالي 40٪ من المعاملات و 50٪ من الحساب لكاشف الكائنات في الوقت الحقيقي الأولى من حيث الدقة والسرعة في التحليل.
-
-## أمثلة على الاستخدام
-
-في وقت كتابة هذا النص ، لا تدعم Ultralytics حاليًا نماذج YOLOv7. لذلك ، سيحتاج أي مستخدمين مهتمين باستخدام YOLOv7 إلى الرجوع مباشرة إلى مستودع YOLOv7 على GitHub للحصول على تعليمات التثبيت والاستخدام.
-
-وفيما يلي نظرة عامة على الخطوات النموذجية التي يمكنك اتباعها لاستخدام YOLOv7:
-
-1. قم بزيارة مستودع YOLOv7 على GitHub: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
-
-2. اتبع التعليمات الموجودة في ملف README لعملية التثبيت. يتضمن ذلك عادةً استنساخ المستودع ، وتثبيت التبعيات اللازمة ، وإعداد أي متغيرات بيئة ضرورية.
-
-3. بمجرد الانتهاء من عملية التثبيت ، يمكنك تدريب النموذج واستخدامه وفقًا لتعليمات الاستخدام الموجودة في المستودع. ينطوي ذلك عادةً على إعداد مجموعة البيانات الخاصة بك ، وتكوين معلمات النموذج ، وتدريب النموذج ، ثم استخدام النموذج المدرب لأداء كشف الكائنات.
-
-يرجى ملاحظة أن الخطوات المحددة قد تختلف اعتمادًا على حالة الاستخدام الخاصة بك والحالة الحالية لمستودع YOLOv7. لذا ، يُوصى بشدة بالرجوع مباشرة إلى التعليمات المقدمة في مستودع YOLOv7 على GitHub.
-
-نأسف على أي إزعاج قد يسببه ذلك وسنسعى لتحديث هذا المستند بأمثلة على الاستخدام لـ Ultralytics عندما يتم تنفيذ الدعم لـ YOLOv7.
-
-## الاقتباسات والشكر
-
-نود أن نشكر كتاب YOLOv7 على مساهماتهم الهامة في مجال اكتشاف الكائنات في الوقت الحقيقي:
-
-!!! 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}
- }
- ```
-
-يمكن العثور على ورقة YOLOv7 الأصلية على [arXiv](https://arxiv.org/pdf/2207.02696.pdf). قدم الكتاب عملهم علنياً، ويمكن الوصول إلى قاعدة الشيفرة على [GitHub](https://github.com/WongKinYiu/yolov7). نحن نقدر جهودهم في تقدم المجال وتوفير عملهم للمجتمع بشكل عام.
diff --git a/docs/ar/models/yolov8.md b/docs/ar/models/yolov8.md
deleted file mode 100644
index 00ba0ec5395..00000000000
--- a/docs/ar/models/yolov8.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-comments: true
-description: استكشف الميزات المثيرة لـ YOLOv8 ، أحدث إصدار من مكتشف الكائنات الحية الخاص بنا في الوقت الحقيقي! تعرّف على العمارات المتقدمة والنماذج المدرّبة مسبقًا والتوازن المثلى بين الدقة والسرعة التي تجعل YOLOv8 الخيار المثالي لمهام الكشف عن الكائنات الخاصة بك.
-keywords: YOLOv8, Ultralytics, مكتشف الكائنات الحية الخاص بنا في الوقت الحقيقي, النماذج المدرّبة مسبقًا, وثائق, الكشف عن الكائنات, سلسلة YOLO, العمارات المتقدمة, الدقة, السرعة
----
-
-# YOLOv8
-
-## نظرة عامة
-
-YOLOv8 هو التطور الأخير في سلسلة YOLO لمكتشفات الكائنات الحية الخاصة بنا في الوقت الحقيقي ، والذي يقدم أداءً متقدمًا في مجال الدقة والسرعة. بناءً على التقدمات التي تم إحرازها في إصدارات YOLO السابقة ، يقدم YOLOv8 ميزات وتحسينات جديدة تجعله الخيار المثالي لمهام الكشف عن الكائنات في مجموعة واسعة من التطبيقات.
-
-![YOLOv8 المقدمة من Ultralytics](https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/yolo-comparison-plots.png)
-
-## الميزات الرئيسية
-
-- **العمارات المتقدمة للظهر والعنق:** يعتمد YOLOv8 على عمارات الظهر والعنق على أحدث طراز ، مما يؤدي إلى تحسين استخراج الميزات وأداء الكشف عن الكائنات.
-- **Ultralytics Head بدون إثبات خطافي:** يعتمد YOLOv8 على Ultralytics Head بدون إثبات خطافي ، مما يسهم في زيادة الدقة وتوفير وقت مكشف أكثر كفاءة مقارنةً بالطرق التي تعتمد على الإثبات.
-- **توازن مثالي بين الدقة والسرعة محسَّن:** بتركيزه على الحفاظ على توازن مثالي بين الدقة والسرعة ، فإن YOLOv8 مناسب لمهام الكشف عن الكائنات في الوقت الحقيقي في مجموعة متنوعة من المجالات التطبيقية.
-- **تشكيلة من النماذج المدرّبة مسبقًا:** يقدم YOLOv8 مجموعة من النماذج المدرّبة مسبقًا لتلبية متطلبات المهام المختلفة ومتطلبات الأداء ، مما يجعل من السهل إيجاد النموذج المناسب لحالتك الاستخدامية الخاصة.
-
-## المهام والأوضاع المدعومة
-
-تقدم سلسلة YOLOv8 مجموعة متنوعة من النماذج ، يتم تخصيص كلًا منها للمهام المحددة في رؤية الحاسوب. تم تصميم هذه النماذج لتلبية متطلبات مختلفة ، بدءًا من الكشف عن الكائنات إلى مهام أكثر تعقيدًا مثل تقسيم الصور إلى أجزاء واكتشاف نقاط المفاتيح والتصنيف.
-
-تمت تحسين كل نوع من سلسلة YOLOv8 للمهام التي تخصها ، مما يضمن أداء ودقة عاليين. بالإضافة إلى ذلك ، تتوافق هذه النماذج مع أوضاع تشغيل مختلفة بما في ذلك [الاستدلال](../modes/predict.md) ، [التحقق](../modes/val.md) ، [التدريب](../modes/train.md) و [التصدير](../modes/export.md) ، مما يسهل استخدامها في مراحل مختلفة من عملية التطوير والتنفيذ.
-
-| النموذج | أسماء الملف | المهمة | استدلال | التحقق | التدريب | التصدير |
-|-------------|----------------------------------------------------------------------------------------------------------------|----------------------------------------------|---------|--------|---------|---------|
-| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [الكشف](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [تقسيم الصور إلى أجزاء](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [المواقق/نقاط المفاتيح](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [التصنيف](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ |
-
-توفر هذه الجدولة نظرة عامة على متغيرات نموذج YOLOv8 ، مما يسلط الضوء على قابليتها للتطبيق في مهام محددة وتوافقها مع أوضاع تشغيل مختلفة مثل الاستدلال والتحقق والتدريب والتصدير. يعرض مرونة وقوة سلسلة YOLOv8 ، مما يجعلها مناسبة لمجموعة متنوعة من التطبيقات في رؤية الحاسوب.
-
-## مقاييس الأداء
-
-!!! الأداء
-
- === "الكشف (COCO)"
-
- انظر إلى [وثائق الكشف](https://docs.ultralytics.com/tasks/detect/) لأمثلة عن الاستخدام مع هذه النماذج المدربة مسبقًا على [COCO](https://docs.ultralytics.com/datasets/detect/coco/) ، التي تضم 80 فئة مدربة مسبقًا.
-
- | النموذج | حجم (بيكسل) | معدل الكشفالتحقق 50-95 | سرعة CPU ONNX (متوسط) | سرعة A100 TensorRT (متوسط) | معلمات (مليون) | FLOPs (مليون) |
- | ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
- | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
-
- === "الكشف (صور مفتوحة V7)"
-
- انظر إلى [وثائق الكشف](https://docs.ultralytics.com/tasks/detect/) لأمثلة عن الاستخدام مع هذه النماذج المدربة مسبقًا على [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/)، والتي تضم 600 فئة مدربة مسبقًا.
-
- | النموذج | حجم (بيكسل) | معدل الكشفالتحقق 50-95 | سرعة CPU ONNX (متوسط) | سرعة A100 TensorRT (متوسط) | معلمات (مليون) | FLOPs (مليون) |
- | ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
- | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
-
- === "تقسيم الصور إلى أجزاء (COCO)"
-
- انظر إلى [وثائق التقسيم](https://docs.ultralytics.com/tasks/segment/) لأمثلة عن الاستخدام مع هذه النماذج المدرّبة مسبقًا على [COCO](https://docs.ultralytics.com/datasets/segment/coco/)، والتي تضم 80 فئة مدربة مسبقًا.
-
- | النموذج | حجم (بيكسل) | معدل التقسيمالتحقق 50-95 | معدل التقسيمالأقنعة 50-95 | سرعة CPU ONNX (متوسط) | سرعة A100 TensorRT (متوسط) | معلمات (مليون) | FLOPs (مليون) |
- | -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
- | [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
-
- === "التصنيف (ImageNet)"
-
- انظر إلى [وثائق التصنيف](https://docs.ultralytics.com/tasks/classify/) لأمثلة عن الاستخدام مع هذه النماذج المدرّبة مسبقًا على [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/)، والتي تضم 1000 فئة مدربة مسبقًا.
-
- | النموذج | حجم (بيكسل) | دقة أعلى أعلى 1 | دقة أعلى أعلى 5 | سرعة CPU ONNX (متوسط) | سرعة A100 TensorRT (متوسط) | معلمات (مليون) | FLOPs (مليون) عند 640 |
- | -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------ | ----------------------------------- | ------------------ | ------------------------ |
- | [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
-
- === "المواقف (COCO)"
-
- انظر إلى [وثائق تقدير المواقع] (https://docs.ultralytics.com/tasks/pose/) لأمثلة على الاستخدام مع هذه النماذج المدربة مسبقًا على [COCO](https://docs.ultralytics.com/datasets/pose/coco/)، والتي تتضمن فئة واحدة مدربة مسبقًا ، 'شخص'.
-
- | النموذج | حجم (بيكسل) | معدل التوضيحالتحقق 50-95 | معدل التوضيح50 | سرعة CPU ONNX (متوسط) | سرعة A100 TensorRT (متوسط) | معلمات (مليون) | FLOPs (مليون) |
- | ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
- | [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
-
-## أمثلة استخدام
-
-يوفر هذا المثال أمثلة بسيطة للتدريب والتنبؤ باستخدام YOLOv8. للحصول على وثائق كاملة حول هذه وغيرها من [الأوضاع](../modes/index.md) ، انظر إلى صفحات وثائق [تنبؤ](../modes/predict.md) ، [تدريب](../modes/train.md) ، [التحقق](../modes/val.md) و [التصدير](../modes/export.md) .
-
-يرجى ملاحظة أن المثال أدناه يتعلق بطراز YOLOv8 [Detect](../tasks/detect.md) للكشف عن الكائنات. لمهام مدعومة إضافية ، انظر إلى وثائق [تقسيم](../tasks/segment.md) ، [تحديد إنتماء](../tasks/classify.md) و [تصوير (Pose)](../tasks/pose.md) .
-
-!!!
-
-!!! Example "مثال"
-
- === "Python"
-
- يمكن تمرير نماذج الـ PyTorch المُدرّبة المُحفوظة بالامتداد `*.pt` بالإضافة إلى ملفات التكوين بامتداد `*.yaml` إلى فئة `YOLO()` لإنشاء نموذج في لغة بايثون:
-
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج YOLOv8n المدرّب مسبقًا على COCO
- model = YOLO('yolov8n.pt')
-
- # عرض معلومات النموذج (اختياري)
- model.info()
-
- # تدريب النموذج على مجموعة بيانات المُدخلات coco8 على سبيل المثال لمدة 100 دورة
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # تشغيل التنبؤ باستخدام نموذج YOLOv8n على صورة 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- تتوفر أوامر CLI لتشغيل النماذج مباشرة:
-
- ```bash
- # تحميل نموذج YOLOv8n المدرّب مسبقًا على COCO واختباره على مجموعة بيانات coco8
- yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # تحميل نموذج YOLOv8n المدرّب مسبقًا على COCO والتنبؤ به على صورة 'bus.jpg'
- yolo predict model=yolov8n.pt source=path/to/bus.jpg
- ```
-
-## الاقتباسات والتقديرات
-
-إذا استخدمت نموذج YOLOv8 أو أي برنامج آخر من هذا المستودع في عملك ، فيرجى استشهاده باستخدام التنسيق التالي:
-
-!!!،
-
-!!! 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}
- }
- ```
-
-يرجى ملاحظة أن وجود معرف الكائن الرقمي (DOI) قيد الانتظار وسيتم إضافته إلى الاقتباس بمجرد توفره. تُقدم نماذج YOLOv8 بموجب [رخصة AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) و [الرخصة المؤسسية](https://ultralytics.com/license).
diff --git a/docs/ar/modes/benchmark.md b/docs/ar/modes/benchmark.md
deleted file mode 100644
index 506240afac0..00000000000
--- a/docs/ar/modes/benchmark.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-comments: true
-description: تعرف على كيفية قياس سرعة ودقة YOLOv8 عبر تنسيقات التصدير المختلفة. احصل على رؤى حول مقاييس mAP50-95 وaccuracy_top5 والمزيد.
-keywords: Ultralytics، YOLOv8، اختبار الأداء، قياس السرعة، قياس الدقة، مقاييس mAP50-95 وaccuracy_top5، ONNX، OpenVINO، TensorRT، تنسيقات تصدير YOLO
----
-
-# اختبار النموذج باستخدام Ultralytics YOLO
-
-
-
-## المقدمة
-
-بمجرد أن يتم تدريب نموذجك وتحقق صحته ، فإن الخطوة التالية بشكل منطقي هي تقييم أدائه في سيناريوهات العالم الحقيقي المختلفة. يوفر وضع الاختبار في Ultralytics YOLOv8 هذا الهدف من خلال توفير إطار قوي لتقييم سرعة ودقة النموذج عبر مجموعة من صيغ التصدير.
-
-## لماذا هو اختبار الأداء مهم؟
-
-- **قرارات مستنيرة:** اكتساب رؤى حول التنازلات بين السرعة والدقة.
-- **تخصيص الموارد:** فهم كيفية أداء تنسيقات التصدير المختلفة على أجهزة مختلفة.
-- **تحسين:** تعلم أي تنسيق تصدير يقدم أفضل أداء لحالتك الاستخدامية المحددة.
-- **كفاءة التكلفة:** استخدام الموارد الأجهزة بشكل أكثر كفاءة بناءً على نتائج الاختبار.
-
-### المقاييس الرئيسية في وضع الاختبار
-
-- **mAP50-95:** لكشف الكائنات وتقسيمها وتحديد الوضع.
-- **accuracy_top5:** لتصنيف الصور.
-- **وقت التتبع:** الوقت المستغرق لكل صورة بالميلي ثانية.
-
-### تنسيقات التصدير المدعومة
-
-- **ONNX:** لأفضل أداء على وحدة المعالجة المركزية.
-- **TensorRT:** لأقصى استفادة من وحدة المعالجة الرسومية.
-- **OpenVINO:** لتحسين الأجهزة من إنتل.
-- **CoreML و TensorFlow SavedModel وما إلى ذلك:** لتلبية احتياجات النشر المتنوعة.
-
-!!! Tip "نصيحة"
-
- * قم بتصدير إلى نموذج ONNX أو OpenVINO لزيادة سرعة وحدة المعالجة المركزية بمقدار 3 مرات.
- * قم بتصدير إلى نموذج TensorRT لزيادة سرعة وحدة المعالجة الرسومية بمقدار 5 مرات.
-
-## أمثلة على الاستخدام
-
-قم بتشغيل اختبارات YOLOv8n على جميع تنسيقات التصدير المدعومة بما في ذلك ONNX و TensorRT وما إلى ذلك. انظر القسم الموجود أدناه للحصول على قائمة كاملة من وسيطات التصدير.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics.utils.benchmarks import benchmark
-
- # اختبار على وحدة المعالجة الرسومية
- 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
- ```
-
-## وسيطات
-
-توفر الوسائط مثل `model` و `data` و `imgsz` و `half` و `device` و `verbose` مرونة للمستخدمين لضبط الاختبارات حسب احتياجاتهم المحددة ومقارنة أداء تنسيقات التصدير المختلفة بسهولة.
-
-| المفتاح | القيمة | الوصف |
-|-----------|---------|---------------------------------------------------------------------------------------------------|
-| `model` | `None` | مسار إلى ملف النموذج ، على سبيل المثال yolov8n.pt ، yolov8n.yaml |
-| `data` | `None` | مسار إلى YAML يشير إلى مجموعة بيانات اختبار الأداء (بتحتوى على بيانات `val`) |
-| `imgsz` | `640` | حجم الصورة كرقم ، أو قائمة (h ، w) ، على سبيل المثال (640، 480) |
-| `half` | `False` | تقليل دقة العدد العشرى للأبعاد (FP16 quantization) |
-| `int8` | `False` | تقليل دقة العدد الصحيح 8 بت (INT8 quantization) |
-| `device` | `None` | الجهاز الذى ستعمل عليه العملية ، على سبيل المثال cuda device=0 أو device=0,1,2,3 أو device=cpu |
-| `verbose` | `False` | عدم المتابعة عند حدوث خطأ (مقدار منطقى)، أو مستوى الكشف عند تجاوز حد القيمة المطلوبة (قيمة عائمة) |
-
-## صيغ التصدير
-
-سيحاول التطبيق تشغيل الاختبارات تلقائيًا على جميع صيغ التصدير الممكنة الموجودة أدناه.
-
-| 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` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
-
-انظر تفاصيل التصدير الكاملة في الصفحة [Export](https://docs.ultralytics.com/modes/export/)
diff --git a/docs/ar/modes/export.md b/docs/ar/modes/export.md
deleted file mode 100644
index f555ec0599f..00000000000
--- a/docs/ar/modes/export.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-comments: true
-description: دليل خطوة بخطوة حول تصدير نماذج YOLOv8 الخاصة بك إلى تنسيقات مختلفة مثل ONNX و TensorRT و CoreML وغيرها للنشر. استكشف الآن!.
-keywords: YOLO، YOLOv8، Ultralytics، تصدير النموذج، ONNX، TensorRT، CoreML، TensorFlow SavedModel، OpenVINO، PyTorch، تصدير النموذج
----
-
-# تصدير النموذج باستخدام يولو من Ultralytics
-
-
-
-## مقدمة
-
-الهدف النهائي لتدريب نموذج هو نشره لتطبيقات العالم الحقيقي. يوفر وضع التصدير في يولو من Ultralytics مجموعة متنوعة من الخيارات لتصدير النموذج المدرب إلى تنسيقات مختلفة، مما يجعله يمكن استخدامه في مختلف الأنظمة والأجهزة. يهدف هذا الدليل الشامل إلى مساعدتك في فهم تفاصيل تصدير النموذج، ويعرض كيفية تحقيق أقصى توافق وأداء.
-
-
-
-
-
- شاهد: كيفية تصدير نموذج Ultralytics YOLOv8 التدريب المخصص وتشغيل الاستدلال المباشر على كاميرا الويب.
-
-
-## لماذا اختيار وضع تصدير YOLOv8؟
-
-- **التنوع:** تصدير إلى تنسيقات متعددة بما في ذلك ONNX و TensorRT و CoreML ، وغيرها.
-- **الأداء:** الحصول على سرعة تسريع تصل إلى 5 أضعاف باستخدام TensorRT وسرعة تسريع معالج الكمبيوتر المركزي بنسبة 3 أضعاف باستخدام ONNX أو OpenVINO.
-- **التوافقية:** جعل النموذج قابلاً للنشر على الأجهزة والبرامج المختلفة.
-- **سهولة الاستخدام:** واجهة سطر الأوامر البسيطة وواجهة برمجة Python لتصدير النموذج بسرعة وسهولة.
-
-### الميزات الرئيسية لوضع التصدير
-
-إليك بعض من الميزات المميزة:
-
-- **تصدير بنقرة واحدة:** أوامر بسيطة لتصدير إلى تنسيقات مختلفة.
-- **تصدير الدُفعات:** تصدير نماذج قادرة على العمل مع الدُفعات.
-- **تنفيذ محسَّن:** يتم تحسين النماذج المصدرة لتوفير وقت تنفيذ أسرع.
-- **فيديوهات تعليمية:** مرشدين وفيديوهات تعليمية لتجربة تصدير سلسة.
-
-!!! Tip "نصيحة"
-
- * صدّر إلى ONNX أو OpenVINO للحصول على تسريع معالج الكمبيوتر المركزي بنسبة 3 أضعاف.
- * صدّر إلى TensorRT للحصول على تسريع وحدة المعالجة الرسومية بنسبة 5 أضعاف.
-
-## أمثلة للاستخدام
-
-قم بتصدير نموذج YOLOv8n إلى تنسيق مختلف مثل ONNX أو TensorRT. انظر الجدول أدناه للحصول على قائمة كاملة من وسائط التصدير.
-
-!!! Example "مثال"
-
- === "بايثون"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل نموذج
- model = YOLO('yolov8n.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مدرب مخصص
-
- # قم بتصدير النموذج
- model.export(format='onnx')
- ```
- === "واجهة سطر الأوامر"
-
- ```bash
- yolo export model=yolov8n.pt format=onnx # تصدير نموذج رسمي
- yolo export model=path/to/best.pt format=onnx # تصدير نموذج مدرب مخصص
- ```
-
-## الوسائط
-
-تشير إعدادات تصدير YOLO إلى التكوينات والخيارات المختلفة المستخدمة لحفظ أو تصدير النموذج للاستخدام في بيئات أو منصات أخرى. يمكن أن تؤثر هذه الإعدادات على أداء النموذج وحجمه وتوافقه مع الأنظمة المختلفة. تشمل بعض إعدادات تصدير YOLO الشائعة تنسيق ملف النموذج المصدر (مثل ONNX وتنسيق TensorFlow SavedModel) والجهاز الذي سيتم تشغيل النموذج عليه (مثل المعالج المركزي أو وحدة المعالجة الرسومية) ووجود ميزات إضافية مثل الأقنعة أو التسميات المتعددة لكل مربع. قد تؤثر عوامل أخرى قد تؤثر عملية التصدير تشمل المهمة النموذجة المحددة التي يتم استخدام النموذج لها ومتطلبات أو قيود البيئة أو المنصة المستهدفة. من المهم أن ننظر بعناية ونقوم بتكوين هذه الإعدادات لضمان أن النموذج المصدر هو محسَّن للحالة الاستخدام المقصودة ويمكن استخدامه بشكل فعال في البيئة المستهدفة.
-
-| المفتاح | القيمة | الوصف |
-|-------------|-----------------|-----------------------------------------------------------------------|
-| `format` | `'torchscript'` | التنسيق المراد تصديره |
-| `imgsz` | `640` | حجم الصورة كمقدار علمي أو قائمة (h ، w) ، على سبيل المثال (640 ، 480) |
-| `keras` | `False` | استخدام Keras لتصدير TF SavedModel |
-| `optimize` | `False` | TorchScript: الأمثل للجوال |
-| `half` | `False` | تكميم FP16 |
-| `int8` | `False` | تكميم INT8 |
-| `dynamic` | `False` | ONNX/TensorRT: المحاور الديناميكية |
-| `simplify` | `False` | ONNX/TensorRT: تبسيط النموذج |
-| `opset` | `None` | ONNX: إصدار opset (اختياري ، الافتراضي هو الأحدث) |
-| `workspace` | `4` | TensorRT: حجم مساحة العمل (GB) |
-| `nms` | `False` | CoreML: إضافة NMS |
-
-## تنسيقات التصدير
-
-صيغ تصدير YOLOv8 المتاحة في الجدول أدناه. يمكنك التصدير إلى أي تنسيق باستخدام الوسيطة `format` ، مثل `format='onnx'` أو `format='engine'`.
-
-| التنسيق | وسيطة format | النموذج | البيانات الوصفية | الوسائط |
-|--------------------------------------------------------------------|---------------|---------------------------|------------------|-----------------------------------------------------|
-| [بايثورش](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
-| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `تورتشسيريبت` | `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` |
-| [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/docs/ar/modes/index.md b/docs/ar/modes/index.md
deleted file mode 100644
index 86e2c4d36ab..00000000000
--- a/docs/ar/modes/index.md
+++ /dev/null
@@ -1,77 +0,0 @@
----
-comments: true
-description: من التدريب إلى التتبع، استفد من YOLOv8 مع Ultralytics. احصل على نصائح وأمثلة لكل وضع مدعوم بما في ذلك التحقق والتصدير واختبار الأداء.
-keywords: Ultralytics, YOLOv8, التعلم الآلي، كشف الكائنات، التدريب، التحقق، التنبؤ، التصدير، التتبع، اختبار الأداء
----
-
-# أوضاع Ultralytics YOLOv8
-
-
-
-## المقدمة
-
-YOLOv8 من Ultralytics ليست مجرد نموذج لكشف الكائنات آخر؛ إنها إطار متعدد الاستخدامات مصمم لتغطية دورة حياة نماذج التعلم الآلي بأكملها - من امتصاص البيانات وتدريب النموذج إلى التحقق والنشر وتتبع الواقع الحقيقي. يخدم كل وضع غرضًا محددًا وهو مصمم لتوفير المرونة والكفاءة المطلوبة للمهام والحالات الاستخدام المختلفة.
-
-!!! Note "ملاحظة"
-
- 🚧 توثيقنا متعدد اللغات قيد الإنشاء حاليًا، ونحن نعمل بجهد لتحسينه. شكرًا لك على صبرك! 🙏
-
-
-
-
-
- شاهد: برنامج التعليم Ultralytics: تدريب، التحقق، التنبؤ، التصدير، واختبار الأداء.
-
-
-### أوضاع مختصرة
-
-فهم ال**أوضاع** المختلفة المدعومة بواسطة Ultralytics YOLOv8 مهم جدًا للاستفادة القصوى من النماذج الخاصة بك:
-
-- وضع **التدريب**: قم بضبط نموذجك على مجموعة بيانات مخصصة أو محملة مسبقًا.
-- وضع **التحقق**: نقطة فحص بعد التدريب لتقييم أداء النموذج.
-- وضع **التنبؤ**: اطلق قوة التنبؤ الخاصة بنموذجك على البيانات الحقيقية.
-- وضع **التصدير**: قم بتجهيز نموذجك للاستخدام في صيغ مختلفة.
-- وضع **التتبع**: قم بتوسيع نموذج الكشف عن الكائنات الخاص بك إلى تطبيقات التتبع في الوقت الحقيقي.
-- وضع **اختبار الأداء**: قم بتحليل سرعة ودقة نموذجك في بيئات نشر متنوعة.
-
-يهدف هذا الدليل الشامل إلى تقديم لمحة عامة ونصائح عملية حول كل وضع، لمساعدتك في استغلال كامل إمكانات YOLOv8.
-
-## [وضع التدريب](train.md)
-
-يتم استخدام وضع التدريب لتدريب نموذج YOLOv8 على مجموعة بيانات مخصصة. في هذا الوضع، يتم تدريب النموذج باستخدام مجموعة البيانات والمعلمات الهايبر للحصول على دقة في توقع الفئات ومواقع الكائنات في الصورة.
-
-[أمثلة التدريب](train.md){ .md-button }
-
-## [وضع التحقق](val.md)
-
-يتم استخدام وضع التحقق للتحقق من نموذج YOLOv8 بعد تدريبه. في هذا الوضع، يتم تقييم النموذج على مجموعة التحقق لقياس دقته وأداء التعميم. يمكن استخدام هذا الوضع لتعديل المعلمات الهايبر للنموذج لتحسين أدائه.
-
-[أمثلة التحقق](val.md){ .md-button }
-
-## [وضع التنبؤ](predict.md)
-
-يتم استخدام وضع التنبؤ لإجراء تنبؤات باستخدام نموذج YOLOv8 المدرب على صور أو فيديوهات جديدة. في هذا الوضع، يتم تحميل النموذج من ملف الفحص، ويمكن للمستخدم توفير الصور أو مقاطع الفيديو لإجراء استدلال. يقوم النموذج بتوقع الفئات ومواقع الكائنات في الصور أو مقاطع الفيديو المدخلة.
-
-[أمثلة التنبؤ](predict.md){ .md-button }
-
-## [وضع التصدير](export.md)
-
-يتم استخدام وضع التصدير لتصدير نموذج YOLOv8 إلى صيغة يمكن استخدامها للنشر. في هذا الوضع، يتم تحويل النموذج إلى صيغة يمكن استخدامها من قبل تطبيقات البرامج الأخرى أو الأجهزة الأجهزة. يكون هذا الوضع مفيدًا عند نشر النموذج في بيئات الإنتاج.
-
-[أمثلة التصدير](export.md){ .md-button }
-
-## [وضع التتبع](track.md)
-
-يتم استخدام وضع التتبع لتتبع الكائنات في الوقت الحقيقي باستخدام نموذج YOLOv8. في هذا الوضع، يتم تحميل النموذج من ملف الفحص، ويمكن للمستخدم توفير تيار فيديو مباشر لأداء تتبع الكائنات في الوقت الفعلي. يكون هذا الوضع مفيدًا لتطبيقات مثل أنظمة المراقبة أو السيارات ذاتية القيادة.
-
-[أمثلة التتبع](track.md){ .md-button }
-
-## [وضع اختبار الأداء](benchmark.md)
-
-يتم استخدام وضع اختبار الأداء لتقييم سرعة ودقة صيغ التصدير المختلفة لـ YOLOv8. تقدم الاختبارات معلومات حول حجم الصيغة المصدر، معيار الأداء `mAP50-95` (لكشف الكائنات والتقسيم والتصوير) أو المعيار `accuracy_top5` (للتصنيف)، ووقت الاستدلال بالملي ثانية لكل صورة في صيغ التصدير المختلفة مثل ONNX و OpenVINO و TensorRT وغيرها. يمكن لهذه المعلومات مساعدة المستخدمين على اختيار صيغة التصدير الأمثل لحالتهم الاستخدامية المحددة بناءً على متطلبات السرعة والدقة.
-
-[أمثلة اختبار الأداء](benchmark.md){ .md-button }
diff --git a/docs/ar/modes/predict.md b/docs/ar/modes/predict.md
deleted file mode 100644
index 69a9cb8b4ac..00000000000
--- a/docs/ar/modes/predict.md
+++ /dev/null
@@ -1,217 +0,0 @@
----
-comments: true
-description: اكتشف كيفية استخدام وضع التنبؤ YOLOv8 لمهام مختلفة. تعرّف على مصادر التنبؤ المختلفة مثل الصور ومقاطع الفيديو وتنسيقات البيانات المختلفة.
-keywords: Ultralytics، YOLOv8، وضع التنبؤ، مصادر التنبؤ، مهام التنبؤ، وضع التدفق، معالجة الصور، معالجة الفيديو، التعلم الآلي، الذكاء الاصطناعي
----
-
-# التنبؤ بالنموذج باستخدام Ultralytics YOLO
-
-
-
-## المقدمة
-
-في عالم التعلم الآلي ورؤية الحاسوب، يُطلق على عملية استخلاص المعنى من البيانات البصرية اسم "الاستدلال" أو "التنبؤ". يوفر YOLOv8 من Ultralytics ميزة قوية تُعرف بـ**وضع التنبؤ** والتي تم تصميمها خصيصًا للاستدلال في الوقت الحقيقي وبأداء عال على مجموعة واسعة من مصادر البيانات.
-
-
-
-
-
- شاهد: كيفية استخراج النتائج من نموذج Ultralytics YOLOv8 لمشاريع مخصصة.
-
-
-## التطبيقات في العالم الحقيقي
-
-| التصنيع | الرياضة | السلامة |
-|:-------------------------------------------------:|:----------------------------------------------------:|:-------------------------------------------:|
-| ![Vehicle Spare Parts Detection][car spare parts] | ![Football Player Detection][football player detect] | ![People Fall Detection][human fall detect] |
-| كشف قطع غيار المركبات | كشف لاعبي كرة القدم | كشف سقوط الأشخاص |
-
-## لماذا يجب استخدام Ultralytics YOLO لعمليات التنبؤ؟
-
-فيما يلي الأسباب التي يجب أخذها في الاعتبار عند الاستفادة من وضع التنبؤ YOLOv8 لاحتياجات التنبؤ المختلفة:
-
-- **التنوع:** قادر على التنبؤ على الصور ومقاطع الفيديو، وحتى التدفقات الحية.
-- **الأداء:** مصمم للتطبيقات في الوقت الحقيقي والمعالجة عالية السرعة دون التضحية بالدقة.
-- **سهولة الاستخدام:** واجهات Python والواجهة السطرية لتسريع النشر والاختبار.
-- **قابلية التخصيص العالية:** إعدادات ومعلمات مختلفة لضبط سلوك التنبؤ النموذج وفقًا لمتطلباتك المحددة.
-
-### الميزات الرئيسية لوضع التنبؤ
-
-تم تصميم وضع التنبؤ الخاص بـ YOLOv8 ليكون قويًا ومتعدد الاستخدامات، ويتميز بما يلي:
-
-- **توافق متعدد مصادر البيانات:** سواء كانت بياناتك عبارة عن صور فردية أو مجموعة من الصور أو ملفات فيديو أو تدفقات فيديو في الوقت الحقيقي، سيتمكن وضع التنبؤ من التعامل معها جميعًا.
-- **وضع التدفق الحي:** استخدم ميزة التدفق لإنشاء مولد فعّال لكائنات "النتائج" باستخدام الذاكرة. قم بتمكين هذا بتعيين `stream=True` في طريقة استدعاء المتنبئ.
-- **معالجة دُفعات:** القدرة على معالجة العديد من الصور أو إطارات الفيديو في دُفعة واحدة، مما يزيد أكثر من سرعة التنبؤ.
-- **سهل التكامل:** يسهل الدمج مع خطوط الأنابيب البيانية الحالية ومكونات البرامج الأخرى بفضل واجهة برمجة التطبيقات المرنة.
-
-تُرجع نماذج Ultralytics YOLO إما قائمة Python من كائنات "النتائج" أو مُنشئ برمجياً فعّال لكائنات الـ "النتائج" في حال تم تمرير `stream=True` إلى النموذج أثناء عملية التنبؤ:
-
-!!! Example "التنبؤ"
-
- === "العودة بقائمة واحدة باستخدام `stream=False`"
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج
- model = YOLO('yolov8n.pt') # نموذج YOLOv8n المُدرَّب مسبقًا
-
- # تشغيل التنبؤ بدُفعة على قائمة من الصور
- results = model(['im1.jpg', 'im2.jpg']) # العودة بقائمة من كائنات 'النتائج'
-
- # معالجة قائمة النتائج
- for result in results:
- boxes = result.boxes # كائن Boxes لمخرجات bbox
- masks = result.masks # كائن Masks لمخرجات قنوات الفصل العنقودي
- keypoints = result.keypoints # كائن Keypoints لمخرجات الاتجاهات
- probs = result.probs # كائن Probs لمخرجات التصنيف
- ```
-
- === "العودة بمُنشئ فعال مع `stream=True`"
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج
- model = YOLO('yolov8n.pt') # نموذج YOLOv8n المُدرَّب مسبقًا
-
- # تشغيل التنبؤ بدُفعة على قائمة من الصور
- results = model(['im1.jpg', 'im2.jpg'], stream=True) # العودة بمُنشئ فعال لكائنات 'النتائج'
-
- # معالجة المُنشئ الفعال
- for result in results:
- boxes = result.boxes # كائن Boxes لمخرجات bbox
- masks = result.masks # كائن Masks لمخرجات قنوات الفصل العنقودي
- keypoints = result.keypoints # كائن Keypoints لمخرجات الاتجاهات
- probs = result.probs # كائن Probs لمخرجات التصنيف
- ```
-
-## مصادر التنبؤ
-
-يمكن لـ YOLOv8 معالجة أنواع مختلفة من مصادر الإدخال لعملية الاستدلال، على النحو الموضح في الجدول أدناه. تشمل المصادر الصور الثابتة وتيارات الفيديو وتنسيقات مختلفة للبيانات. يشير الجدول أيضًا إلى ما إذا كان يمكن استخدام كل مصدر في وضع التدفق باستخدام الوسيط `stream=True` ✅. يعتبر وضع التدفق مفيدًا لمعالجة مقاطع الفيديو أو التدفقات الحية حيث يقوم بإنشاء مُنشئ للنتائج بدلاً من تحميل جميع الإطارات في الذاكرة.
-
-!!! Tip "طراز"
-
- استخدم `stream=True` لمعالجة مقاطع الفيديو الطويلة أو مجموعات البيانات الكبيرة لإدارة الذاكرة بكفاءة. عندما تكون القيمة مساوية لـ `stream=False`، يتم تخزين النتائج لجميع الإطارات أو نقاط البيانات في الذاكرة، والتي يمكن أن تتراكم بسرعة وتُسبِّب أخطاء الذاكرة غير الكافية للمدخلات الكبيرة. على النقيض من ذلك، يستخدم التدفق `stream=True` مولدًا يُبقي نتائج الإطار الحالي أو نقطة البيانات الحالية في الذاكرة فقط، مما يقلل بشكل كبير من استهلاك الذاكرة ويمنع مشكلات عدم كفاية الذاكرة.
-
-| مصدر | الوسيط | النوع | الملاحظات |
-|------------------|--------------------------------------------|-----------------|----------------------------------------------------------------------------------------------|
-| صورة | `'صورة.jpg'` | `str` or `Path` | ملف صورة واحدة. |
-| رابط URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | رابط URL لصورة ما. |
-| لقطة شاشة برمجية | `'الشاشة'` | `str` | قم بالتقاط لقطة شاشة برمجية. |
-| PIL | `Image.open('im.jpg')` | `PIL.Image` | الصيغة HWC مع قنوات RGB. |
-| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | الصيغة HWC مع قنوات BGR `uint8 (0-255)`. |
-| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | الصيغة HWC مع قنوات BGR `uint8 (0-255)`. |
-| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | الصيغة BCHW مع قنوات RGB `float32 (0.0-1.0)`. |
-| CSV | `'المصادر.csv'` | `str` or `Path` | ملف CSV يحتوي على مسارات الصور أو مقاطع الفيديو أو المجلدات. |
-| فيديو ✅ | `'الفيديو.mp4'` | `str` or `Path` | ملف فيديو بتنسيقات مثل MP4 و AVI وما إلى ذلك. |
-| الدليل ✅ | `'المسار/'` | `str` or `Path` | مسار إلى مجلد يحتوي على صور أو مقاطع فيديو. |
-| glob ✅ | `'المسار/*.jpg'` | `str` | نمط glob لمطابقة عدة ملفات. استخدم حرف `*` كحرطوم. |
-| يوتيوب ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | رابط URL إلى فيديو يوتيوب. |
-| تدفق ✅ | `'rtsp://example.com/media.mp4'` | `str` | عنوان URL لبروتوكولات التدفق مثل RTSP و RTMP و TCP أو عنوان IP. |
-| تدفق متعدد ✅ | `'list.streams'` | `str` or `Path` | ملف نصي `*.streams` مع عنوان تدفق URL في كل صف، على سبيل المثال 8 تدفقات ستعمل بحجم دُفعة 8. |
-
-فيما يلي أمثلة تعليمات برمجية لاستخدام كل نوع من مصدر:
-
-!!! Example "مصادر التنبؤ"
-
- === "الصورة"
- قم بأجراء عملية التنبؤ على ملف صورة.
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج YOLOv8n المدرب مسبقًا
- model = YOLO('yolov8n.pt')
-
- # تنشيط عملية التنبؤ لملف الصورة
- source = 'المسار/إلى/الصورة.jpg'
-
- # الجمع بين التنبؤ على المصدر
- results = model(source) # قائمة كائنات النتائج
- ```
-
- === "لقطة شاشة برمجية"
- قم بأجراء عملية التنبؤ على محتوى الشاشة الحالي كلقطة شاشة.
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج YOLOv8n المدرب مسبقًا
- model = YOLO('yolov8n.pt')
-
- # تعريف اللقطة الحالية كمصدر
- source = 'الشاشة'
-
- # الجمع بين التنبؤ على المصدر
- results = model(source) # قائمة كائنات النتائج
- ```
-
- === "رابط URL"
- قم بأجراء عملية التنبؤ على صورة موجودة على الإنترنت أو فيديو.
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج YOLOv8n المدرب مسبقًا
- model = YOLO('yolov8n.pt')
-
- # تعريف رابط الصورة أو الفيديو على الإنترنت
- source = 'https://ultralytics.com/images/bus.jpg'
-
- # الجمع بين التنبؤ على المصدر
- results = model(source) # قائمة كائنات النتائج
- ```
-
- === "PIL"
- قم بأجراء عملية التنبؤ على صورة مفتوحة بواسطة مكتبة Python Imaging Library (PIL).
- ```python
- from PIL import Image
- from ultralytics import YOLO
-
- # تحميل نموذج YOLOv8n المدرب مسبقًا
- model = YOLO('yolov8n.pt')
-
- # فتح صورة باستخدام PIL
- source = Image.open('المسار/إلى/الصورة.jpg')
-
- # الجمع بين التنبؤ على المصدر
- results = model(source) # قائمة كائنات النتائج
- ```
-
- === "OpenCV"
- قم بأجراء عملية التنبؤ على صورة مُقروءة بواسطة OpenCV.
- ```python
- import cv2
- from ultralytics import YOLO
-
- # تحميل نموذج YOLOv8n المدرب مسبقًا
- model = YOLO('yolov8n.pt')
-
- # قراءة صورة باستخدام OpenCV
- source = cv2.imread('المسار/إلى/الصورة.jpg')
-
- # الجمع بين التنبؤ على المصدر
- results = model(source) # قائمة كائنات النتائج
- ```
-
- === "numpy"
- قم بأجراء عملية التنبؤ على صورة مُمثلة كمصفوفة numpy.
- ```python
- import numpy as np
- from ultralytics import YOLO
-
- # تحميل نموذج YOLOv8n المدرب مسبقًا
- model = YOLO('yolov8n.pt')
-
- # إنشاء مصفوفة numpy عشوائية في صيغة HWC (640, 640, 3) بقيم بين [0, 255] ونوع uint8
- source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')
-
- # الجمع بين التنبؤ على المصدر
- results = model(source) # قائمة كائنات النتائج
- ```
-
-[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/docs/ar/modes/track.md b/docs/ar/modes/track.md
deleted file mode 100644
index 5300ecfb806..00000000000
--- a/docs/ar/modes/track.md
+++ /dev/null
@@ -1,360 +0,0 @@
----
-comments: true
-description: تعرف على كيفية استخدام Ultralytics YOLO لتتبع الكائنات في تدفقات الفيديو. أدلة لاستخدام مختلف المتتبعين وتخصيص إعدادات المتتبع.
-keywords: Ultralytics، YOLO، تتبع الكائنات، تدفقات الفيديو، BoT-SORT، ByteTrack، دليل Python، دليل خط الأوامر (CLI)
----
-
-# تتبع عدة كائنات باستخدام Ultralytics YOLO
-
-
-
-يعد تتبع الكائنات في مجال تحليل الفيديو مهمة حرجة ليس فقط في تحديد موقع وفئة الكائنات داخل الإطار، ولكن أيضًا في الحفاظ على هوية فريدة لكل كائن يتم اكتشافه مع تقدم الفيديو. تكاد التطبيقات لا تعد ولا تحصى - تتراوح من المراقبة والأمان إلى تحليل الرياضة الفورية.
-
-## لماذا يجب اختيار Ultralytics YOLO لتتبع الكائنات؟
-
-إن مخرجات المتتبعين في Ultralytics متسقة مع كشف الكائنات القياسي ولها قيمة مضافة من هويات الكائنات. هذا يجعل من السهل تتبع الكائنات في تدفقات الفيديو وأداء التحليلات التالية. إليك لماذا يجب أن تفكر في استخدام Ultralytics YOLO لتلبية احتياجات تتبع الكائنات الخاصة بك:
-
-- **الكفاءة:** معالجة تدفقات الفيديو في الوقت الحقيقي دون المساومة على الدقة.
-- **المرونة:** يدعم العديد من خوارزميات التتبع والتكوينات.
-- **سهولة الاستخدام:** واجهة برمجة تطبيقات بسيطة للغاية وخيارات سطر الأوامر للاستدماج السريع والنشر.
-- **إمكانية التخصيص:** سهل الاستخدام مع نماذج YOLO مدربة مخصصة، مما يسمح بالاكتمال في التطبيقات ذات النطاق الخاص.
-
-
-
-
-
- شاهد: كشف الكائنات وتتبعها باستخدام Ultralytics YOLOv8.
-
-
-## تطبيقات في العالم الحقيقي
-
-| النقل | البيع بالتجزئة | الاستزراع المائي |
-|:----------------------------------:|:--------------------------------:|:----------------------------:|
-| ![Vehicle Tracking][vehicle track] | ![People Tracking][people track] | ![Fish Tracking][fish track] |
-| تتبع المركبات | تتبع الأشخاص | تتبع الأسماك |
-
-## ملامح بلمحة
-
-يوفر Ultralytics YOLO ميزات كشف الكائنات لتوفير تتبع فعال ومتعدد الاستخدامات للكائنات:
-
-- **تتبع فوري:** تتبع الكائنات بسلاسة في مقاطع الفيديو ذات معدل الإطارات العالي.
-- **دعم عدة متتبعين:** اختيار بين مجموعة متنوعة من خوارزميات التتبع المعتمدة.
-- **تخصيص تكوينات المتتبع المتاحة:** ضبط خوارزمية التتبع لتلبية المتطلبات المحددة عن طريق ضبط مختلف المعلمات.
-
-## متتبعون متاحون
-
-يدعم Ultralytics YOLO الخوارزميات التالية للتتبع. يمكن تمكينها عن طريق تمرير ملف تكوين YAML ذي الصلة مثل "tracker=tracker_type.yaml":
-
-* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - استخدم `botsort.yaml` لتمكين هذا المتتبع.
-* [ByteTrack](https://github.com/ifzhang/ByteTrack) - استخدم `bytetrack.yaml` لتمكين هذا المتتبع.
-
-المتتبع الافتراضي هو BoT-SORT.
-
-## تتبع
-
-لتشغيل المتتبع على تدفقات الفيديو، استخدم نموذج تحديد (Detect) أو قطع (Segment) أو وضع (Pose) مدرب مثل YOLOv8n و YOLOv8n-seg و YOLOv8n-pose.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل نموذج رسمي أو مخصص
- model = YOLO('yolov8n.pt') # قم بتحميل نموذج رسمي Detect
- model = YOLO('yolov8n-seg.pt') # قم بتحميل نموذج رسمي Segment
- model = YOLO('yolov8n-pose.pt') # قم بتحميل نموذج رسمي Pose
- model = YOLO('path/to/best.pt') # قم بتحميل نموذج مخصص مدرب
-
- # قم بتنفيذ التتبع باستخدام النموذج
- results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # التتبع باستخدام المتتبع الافتراضي
- results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # التتبع باستخدام متتبع ByteTrack
- ```
-
- === "CLI"
-
- ```bash
- # قم بتنفيذ التتبع باستخدام مختلف النماذج باستخدام واجهة سطر الأوامر
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # نموذج Detect رسمي
- yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # نموذج Segment رسمي
- yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # نموذج Pose رسمي
- yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # تم تدريب نموذج مخصص
-
- # تتبع عن طريق ByteTrack متتبع
- yolo track model=path/to/best.pt tracker="bytetrack.yaml"
- ```
-
-كما يظهر في الاستخدام أعلاه، يتوفر التتبع لجميع نماذج Detect و Segment و Pose التي تعمل على مقاطع الفيديو أو مصادر البث.
-
-## الاعدادات
-
-### معاملات التتبع
-
-تتشارك إعدادات التتبع الخصائص مع وضع التوقعات (Predict)، مثل `conf` و `iou` و `show`. للحصول على مزيد من التكوينات، راجع صفحة النموذج [Predict](../modes/predict.md#inference-arguments).
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتكوين معلمات التتبع وقم بتشغيل التتبع
- model = YOLO('yolov8n.pt')
- results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
- ```
-
- === "CLI"
-
- ```bash
- # قم بتكوين معلمات التتبع وقم بتشغيل التتبع باستخدام واجهة سطر الأوامر
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
- ```
-
-### اختيار المتتبع
-
-يتيح لك Ultralytics أيضًا استخدام ملف تكوين متتبع معدل. للقيام بذلك، أنقل نسخة من ملف تكوين المتتبع (مثل `custom_tracker.yaml`) من [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) وقم بتعديل أي تكوينات (باستثناء `tracker_type`) حسب احتياجاتك.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل النموذج وتشغيل التتبع باستخدام ملف تكوين مخصص
- model = YOLO('yolov8n.pt')
- results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
- ```
-
- === "CLI"
-
- ```bash
- # قم بتحميل النموذج وتشغيل التتبع باستخدام ملف تكوين مخصص باستخدام واجهة سطر الأوامر
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
- ```
-
-للحصول على قائمة شاملة من وسائط تتبع، راجع الصفحة [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
-
-## أمثلة Python
-
-### الحفاظ على المسارات التكرارية
-
-فيما يلي سكريبت Python باستخدام OpenCV (cv2) و YOLOv8 لتشغيل تتبع الكائنات على إطارات الفيديو. يفترض هذا السكريبت أنك قد قمت بالفعل بتثبيت الحزم اللازمة (opencv-python و ultralytics). المعامل `persist=True` يخبر المتتبع أن الصورة الحالية أو الإطار التالي في التسلسل ومن المتوقع أن يتوفر مسارات من الصورة السابقة في الصورة الحالية.
-
-!!! Example "For-loop للتدفق مع التتبع"
-
- ```python
- import cv2
- from ultralytics import YOLO
-
- # حمّل نموذج YOLOv8
- model = YOLO('yolov8n.pt')
-
- # افتح ملف الفيديو
- video_path = "path/to/video.mp4"
- cap = cv2.VideoCapture(video_path)
-
- # تحلق عبر إطارات الفيديو
- while cap.isOpened():
- # قراءة الإطار من الفيديو
- success, frame = cap.read()
-
- if success:
- # تشغيل تتبع YOLOv8 على الإطار ، وحفظ المسارات بين الإطارات
- results = model.track(frame, persist=True)
-
- # تصور النتائج على الإطار
- annotated_frame = results[0].plot()
-
- # عرض الإطار المعلق
- cv2.imshow("YOLOv8 Tracking", annotated_frame)
-
- # كسر اللوب في حالة الضغط على 'q'
- if cv2.waitKey(1) & 0xFF == ord("q"):
- break
- else:
- # كسر اللوب في نهاية الفيديو
- break
-
- # إطلاق كائن التقاط الفيديو وإغلاق نافذة العرض
- cap.release()
- cv2.destroyAllWindows()
- ```
-
-يرجى ملاحظة التغيير من `model(frame)` إلى `model.track(frame)` ، مما يمكن التتبع بدلاً من الكشف البسيط. سيتم تشغيل البرنامج المعدل على كل إطار فيديو وتصور النتائج وعرضها في نافذة. يمكن الخروج من الحلقة عن طريق الضغط على 'q'.
-
-### رسم المسارات عبر الوقت
-
-يمكن أن يوفر رسم المسارات الكائنية عبر الإطارات المتتالية إشارات قيمة حول أنماط الحركة والسلوك للكائنات المكتشفة في الفيديو. باستخدام Ultralytics YOLOv8 ، يعد تصوير هذه المسارات عملية سلسة وفعالة.
-
-في المثال التالي ، نوضح كيفية استخدام قدرات يوكو 8 YOLO لتتبع الكائنات لرسم حركة الكائنات المكتشفة عبر إطارات الفيديو المتعددة. يتضمن هذا البرنامج فتح ملف فيديو وقراءته إطارًا بإطار ، واستخدام نموذج YOLO لتحديد وتتبع العديد من الكائنات. عن طريق الاحتفاظ بنقاط الوسط لمربعات الحدود المكتشفة وتوصيلها ، يمكننا رسم خطوط تمثل المسارات التي تم اتباعها بواسطة الكائنات التي تمت متابعتها.
-
-!!! Example "رسم المسارات عبر إطارات الفيديو المتعددة"
-
- ```python
- from collections import defaultdict
-
- import cv2
- import numpy as np
-
- from ultralytics import YOLO
-
- # حمّل نموذج YOLOv8
- model = YOLO('yolov8n.pt')
-
- # افتح ملف الفيديو
- video_path = "path/to/video.mp4"
- cap = cv2.VideoCapture(video_path)
-
- # احفظ تاريخ المسارات
- track_history = defaultdict(lambda: [])
-
- # تحلق عبر إطارات الفيديو
- while cap.isOpened():
- # قراءة الإطار من الفيديو
- success, frame = cap.read()
-
- if success:
- # تشغيل تتبع YOLOv8 على الإطار ، وحفظ المسارات بين الإطارات
- results = model.track(frame, persist=True)
-
- # الحصول على المربعات ومعرفات المسار
- boxes = results[0].boxes.xywh.cpu()
- track_ids = results[0].boxes.id.int().cpu().tolist()
-
- # تصور النتائج على الإطار
- annotated_frame = results[0].plot()
-
- # رسم المسارات
- 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 نقطة الوسط
- if len(track) > 30: # احتفظ بـ 90 مسارًا لـ 90 إطارًا
- track.pop(0)
-
- # رسم خطوط التتبع
- points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
- cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
-
- # عرض الإطار المعلق
- cv2.imshow("YOLOv8 Tracking", annotated_frame)
-
- # كسر اللوب في حالة الضغط على 'q'
- if cv2.waitKey(1) & 0xFF == ord("q"):
- break
- else:
- # كسر اللوب في نهاية الفيديو
- break
-
- # إطلاق كائن التقاط الفيديو وإغلاق نافذة العرض
- cap.release()
- cv2.destroyAllWindows()
- ```
-
-### التتبع متعدد الخيوط
-
-يوفر التتبع متعدد الخيوط القدرة على تشغيل تتبع الكائنات على عدة تدفقات فيديو في وقت واحد. هذا مفيد بشكل خاص عند التعامل مع مدخلات فيديو متعددة ، مثل من كاميرات المراقبة المتعددة ، حيث يمكن أن يعزز المعالجة المتزامنة الكفاءة والأداء بشكل كبير.
-
-في السكريبت البايثون المقدم ، نستخدم وحدة `threading` في Python لتشغيل عدة نسخ متزامنة من المتتبع. يكون لكل موضوع مسؤولية تشغيل المتتبع على ملف فيديو واحد ، وتعمل جميع الخيوط في الخلفية في نفس الوقت.
-
-للتأكد من أن كل خيط يتلقى المعلمات الصحيحة (ملف الفيديو والنموذج المستخدم وفهرس الملف) ، نحدد وظيفة `run_tracker_in_thread` التي تقبل هذه المعلمات وتحتوي على حلقة المتابعة الرئيسية. هذه الوظيفة تقرأ إطار الفيديو الخاصة بالفيديو مباشرة من مصدر الملف الواحد ، وتشغيل المتتبع ، وعرض النتائج.
-
-تستخدم في هذا المثال نموذجين مختلفين: 'yolov8n.pt' و 'yolov8n-seg.pt' ، يقوم كل منهما بتتبع الكائنات في ملف فيديو مختلف. تم تحديد ملفات الفيديو في `video_file1` و `video_file2`.
-
-تعديل معلمات `daemon=True` في `threading.Thread` يعني أن هذه الخيوط ستتم إغلاقها بمجرد انتهاء البرنامج الرئيسي. ثم نبدأ الخيوط باستخدام `start ()` واستخدم `join ()` لجعل الخيط الرئيسي ينتظر حتى ينتهي خيطي المتتبع.
-
-أخيرًا ، بعد اكتمال جميع الخيوط لمهمتها ، يتم إغلاق النوافذ التي تعرض النتائج باستخدام `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):
- """
- يشغل ملف فيديو أو مصدر تيار الكاميرا بالتزامن مع YOLOv8 النموذج باستخدام تعدد الخيوط.
-
- هذه الوظيفة تلتقط إطارات الفيديو من ملف أو مصدر الكاميرا المعروف ، وتستخدم نموذج YOLOv8 لتتبع الكائنات.
- يعمل البرنامج في خيطه الخاص للمعالجة المتزامنة.
-
- Args:
- filename (str): مسار ملف الفيديو أو معرف مصدر كاميرا الويب / خارجية.
- model (obj): كائن نموذج YOLOv8.
- file_index (int): مؤشر لتحديد الملف بشكل فريد ، يُستخدم لأغراض العرض.
-
- ملاحظة:
- اضغط على 'q' لإنهاء نافذة عرض الفيديو.
- """
- video = cv2.VideoCapture(filename) # قراءة ملف الفيديو
-
- while True:
- ret, frame = video.read() # قراءة إطارات الفيديو
-
- # إنهاء الدورة إذا لم يتبقى إطارات على الفيديوين
- if not ret:
- break
-
- # تتبع كائنات في الإطارات إذا توفرت
- 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
-
- # إطلاق مصدري الفيديو
- video.release()
-
-
- # حمّل النماذج
- model1 = YOLO('yolov8n.pt')
- model2 = YOLO('yolov8n-seg.pt')
-
- # حدد ملفات الفيديو للمتابعين
- video_file1 = "path/to/video1.mp4" # مسار ملف الفيديو ، 0 لكاميرا الويب
- video_file2 = 0 # مسار ملف الفيديو ، 0 لكاميرا الويب ، 1 لكاميرا خارجية
-
- # إنشاء خيوط المتابع
- 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)
-
- # بدء خيوط المتابع
- tracker_thread1.start()
- tracker_thread2.start()
-
- # انتظر حتى ينتهي خيط المتابع
- tracker_thread1.join()
- tracker_thread2.join()
-
- # Clean up and close windows
- cv2.destroyAllWindows()
- ```
-
-يمكن بسهولة توسيع هذا المثال للتعامل مع ملفات فيديو ونماذج أخرى من خلال إنشاء مزيد من الخيوط وتطبيق نفس المنهجية.
-
-## المساهمة في المتتبعون الجديدون
-
-هل أنت ماهر في التتبع متعدد الكائنات وقد نفذت أو صيغت بنجاح خوارزمية تتبع باستخدام Ultralytics YOLO؟ ندعوك للمشاركة في قسم المتتبعين لدينا في [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! قد تكون التطبيقات في العالم الحقيقي والحلول التي تقدمها لا تقدر بثمن للمستخدمين العاملين على مهام التتبع.
-
-من خلال المساهمة في هذا القسم ، تساعد في توسيع نطاق حلول التتبع المتاحة في إطار Ultralytics YOLO ، مضيفًا طبقة أخرى من الوظائف والفعالية للمجتمع.
-
-لبدء المساهمة ، يرجى الرجوع إلى [دليل المساهمة الخاص بنا](https://docs.ultralytics.com/help/contributing) للحصول على تعليمات شاملة حول تقديم طلب سحب (PR) 🛠️. نتطلع بشكل كبير إلى ما ستجلبه للطاولة!
-
-لنعزز معًا قدرات عملية التتبع لأجهزة Ultralytics YOLO 🙏!
-
-[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/docs/ar/modes/train.md b/docs/ar/modes/train.md
deleted file mode 100644
index 54881f11a80..00000000000
--- a/docs/ar/modes/train.md
+++ /dev/null
@@ -1,286 +0,0 @@
----
-comments: true
-description: دليل خطوة بخطوة لتدريب نماذج YOLOv8 باستخدام Ultralytics YOLO بما في ذلك أمثلة على التدريب باستخدام بطاقة رسومات منفصلة ومتعددة البطاقات الرسومية
-keywords: Ultralytics، YOLOv8، YOLO، كشف الكائنات، وضع تدريب، مجموعة بيانات مخصصة، تدريب بطاقة رسومات، متعددة البطاقات الرسومية، معلمات تكبير، أمثلة سطر الأوامر، أمثلة بايثون
----
-
-# تدريب النموذج باستخدام Ultralytics YOLO
-
-
-
-## المقدمة
-
-يتضمن تدريب نموذج التعلم العميق تزويده بالبيانات وضبط معلماته بحيث يتمكن من إجراء توقعات دقيقة. يتم تصميم وضع التدريب في Ultralytics YOLOv8 لتدريب فعال وفعال لنماذج كشف الكائنات، مستغلاً تمامًا إمكانات الأجهزة الحديثة. يهدف هذا الدليل إلى شرح جميع التفاصيل التي تحتاج إلى البدء في تدريب النماذج الخاصة بك باستخدام مجموعة متينة من ميزات YOLOv8.
-
-
-
-
-
- شاهد: كيفية تدريب نموذج YOLOv8 على مجموعة البيانات المخصصة الخاصة بك في Google Colab.
-
-
-## لماذا اختيار Ultralytics YOLO للتدريب؟
-
-إليك بعض الأسباب المقنعة لاختيار وضع التدريب في YOLOv8:
-
-- **الكفاءة:** استفد إلى أقصى حد من الأجهزة الخاصة بك، سواء كنت تستخدم بطاقة رسومات واحدة أو توسيعها عبر عدة بطاقات رسومات.
-- **تعدد الاستخدامات:** قم بالتدريب على مجموعات البيانات المخصصة بالإضافة إلى المجموعات المتاحة بسهولة مثل COCO و VOC و ImageNet.
-- **سهل الاستخدام:** واجهة سطر الأوامر CLI وواجهة Python البسيطة والقوية لتجربة تدريب مباشرة.
-- **مرونة المعلمات:** مجموعة واسعة من المعلمات القابلة للتخصيص لضبط أداء النموذج.
-
-### الميزات الرئيسية لوضع التدريب
-
-تتمثل الميزات البارزة لوضع التدريب في YOLOv8 في ما يلي:
-
-- **تنزيل مجموعة البيانات تلقائيًا:** تقوم مجموعات البيانات القياسية مثل COCO و VOC و ImageNet بالتنزيل تلقائيًا عند أول استخدام.
-- **دعم متعدد البطاقات الرسومية:** قم بتوزيع العمليات التدريبية بسلاسة عبر عدة بطاقات رسومات لتسريع العملية.
-- **ضبط المعلمات:** الخيار لتعديل المعلمات التكبير من خلال ملفات تكوين YAML أو وسائط سطر الأوامر.
-- **مراقبة وتتبع:** تتبع في الوقت الفعلي لمقاييس التدريب وتصور عملية التعلم لتحقيق رؤى أفضل.
-
-!!! Example "نصيحة"
-
- * يتم تنزيل مجموعات YOLOv8 القياسية مثل COCO و VOC و ImageNet وغيرها تلقائيًا عند الاستخدام الأول، على سبيل المثال: `yolo train data=coco.yaml`
-
-## أمثلة استخدام
-
-تدريب YOLOv8n على مجموعة بيانات COCO128 لمدة 100 حقبة بحجم صورة 640. يمكن تحديد جهاز التدريب باستخدام الوسيطة `device`. إذا لم يتم تمرير وسيطة، سيتم استخدام الجهاز بطاقة الرسومات "device=0" إذا كانت متاحة، وإلا سيتم استخدام `device=cpu`. استعرض الجدول الزمني أدناه للحصول على قائمة كاملة بوسائط التدريب.
-
-!!! Example "أمثلة سطر الأوامر للتدريب باستخدام بطاقة رسومات مستقلة ومعالج مركزي"
-
- يتم تحديد الجهاز تلقائيًا. إذا كانت بطاقة رسومات متاحة، سيتم استخدامها، وإلا ستبدأ التدريب على المعالج المركزي.
-
- === "بايثون"
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n.yaml') # إنشاء نموذج جديد من ملف YAML
- model = YOLO('yolov8n.pt') # تحميل نموذج مدرب مسبقًا (الأكثر توصية للتدريب)
- model = YOLO('yolov8n.yaml').load('yolov8n.pt') # إنشاء من ملف YAML ونقل الأوزان
-
- # تدريب النموذج
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
- ```
-
- === "سطر الأوامر"
- ```bash
- # إنشاء نموذج جديد من ملف YAML وبدء التدريب من البداية
- yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
-
- # بدء التدريب من نموذج *.pt مدرب مسبقًا
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
-
- # إنشاء نموذج جديد من ملف YAML ونقل الأوزان المدربة مسبقًا وبدء التدريب
- yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
- ```
-
-### التدريب متعدد البطاقات الرسومية
-
-يتيح التدريب متعدد البطاقات الرسومية استخدام الموارد الأجهزة المتاحة بكفاءة أكبر من خلال توزيع أعباء التدريب عبر عدة بطاقات رسومية. هذه الميزة متاحة من خلال واجهة برمجة التطبيقات باستخدام Python وسطر الأوامر. لتمكين التدريب متعدد البطاقات الرسومية، حدد معرفات أجهزة GPU التي ترغب في استخدامها.
-
-!!! Example "أمثلة على التدريب متعدد البطاقات الرسومية"
-
- للتدريب باستخدام أجهزتي GPU، جهاز CUDA 0 و 1، استخدم الأوامر التالية. قم بتوسيعها لاستخدام المزيد من البطاقات.
-
- === "بايثون"
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n.pt') # تحميل نموذج مدرب مسبقًا (الأكثر توصية للتدريب)
-
- # تدريب النموذج بأجهزة GPU 2
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
- ```
-
- === "سطر الأوامر"
- ```bash
- # بدء التدريب من نموذج *.pt مدرب مسبقًا باستخدام بطاقات GPU 0 و 1
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
- ```
-
-### التدريب باستخدام Apple M1 و M2 MPS
-
-مع دعم شرائح Apple M1 و M2 المدمج في نماذج Ultralytics YOLO، يمكنك الآن تدريب نماذجك على الأجهزة التي تستخدم نظام Metal Performance Shaders (MPS) القوي. يوفر MPS طريقة عالية الأداء لتنفيذ المهام الحسابية ومعالجة الصور على شرائح السيليكون المخصصة لعبة Apple.
-
-لتمكين التدريب على شرائح Apple M1 و M2، يجب عليك تحديد "mps" كجهازك عند بدء عملية التدريب. فيما يلي مثال لكيفية القيام بذلك في بايثون وعبر سطر الأوامر:
-
-!!! Example "مثال على التدريب بواسطة MPS"
-
- === "بايثون"
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n.pt') # تحميل نموذج مدرب مسبقًا (الأكثر توصية للتدريب)
-
- # تدريب النموذج باستخدام 2 بطاقات GPU
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
- ```
-
- === "سطر الأوامر"
- ```bash
- # بدء التدريب من نموذج *.pt مدرب مسبقًا باستخدام بطاقات GPU 0 و 1
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
- ```
-
-عند الاستفادة من قدرة المعالجة الحاسوبية لشرائح M1/M2، يتيح لك هذا الحمل أداءً أكثر كفاءة لمهام التدريب. للحصول على إرشادات أكثر تفصيلاً وخيارات تكوين متقدمة، يرجى الرجوع إلى [وثائق PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html).
-
-### استئناف التدريب المقطوع
-
-يعتبر استئناف التدريب من الحالات التخزين السابقة ميزة حاسمة عند العمل مع نماذج التعلم العميق. يمكن أن يكون هذا مفيدًا في العديد من السيناريوهات، مثل عند تعطل عملية التدريب بشكل غير متوقع، أو عند الرغبة في متابعة تدريب نموذج بيانات جديدة أو لفترة زمنية أطول.
-
-عند استئناف التدريب، يقوم Ultralytics YOLO بتحميل الأوزان من آخر نموذج محفوظ وأيضًا استعادة حالة المحسن، وجدولة معدل التعلم، وعدد الحقبة. هذا يتيح لك متابعة عملية التدريب بشكل سلس من حيث توقفت.
-
-يمكنك بسهولة استئناف التدريب في Ultralytics YOLO عن طريق تعيين الوسيطة `resume` إلى `True` عند استدعاء طريقة `train`، وتحديد المسار إلى ملف `.pt` الذي يحتوي على أوزان النموذج المدرب جزئيًا.
-
-فيما يلي مثال لكيفية استئناف تدريب مقطوع باستخدام بايثون وعبر سطر الأوامر:
-
-!!! Example "مثال على استئناف التدريب"
-
- === "بايثون"
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('path/to/last.pt') # تحميل نموذج مدرب جزئيًا
-
- # استئناف التدريب
- results = model.train(resume=True)
- ```
-
- === "سطر الأوامر"
- ```bash
- # استئناف تدريب متقطع
- yolo train resume model=path/to/last.pt
- ```
-
-من خلال تعيين `resume=True`، ستواصل وظيفة 'train' التدريب من حيث توقفت، باستخدام الحالة المخزنة في ملف 'path/to/last.pt'. إذا تم حذف الوسيطة `resume` أو تعيينها على `False`، ستبدأ وظيفة 'train' جلسة تدريب جديدة.
-
-تذكر أنه يتم حفظ نقاط التفتيش في نهاية كل حقبة افتراضياً، أو في فترة ثابتة باستخدام وسيطة 'save_period'، لذا يجب عليك إتمام حقبة واحدة على الأقل لاستئناف تشغيل تدريب.
-
-## الوسائط
-
-تتعلق إعدادات التدريب لنماذج YOLO بالمعلمات والتكوينات المختلفة المستخدمة لتدريب النموذج على مجموعة بيانات ما. يمكن أن تؤثر هذه الإعدادات على أداء النموذج وسرعته ودقته. تتضمن بعض إعدادات YOLO التدريب الشائعة حجم الدُفعات، معدل التعلم، الزخم، والتقليل القيمي للأوزان. العوامل الأخرى التي قد تؤثر في عملية التدريب تشمل اختيار المحسن، اختيار دالة الخسارة، وحجم وتركيب مجموعة البيانات التدريب. من المهم ضبط وتجربة هذه الإعدادات بعناية لتحقيق أفضل أداء ممكن لمهمة معينة.
-
-| المفتاح | القيمة | الوصف |
-|-------------------|----------|---------------------------------------------------------------------------------------------------------------------------|
-| `model` | `None` | مسار إلى ملف النموذج، على سبيل المثال yolov8n.pt، yolov8n.yaml |
-| `data` | `None` | مسار إلى ملف البيانات، على سبيل المثال coco128.yaml |
-| `epochs` | `100` | عدد الحقب للتدريب ل |
-| `patience` | `50` | حقب للانتظار بدون تحسن ظاهر لإيقاف التدريب مبكرا |
-| `batch` | `16` | عدد الصور في كل دُفعة (-1 for AutoBatch) |
-| `imgsz` | `640` | حجم الصور الدخل بصورة مثالية |
-| `save` | `True` | حال إنقاذ النقاط المفتوحة للتدريب ونتائج الكشف |
-| `save_period` | `-1` | حفظ النقطة الفاصلة كل x حقبة (تكون معطلة إذا كانت < 1) |
-| `cache` | `False` | صحيح / ذاكرة عشوائية أو قرص / غير صحيح. استخدم ذاكرة التخزين المؤقت في تحميل البيانات |
-| `device` | `None` | الجهاز لتشغيل التدريب عليه، على سبيل المثال جهاز الرسومات cuda=0 أو جهاز الرسومات cuda=0,1,2,3 أو جهاز المعالج المركزيcpu |
-| `workers` | `8` | عدد خيوط العاملة لتحميل البيانات (لكل RANK إذا كان DDP) |
-| `project` | `None` | اسم المشروع |
-| `name` | `None` | اسم التجربة |
-| `exist_ok` | `False` | ما إذا كان سيتم الكتابة فوق تجربة موجودة |
-| `pretrained` | `True` | (bool أو str) ما إذا كان سيتم استخدام نموذج متدرب مسبقًا (bool) أو نموذج لتحميل الأوزان منه (str) |
-| `optimizer` | `'auto'` | المحسن لاستخدامه، الخيارات=[SGD، Adam، Adamax، AdamW، NAdam، RAdam، RMSProp، Auto] |
-| `verbose` | `False` | ما إذا كان سيتم طباعة مخرجات مفصلة |
-| `seed` | `0` | البذرة العشوائية لإعادة الإنتاجية |
-| `deterministic` | `True` | ما إذا كان يتم تمكين الوضع المحدد |
-| `single_cls` | `False` | يجب تدريب بيانات متعددة الفئات كفئة واحدة |
-| `rect` | `False` | تدريب مستطيل باستخدام تجميع الدُفعات للحد الأدنى من الحشو |
-| `cos_lr` | `False` | استخدم جدولة معدل التعلم بتوقيت الكوسا |
-| `close_mosaic` | `10` | (int) تعطيل التكبير التجانبي للحجم للحقب النهائية (0 للتعطيل) |
-| `resume` | `False` | استأنف التدريب من النقطة الأخيرة |
-| `amp` | `True` | تدريب دقة مختلطة تلقائية (AMP)، الخيارات=[True، False] |
-| `fraction` | `1.0` | نسبة مجموعة البيانات المراد تدريبها (الافتراضي هو 1.0، جميع الصور في مجموعة التدريب) |
-| `profile` | `False` | قم بتشغيل بروفايل السرعة لمشغلات ONNX و TensorRT أثناء التدريب للمسجلات |
-| `freeze` | `None` | (int أو list، اختياري) تجميد أول n طبقة، أو قائمة طبقات الفهرس خلال التدريب |
-| `lr0` | `0.01` | معدل التعلم الأولي (على سبيل المثال SGD=1E-2، Adam=1E-3) |
-| `lrf` | `0.01` | معدل التعلم النهائي (lr0 * lrf) |
-| `momentum` | `0.937` | الزخم SGD / Adam beta1 |
-| `weight_decay` | `0.0005` | تقليل الأوزان للمحسن (5e-4) |
-| `warmup_epochs` | `3.0` | حقب الاحماء (الأجزاء المئوية مقبولة) |
-| `warmup_momentum` | `0.8` | الزخم الأولي للتدفق الأعلى |
-| `warmup_bias_lr` | `0.1` | نسبة تعلم الانحياز الأولي للتدفق العلوي |
-| `box` | `7.5` | وزن فاقد الصندوق |
-| `cls` | `0.5` | وزن فاقد التصنيف (تناسب مع البكسل) |
-| `dfl` | `1.5` | وزن الخسارة الأمامية للتصنيف والصندوق |
-| `pose` | `12.0` | وزن فاقد الوضع (الوضع فقط) |
-| `kobj` | `2.0` | وزن فاقد نقطة المفتاح (الوضع فقط) |
-| `label_smoothing` | `0.0` | التسوية الغموض (كسر) |
-| `nbs` | `64` | حجم الدُفعة الاسمي |
-| `overlap_mask` | `True` | التحجيم يجب أن يتداخل أقنعة التدريب (التدريب الفصلي فقط) |
-| `mask_ratio` | `4` | معدل تحجيم أقنعة (التدريب الفصلي فقط) |
-| `dropout` | `0.0` | استخدام تنظيم الإسقاط (التدريب التطبيقي فقط) |
-| `val` | `True` | التحقق/الاختبار خلال التدريب |
-
-## تسجيل
-
-عند تدريب نموذج YOLOv8، قد تجد أنه من المفيد تتبع أداء النموذج مع مرور الوقت. هنا يأتي دور تسجيل. يوفر Ultralytics' YOLO دعمًا لثلاثة أنواع من أجهزة السجل - Comet و ClearML و TensorBoard.
-
-لاستخدام سجل، حدده من قائمة السحب أسفل الكود وقم بتشغيله. سيتم تثبيت السجل المختار وتهيئته.
-
-### Comet
-
-[Comet](../../../integrations/comet.md) هو منصة تسمح لعلماء البيانات والمطورين بمتابعة ومقارنة وشرح وتحسين التجارب والنماذج. يوفر وظائف مثل المقاييس الزمنية في الوقت الحقيقي وفروقات الشفرة وتتبع المعلمات.
-
-لاستخدام Comet:
-
-!!! Example "أمثلة بايثون"
-
- === "بايثون"
- ```python
- # pip install comet_ml
- import comet_ml
-
- comet_ml.init()
- ```
-
-تذكر تسجيل الدخول إلى حسابك في Comet على موقعهم على الويب والحصول على مفتاح API الخاص بك. ستحتاج إلى إضافته إلى الإعدادات المتغيرة في البيئة الخاصة بك أو برنامج النص الخاص بك لتسجيل التجارب الخاصة بك.
-
-### ClearML
-
-[ClearML](https://www.clear.ml/) هي منصة مفتوحة المصدر تعمل على تتبع التجارب وتسهيل مشاركة الموارد بكفاءة. تم تصميمه لمساعدة الفرق في إدارة وتنفيذ وإعادة إنتاج عملهم في مجال تعلم الآلة بكفاءة أكبر.
-
-لاستخدام ClearML:
-
-!!! Example "أمثلة بايثون"
-
- === "بايثون"
- ```python
- # pip install clearml
- import clearml
-
- clearml.browser_login()
- ```
-
-بعد تشغيل هذا السكريبت، ستحتاج إلى تسجيل الدخول إلى حساب ClearML الخاص بك على المستعرض ومصادقة جلستك.
-
-## TensorBoard
-
-[TensorBoard](https://www.tensorflow.org/tensorboard) هي مجموعة أدوات لتصور TensorFlow ، تسمح لك بتصور نموذج TensorFlow الخاص بك ، ورسم المقاييس الكمية حول تنفيذ النموذج الخاص بك ، وعرض بيانات إضافية مثل الصور التي تمر عبرها.
-
-للاستفادة من TensorBoard في [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb):
-
-!!! Example "أمثلة سطر الأوامر"
-
- === "سطر الأوامر"
- ```bash
- load_ext tensorboard
- tensorboard --logdir ultralytics/runs # استبدل بالدليل 'runs'
- ```
-
-لاستخدام TensorBoard محليًا، قم بتشغيل الأمر أدناه واعرض النتائج على الرابط http://localhost:6006/.
-
-!!! Example "أمثلة سطر الأوامر"
-
- === "سطر الأوامر"
- ```bash
- tensorboard --logdir ultralytics/runs # استبدل بالدليل 'runs'
- ```
-
-سيتم تحميل TensorBoard وتوجيهه إلى الدليل الذي يتم حفظ سجلات التدريب فيه.
-
-بعد إعداد السجل الخاص بك، يمكنك الاستمرار في تدريب النموذج. سيتم سجل جميع مقاييس التدريب تلقائيًا في المنصة التي اخترتها، ويمكنك الوصول إلى هذه السجلات لمراقبة أداء النموذج الخاص بك مع مرور الوقت ومقارنة نماذج مختلفة وتحديد المجالات التي يمكن تحسينها.
diff --git a/docs/ar/modes/val.md b/docs/ar/modes/val.md
deleted file mode 100644
index ed954326fd8..00000000000
--- a/docs/ar/modes/val.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-comments: true
-description: دليل لاختبار نماذج YOLOv8 الصحيحة. تعرف على كيفية تقييم أداء نماذج YOLO الخاصة بك باستخدام إعدادات ومقاييس التحقق من الصحة مع أمثلة برمجية باللغة البايثون وواجهة سطر الأوامر.
-keywords: Ultralytics, YOLO Docs, YOLOv8, التحقق من الصحة, تقييم النموذج, المعلمات الفرعية, الدقة, المقاييس, البايثون, واجهة سطر الأوامر
----
-
-# التحقق من النماذج باستخدام Ultralytics YOLO
-
-
-
-## مقدمة
-
-يعتبر التحقق من النموذج خطوة حاسمة في خط أنابيب التعلم الآلي، حيث يتيح لك تقييم جودة النماذج المدربة. يوفر وضع الـ Val في Ultralytics YOLOv8 مجموعة أدوات ومقاييس قوية لتقييم أداء نماذج الكشف عن الكائنات الخاصة بك. يعمل هذا الدليل كمصدر كامل لفهم كيفية استخدام وضع الـ Val بشكل فعال لضمان أن نماذجك دقيقة وموثوقة.
-
-## لماذا يوفر Ultralytics YOLO التحقق من الصحة
-
-هنا هي الأسباب التي تجعل استخدام وضع الـ Val في YOLOv8 مفيدًا:
-
-- **الدقة:** الحصول على مقاييس دقيقة مثل mAP50 و mAP75 و mAP50-95 لتقييم نموذجك بشكل شامل.
-- **الراحة:** استخدم الميزات المدمجة التي تتذكر إعدادات التدريب، مما يبسط عملية التحقق من الصحة.
-- **مرونة:** قم بالتحقق من النموذج باستخدام نفس المجموعات البيانات وأحجام الصور أو مجموعات بيانات وأحجام صور مختلفة.
-- **ضبط المعلمات الفرعية:** استخدم المقاييس التحقق لضبط نموذجك لتحسين الأداء.
-
-### الميزات الرئيسية لوضع الـ Val
-
-هذه هي الوظائف المميزة التي يوفرها وضع الـ Val في YOLOv8:
-
-- **الإعدادات التلقائية:** يتذكر النماذج إعدادات التدريب الخاصة بها للتحقق من الصحة بسهولة.
-- **دعم متعدد المقاييس:** قيم نموذجك بناءً على مجموعة من مقاييس الدقة.
-- **واجهة سطر الأوامر وواجهة برمجة Python:** اختر بين واجهة سطر الأوامر أو واجهة برمجة Python حسب تفضيلك للتحقق من الصحة.
-- **توافق البيانات:** يعمل بسلاسة مع مجموعات البيانات المستخدمة خلال مرحلة التدريب بالإضافة إلى مجموعات البيانات المخصصة.
-
-!!! Tip "نصيحة"
-
- * تتذكر نماذج YOLOv8 إعدادات التدريب تلقائيًا، لذا يمكنك التحقق من النموذج بنفس حجم الصورة وعلى مجموعة البيانات الأصلية بسهولة باستخدام "yolo val model=yolov8n.pt" أو "model('yolov8n.pt').val()"
-
-## أمثلة الاستخدام
-
-تحقق من دقة النموذج المدرب YOLOv8n على مجموعة بيانات COCO128. لا يلزم تمرير أي وسيطة كوسيطة يتذكر الـ model التدريب والوسيطات كسمات النموذج. انظر الجدول أدناه للحصول على قائمة كاملة من وسيطات التصدير.
-
-!!! Example "مثال"
-
- === "البايثون"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n.pt') # تحميل النموذج الرسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مخصص
-
- # التحقق من النموذج
- metrics = model.val() # لا يلزم أي وسيطات، يتذكر التكوين والوسيطات
- metrics.box.map # map50-95
- metrics.box.map50 # map50
- metrics.box.map75 # map75
- metrics.box.maps # قائمة تحتوي على map50-95 لكل فئة
- ```
- === "واجهة سطر الأوامر"
-
- ```bash
- yolo detect val model=yolov8n.pt # تجريب نموذج رسمي
- yolo detect val model=path/to/best.pt # تجٌَرب نموذج مخصص
- ```
-
-## الوسيطات
-
-تشير إعدادات التحقق بالنسبة لنماذج YOLO إلى المعلمات الفرعية والتكوينات المختلفة المستخدمة لتقييم أداء النموذج على مجموعة بيانات التحقق. هذه الإعدادات يمكن أن تؤثر على أداء النموذج وسرعته ودقته. تشمل بعض إعدادات التحقق الشائعة في YOLO حجم الدفعة وتكرارات تنفيذ التحقق أثناء التدريب والمقاييس المستخدمة لتقييم أداء النموذج. العوامل الأخرى التي قد تؤثر على العملية الخاصة بالتحقق تشمل حجم وتركيب مجموعة البيانات التحقق والمهمة المحددة التي يتم استخدام النموذج فيها. من المهم ضبط هذه الإعدادات وتجربتها بعناية لضمان أداء جيد للنموذج على مجموعة بيانات التحقق وكشف ومنع الحالة التي يتم فيها ضبط الطراز بشكل جيد.
-
-| مفتاح | القيمة | الوصف |
-|---------------|---------|------------------------------------------------------------------------------------|
-| `data` | `None` | مسار إلى ملف البيانات، على سبيل المثال coco128.yaml |
-| `imgsz` | `640` | حجم الصور الداخلية باعتبارها عدد صحيح |
-| `batch` | `16` | عدد الصور لكل دفعة (-1 للدفع الآلي) |
-| `save_json` | `False` | حفظ النتائج في ملف JSON |
-| `save_hybrid` | `False` | حفظ النسخة المختلطة للتسميات (التسميات + التنبؤات الإضافية) |
-| `conf` | `0.001` | حد الثقة في كشف الكائن |
-| `iou` | `0.6` | حد تداخل على المتحدة (IoU) لعملية الجمع والطرح |
-| `max_det` | `300` | العدد الأقصى من الكشفات لكل صورة |
-| `half` | `True` | استخدم التنصت نصف الدقة (FP16) |
-| `device` | `None` | الجهاز الذي يتم تشغيله عليه، على سبيل المثال جهاز Cuda=0/1/2/3 أو جهاز=معالج (CPU) |
-| `dnn` | `False` | استخدم OpenCV DNN لعملية التنصت الأمثل |
-| `plots` | `False` | إظهار الرسوم البيانية أثناء التدريب |
-| `rect` | `False` | تحقق صيغة *rectangular* مع تجميع كل دفعة للحصول على الحد الأدنى من التعبئة |
-| `split` | `val` | اختر تقسيم البيانات للتحقق من الصحة، على سبيل المثال "val"، "test" أو "train" |
-|
diff --git a/docs/ar/quickstart.md b/docs/ar/quickstart.md
deleted file mode 100644
index 0b182193532..00000000000
--- a/docs/ar/quickstart.md
+++ /dev/null
@@ -1,326 +0,0 @@
----
-comments: true
-description: استكشف أساليب مختلفة لتثبيت Ultralytics باستخدام pip و conda و git و Docker. تعرّف على كيفية استخدام Ultralytics مع واجهة سطر الأوامر أو ضمن مشاريع Python الخاصة بك.
-keywords: تثبيت Ultralytics, pip install Ultralytics, Docker install Ultralytics, Ultralytics command line interface, Ultralytics Python interface
----
-
-## تثبيت Ultralytics
-
-يوفر Ultralytics طرق تثبيت مختلفة بما في ذلك pip و conda و Docker. يمكنك تثبيت YOLOv8 عن طريق حزمة `ultralytics` من خلال pip للإصدار الأحدث والمستقر أو من خلال استنساخ [مستودع Ultralytics على GitHub](https://github.com/ultralytics/ultralytics) للحصول على الإصدار الأحدث. يمكن استخدام Docker لتنفيذ الحزمة في حاوية معزولة، وتجنب التثبيت المحلي.
-
-!!! Note "ملاحظة"
-
- 🚧 تم بناء وثائقنا متعددة اللغات حاليًا، ونعمل بجد لتحسينها. شكرًا لك على صبرك! 🙏
-
-!!! Example "تثبيت"
-
- === "تثبيت باستخدام pip (الموصَى به)"
- قم بتثبيت حزمة `ultralytics` باستخدام pip، أو قم بتحديث التثبيت الحالي عن طريق تشغيل `pip install -U ultralytics`. قم بزيارة مؤشر Python Package Index (PyPI) للحصول على مزيد من التفاصيل حول حزمة `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
-
- [![نسخة PyPI](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![التنزيلات](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
-
- ```bash
- # قم بتثبيت حزمة ultralytics من PyPI
- pip install ultralytics
- ```
-
- يمكنك أيضًا تثبيت حزمة `ultralytics` مباشرة من مستودع GitHub [repository](https://github.com/ultralytics/ultralytics). قد يكون ذلك مفيدًا إذا كنت ترغب في الحصول على الإصدار التجريبي الأحدث. تأكد من تثبيت أداة الأوامر Git على نظامك. يُثبّت الأمر `@main` الفرع `main` ويمكن تعديله إلى فرع آخر، على سبيل المثال `@my-branch`، أو يمكن إزالته تمامًا للانتقال إلى الفرع الرئيسي `main`.
-
- ```bash
- # قم بتثبيت حزمة ultralytics من GitHub
- pip install git+https://github.com/ultralytics/ultralytics.git@main
- ```
-
-
- === "تثبيت باستخدام conda"
- Conda هو مدير حزم بديل لـ pip ويمكن استخدامه أيضًا للتثبيت. قم بزيارة Anaconda للحصول على مزيد من التفاصيل على [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). يمكن العثور على مستودع Ultralytics feedstock لتحديث حزمة conda على [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
-
-
- [![وصفة conda](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![تنزيلات conda](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![إصدار conda](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![منصات conda](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics)
-
- ```bash
- # قم بتثبيت حزمة ultralytics باستخدام conda
- conda install -c conda-forge ultralytics
- ```
-
- !!! Note "ملاحظة"
-
- إذا كنت تقوم بالتثبيت في بيئة CUDA، فإن الممارسة الجيدة هي تثبيت `ultralytics`, `pytorch` و `pytorch-cuda` في نفس الأمر للسماح لمدير حزم conda بحل أي تعارضات، أو وإلا فقوم بتثبيت `pytorch-cuda` في نهاية الأمر للسماح له بتجاوز حزمة `pytorch` المحددة لوحدة المعالجة المركزية إذا لزم الأمر.
- ```bash
- # قم بتثبيت كافة الحزم معًا باستخدام conda
- conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
- ```
-
- ### صورة Docker في Conda
-
- تتوفر أيضًا صور Docker لـ Conda لـ Ultralytics من [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). تستند هذه الصور إلى [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) وهي وسيلة بسيطة لبدء استخدام `ultralytics` في بيئة Conda.
-
- ```bash
- # قم بتعيين اسم الصورة بوصفه متغير
- t=ultralytics/ultralytics:latest-conda
-
- # اسحب أحدث صورة ultralytics من Docker Hub
- sudo docker pull $t
-
- # قم بتشغيل صورة ultralytics في حاوية مع دعم GPU
- sudo docker run -it --ipc=host --gpus all $t # all GPUs
- sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # قد يتم تحديد GPUs
- ```
-
- === "استنساخ Git"
- قم بنسخ مستودع `ultralytics` إذا كنت مهتمًا بالمساهمة في التطوير أو ترغب في تجربة الشفرة المصدرية الأحدث. بعد الاستنساخ، انتقل إلى الدليل وقم بتثبيت الحزمة في وضع التحرير `-e` باستخدام pip.
- ```bash
- # قم بنسخ مستودع ultralytics
- git clone https://github.com/ultralytics/ultralytics
-
- # انتقل إلى الدليل المنسوخ
- cd ultralytics
-
- # قم بتثبيت الحزمة في وضع التحرير
- pip install -e .
- ```
-
- === "Docker"
-
- تمكنك من استخدام Docker بسهولة لتنفيذ حزمة `ultralytics` في حاوية معزولة، مما يضمن أداءً سلسًا ومتسقًا في مختلف البيئات. عن طريق اختيار إحدى صور Docker الأصلية لـ `ultralytics` من [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics)، لن تتجنب فقط تعقيد التثبيت المحلي ولكنك ستستفيد أيضًا من وصول إلى بيئة عمل متحققة وفعالة. يقدم Ultralytics 5 صور Docker مدعومة رئيسية، يتم تصميم كل منها لتوفير توافق عالي وكفاءة لمنصات وحالات استخدام مختلفة:
-
-
-
- - **Dockerfile:** صورة GPU الموصى بها للتدريب.
- - **Dockerfile-arm64:** محسّن لبنية ARM64، مما يتيح النشر على أجهزة مثل Raspberry Pi ومنصات أخرى تعتمد على ARM64.
- - **Dockerfile-cpu:** إصدار مناسب للتحكم بوحدة المعالجة المركزية فقط بدون دعم لل GPU.
- - **Dockerfile-jetson:** مصمم خصيصًا لأجهزة NVIDIA Jetson، ويدمج دعمًا لل GPU المحسن لهذه المنصات.
- - **Dockerfile-python:** صورة صغيرة بها فقط Python والتبعيات الضرورية، مثالية للتطبيقات والتطوير الخفيف.
- - **Dockerfile-conda:** قائمة على Miniconda3 مع تثبيت conda لحزمة ultralytics.
-
- فيما يلي الأوامر للحصول على أحدث صورة وتشغيلها:
-
- ```bash
- # قم بتعيين اسم الصورة بوصفه متغير
- t=ultralytics/ultralytics:latest
-
- # اسحب أحدث صورة ultralytics من Docker Hub
- sudo docker pull $t
-
- # قم بتشغيل صورة ultralytics في حاوية مع دعم GPU
- sudo docker run -it --ipc=host --gpus all $t # all GPUs
- sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # قد يتم تحديد GPUs
- ```
-
- يقوم الأمر أعلاه بتهيئة حاوية Docker بأحدث صورة `ultralytics`. يُسند العلامة `-it` جهازًا افتراضيًا TTY ويحافظ على فتح stdin لتمكينك من التفاعل مع الحاوية. تعيين العلامة `--ipc=host` مساحة اسم IPC (Inter-Process Communication) إلى المضيف، وهو أمر ضروري لمشاركة الذاكرة بين العمليات. تُمكّن العلامة `--gpus all` الوصول إلى كل وحدات المعالجة المركزية الرسومية المتاحة داخل الحاوية، مما هو أمر حاسم للمهام التي تتطلب حسابات GPU.
-
- ملاحظة: للعمل مع الملفات على جهازك المحلي داخل الحاوية، استخدم مجلدات Docker لتوصيل دليل محلي بالحاوية:
-
- ```bash
- # مجلد الدليل المحلي بالحاوية
- sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
- ```
-
- قم بتغيير `/path/on/host` بمسار الدليل على جهازك المحلي، و `/path/in/container` باالمسار المطلوب داخل حاوية Docker للوصول إليه.
-
- للاستفادة القصوى من استخدام Docker المتقدم، لا تتردد في استكشاف [دليل Ultralytics Docker](https://docs.ultralytics.com/guides/docker-quickstart/).
-
-راجع ملف `requirements.txt` الخاص بـ `ultralytics` [هنا](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) للحصول على قائمة المتطلبات. يُرجى ملاحظة أن جميع الأمثلة أعلاه يتم تثبيت جميع المتطلبات المطلوبة.
-
-
-
-
-
- شاهد: دليل فتع Ultralytics YOLO السريع
-
-
-!!! Tip "نصيحة"
-
- يختلف متطلبات PyTorch حسب نظام التشغيل ومتطلبات CUDA، لذا يُوصَى بتثبيت PyTorch أولاً باستخدام التعليمات الموجودة في [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
-
-
-
-
-
-## استخدم Ultralytics مع واجهة سطر الأوامر (CLI)
-
-تتيح واجهة سطر الأوامر (CLI) في Ultralytics تشغيل أوامر بسيطة بدون الحاجة إلى بيئة Python. لا تحتاج CLI إلى أي تخصيص أو كود Python. يمكنك ببساطة تشغيل جميع المهام من الطرفية باستخدام الأمر `yolo`. تحقق من [دليل CLI](/../usage/cli.md) لمعرفة المزيد حول استخدام YOLOv8 من سطر الأوامر.
-
-!!! Example "مثال"
-
- === "الصيغة"
- تستخدم أوامر Ultralytics `yolo` الصيغة التالية:
- ```bash
- yolo TASK MODE ARGS
- ```
-
- - `TASK` (اختياري) أحد التالي ([detect](tasks/detect.md), [segment](tasks/segment.md), [classify](tasks/classify.md), [pose](tasks/pose.md))
- - `MODE` (مطلوب) واحد من ([train](modes/train.md), [val](modes/val.md), [predict](modes/predict.md), [export](modes/export.md), [track](modes/track.md))
- - `ARGS` (اختياري) أزواج "arg=value" مثل `imgsz=640` التي تستبدل القيم الافتراضية.
-
- راجع جميع `ARGS` [هنا](/../usage/cfg.md) أو باستخدام الأمر `yolo cfg` في سطر الأوامر.
-
- === "التدريب"
- قم بتدريب نموذج اكتشاف لمدة 10 حلقات مع سعر تعلم بدءي 0.01
- ```bash
- yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
- ```
-
- === "التنبؤ"
- تنبؤ بفيديو YouTube باستخدام نموذج تجزئة معتمد مسبقًا عند حجم الصورة 320:
- ```bash
- yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
- ```
-
- === "التحقق"
- التحقق من نموذج اكتشاف معتمد مسبقًا على دُفعَة واحدة وحجم صورة قدره 640:
- ```bash
- yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
- ```
-
- === "التصدير"
- قم بتصدير نموذج فئة YOLOv8n إلى تنسيق ONNX على حجم صورة 224 بواسطة 128 (لا يلزم TASK)
- ```bash
- yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
- ```
-
- === "خاص"
- قم بتشغيل أوامر خاصة لعرض الإصدارة وعرض الإعدادات وتشغيل عمليات التحقق والمزيد:
- ```bash
- yolo help
- yolo checks
- yolo version
- yolo settings
- yolo copy-cfg
- yolo cfg
- ```
-
-!!! Warning "تحذير"
-يجب تمرير الوسوم كأزواج "arg=val"، وأن تُفصل بعلامة تساوي `=` وأن تُفصل بمسافات بين الأزواج. لا تستخدم بادئات الوسوم `--` أو فواصل `,` بين الوسوم.
-
- - `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` ❌ (لا تستخدم `,`)
- - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` ❌ (لا تستخدم `--`)
-
-[دليل CLI](/../usage/cli.md){ .md-button }
-
-## استخدم Ultralytics مع Python
-
-تسمح واجهة Python في YOLOv8 بالتكامل السلس في مشاريع Python الخاصة بك، مما يجعل من السهل تحميل النموذج وتشغيله ومعالجة نتائجه. المصممة ببساطة وسهولة الاستخدام في الاعتبار، تمكن واجهة Python المستخدمين من تنفيذ الكشف على الكائنات والتجزئة والتصنيف في مشاريعهم. يجعل هذا واجهة YOLOv8 Python أداة قيمة لأي شخص يرغب في دمج هذه الوظائف في مشاريعهم باسياتو.
-
-على سبيل المثال، يمكن للمستخدمين تحميل نموذج، تدريبه، تقييم أدائه على مجموعة التحقق، وحتى تصديره إلى تنسيق ONNX ببضعة أسطر فقط من الشفرة. تحقق من [دليل Python](/../usage/python.md) لمعرفة المزيد حول استخدام YOLOv8 داخل مشاريعك الخاصة.
-
-!!! Example "مثال"
-
- ```python
- from ultralytics import YOLO
-
- # أنشئ نموذج YOLO جديد من البداية
- model = YOLO('yolov8n.yaml')
-
- # قم بتحميل نموذج YOLO معتمد مسبقًا (موصَى به للتدريب)
- model = YOLO('yolov8n.pt')
-
- # قم بتدريب النموذج باستخدام مجموعة البيانات 'coco128.yaml' لمدة 3 حلقات
- results = model.train(data='coco128.yaml', epochs=3)
-
- # قم بتقييم أداء النموذج على مجموعة التحقق
- results = model.val()
-
- # قم بإجراء الكشف على صورة باستخدام النموذج
- results = model('https://ultralytics.com/images/bus.jpg')
-
- # قم بتصدير النموذج إلى تنسيق ONNX
- success = model.export(format='onnx')
- ```
-
-[دليل Python](/../usage/python.md){.md-button .md-button--primary}
-
-## إعدادات Ultralytics
-
-يوفر مكتبة Ultralytics نظامًا قويًا لإدارة الإعدادات لتمكين التحكم بمحاكاة تفصيلية لتجاربك. من خلال استخدام `SettingsManager` في الوحدة `ultralytics.utils`، يمكن للمستخدمين الوصول بسهولة إلى إعداداتهم وتعديلها. يتم تخزينها في ملف YAML ويمكن عرضها أو تعديلها إما مباشرة في بيئة Python أو من خلال واجهة سطر الأوامر (CLI).
-
-### فحص الإعدادات
-
-للحصول على فهم للتكوين الحالي لإعداداتك، يمكنك عرضها مباشرةً:
-
-!!! Example "عرض الإعدادات"
-
- === "Python"
- يُمكنك استخدام Python لعرض الإعدادات الخاصة بك. ابدأ بـاستيراد الكائن `settings` من وحدة `ultralytics`. استخدم الأوامر التالية لطباعة الإعدادات والعودة منها:
- ```python
- from ultralytics import settings
-
- # عرض كل الإعدادات
- print(settings)
-
- # إرجاع إعداد محدد
- value = settings['runs_dir']
- ```
-
- === "CLI"
- بدلاً من ذلك، واجهة سطر الأوامر تسمح لك بالتحقق من الإعدادات الخاصة بك باستخدام أمر بسيط:
- ```bash
- yolo settings
- ```
-
-### تعديل الإعدادات
-
-يسمح لك Ultralytics بتعديل الإعدادات بسهولة. يمكن تنفيذ التغييرات بالطرق التالية:
-
-!!! Example "تحديث الإعدادات"
-
- === "Python"
- داخل بيئة Python، اطلب الطريقة `update` على الكائن `settings` لتغيير إعداداتك:
-
- ```python
- from ultralytics import settings
-
- # تحديث إعداد واحد
- settings.update({'runs_dir': '/path/to/runs'})
-
- # تحديث إعدادات متعددة
- settings.update({'runs_dir': '/path/to/runs', 'tensorboard': False})
-
- # إعادة الإعدادات إلى القيم الافتراضية
- settings.reset()
- ```
-
- === "CLI"
- إذا كنت تفضل استخدام واجهة سطر الأوامر، يمكنك استخدام الأوامر التالية لتعديل إعداداتك:
-
- ```bash
- # تحديث إعداد واحد
- yolo settings runs_dir='/path/to/runs'
-
- # تحديث إعدادات متعددة
- yolo settings runs_dir='/path/to/runs' tensorboard=False
-
- # إعادة الإعدادات إلى القيم الافتراضية
- yolo settings reset
- ```
-
-### فهم الإعدادات
-
-يوفر الجدول أدناه نظرة عامة على الإعدادات المتاحة للضبط في Ultralytics. يتم توضيح كل إعداد بالإضافة إلى قيمة مثالية ونوع البيانات ووصف موجز.
-
-| الاسم | القيمة المثالية | نوع البيانات | الوصف |
-|--------------------|-----------------------|--------------|-------------------------------------------------------------------------------------------------------------|
-| `settings_version` | `'0.0.4'` | `str` | إصدار إعدادات Ultralytics (مختلف عن إصدار Ultralytics [pip](https://pypi.org/project/ultralytics/)) |
-| `datasets_dir` | `'/path/to/datasets'` | `str` | المسار الذي يتم تخزينه فيه مجموعات البيانات |
-| `weights_dir` | `'/path/to/weights'` | `str` | المسار الذي يتم تخزينه فيه أوزان النموذج |
-| `runs_dir` | `'/path/to/runs'` | `str` | المسار الذي يتم تخزينه فيه تشغيل التجارب |
-| `uuid` | `'a1b2c3d4'` | `str` | مُعرِّف فريد لإعدادات الحالية |
-| `sync` | `True` | `bool` | ما إذا كان يتم مزامنة التحليلات وحوادث الأعطال إلى HUB |
-| `api_key` | `''` | `str` | HUB الخاص بـ Ultralytics [API Key](https://hub.ultralytics.com/settings?tab=api+keys) |
-| `clearml` | `True` | `bool` | ما إذا كان يتم استخدام ClearML لتسجيل التجارب |
-| `comet` | `True` | `bool` | ما إذا كان يتم استخدام [Comet ML](https://bit.ly/yolov8-readme-comet) لتتبع وتصور التجارب |
-| `dvc` | `True` | `bool` | ما إذا كان يتم استخدام [DVC لتتبع التجارب](https://dvc.org/doc/dvclive/ml-frameworks/yolo) والتحكم في النسخ |
-| `hub` | `True` | `bool` | ما إذا كان يتم استخدام [Ultralytics HUB](https://hub.ultralytics.com) للتكامل |
-| `mlflow` | `True` | `bool` | ما إذا كان يتم استخدام MLFlow لتتبع التجارب |
-| `neptune` | `True` | `bool` | ما إذا كان يتم استخدام Neptune لتتبع التجارب |
-| `raytune` | `True` | `bool` | ما إذا كان يتم استخدام Ray Tune لضبط الحساسية |
-| `tensorboard` | `True` | `bool` | ما إذا كان يتم استخدام TensorBoard للتصور |
-| `wandb` | `True` | `bool` | ما إذا كان يتم استخدام Weights & Biases لتسجيل البيانات |
-
-أثناء تنقلك في مشاريعك أو تجاربك، تأكد من مراجعة هذه الإعدادات لضمان تكوينها بشكل مثالي وفقًا لاحتياجاتك.
diff --git a/docs/ar/tasks/classify.md b/docs/ar/tasks/classify.md
deleted file mode 100644
index 8841dda90ea..00000000000
--- a/docs/ar/tasks/classify.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-comments: true
-description: تعرّف على نماذج YOLOv8 Classify لتصنيف الصور. احصل على معلومات مفصلة حول قائمة النماذج المدرّبة مسبقًا وكيفية التدريب والتحقق والتنبؤ وتصدير النماذج.
-keywords: Ultralytics، YOLOv8، تصنيف الصور، النماذج المدربة مسبقًا، YOLOv8n-cls، التدريب، التحقق، التنبؤ، تصدير النماذج
----
-
-# تصنيف الصور
-
-
-
-تعتبر عملية تصنيف الصور أبسط المهام الثلاثة وتنطوي على تصنيف صورة كاملة في إحدى الفئات المحددة سابقًا.
-
-ناتج نموذج تصنيف الصور هو تسمية فئة واحدة ودرجة ثقة. يكون تصنيف الصور مفيدًا عندما تحتاج فقط إلى معرفة فئة الصورة ولا تحتاج إلى معرفة موقع الكائنات التابعة لتلك الفئة أو شكلها الدقيق.
-
-!!! Tip "نصيحة"
-
- تستخدم نماذج YOLOv8 Classify اللاحقة "-cls"، مثالًا "yolov8n-cls.pt" وتم تدريبها على [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-## [النماذج](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-تظهر هنا النماذج المدرّبة مسبقًا لـ YOLOv8 للتصنيف. تم تدريب نماذج الكشف والشعبة والموضع على مجموعة البيانات [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)، بينما تم تدريب نماذج التصنيف مسبقًا على مجموعة البيانات [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-يتم تنزيل [النماذج](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) تلقائيًا من أحدث إصدار لـ Ultralytics [releases](https://github.com/ultralytics/assets/releases) عند الاستخدام الأول.
-
-| النموذج | الحجم (بكسل) | دقة (أعلى 1) acc | دقة (أعلى 5) acc | سرعة التنفيذ ONNX للوحدة المركزية (مللي ثانية) | سرعة التنفيذ A100 TensorRT (مللي ثانية) | المعلمات (مليون) | FLOPs (مليار) لحجم 640 |
-|----------------------------------------------------------------------------------------------|----------------------|--------------------------|--------------------------|-----------------------------------------------------------|----------------------------------------------------|--------------------------|--------------------------------|
-| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
-
-- قيمة **acc** هي دقة النماذج على مجموعة بيانات التحقق [ImageNet](https://www.image-net.org/).
- لإعادة إنتاج ذلك، استخدم `yolo val classify data=path/to/ImageNet device=0`
-- يتم حساب سرعة **Speed** بناءً على متوسط صور التحقق من ImageNet باستخدام [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
- لإعادة إنتاج ذلك، استخدم `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
-
-## التدريب
-
-قم بتدريب YOLOv8n-cls على مجموعة بيانات MNIST160 لمدة 100 دورة عند حجم الصورة 64 بكسل. للحصول على قائمة كاملة بالوسائط المتاحة، اطلع على صفحة [تكوين](/../usage/cfg.md).
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج
- model = YOLO('yolov8n-cls.yaml') # إنشاء نموذج جديد من نموذج YAML
- model = YOLO('yolov8n-cls.pt') # تحميل نموذج مدرّب مسبقًا (موصى به للتدريب)
- model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # إنشاء من YAML ونقل الأوزان
-
- # تدريب النموذج
- results = model.train(data='mnist160', epochs=100, imgsz=64)
- ```
-
- === "CLI"
-
- ```bash
- # إنشاء نموذج جديد من YAML وبدء التدريب من البداية
- yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
-
- # بدء التدريب من نموذج مدرّب بصيغة pt
- yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
-
- # إنشاء نموذج جديد من YAML ونقل الأوزان المدرّبة مسبقًا وبدء التدريب
- yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
- ```
-
-### تنسيق مجموعة البيانات
-
-يمكن العثور على تنسيق مجموعة بيانات تصنيف YOLO بالتفصيل في [مرشد المجموعة](../../../datasets/classify/index.md).
-
-## التحقق
-
-قم بتحديد دقة النموذج YOLOv8n-cls المدرّب على مجموعة بيانات MNIST160. لا يلزم تمرير أي وسيطة حيث يحتفظ `model` ببيانات التدريب والوسائط كسمات النموذج.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج
- model = YOLO('yolov8n-cls.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مخصص
-
- # التحقق من النموذج
- metrics = model.val() # لا تحتاج إلى وسائط، يتم تذكر مجموعة البيانات والإعدادات النموذج
- metrics.top1 # دقة أعلى 1
- metrics.top5 # دقة أعلى 5
- ```
- === "CLI"
-
- ```bash
- yolo classify val model=yolov8n-cls.pt # تحقق من النموذج الرسمي
- yolo classify val model=path/to/best.pt # تحقق من النموذج المخصص
- ```
-
-## التنبؤ
-
-استخدم نموذج YOLOv8n-cls المدرّب لتنفيذ تنبؤات على الصور.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج
- model = YOLO('yolov8n-cls.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مخصص
-
- # تنبؤ باستخدام النموذج
- results = model('https://ultralytics.com/images/bus.jpg') # تنبؤ على صورة
- ```
- === "CLI"
-
- ```bash
- yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # تنبؤ باستخدام النموذج الرسمي
- yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # تنبؤ باستخدام النموذج المخصص
- ```
-
-راجع تفاصيل كاملة حول وضع `predict` في الصفحة [Predict](https://docs.ultralytics.com/modes/predict/).
-
-## تصدير
-
-قم بتصدير نموذج YOLOv8n-cls إلى تنسيق مختلف مثل ONNX، CoreML، وما إلى ذلك.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل نموذج
- model = YOLO('yolov8n-cls.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مدرّب مخصص
-
- # تصدير النموذج
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n-cls.pt format=onnx # تصدير النموذج الرسمي
- yolo export model=path/to/best.pt format=onnx # تصدير نموذج مدرّب مخصص
- ```
-
-تتوفر صيغ تصدير YOLOv8-cls في الجدول أدناه. يمكنك تنبؤ أو التحقق من الصحة مباشرةً على النماذج المصدر، أي "yolo predict model=yolov8n-cls.onnx". يتم عرض أمثلة لاستخدام النموذج الخاص بك بعد الانتهاء من التصدير.
-
-| الصيغة | وسيطة الصيغة | النموذج | البيانات الوصفية | الوسيطات |
-|--------------------------------------------------------------------|---------------|-------------------------------|------------------|-----------------------------------------------------|
-| [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` |
-
-راجع التفاصيل الكاملة حول `export` في الصفحة [Export](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/ar/tasks/detect.md b/docs/ar/tasks/detect.md
deleted file mode 100644
index 9e5974d342d..00000000000
--- a/docs/ar/tasks/detect.md
+++ /dev/null
@@ -1,185 +0,0 @@
----
-comments: true
-description: وثائق رسمية لـ YOLOv8 بواسطة Ultralytics. تعلم كيفية تدريب و التحقق من صحة و التنبؤ و تصدير النماذج بتنسيقات مختلفة. تتضمن إحصائيات الأداء التفصيلية.
-keywords: YOLOv8, Ultralytics, التعرف على الكائنات, النماذج المدربة من قبل, التدريب, التحقق من الصحة, التنبؤ, تصدير النماذج, COCO, ImageNet, PyTorch, ONNX, CoreML
----
-
-# التعرف على الكائنات
-
-
-
-Task التعرف على الكائنات هو عبارة عن تعرف على موقع و فئة الكائنات في صورة أو فيديو.
-
-مخرجات جهاز الاستشعار هي مجموعة من مربعات تحيط بالكائنات في الصورة، مع تصنيف الفئة ودرجات وثقة لكل مربع. التعرف على الكائنات هو اختيار جيد عندما تحتاج إلى تحديد كائنات مهمة في مشهد، ولكنك لا تحتاج إلى معرفة بالضبط أين يكمن الكائن أو شكله الدقيق.
-
-
-
-
-
- شاهد: التعرف على الكائنات باستخدام نموذج Ultralytics YOLOv8 مع تدريب مسبق.
-
-
-!!! Tip "تلميح"
-
- نماذج YOLOv8 Detect هي النماذج الافتراضية YOLOv8، أي `yolov8n.pt` و هي مدربة مسبقًا على [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
-
-## [النماذج](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-تُعرض هنا النماذج المدربة مسبقًا لـ YOLOv8 Detect. النماذج Detect و Segment و Pose معتمدة على مجموعة البيانات [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)، بينما النماذج Classify معتمدة على مجموعة البيانات [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-تُقوم النماذج بالتنزيل تلقائيًا من أحدث [إصدار Ultralytics](https://github.com/ultralytics/assets/releases) عند الاستخدام لأول مرة.
-
-| النموذج | الحجم (بكسل) | mAPval 50-95 | السرعة CPU ONNX (مللي ثانية) | السرعة A100 TensorRT (مللي ثانية) | الوزن (ميغا) | FLOPs (مليار) |
-|--------------------------------------------------------------------------------------|----------------------|----------------------|-----------------------------------------|----------------------------------------------|----------------------|-----------------------|
-| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
-| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
-| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
-| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
-| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
-
-- قيم mAPval تنطبق على مقياس نموذج واحد-مقياس واحد على مجموعة بيانات [COCO val2017](https://cocodataset.org).
- اعيد حسابها بواسطة `yolo val detect data=coco.yaml device=0`
-- السرعةتمت متوسطة على صور COCO val باستخدام [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
- instance.
- اعيد حسابها بواسطة `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
-
-## تدريب
-
-قم بتدريب YOLOv8n على مجموعة البيانات COCO128 لمدة 100 دورة على حجم صورة 640. للحصول على قائمة كاملة بالوسائط المتاحة انظر الصفحة [التكوين](/../usage/cfg.md).
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل نموذج
- model = YOLO('yolov8n.yaml') # بناء نموذج جديد من YAML
- model = YOLO('yolov8n.pt') # قم بتحميل نموذج مدرب مسبقًا (موصى به للتدريب)
- model = YOLO('yolov8n.yaml').load('yolov8n.pt') # بناء من YAML و نقل الأوزان
-
- # قم بتدريب النموذج
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
- ```
- === "CLI"
-
- ```bash
- # قم ببناء نموذج جديد من YAML وابدأ التدريب من الصفر
- yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
-
- # ابدأ التدريب من نموذج *.pt مدرب مسبقًا
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
-
- # بناء نموذج جديد من YAML، ونقل الأوزان المدربة مسبقاً إلى النموذج وابدأ التدريب
- yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
- ```
-
-### تنسيق مجموعة بيانات
-
-يمكن العثور على تنسيق مجموعة بيانات التعرف على الكائنات بالتفصيل في [دليل مجموعة البيانات](../../../datasets/detect/index.md). لتحويل مجموعة البيانات الحالية من تنسيقات أخرى (مثل COCO الخ) إلى تنسيق YOLO، يرجى استخدام أداة [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) المقدمة من Ultralytics.
-
-## التحقق من الصحة
-
-قم بتحقق من دقة النموذج المدرب مسبقًا YOLOv8n على مجموعة البيانات COCO128. ليس هناك حاجة إلى تمرير أي وسيطات حيث يحتفظ النموذج ببياناته التدريبية والوسيطات كسمات النموذج.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل نموذج
- model = YOLO('yolov8n.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مخصص
-
- # قم بالتحقق من النموذج
- metrics = model.val() # لا حاجة لأي بيانات، يتذكر النموذج بيانات التدريب و الوسيطات
- metrics.box.map # map50-95
- metrics.box.map50 # map50
- metrics.box.map75 # map75
- metrics.box.maps # قائمة تحتوي map50-95 لكل فئة
- ```
- === "CLI"
-
- ```bash
- yolo detect val model=yolov8n.pt # التحقق من النموذج الرسمي
- yolo detect val model=path/to/best.pt # التحقق من النموذج المخصص
- ```
-
-## التنبؤ
-
-استخدم نموذج YOLOv8n المدرب مسبقًا لتشغيل التنبؤات على الصور.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل نموذج
- model = YOLO('yolov8n.pt') # قم بتحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # قم بتحميل نموذج مخصص
-
- # أجرِ التنبؤ باستخدام النموذج
- results = model('https://ultralytics.com/images/bus.jpg') # التنبؤ على صورة
- ```
- === "CLI"
-
- ```bash
- yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # التنبؤ باستخدام النموذج الرسمي
- yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # التنبؤ بالنموذج المخصص
- ```
-
-انظر تفاصيل وضع الـ `predict` الكامل في صفحة [Predict](https://docs.ultralytics.com/modes/predict/).
-
-## تصدير
-
-قم بتصدير نموذج YOLOv8n إلى تنسيق مختلف مثل ONNX، CoreML وغيرها.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل نموذج
- model = YOLO('yolov8n.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مدرب مخصص
-
- # قم بتصدير النموذج
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n.pt format=onnx # تصدير النموذج الرسمي
- yolo export model=path/to/best.pt format=onnx # تصدير النموذج المدرب مخصص
- ```
-
-التنسيقات المدعومة لتصدير YOLOv8 مدرجة في الجدول أدناه. يمكنك التنبؤ أو التحقق من صحة النماذج المصدرة مباشرة، على سبيل المثال `yolo predict model=yolov8n.onnx`. سيتم عرض أمثلة استخدام لنموذجك بعد اكتمال التصدير.
-
-| الشكل | مسافة `format` | النموذج | بيانات الوصف | وسيطات |
-|--------------------------------------------------------------------|----------------|---------------------------|--------------|-----------------------------------------------------|
-| [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` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
-
-انظر تفاصيل كاملة للـ `export` في صفحة [Export](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/ar/tasks/index.md b/docs/ar/tasks/index.md
deleted file mode 100644
index dfb2f43da20..00000000000
--- a/docs/ar/tasks/index.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-comments: true
-description: تعرّف على المهام الأساسية لتقنية YOLOv8 للرؤية الحاسوبية والتي تشمل الكشف، التجزئة، التصنيف وتقدير الوضعية. تعرف على استخداماتها في مشاريع الذكاء الاصطناعي الخاصة بك.
-keywords: Ultralytics، YOLOv8، الكشف، التجزئة، التصنيف، تقدير الوضعية، الإطار الذكي للذكاء الاصطناعي، المهام الرؤية الحاسوبية
----
-
-# مهام Ultralytics YOLOv8
-
-
-
-
-YOLOv8 هو إطار ذكاء اصطناعي يدعم عدة **مهام** للرؤية الحاسوبية. يمكن استخدام الإطار لأداء [الكشف](detect.md)، [التجزئة](segment.md)، [التصنيف](classify.md)، و[تقدير الوضعية](pose.md). كل من هذه المهام لها هدف مختلف واستخدام محدد.
-
-!!! Note "ملاحظة"
-
- 🚧 يجري بناء وثائقنا متعددة اللغات حاليًا، ونعمل جاهدين على تحسينها. شكرًا لصبرك! 🙏
-
-
-
-## [الكشف](detect.md)
-
-الكشف هو المهمة الأساسية المدعومة بواسطة YOLOv8. يتضمن الكشف اكتشاف الكائنات في صورة أو إطار فيديو ورسم مربعات محيطة حولها. يتم تصنيف الكائنات المكتشفة إلى فئات مختلفة استنادًا إلى ميزاتها. يمكن لـ YOLOv8 اكتشاف أكثر من كائن واحد في صورة أو إطار فيديو واحد بدقة وسرعة عالية.
-
-[أمثلة للكشف](detect.md){ .md-button }
-
-## [التجزئة](segment.md)
-
-التجزئة هي مهمة تتضمن تقسيم صورة إلى مناطق مختلفة استنادًا إلى محتوى الصورة. يتم تعيين علامة لكل منطقة استنادًا إلى محتواها. تعتبر هذه المهمة مفيدة في تطبيقات مثل تجزئة الصور وتصوير الطبية. يستخدم YOLOv8 نسخة معدلة من هندسة U-Net لأداء التجزئة.
-
-[أمثلة للتجزئة](segment.md){ .md-button }
-
-## [التصنيف](classify.md)
-
-التصنيف هو مهمة تتضمن تصنيف صورة إلى فئات مختلفة. يمكن استخدام YOLOv8 لتصنيف الصور استنادًا إلى محتواها. يستخدم نسخة معدلة من هندسة EfficientNet لأداء التصنيف.
-
-[أمثلة للتصنيف](classify.md){ .md-button }
-
-## [تقدير الوضعية](pose.md)
-
-تقدير الوضعية/النقاط الرئيسية هو مهمة تتضمن اكتشاف نقاط محددة في صورة أو إطار فيديو. يُشار إلى هذه النقاط بمصطلح النقاط الرئيسية وتُستخدم لتتبع الحركة أو تقدير الوضعية. يمكن لـ YOLOv8 اكتشاف النقاط الرئيسية في صورة أو إطار فيديو بدقة وسرعة عالية.
-
-[أمثلة لتقدير الوضعية](pose.md){ .md-button }
-
-## الاستنتاج
-
-يدعم YOLOv8 مهام متعددة، بما في ذلك الكشف، التجزئة، التصنيف، وكشف النقاط الرئيسية. لكل من هذه المهام أهداف واستخدامات مختلفة. عن طريق فهم الاختلافات بين هذه المهام، يمكنك اختيار المهمة المناسبة لتطبيق الرؤية الحاسوبية الخاص بك.
diff --git a/docs/ar/tasks/pose.md b/docs/ar/tasks/pose.md
deleted file mode 100644
index 7d5627fa8d9..00000000000
--- a/docs/ar/tasks/pose.md
+++ /dev/null
@@ -1,186 +0,0 @@
----
-comments: true
-description: تعرّف على كيفية استخدام Ultralytics YOLOv8 لمهام تقدير الوضعية. اعثر على نماذج مدرّبة مسبقًا، وتعلم كيفية التدريب والتحقق والتنبؤ وتصدير نموذجك الخاص.
-keywords: Ultralytics، YOLO، YOLOv8، تقدير الوضعية ، كشف نقاط المفاتيح ، كشف الكائنات ، نماذج مدرّبة مسبقًا ، تعلم الآلة ، الذكاء الاصطناعي
----
-
-# تقدير الوضعية
-
-تقدير الوضعية هو مهمة تنطوي على تحديد موقع نقاط محددة في الصورة ، وعادةً ما يشار إليها بنقاط الوضوح. يمكن أن تمثل نقاط الوضوح أجزاءً مختلفةً من الكائن مثل المفاصل أو العلامات المميزة أو الميزات البارزة الأخرى. عادةً ما يتم تمثيل مواقع نقاط الوضوح كمجموعة من الإحداثيات 2D `[x ، y]` أو 3D `[x ، y ، visible]`.
-
-يكون ناتج نموذج تقدير الوضعية مجموعة من النقاط التي تمثل نقاط الوضوح على كائن في الصورة ، عادةً مع نقاط الثقة لكل نقطة. تقدير الوضعية هو خيار جيد عندما تحتاج إلى تحديد أجزاء محددة من كائن في مشهد، وموقعها بالنسبة لبعضها البعض.
-
-
-
-!!! Tip "نصيحة"
-
- النماذج التي تحتوي على البادئة "-pose" تستخدم لنماذج YOLOv8 pose ، على سبيل المثال `yolov8n-pose.pt`. هذه النماذج مدربة على [مجموعة بيانات نقاط الوضوح COCO]("https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml") وهي مناسبة لمجموعة متنوعة من مهام تقدير الوضعية.
-
-## [النماذج]("https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8")
-
-تعرض نماذج مدرّبة مسبقًا لـ YOLOv8 التي تستخدم لتقدير الوضعية هنا. النماذج للكشف والشريحة والوضعية يتم تدريبها على [مجموعة بيانات COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)، بينما تتم تدريب نماذج التصنيف على مجموعة بيانات ImageNet.
-
-يتم تنزيل النماذج من [آخر إصدار Ultralytics]("https://github.com/ultralytics/assets/releases") تلقائيًا عند استخدامها لأول مرة.
-
-| النموذج | الحجم (بالبكسل) | mAPالوضعية 50-95 | mAPالوضعية 50 | سرعةالوحدة المركزية ONNX(ms) | سرعةA100 TensorRT(ms) | المعلمات (مليون) | FLOPs (بالمليار) |
-|------------------------------------------------------------------------------------------------------|-----------------|-----------------------|--------------------|----------------------------------------|---------------------------------|------------------|------------------|
-| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
-
-- تعتبر القيم **mAPval** لنموذج واحد ومقياس واحد فقط على [COCO Keypoints val2017](https://cocodataset.org)
- مجموعة البيانات.
- يمكن إعادة إنتاجه بواسطة `يولو val pose data=coco-pose.yaml device=0`
-- يتم حساب **السرعة** من خلال متوسط صور COCO val باستخدام [المروحة الحرارية Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
- مثيل.
- يمكن إعادة إنتاجه بواسطة `يولو val pose data=coco8-pose.yaml batch=1 device=0|cpu`
-
-## التدريب
-
-يتم تدريب نموذج YOLOv8-pose على مجموعة بيانات COCO128-pose.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n-pose.yaml') # بناء نموذج جديد من ملف YAML
- model = YOLO('yolov8n-pose.pt') # تحميل نموذج مدرّب مسبقًا (موصى به للتدريب)
- model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # بناء نموذج من YAML ونقل الوزن
-
- # تدريب النموذج
- results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
- ```
- === "CLI"
-
- ```bash
- # بناء نموذج جديد من YAML وبدء التدريب من البداية.
- yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
-
- # البدء في التدريب من نموذج مدرب مسبقًا *.pt
- yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
-
- # بناء نموذج جديد من YAML ، ونقل الأوزان المدرّبة مسبقًا إليه ، والبدء في التدريب.
- yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
- ```
-
-### تنسيق مجموعة البيانات
-
-يمكن العثور على تنسيق مجموعات بيانات نقاط الوضوح YOLO في [دليل المجموعة البيانات](../../../datasets/pose/index.md). لتحويل مجموعة البيانات الحالية التي لديك من تنسيقات أخرى (مثل COCO إلخ) إلى تنسيق YOLO ، يرجى استخدام أداة [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) من Ultralytics.
-
-## التحقق من الصحة
-
-تحقق من دقة نموذج YOLOv8n-pose المدرّب على مجموعة بيانات COCO128-pose. لا يلزم تمرير سبب ما كوسيط إلى `model`
-عند استدعاء.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n-pose.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مخصص
-
- # التحقق من النموذج
- metrics = model.val() # لا يوجد حاجة لأي سبب، يتذكر النموذج البيانات والوسائط كمجالات للنموذج
- metrics.box.map # map50-95
- metrics.box.map50 # map50
- metrics.box.map75 # map75
- metrics.box.maps # قائمة تحتوي على map50-95 لكل فئة
- ```
- === "CLI"
-
- ```bash
- yolo pose val model=yolov8n-pose.pt # التحقق من النموذج الرسمي
- yolo pose val model=path/to/best.pt # التحقق من النموذج المخصص
- ```
-
-## التنبؤ
-
-استخدم نموذج YOLOv8n-pose المدرّب لتشغيل توقعات على الصور.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n-pose.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مخصص
-
- # التنبؤ باستخدام النموذج
- results = model('https://ultralytics.com/images/bus.jpg') # التنبؤ بصورة
- ```
- === "CLI"
-
- ```bash
- yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # التنبؤ باستخدام النموذج الرسمي
- yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # التنبؤ باستخدام النموذج المخصص
- ```
-
-انظر تفاصيل `predict` كاملة في [صفحة التنبؤ](https://docs.ultralytics.com/modes/predict/).
-
-## التصدير
-
-قم بتصدير نموذج YOLOv8n-pose إلى تنسيق مختلف مثل ONNX، CoreML، الخ.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # تحميل النموذج
- model = YOLO('yolov8n-pose.pt') # تحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # تحميل نموذج مدرب مخصص
-
- # تصدير النموذج
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n-pose.pt format=onnx # تصدير نموذج رسمي
- yolo export model=path/to/best.pt format=onnx # تصدير نموذج مخصص
- ```
-
-تتوفر تنسيقات تصدير YOLOv8-pose في الجدول أدناه. يمكنك التنبؤ أو التحقق مباشرةً على النماذج المصدرة ، على سبيل المثال `yolo predict model=yolov8n-pose.onnx`. توجد أمثلة استخدام متاحة لنموذجك بعد اكتمال عملية التصدير.
-
-| تنسيق | إجراء `format` | النموذج | البيانات الوصفية | الوسائط |
-|--------------------------------------------------------------------|----------------|--------------------------------|------------------|-----------------------------------------------------|
-| [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` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` |
-
-انظر تفاصيل `export` كاملة في [صفحة التصدير](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/ar/tasks/segment.md b/docs/ar/tasks/segment.md
deleted file mode 100644
index 9a81e6bc3fb..00000000000
--- a/docs/ar/tasks/segment.md
+++ /dev/null
@@ -1,189 +0,0 @@
----
-comments: true
-description: تعلم كيفية استخدام نماذج فصل الأشكال الفردية مع Ultralytics YOLO. تعليمات حول التدريب والتحقق من الصحة وتوقع الصورة وتصدير النموذج.
-keywords: yolov8 ، فصل الأشكال الفردية ، Ultralytics ، مجموعة بيانات COCO ، تجزئة الصورة ، كشف الكائنات ، تدريب النموذج ، التحقق من صحة النموذج ، توقع الصورة ، تصدير النموذج
----
-
-# فصل الأشكال الفردية
-
-
-
-يذهب فصل الأشكال الفردية خطوة أبعد من كشف الكائنات وينطوي على تحديد الكائنات الفردية في صورة وتجزيئها عن بقية الصورة.
-
-ناتج نموذج فصل الأشكال الفردية هو مجموعة من الأقنعة أو الحدود التي تحدد كل كائن في الصورة ، جنبًا إلى جنب مع تصنيف الصنف ونقاط الثقة لكل كائن. يكون فصل الأشكال الفردية مفيدًا عندما تحتاج إلى معرفة ليس فقط أين توجد الكائنات في الصورة ، ولكن أيضًا ما هو شكلها الدقيق.
-
-
-
-
-
- المشاهدة: تشغيل فصل الأشكال مع نموذج Ultralytics YOLOv8 مدرب مسبقًا باستخدام Python.
-
-
-!!! Tip "نصيحة"
-
- تستخدم نماذج YOLOv8 Seg اللاحقة `-seg`، أي `yolov8n-seg.pt` وتكون مدربة مسبقًا على [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
-
-## [النماذج](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-تُعرض هنا النماذج الجاهزة المدربة مسبقًا لـ YOLOv8 Segment. يتم تدريب نماذج الكشف والتجزيء والمواقف على مجموعة البيانات [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) ، بينما تدرب نماذج التصنيف على مجموعة البيانات [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-تتم تنزيل [النماذج](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) تلقائيًا من [الإصدار](https://github.com/ultralytics/assets/releases) الأخير لـ Ultralytics عند أول استخدام.
-
-| النموذج | الحجم بكسل | mAPbox 50-95 | mAPmask 50-95 | السرعة CPU ONNX (مللي ثانية) | السرعة A100 TensorRT (مللي ثانية) | المعلمات (مليون) | FLOPs (مليار) |
-|----------------------------------------------------------------------------------------------|--------------------|----------------------|-----------------------|-----------------------------------------|----------------------------------------------|--------------------------|-----------------------|
-| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
-
-- تُستخدم قيم **mAPval** لنموذج واحد وحجم واحد على مجموعة بيانات [COCO val2017](https://cocodataset.org).
- يمكن إعادة إنتاجها باستخدام `yolo val segment data=coco.yaml device=0`
-- **تُحسب السرعة** كمتوسط على صور COCO val باستخدام [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
- instance.
- يمكن إعادة إنتاجها باستخدام `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
-
-## التدريب
-
-قم بتدريب YOLOv8n-seg على مجموعة بيانات COCO128-seg لمدة 100 دورة عند حجم صورة 640. للحصول على قائمة كاملة بالوسائط المتاحة ، راجع صفحة [التكوين](/../usage/cfg.md).
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل النموذج
- model = YOLO('yolov8n-seg.yaml') # قم ببناء نموذج جديد من ملف YAML
- model = YOLO('yolov8n-seg.pt') # قم بتحميل نموذج مدرب مسبقًا (موصى به للتدريب)
- model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # قم ببنائه من YAML ونقل الوزن
-
- # قم بتدريب النموذج
- results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
- ```
- === "CLI"
-
- ```bash
- # قم ببناء نموذج جديد من ملف YAML وبدء التدريب من البداية
- yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
-
- # قم ببدء التدريب من نموذج *.pt مدرب مسبقًا
- yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
-
- # قم ببناء نموذج جديد من YAML ونقل الأوزان المدربة مسبَقًا إليه وابدأ التدريب
- yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
- ```
-
-### تنسيق مجموعة البيانات
-
-يمكن العثور على تنسيق مجموعة بيانات تجزيء YOLO بالتفصيل في [دليل مجموعة البيانات](../../../datasets/segment/index.md). لتحويل مجموعة البيانات الحالية التي تتبع تنسيقات أخرى (مثل COCO إلخ) إلى تنسيق YOLO ، يُرجى استخدام أداة [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) من Ultralytics.
-
-## التحقق من الصحة
-
-قم بالتحقق من دقة نموذج YOLOv8n-seg المدرب على مجموعة بيانات COCO128-seg. لا حاجة لتمرير أي وسيطة كما يحتفظ النموذج ببيانات "تدريبه" والوسيطات كسمات النموذج.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل النموذج
- model = YOLO('yolov8n-seg.pt') # قم بتحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # قم بتحميل نموذج مخصص
-
- # قم بالتحقق من النموذج
- metrics = model.val() # لا حاجة إلى أي وسيطة ، يتذكر النموذج بيانات التدريب والوسيطات كسمات النموذج
- metrics.box.map # map50-95(B)
- metrics.box.map50 # map50(B)
- metrics.box.map75 # map75(B)
- metrics.box.maps # قائمة تحتوي على map50-95(B) لكل فئة
- metrics.seg.map # map50-95(M)
- metrics.seg.map50 # map50(M)
- metrics.seg.map75 # map75(M)
- metrics.seg.maps # قائمة تحتوي على map50-95(M) لكل فئة
- ```
- === "CLI"
-
- ```bash
- yolo segment val model=yolov8n-seg.pt # التحقق من النموذج الرسمي
- yolo segment val model=path/to/best.pt # التحقق من النموذج المخصص
- ```
-
-## التنبؤ
-
-استخدم نموذج YOLOv8n-seg المدرب للقيام بالتنبؤات على الصور.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل النموذج
- model = YOLO('yolov8n-seg.pt') # قم بتحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # قم بتحميل نموذج مخصص
-
- # التنبؤ باستخدام النموذج
- results = model('https://ultralytics.com/images/bus.jpg') # التنبؤ على صورة
- ```
- === "CLI"
-
- ```bash
- yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # التنبؤ باستخدام النموذج الرسمي
- yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # التنبؤ باستخدام النموذج المخصص
- ```
-
-انظر تفاصيل "التنبؤ" الكاملة في [الصفحة](https://docs.ultralytics.com/modes/predict/).
-
-## التصدير
-
-قم بتصدير نموذج YOLOv8n-seg إلى تنسيق مختلف مثل ONNX و CoreML وما إلى ذلك.
-
-!!! Example "مثال"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # قم بتحميل النموذج
- model = YOLO('yolov8n-seg.pt') # قم بتحميل نموذج رسمي
- model = YOLO('path/to/best.pt') # قم بتحميل نموذج مدرب مخصص
-
- # قم بتصدير النموذج
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n-seg.pt format=onnx # تصدير نموذج رسمي
- yolo export model=path/to/best.pt format=onnx # تصدير نموذج مدرب مخصص
- ```
-
-صيغ تصدير YOLOv8-seg المتاحة في الجدول أدناه. يمكنك التنبؤ أو التحقق من صحة الموديل المصدر بشكل مباشر ، أي `yolo predict model=yolov8n-seg.onnx`. يتم عرض أمثلة عن الاستخدام لنموذجك بعد اكتمال التصدير.
-
-| الصيغة | `format` Argument | النموذج | التعليمات | الخيارات |
-|--------------------------------------------------------------------|-------------------|-------------------------------|-----------|-------------------------------------------------|
-| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - |
-| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `الحجم ، الأمان` |
-| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `الحجم ، half ، dynamic ، simplify ، opset` |
-| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `الحجم ، half` |
-| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `الحجم ، half ، dynamic ، simplify ، workspace` |
-| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `الحجم ، half ، int8 ، nms` |
-| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `الحجم ، keras` |
-| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `الحجم` |
-| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `الحجم ، half ، int8` |
-| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `الحجم` |
-| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `الحجم` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `الحجم` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `الحجم ، half` |
-
-انظر تفاصيل "التصدير" الكاملة في [الصفحة](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/build_docs.py b/docs/build_docs.py
index 1f0911b9f5b..71556781b98 100644
--- a/docs/build_docs.py
+++ b/docs/build_docs.py
@@ -35,7 +35,7 @@
SITE = DOCS.parent / "site"
-def build_docs(use_languages=False, clone_repos=True):
+def build_docs(clone_repos=True):
"""Build docs using mkdocs."""
if SITE.exists():
print(f"Removing existing {SITE}")
@@ -56,52 +56,10 @@ def build_docs(use_languages=False, clone_repos=True):
# Build the main documentation
print(f"Building docs from {DOCS}")
- subprocess.run(f"mkdocs build -f {DOCS}/mkdocs.yml", check=True, shell=True)
-
- # Build other localized documentations
- if use_languages:
- for file in DOCS.glob("mkdocs_*.yml"):
- print(f"Building MkDocs site with configuration file: {file}")
- subprocess.run(f"mkdocs build -f {file}", check=True, shell=True)
- update_html_links() # update .md in href links
+ subprocess.run(f"mkdocs build -f {DOCS.parent}/mkdocs.yml", check=True, shell=True)
print(f"Site built at {SITE}")
-def update_html_links():
- """Update href links in HTML files to remove '.md' and '/index.md', excluding links starting with 'https://'."""
- html_files = SITE.rglob("*.html")
- total_updated_links = 0
-
- for html_file in html_files:
- with open(html_file, "r+", encoding="utf-8") as file:
- content = file.read()
- # Find all links to be updated, excluding those starting with 'https://'
- links_to_update = re.findall(r'href="(?!https://)([^"]+?)(/index)?\.md"', content)
-
- # Update the content and count the number of links updated
- updated_content, number_of_links_updated = re.subn(
- r'href="(?!https://)([^"]+?)(/index)?\.md"', r'href="\1"', content
- )
- total_updated_links += number_of_links_updated
-
- # Special handling for '/index' links
- updated_content, number_of_index_links_updated = re.subn(
- r'href="([^"]+)/index"', r'href="\1/"', updated_content
- )
- total_updated_links += number_of_index_links_updated
-
- # Write the updated content back to the file
- file.seek(0)
- file.write(updated_content)
- file.truncate()
-
- # Print updated links for this file
- for link in links_to_update:
- print(f"Updated link in {html_file}: {link[0]}")
-
- print(f"Total number of links updated: {total_updated_links}")
-
-
def update_page_title(file_path: Path, new_title: str):
"""Update the title of an HTML file."""
@@ -170,7 +128,9 @@ def main():
)
# Update HTML file head section
- # update_html_head("")
+ script = ""
+ if any(script):
+ update_html_head(script)
# Show command to serve built website
print('Serve site at http://localhost:8000 with "python -m http.server --directory site"')
diff --git a/docs/de/datasets/index.md b/docs/de/datasets/index.md
deleted file mode 100644
index 53a96e51fb4..00000000000
--- a/docs/de/datasets/index.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-comments: true
-description: Erkunden Sie verschiedene von Ultralytics unterstützte Computer Vision Datensätze für Objekterkennung, Segmentierung, Posenschätzung, Bildklassifizierung und Multi-Objekt-Verfolgung.
-keywords: Computer Vision, Datensätze, Ultralytics, YOLO, Objekterkennung, Instanzsegmentierung, Posenschätzung, Bildklassifizierung, Multi-Objekt-Verfolgung
----
-
-# Übersicht über Datensätze
-
-Ultralytics bietet Unterstützung für verschiedene Datensätze an, um Computervisionsaufgaben wie Erkennung, Instanzsegmentierung, Posenschätzung, Klassifizierung und Verfolgung mehrerer Objekte zu erleichtern. Unten finden Sie eine Liste der wichtigsten Ultralytics-Datensätze, gefolgt von einer Zusammenfassung jeder Computervisionsaufgabe und den jeweiligen Datensätzen.
-
-!!! Note "Hinweis"
-
- 🚧 Unsere mehrsprachige Dokumentation befindet sich derzeit im Aufbau und wir arbeiten intensiv an deren Verbesserung. Vielen Dank für Ihre Geduld! 🙏
-
-## [Erkennungsdatensätze](../../datasets/detect/index.md)
-
-Die Objekterkennung mittels Bounding Box ist eine Computervisionstechnik, die das Erkennen und Lokalisieren von Objekten in einem Bild anhand des Zeichnens einer Bounding Box um jedes Objekt beinhaltet.
-
-- [Argoverse](../../datasets/detect/argoverse.md): Ein Datensatz mit 3D-Tracking- und Bewegungsvorhersagedaten aus städtischen Umgebungen mit umfassenden Annotationen.
-- [COCO](../../datasets/detect/coco.md): Ein umfangreicher Datensatz für Objekterkennung, Segmentierung und Beschreibung mit über 200.000 beschrifteten Bildern.
-- [COCO8](../../datasets/detect/coco8.md): Enthält die ersten 4 Bilder aus COCO Train und COCO Val, geeignet für schnelle Tests.
-- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Ein Datensatz mit Bildern von Weizenköpfen aus aller Welt für Objekterkennungs- und Lokalisierungsaufgaben.
-- [Objects365](../../datasets/detect/objects365.md): Ein hochwertiger, großer Datensatz für Objekterkennung mit 365 Objektkategorien und über 600.000 annotierten Bildern.
-- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Ein umfassender Datensatz von Google mit 1,7 Millionen Trainingsbildern und 42.000 Validierungsbildern.
-- [SKU-110K](../../datasets/detect/sku-110k.md): Ein Datensatz mit dichter Objekterkennung in Einzelhandelsumgebungen mit über 11.000 Bildern und 1,7 Millionen Bounding Boxen.
-- [VisDrone](../../datasets/detect/visdrone.md): Ein Datensatz mit Objekterkennungs- und Multi-Objekt-Tracking-Daten aus Drohnenaufnahmen mit über 10.000 Bildern und Videosequenzen.
-- [VOC](../../datasets/detect/voc.md): Der Pascal Visual Object Classes (VOC) Datensatz für Objekterkennung und Segmentierung mit 20 Objektklassen und über 11.000 Bildern.
-- [xView](../../datasets/detect/xview.md): Ein Datensatz für Objekterkennung in Überwachungsbildern mit 60 Objektkategorien und über 1 Million annotierten Objekten.
-
-## [Datensätze für Instanzsegmentierung](../../datasets/segment/index.md)
-
-Die Instanzsegmentierung ist eine Computervisionstechnik, die das Identifizieren und Lokalisieren von Objekten in einem Bild auf Pixelebene beinhaltet.
-
-- [COCO](../../datasets/segment/coco.md): Ein großer Datensatz für Objekterkennung, Segmentierung und Beschreibungsaufgaben mit über 200.000 beschrifteten Bildern.
-- [COCO8-seg](../../datasets/segment/coco8-seg.md): Ein kleinerer Datensatz für Instanzsegmentierungsaufgaben, der eine Teilmenge von 8 COCO-Bildern mit Segmentierungsannotationen enthält.
-
-## [Posenschätzung](../../datasets/pose/index.md)
-
-Die Posenschätzung ist eine Technik, die verwendet wird, um die Position des Objekts relativ zur Kamera oder zum Weltkoordinatensystem zu bestimmen.
-
-- [COCO](../../datasets/pose/coco.md): Ein großer Datensatz mit menschlichen Pose-Annotationen für Posenschätzungsaufgaben.
-- [COCO8-pose](../../datasets/pose/coco8-pose.md): Ein kleinerer Datensatz für Posenschätzungsaufgaben, der eine Teilmenge von 8 COCO-Bildern mit menschlichen Pose-Annotationen enthält.
-- [Tiger-pose](../../datasets/pose/tiger-pose.md): Ein kompakter Datensatz bestehend aus 263 Bildern, die auf Tiger fokussiert sind, mit Annotationen von 12 Schlüsselpunkten pro Tiger für Posenschätzungsaufgaben.
-
-## [Bildklassifizierung](../../datasets/classify/index.md)
-
-Die Bildklassifizierung ist eine Computervisionsaufgabe, bei der ein Bild basierend auf seinem visuellen Inhalt in eine oder mehrere vordefinierte Klassen oder Kategorien eingeteilt wird.
-
-- [Caltech 101](../../datasets/classify/caltech101.md): Enthält Bilder von 101 Objektkategorien für Bildklassifizierungsaufgaben.
-- [Caltech 256](../../datasets/classify/caltech256.md): Eine erweiterte Version von Caltech 101 mit 256 Objektkategorien und herausfordernderen Bildern.
-- [CIFAR-10](../../datasets/classify/cifar10.md): Ein Datensatz mit 60.000 32x32 Farbbildern in 10 Klassen, mit 6.000 Bildern pro Klasse.
-- [CIFAR-100](../../datasets/classify/cifar100.md): Eine erweiterte Version von CIFAR-10 mit 100 Objektkategorien und 600 Bildern pro Klasse.
-- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Ein Datensatz mit 70.000 Graustufenbildern von 10 Modekategorien für Bildklassifizierungsaufgaben.
-- [ImageNet](../../datasets/classify/imagenet.md): Ein großer Datensatz für Objekterkennung und Bildklassifizierung mit über 14 Millionen Bildern und 20.000 Kategorien.
-- [ImageNet-10](../../datasets/classify/imagenet10.md): Ein kleinerer Teildatensatz von ImageNet mit 10 Kategorien für schnelleres Experimentieren und Testen.
-- [Imagenette](../../datasets/classify/imagenette.md): Ein kleinerer Teildatensatz von ImageNet, der 10 leicht unterscheidbare Klassen für ein schnelleres Training und Testen enthält.
-- [Imagewoof](../../datasets/classify/imagewoof.md): Ein herausfordernderer Teildatensatz von ImageNet mit 10 Hundezuchtkategorien für Bildklassifizierungsaufgaben.
-- [MNIST](../../datasets/classify/mnist.md): Ein Datensatz mit 70.000 Graustufenbildern von handgeschriebenen Ziffern für Bildklassifizierungsaufgaben.
-
-## [Orientierte Bounding Boxes (OBB)](../../datasets/obb/index.md)
-
-Orientierte Bounding Boxes (OBB) ist eine Methode in der Computervision für die Erkennung von geneigten Objekten in Bildern mithilfe von rotierten Bounding Boxen, die oft auf Luft- und Satellitenbilder angewendet wird.
-
-- [DOTAv2](../../datasets/obb/dota-v2.md): Ein beliebter OBB-Datensatz für Luftbildaufnahmen mit 1,7 Millionen Instanzen und 11.268 Bildern.
-
-## [Multi-Objekt-Verfolgung](../../datasets/track/index.md)
-
-Die Verfolgung mehrerer Objekte ist eine Computervisionstechnik, die das Erkennen und Verfolgen mehrerer Objekte über die Zeit in einer Videosequenz beinhaltet.
-
-- [Argoverse](../../datasets/detect/argoverse.md): Ein Datensatz mit 3D-Tracking- und Bewegungsvorhersagedaten aus städtischen Umgebungen mit umfassenden Annotationen für Multi-Objekt-Verfolgungsaufgaben.
-- [VisDrone](../../datasets/detect/visdrone.md): Ein Datensatz mit Daten zur Objekterkennung und Multi-Objekt-Verfolgung aus Drohnenaufnahmen mit über 10.000 Bildern und Videosequenzen.
-
-## Neue Datensätze beitragen
-
-Das Bereitstellen eines neuen Datensatzes umfasst mehrere Schritte, um sicherzustellen, dass er gut in die bestehende Infrastruktur integriert werden kann. Unten finden Sie die notwendigen Schritte:
-
-### Schritte um einen neuen Datensatz beizutragen
-
-1. **Bilder sammeln**: Sammeln Sie die Bilder, die zum Datensatz gehören. Diese können von verschiedenen Quellen gesammelt werden, wie öffentlichen Datenbanken oder Ihrer eigenen Sammlung.
-
-2. **Bilder annotieren**: Annotieren Sie diese Bilder mit Bounding Boxen, Segmenten oder Schlüsselpunkten, je nach Aufgabe.
-
-3. **Annotationen exportieren**: Konvertieren Sie diese Annotationen in das von Ultralytics unterstützte YOLO `*.txt`-Dateiformat.
-
-4. **Datensatz organisieren**: Ordnen Sie Ihren Datensatz in die richtige Ordnerstruktur an. Sie sollten übergeordnete Verzeichnisse `train/` und `val/` haben, und innerhalb dieser je ein Unterverzeichnis `images/` und `labels/`.
-
- ```
- dataset/
- ├── train/
- │ ├── images/
- │ └── labels/
- └── val/
- ├── images/
- └── labels/
- ```
-
-5. **Eine `data.yaml`-Datei erstellen**: Erstellen Sie in Ihrem Stammverzeichnis des Datensatzes eine Datei `data.yaml`, die den Datensatz, die Klassen und andere notwendige Informationen beschreibt.
-
-6. **Bilder optimieren (Optional)**: Wenn Sie die Größe des Datensatzes für eine effizientere Verarbeitung reduzieren möchten, können Sie die Bilder mit dem untenstehenden Code optimieren. Dies ist nicht erforderlich, wird aber für kleinere Datensatzgrößen und schnellere Download-Geschwindigkeiten empfohlen.
-
-7. **Datensatz zippen**: Komprimieren Sie das gesamte Datensatzverzeichnis in eine Zip-Datei.
-
-8. **Dokumentation und PR**: Erstellen Sie eine Dokumentationsseite, die Ihren Datensatz beschreibt und wie er in das bestehende Framework passt. Danach reichen Sie einen Pull Request (PR) ein. Weitere Details zur Einreichung eines PR finden Sie in den [Ultralytics Beitragshinweisen](https://docs.ultralytics.com/help/contributing).
-
-### Beispielcode zum Optimieren und Zippen eines Datensatzes
-
-!!! Example "Optimieren und Zippen eines Datensatzes"
-
- === "Python"
-
- ```python
- from pathlib import Path
- from ultralytics.data.utils import compress_one_image
- from ultralytics.utils.downloads import zip_directory
-
- # Definieren des Verzeichnisses des Datensatzes
- path = Path('Pfad/zum/Datensatz')
-
- # Bilder im Datensatz optimieren (optional)
- for f in path.rglob('*.jpg'):
- compress_one_image(f)
-
- # Datensatz in 'Pfad/zum/Datensatz.zip' zippen
- zip_directory(path)
- ```
-
-Indem Sie diesen Schritten folgen, können Sie einen neuen Datensatz beitragen, der gut in die bestehende Struktur von Ultralytics integriert wird.
diff --git a/docs/de/index.md b/docs/de/index.md
deleted file mode 100644
index 1dca159f335..00000000000
--- a/docs/de/index.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-comments: true
-description: Entdecken Sie einen vollständigen Leitfaden zu Ultralytics YOLOv8, einem schnellen und präzisen Modell zur Objekterkennung und Bildsegmentierung. Installations-, Vorhersage-, Trainingstutorials und mehr.
-keywords: Ultralytics, YOLOv8, Objekterkennung, Bildsegmentierung, maschinelles Lernen, Deep Learning, Computer Vision, YOLOv8 Installation, YOLOv8 Vorhersage, YOLOv8 Training, YOLO-Geschichte, YOLO-Lizenzen
----
-
-
-
-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/docs/de/models/fast-sam.md b/docs/de/models/fast-sam.md
deleted file mode 100644
index e726c5cdf65..00000000000
--- a/docs/de/models/fast-sam.md
+++ /dev/null
@@ -1,193 +0,0 @@
----
-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.
-
-![Übersicht über die Architektur des Fast Segment Anything Model (FastSAM)](https://user-images.githubusercontent.com/26833433/248551984-d98f0f6d-7535-45d0-b380-2e1440b52ad7.jpg)
-
-## Ü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/docs/de/models/index.md b/docs/de/models/index.md
deleted file mode 100644
index 4482ccc0dcc..00000000000
--- a/docs/de/models/index.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-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/docs/de/models/mobile-sam.md b/docs/de/models/mobile-sam.md
deleted file mode 100644
index 7f301756b78..00000000000
--- a/docs/de/models/mobile-sam.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-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
----
-
-![MobileSAM Logo](https://github.com/ChaoningZhang/MobileSAM/blob/master/assets/logo2.png?raw=true)
-
-# 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.
-
-![Bild mit Punkt als Prompt](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-![Bild mit Kasten als Prompt](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-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/docs/de/models/rtdetr.md b/docs/de/models/rtdetr.md
deleted file mode 100644
index dbc0b412364..00000000000
--- a/docs/de/models/rtdetr.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-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.
-
-![Beispielbild des Modells](https://user-images.githubusercontent.com/26833433/238963168-90e8483f-90aa-4eb6-a5e1-0d408b23dd33.png)
-**Ü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/docs/de/models/sam.md b/docs/de/models/sam.md
deleted file mode 100644
index 9ca50b9e564..00000000000
--- a/docs/de/models/sam.md
+++ /dev/null
@@ -1,226 +0,0 @@
----
-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.
-
-![Beispielbild aus dem Datensatz](https://user-images.githubusercontent.com/26833433/238056229-0e8ffbeb-f81a-477e-a490-aff3d82fd8ce.jpg)
-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/docs/de/models/yolo-nas.md b/docs/de/models/yolo-nas.md
deleted file mode 100644
index 952aa2dcf13..00000000000
--- a/docs/de/models/yolo-nas.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-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.
-
-![Modellbeispielbild](https://learnopencv.com/wp-content/uploads/2023/05/yolo-nas_COCO_map_metrics.png)
-**Ü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/v8.1.0/yolo_nas_s.pt) | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_m.pt) | [Objekterkennung](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v8.1.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/docs/de/models/yolov3.md b/docs/de/models/yolov3.md
deleted file mode 100644
index de1cf46a60f..00000000000
--- a/docs/de/models/yolov3.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-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.
-
-![Ultralytics YOLOv3](https://raw.githubusercontent.com/ultralytics/assets/main/yolov3/banner-yolov3.png)
-
-## 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/docs/de/models/yolov4.md b/docs/de/models/yolov4.md
deleted file mode 100644
index 3d3fd2dcd27..00000000000
--- a/docs/de/models/yolov4.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-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](https://user-images.githubusercontent.com/26833433/246185689-530b7fe8-737b-4bb0-b5dd-de10ef5aface.png)
-**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/docs/de/models/yolov5.md b/docs/de/models/yolov5.md
deleted file mode 100644
index 049426067f8..00000000000
--- a/docs/de/models/yolov5.md
+++ /dev/null
@@ -1,113 +0,0 @@
----
-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.
-
-![Ultralytics YOLOv5](https://raw.githubusercontent.com/ultralytics/assets/main/yolov5/v70/splash.png)
-
-## 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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/docs/de/models/yolov6.md b/docs/de/models/yolov6.md
deleted file mode 100644
index 0246170c1f5..00000000000
--- a/docs/de/models/yolov6.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-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.
-
-![Meituan YOLOv6](https://user-images.githubusercontent.com/26833433/240750495-4da954ce-8b3b-41c4-8afd-ddb74361d3c2.png)
-![Modellbeispielbild](https://user-images.githubusercontent.com/26833433/240750557-3e9ec4f0-0598-49a8-83ea-f33c91eb6d68.png)
-**Ü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/docs/de/models/yolov7.md b/docs/de/models/yolov7.md
deleted file mode 100644
index 4edb9698b37..00000000000
--- a/docs/de/models/yolov7.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-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 YOLOv7 mit SOTA-Objektdetektoren](https://github.com/ultralytics/ultralytics/assets/26833433/5e1e0420-8122-4c79-b8d0-2860aa79af92)
-**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/docs/de/models/yolov8.md b/docs/de/models/yolov8.md
deleted file mode 100644
index 5229e8b3dad..00000000000
--- a/docs/de/models/yolov8.md
+++ /dev/null
@@ -1,162 +0,0 @@
----
-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.
-
-![Ultralytics YOLOv8](https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/yolo-comparison-plots.png)
-
-## 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/v8.1.0/yolov8n.pt) | 640 | 37,3 | 80,4 | 0,99 | 3,2 | 8,7 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44,9 | 128,4 | 1,20 | 11,2 | 28,6 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50,2 | 234,7 | 1,83 | 25,9 | 78,9 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52,9 | 375,2 | 2,39 | 43,7 | 165,2 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.0/yolov8n-oiv7.pt) | 640 | 18,4 | 142,4 | 1,21 | 3,5 | 10,5 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640 | 27,7 | 183,1 | 1,40 | 11,4 | 29,7 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640 | 33,6 | 408,5 | 2,26 | 26,2 | 80,6 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640 | 34,9 | 596,9 | 2,43 | 44,1 | 167,4 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640 | 36,3 | 860,6 | 3,56 | 68,7 | 260,6 |
-
- === "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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/docs/de/modes/benchmark.md b/docs/de/modes/benchmark.md
deleted file mode 100644
index 93908a14564..00000000000
--- a/docs/de/modes/benchmark.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-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/docs/de/modes/export.md b/docs/de/modes/export.md
deleted file mode 100644
index c62a1d6863c..00000000000
--- a/docs/de/modes/export.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-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/docs/de/modes/index.md b/docs/de/modes/index.md
deleted file mode 100644
index c73b488b626..00000000000
--- a/docs/de/modes/index.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-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/docs/de/modes/predict.md b/docs/de/modes/predict.md
deleted file mode 100644
index febec46dbaa..00000000000
--- a/docs/de/modes/predict.md
+++ /dev/null
@@ -1,227 +0,0 @@
----
-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 |
-|:---------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|
-| ![Ersatzteilerkennung für Fahrzeuge](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Erkennung von Fußballspielern](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Erkennung von stürzenden Personen](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) |
-| 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/docs/de/modes/track.md b/docs/de/modes/track.md
deleted file mode 100644
index f29dae9c318..00000000000
--- a/docs/de/modes/track.md
+++ /dev/null
@@ -1,200 +0,0 @@
----
-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](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Personenverfolgung](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Fischverfolgung](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) |
-| 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/docs/de/modes/train.md b/docs/de/modes/train.md
deleted file mode 100644
index b7ee65e50b4..00000000000
--- a/docs/de/modes/train.md
+++ /dev/null
@@ -1,206 +0,0 @@
----
-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/docs/de/modes/val.md b/docs/de/modes/val.md
deleted file mode 100644
index 3f0c1880b08..00000000000
--- a/docs/de/modes/val.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-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/docs/de/quickstart.md b/docs/de/quickstart.md
deleted file mode 100644
index 1c9e629eabb..00000000000
--- a/docs/de/quickstart.md
+++ /dev/null
@@ -1,198 +0,0 @@
----
-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/).
-
- [![PyPI-Version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
-
- ```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/).
-
-
- [![Conda Rezept](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Plattformen](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](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/pyproject.toml) 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/docs/de/tasks/classify.md b/docs/de/tasks/classify.md
deleted file mode 100644
index bc2cf9ff2c7..00000000000
--- a/docs/de/tasks/classify.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/docs/de/tasks/detect.md b/docs/de/tasks/detect.md
deleted file mode 100644
index 7ebd7a67f02..00000000000
--- a/docs/de/tasks/detect.md
+++ /dev/null
@@ -1,184 +0,0 @@
----
-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/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
-| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
-| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
-| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
-| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.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](https://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/docs/de/tasks/index.md b/docs/de/tasks/index.md
deleted file mode 100644
index 4077c5e4b58..00000000000
--- a/docs/de/tasks/index.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-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/docs/de/tasks/pose.md b/docs/de/tasks/pose.md
deleted file mode 100644
index be2905852da..00000000000
--- a/docs/de/tasks/pose.md
+++ /dev/null
@@ -1,185 +0,0 @@
----
-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
-
-![Beispiele für die Pose-Schätzung](https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png)
-
-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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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](https://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/docs/de/tasks/segment.md b/docs/de/tasks/segment.md
deleted file mode 100644
index 36638b62162..00000000000
--- a/docs/de/tasks/segment.md
+++ /dev/null
@@ -1,188 +0,0 @@
----
-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
-
-![Beispiele für Instanzsegmentierung](https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png)
-
-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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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](https://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/docs/es/datasets/index.md b/docs/es/datasets/index.md
deleted file mode 100644
index 06393fa24e2..00000000000
--- a/docs/es/datasets/index.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-comments: true
-description: Explore diferentes conjuntos de datos de visión por computadora soportados por Ultralytics para la detección de objetos, segmentación, estimación de poses, clasificación de imágenes y seguimiento de múltiples objetos.
-keywords: visión por computadora, conjuntos de datos, Ultralytics, YOLO, detección de objetos, segmentación de instancias, estimación de poses, clasificación de imágenes, seguimiento de múltiples objetos
----
-
-# Resumen de Conjuntos de Datos
-
-Ultralytics brinda soporte para varios conjuntos de datos para facilitar tareas de visión por computadora como detección, segmentación de instancias, estimación de poses, clasificación y seguimiento de múltiples objetos. A continuación se presenta una lista de los principales conjuntos de datos de Ultralytics, seguido por un resumen de cada tarea de visión por computadora y los respectivos conjuntos de datos.
-
-!!! Note "Nota"
-
- 🚧 Nuestra documentación multilingüe está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏
-
-## [Conjuntos de Datos de Detección](../../datasets/detect/index.md)
-
-La detección de objetos con cuadros delimitadores es una técnica de visión por computadora que implica detectar y localizar objetos en una imagen dibujando un cuadro alrededor de cada objeto.
-
-- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas.
-- [COCO](../../datasets/detect/coco.md): Un conjunto de datos a gran escala diseñado para detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas.
-- [COCO8](../../datasets/detect/coco8.md): Contiene las primeras 4 imágenes de COCO train y COCO val, adecuado para pruebas rápidas.
-- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Un conjunto de datos de imágenes de cabezas de trigo recolectadas alrededor del mundo para tareas de detección y localización de objetos.
-- [Objects365](../../datasets/detect/objects365.md): Un conjunto de datos a gran escala y de alta calidad para la detección de objetos con 365 categorías y más de 600 mil imágenes anotadas.
-- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Un conjunto de datos completo de Google con 1.7 millones de imágenes de entrenamiento y 42 mil imágenes de validación.
-- [SKU-110K](../../datasets/detect/sku-110k.md): Un conjunto de datos que presenta detección de objetos densa en entornos minoristas con más de 11 mil imágenes y 1.7 millones de cuadros delimitadores.
-- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video.
-- [VOC](../../datasets/detect/voc.md): El conjunto de datos de Clases de Objetos Visuales de Pascal (VOC) para la detección de objetos y segmentación con 20 clases de objetos y más de 11 mil imágenes.
-- [xView](../../datasets/detect/xview.md): Un conjunto de datos para la detección de objetos en imágenes aéreas con 60 categorías de objetos y más de un millón de objetos anotados.
-
-## [Conjuntos de Datos de Segmentación de Instancias](../../datasets/segment/index.md)
-
-La segmentación de instancias es una técnica de visión por computadora que implica identificar y localizar objetos en una imagen a nivel de píxel.
-
-- [COCO](../../datasets/segment/coco.md): Un conjunto de datos a gran escala diseñado para tareas de detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas.
-- [COCO8-seg](../../datasets/segment/coco8-seg.md): Un conjunto de datos más pequeño para tareas de segmentación de instancias, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de segmentación.
-
-## [Estimación de Poses](../../datasets/pose/index.md)
-
-La estimación de poses es una técnica utilizada para determinar la pose del objeto en relación con la cámara o el sistema de coordenadas del mundo.
-
-- [COCO](../../datasets/pose/coco.md): Un conjunto de datos a gran escala con anotaciones de pose humana diseñado para tareas de estimación de poses.
-- [COCO8-pose](../../datasets/pose/coco8-pose.md): Un conjunto de datos más pequeño para tareas de estimación de poses, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de pose humana.
-- [Tiger-pose](../../datasets/pose/tiger-pose.md): Un conjunto de datos compacto que consiste en 263 imágenes centradas en tigres, anotadas con 12 puntos clave por tigre para tareas de estimación de poses.
-
-## [Clasificación](../../datasets/classify/index.md)
-
-La clasificación de imágenes es una tarea de visión por computadora que implica categorizar una imagen en una o más clases o categorías predefinidas basadas en su contenido visual.
-
-- [Caltech 101](../../datasets/classify/caltech101.md): Un conjunto de datos que contiene imágenes de 101 categorías de objetos para tareas de clasificación de imágenes.
-- [Caltech 256](../../datasets/classify/caltech256.md): Una versión extendida de Caltech 101 con 256 categorías de objetos y imágenes más desafiantes.
-- [CIFAR-10](../../datasets/classify/cifar10.md): Un conjunto de datos de 60 mil imágenes a color de 32x32 en 10 clases, con 6 mil imágenes por clase.
-- [CIFAR-100](../../datasets/classify/cifar100.md): Una versión extendida de CIFAR-10 con 100 categorías de objetos y 600 imágenes por clase.
-- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Un conjunto de datos compuesto por 70 mil imágenes en escala de grises de 10 categorías de moda para tareas de clasificación de imágenes.
-- [ImageNet](../../datasets/classify/imagenet.md): Un conjunto de datos a gran escala para detección de objetos y clasificación de imágenes con más de 14 millones de imágenes y 20 mil categorías.
-- [ImageNet-10](../../datasets/classify/imagenet10.md): Un subconjunto más pequeño de ImageNet con 10 categorías para experimentación y pruebas más rápidas.
-- [Imagenette](../../datasets/classify/imagenette.md): Un subconjunto más pequeño de ImageNet que contiene 10 clases fácilmente distinguibles para entrenamientos y pruebas más rápidos.
-- [Imagewoof](../../datasets/classify/imagewoof.md): Un subconjunto más desafiante de ImageNet que contiene 10 categorías de razas de perros para tareas de clasificación de imágenes.
-- [MNIST](../../datasets/classify/mnist.md): Un conjunto de datos de 70 mil imágenes en escala de grises de dígitos escritos a mano para tareas de clasificación de imágenes.
-
-## [Cuadros Delimitadores Orientados (OBB)](../../datasets/obb/index.md)
-
-Los Cuadros Delimitadores Orientados (OBB) es un método en visión por computadora para detectar objetos angulados en imágenes utilizando cuadros delimitadores rotados, a menudo aplicado en imágenes aéreas y satelitales.
-
-- [DOTAv2](../../datasets/obb/dota-v2.md): Un popular conjunto de datos de imágenes aéreas de OBB con 1.7 millones de instancias y 11,268 imágenes.
-
-## [Seguimiento de Múltiples Objetos](../../datasets/track/index.md)
-
-El seguimiento de múltiples objetos es una técnica de visión por computadora que implica detectar y seguir múltiples objetos a lo largo del tiempo en una secuencia de video.
-
-- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas para tareas de seguimiento de múltiples objetos.
-- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video.
-
-## Contribuir con Nuevos Conjuntos de Datos
-
-Contribuir con un nuevo conjunto de datos implica varios pasos para garantizar que se alinee bien con la infraestructura existente. A continuación, se presentan los pasos necesarios:
-
-### Pasos para Contribuir con un Nuevo Conjunto de Datos
-
-1. **Recolectar Imágenes**: Reúne las imágenes que pertenecen al conjunto de datos. Estas podrían ser recopiladas de varias fuentes, tales como bases de datos públicas o tu propia colección.
-
-2. **Annotar Imágenes**: Anota estas imágenes con cuadros delimitadores, segmentos o puntos clave, dependiendo de la tarea.
-
-3. **Exportar Anotaciones**: Convierte estas anotaciones en el formato de archivo `*.txt` de YOLO que Ultralytics soporta.
-
-4. **Organizar Conjunto de Datos**: Organiza tu conjunto de datos en la estructura de carpetas correcta. Deberías tener directorios de nivel superior `train/` y `val/`, y dentro de cada uno, un subdirectorio `images/` y `labels/`.
-
- ```
- dataset/
- ├── train/
- │ ├── images/
- │ └── labels/
- └── val/
- ├── images/
- └── labels/
- ```
-
-5. **Crear un Archivo `data.yaml`**: En el directorio raíz de tu conjunto de datos, crea un archivo `data.yaml` que describa el conjunto de datos, clases y otra información necesaria.
-
-6. **Optimizar Imágenes (Opcional)**: Si deseas reducir el tamaño del conjunto de datos para un procesamiento más eficiente, puedes optimizar las imágenes usando el código a continuación. Esto no es requerido, pero se recomienda para tamaños de conjuntos de datos más pequeños y velocidades de descarga más rápidas.
-
-7. **Comprimir Conjunto de Datos**: Comprime toda la carpeta del conjunto de datos en un archivo .zip.
-
-8. **Documentar y PR**: Crea una página de documentación describiendo tu conjunto de datos y cómo encaja en el marco existente. Después de eso, envía una Solicitud de Extracción (PR). Consulta las [Pautas de Contribución de Ultralytics](https://docs.ultralytics.com/help/contributing) para obtener más detalles sobre cómo enviar una PR.
-
-### Código de Ejemplo para Optimizar y Comprimir un Conjunto de Datos
-
-!!! Example "Optimizar y Comprimir un Conjunto de Datos"
-
- === "Python"
-
- ```python
- from pathlib import Path
- from ultralytics.data.utils import compress_one_image
- from ultralytics.utils.downloads import zip_directory
-
- # Definir el directorio del conjunto de datos
- path = Path('ruta/al/conjunto-de-datos')
-
- # Optimizar imágenes en el conjunto de datos (opcional)
- for f in path.rglob('*.jpg'):
- compress_one_image(f)
-
- # Comprimir el conjunto de datos en 'ruta/al/conjunto-de-datos.zip'
- zip_directory(path)
- ```
-
-Siguiendo estos pasos, puedes contribuir con un nuevo conjunto de datos que se integre bien con la estructura existente de Ultralytics.
diff --git a/docs/es/index.md b/docs/es/index.md
deleted file mode 100644
index e3759f8e9a6..00000000000
--- a/docs/es/index.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-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/docs/es/models/fast-sam.md b/docs/es/models/fast-sam.md
deleted file mode 100644
index dfaee11f9d3..00000000000
--- a/docs/es/models/fast-sam.md
+++ /dev/null
@@ -1,193 +0,0 @@
----
-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 de la arquitectura del Modelo para Segmentar Cualquier Cosa Rápidamente (FastSAM)](https://user-images.githubusercontent.com/26833433/248551984-d98f0f6d-7535-45d0-b380-2e1440b52ad7.jpg)
-
-## 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/docs/es/models/index.md b/docs/es/models/index.md
deleted file mode 100644
index a7137f913fd..00000000000
--- a/docs/es/models/index.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-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/docs/es/models/mobile-sam.md b/docs/es/models/mobile-sam.md
deleted file mode 100644
index bf68ab7ad1d..00000000000
--- a/docs/es/models/mobile-sam.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-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
----
-
-![Logotipo de MobileSAM](https://github.com/ChaoningZhang/MobileSAM/blob/master/assets/logo2.png?raw=true)
-
-# 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.
-
-![Imagen con Punto como Instrucción](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-![Imagen con Caja como Instrucción](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-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/docs/es/models/rtdetr.md b/docs/es/models/rtdetr.md
deleted file mode 100644
index fada0ae5417..00000000000
--- a/docs/es/models/rtdetr.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-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.
-
-![Ejemplo de imagen del modelo](https://user-images.githubusercontent.com/26833433/238963168-90e8483f-90aa-4eb6-a5e1-0d408b23dd33.png)
-**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/docs/es/models/sam.md b/docs/es/models/sam.md
deleted file mode 100644
index 966c5be2b1d..00000000000
--- a/docs/es/models/sam.md
+++ /dev/null
@@ -1,226 +0,0 @@
----
-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.
-
-![Ejemplo de imagen del conjunto de datos](https://user-images.githubusercontent.com/26833433/238056229-0e8ffbeb-f81a-477e-a490-aff3d82fd8ce.jpg)
-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/docs/es/models/yolo-nas.md b/docs/es/models/yolo-nas.md
deleted file mode 100644
index 5d13f51386b..00000000000
--- a/docs/es/models/yolo-nas.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-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.
-
-![Ejemplo de imagen del modelo](https://learnopencv.com/wp-content/uploads/2023/05/yolo-nas_COCO_map_metrics.png)
-**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/v8.1.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/v8.1.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/v8.1.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/docs/es/models/yolov3.md b/docs/es/models/yolov3.md
deleted file mode 100644
index 1990e5b5ed5..00000000000
--- a/docs/es/models/yolov3.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-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.
-
-![Ultralytics YOLOv3](https://raw.githubusercontent.com/ultralytics/assets/main/yolov3/banner-yolov3.png)
-
-## 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/docs/es/models/yolov4.md b/docs/es/models/yolov4.md
deleted file mode 100644
index 05bd43ccabb..00000000000
--- a/docs/es/models/yolov4.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-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](https://user-images.githubusercontent.com/26833433/246185689-530b7fe8-737b-4bb0-b5dd-de10ef5aface.png)
-**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/docs/es/models/yolov5.md b/docs/es/models/yolov5.md
deleted file mode 100644
index 5ed1d85a9e4..00000000000
--- a/docs/es/models/yolov5.md
+++ /dev/null
@@ -1,113 +0,0 @@
----
-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.
-
-![Ultralytics YOLOv5](https://raw.githubusercontent.com/ultralytics/assets/main/yolov5/v70/splash.png)
-
-## 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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/docs/es/models/yolov6.md b/docs/es/models/yolov6.md
deleted file mode 100644
index f65f37fcc82..00000000000
--- a/docs/es/models/yolov6.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-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.
-
-![Meituan YOLOv6](https://user-images.githubusercontent.com/26833433/240750495-4da954ce-8b3b-41c4-8afd-ddb74361d3c2.png)
-![Ejemplo de imagen del modelo](https://user-images.githubusercontent.com/26833433/240750557-3e9ec4f0-0598-49a8-83ea-f33c91eb6d68.png)
-**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/docs/es/models/yolov7.md b/docs/es/models/yolov7.md
deleted file mode 100644
index 64520439468..00000000000
--- a/docs/es/models/yolov7.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-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 YOLOv7 con detectores de objetos SOTA](https://github.com/ultralytics/ultralytics/assets/26833433/5e1e0420-8122-4c79-b8d0-2860aa79af92)
-**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/docs/es/models/yolov8.md b/docs/es/models/yolov8.md
deleted file mode 100644
index 4e299777f64..00000000000
--- a/docs/es/models/yolov8.md
+++ /dev/null
@@ -1,162 +0,0 @@
----
-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.
-
-![Ultralytics YOLOv8](https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/yolo-comparison-plots.png)
-
-## 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/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
-
- === "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 50-95 | mAPmáscara 50-95 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | parámetros (M) | FLOPs (B) |
- | -------------------------------------------------------------------------------------------- | ----------------------- | ---------------------- | ----------------------- | -------------------------------- | --------------------------------------- | ---------------------- | ----------------- |
- | [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
-
- === "Clasificación (ImageNet)"
-
- Consulta la [documentación de Clasificación](https://docs.ultralytics.com/tasks/classify/) para ejemplos de uso con estos modelos entrenados en [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), que incluyen 1000 clases preentrenadas.
-
- | Modelo | tamaño (píxeles) | acc top1 | acc top5 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | parámetros (M) | FLOPs (B) a 640 |
- | -------------------------------------------------------------------------------------------- | ----------------------- | ---------------- | ---------------- | -------------------------------- | --------------------------------------- | ---------------------- | ------------------------ |
- | [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
-
- === "Pose (COCO)"
-
- Consulta la [documentación de Estimación de Poses](https://docs.ultralytics.com/tasks/segment/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/pose/coco/), que incluyen 1 clase preentrenada, 'person'.
-
- | Modelo | tamaño (píxeles) | mAPpose 50-95 | mAPpose 50 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | parámetros (M) | FLOPs (B) |
- | ---------------------------------------------------------------------------------------------------- | ----------------------- | --------------------- | ------------------ | -------------------------------- | --------------------------------------- | ---------------------- | ----------------- |
- | [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
-
-## Ejemplos de uso
-
-Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia con YOLOv8. 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).
-
-Ten en cuenta que el siguiente ejemplo es para modelos de detección YOLOv8. Para ver las tareas adicionales compatibles, consulta la documentación de [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) y [Pose](../tasks/pose.md).
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- Los modelos preentrenados en PyTorch `*.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
-
- # Carga un modelo YOLOv8n preentrenado en COCO
- model = YOLO('yolov8n.pt')
-
- # Muestra información del modelo (opcional)
- model.info()
-
- # Entrena el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # Realiza inferencia con el modelo YOLOv8n en la imagen 'bus.jpg'
- results = model('ruta/a/bus.jpg')
- ```
-
- === "CLI"
-
- Hay comandos de CLI disponibles para ejecutar directamente los modelos:
-
- ```bash
- # Carga un modelo YOLOv8n preentrenado en COCO y entrénalo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
- yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # Carga un modelo YOLOv8n preentrenado en COCO y realiza inferencia en la imagen 'bus.jpg'
- yolo predict model=yolov8n.pt source=ruta/a/bus.jpg
- ```
-
-## Citas y reconocimientos
-
-Si utilizas el modelo YOLOv8 u otro software de este repositorio en tu trabajo, por favor cítalo utilizando el siguiente formato:
-
-!!! 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}
- }
- ```
-
- Ten en cuenta que el DOI está pendiente y se agregará a la cita una vez que esté disponible. Los modelos de YOLOv8 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/docs/es/modes/benchmark.md b/docs/es/modes/benchmark.md
deleted file mode 100644
index 3a165da65bb..00000000000
--- a/docs/es/modes/benchmark.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-comments: true
-description: Aprenda cómo perfilar la velocidad y exactitud de YOLOv8 en varios formatos de exportación; obtenga perspectivas sobre las métricas mAP50-95, accuracy_top5 y más.
-keywords: Ultralytics, YOLOv8, benchmarking, perfilado de velocidad, perfilado de exactitud, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formatos de exportación YOLO
----
-
-# Model Benchmarking con Ultralytics YOLO
-
-
-
-## Introducción
-
-Una vez que su modelo está entrenado y validado, el siguiente paso lógico es evaluar su rendimiento en varios escenarios del mundo real. El modo benchmark en Ultralytics YOLOv8 cumple con este propósito proporcionando un marco sólido para valorar la velocidad y exactitud de su modelo a través de una gama de formatos de exportación.
-
-## ¿Por Qué Es Crucial el Benchmarking?
-
-- **Decisiones Informadas:** Obtenga perspectivas sobre el equilibrio entre velocidad y precisión.
-- **Asignación de Recursos:** Entienda cómo diferentes formatos de exportación se desempeñan en diferentes hardware.
-- **Optimización:** Aprenda cuál formato de exportación ofrece el mejor rendimiento para su caso de uso específico.
-- **Eficiencia de Costo:** Haga un uso más eficiente de los recursos de hardware basado en los resultados del benchmark.
-
-### Métricas Clave en el Modo Benchmark
-
-- **mAP50-95:** Para detección de objetos, segmentación y estimación de pose.
-- **accuracy_top5:** Para clasificación de imágenes.
-- **Tiempo de Inferencia:** Tiempo tomado para cada imagen en milisegundos.
-
-### Formatos de Exportación Soportados
-
-- **ONNX:** Para un rendimiento óptimo de CPU
-- **TensorRT:** Para la máxima eficiencia de GPU
-- **OpenVINO:** Para la optimización en hardware de Intel
-- **CoreML, TensorFlow SavedModel y Más:** Para necesidades de despliegue diversas.
-
-!!! Tip "Consejo"
-
- * Exporte a ONNX o OpenVINO para acelerar la velocidad de CPU hasta 3 veces.
- * Exporte a TensorRT para acelerar la velocidad de GPU hasta 5 veces.
-
-## Ejemplos de Uso
-
-Ejecute benchmarks de YOLOv8n en todos los formatos de exportación soportados incluyendo ONNX, TensorRT, etc. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics.utils.benchmarks import benchmark
-
- # Benchmark en 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
- ```
-
-## Argumentos
-
-Argumentos como `model`, `data`, `imgsz`, `half`, `device`, y `verbose` proporcionan a los usuarios la flexibilidad de ajustar los benchmarks a sus necesidades específicas y comparar el rendimiento de diferentes formatos de exportación con facilidad.
-
-| Clave | Valor | Descripción |
-|-----------|---------|----------------------------------------------------------------------------------------------------------|
-| `model` | `None` | ruta al archivo del modelo, es decir, yolov8n.pt, yolov8n.yaml |
-| `data` | `None` | ruta a YAML que referencia el conjunto de datos de benchmarking (bajo la etiqueta `val`) |
-| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), es decir, (640, 480) |
-| `half` | `False` | cuantificación FP16 |
-| `int8` | `False` | cuantificación INT8 |
-| `device` | `None` | dispositivo en el que se ejecutará, es decir, dispositivo cuda=0 o dispositivo=0,1,2,3 o dispositivo=cpu |
-| `verbose` | `False` | no continuar en caso de error (bool), o umbral de piso de valor (float) |
-
-## Formatos de Exportación
-
-Los benchmarks intentarán ejecutarse automáticamente en todos los posibles formatos de exportación a continuación.
-
-| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
-|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------|
-| [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` |
-
-Vea los detalles completos de `export` en la página [Export](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/es/modes/export.md b/docs/es/modes/export.md
deleted file mode 100644
index e701ccb268e..00000000000
--- a/docs/es/modes/export.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-comments: true
-description: Guía paso a paso sobre cómo exportar sus modelos YOLOv8 a varios formatos como ONNX, TensorRT, CoreML y más para su despliegue. ¡Explora ahora!.
-keywords: YOLO, YOLOv8, Ultralytics, Exportación de modelos, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exportar modelo
----
-
-# Exportación de Modelos con Ultralytics YOLO
-
-
-
-## Introducción
-
-El objetivo final de entrenar un modelo es desplegarlo para aplicaciones en el mundo real. El modo exportación en Ultralytics YOLOv8 ofrece una gama versátil de opciones para exportar tu modelo entrenado a diferentes formatos, haciéndolo desplegable en varias plataformas y dispositivos. Esta guía integral pretende guiarte a través de los matices de la exportación de modelos, mostrando cómo lograr la máxima compatibilidad y rendimiento.
-
-
-
-
-
- Ver: Cómo Exportar un Modelo Entrenado Personalizado de Ultralytics YOLOv8 y Ejecutar Inferencia en Vivo en la Webcam.
-
-
-## ¿Por Qué Elegir el Modo Exportación de YOLOv8?
-
-- **Versatilidad:** Exporta a múltiples formatos incluyendo ONNX, TensorRT, CoreML y más.
-- **Rendimiento:** Acelera hasta 5 veces la velocidad en GPU con TensorRT y 3 veces en CPU con ONNX o OpenVINO.
-- **Compatibilidad:** Hacer que tu modelo sea universalmente desplegable en numerosos entornos de hardware y software.
-- **Facilidad de Uso:** Interfaz de línea de comandos simple y API de Python para una exportación de modelos rápida y sencilla.
-
-### Características Clave del Modo de Exportación
-
-Aquí tienes algunas de las funcionalidades destacadas:
-
-- **Exportación con Un Solo Clic:** Comandos simples para exportar a diferentes formatos.
-- **Exportación por Lotes:** Exporta modelos capaces de inferencia por lotes.
-- **Inferencia Optimizada:** Los modelos exportados están optimizados para tiempos de inferencia más rápidos.
-- **Vídeos Tutoriales:** Guías y tutoriales en profundidad para una experiencia de exportación fluida.
-
-!!! Tip "Consejo"
-
- * Exporta a ONNX u OpenVINO para acelerar la CPU hasta 3 veces.
- * Exporta a TensorRT para acelerar la GPU hasta 5 veces.
-
-## Ejemplos de Uso
-
-Exporta un modelo YOLOv8n a un formato diferente como ONNX o TensorRT. Consulta la sección Argumentos más abajo para una lista completa de argumentos de exportación.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Carga un modelo
- model = YOLO('yolov8n.pt') # carga un modelo oficial
- model = YOLO('path/to/best.pt') # carga un modelo entrenado personalizado
-
- # Exporta el modelo
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n.pt format=onnx # exporta modelo oficial
- yolo export model=path/to/best.pt format=onnx # exporta modelo entrenado personalizado
- ```
-
-## Argumentos
-
-Los ajustes de exportación para modelos YOLO se refieren a las diversas configuraciones y opciones utilizadas para guardar o exportar el modelo para su uso en otros entornos o plataformas. Estos ajustes pueden afectar el rendimiento del modelo, su tamaño y su compatibilidad con diferentes sistemas. Algunos ajustes comunes de exportación de YOLO incluyen el formato del archivo del modelo exportado (p. ej., ONNX, TensorFlow SavedModel), el dispositivo en el que se ejecutará el modelo (p. ej., CPU, GPU) y la presencia de características adicionales como máscaras o múltiples etiquetas por caja. Otros factores que pueden afectar el proceso de exportación incluyen la tarea específica para la que se está utilizando el modelo y los requisitos o limitaciones del entorno o plataforma objetivo. Es importante considerar y configurar cuidadosamente estos ajustes para asegurar que el modelo exportado está optimizado para el caso de uso previsto y se pueda utilizar eficazmente en el entorno objetivo.
-
-| Llave | Valor | Descripción |
-|-------------|-----------------|-----------------------------------------------------------------|
-| `format` | `'torchscript'` | formato al que exportar |
-| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), p. ej. (640, 480) |
-| `keras` | `False` | usu Keras para la exportación de TF SavedModel |
-| `optimize` | `False` | TorchScript: optimizar para móvil |
-| `half` | `False` | cuantificación FP16 |
-| `int8` | `False` | cuantificación INT8 |
-| `dynamic` | `False` | ONNX/TensorRT: ejes dinámicos |
-| `simplify` | `False` | ONNX/TensorRT: simplificar modelo |
-| `opset` | `None` | ONNX: versión de opset (opcional, por defecto la más reciente) |
-| `workspace` | `4` | TensorRT: tamaño del espacio de trabajo (GB) |
-| `nms` | `False` | CoreML: añadir NMS |
-
-## Formatos de Exportación
-
-Los formatos de exportación disponibles de YOLOv8 están en la tabla a continuación. Puedes exportar a cualquier formato usando el argumento `format`, por ejemplo, `format='onnx'` o `format='engine'`.
-
-| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
-|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------|
-| [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/docs/es/modes/index.md b/docs/es/modes/index.md
deleted file mode 100644
index 1c9b408b047..00000000000
--- a/docs/es/modes/index.md
+++ /dev/null
@@ -1,73 +0,0 @@
----
-comments: true
-description: Desde el entrenamiento hasta el seguimiento, aprovecha al máximo YOLOv8 con Ultralytics. Obtén información y ejemplos para cada modo compatible incluyendo validación, exportación y evaluación comparativa.
-keywords: Ultralytics, YOLOv8, Aprendizaje Automático, Detección de Objetos, Entrenamiento, Validación, Predicción, Exportación, Seguimiento, Benchmarking
----
-
-# Modos de Ultralytics YOLOv8
-
-
-
-## Introducción
-
-Ultralytics YOLOv8 no es solo otro modelo de detección de objetos; es un marco de trabajo versátil diseñado para cubrir todo el ciclo de vida de los modelos de aprendizaje automático, desde la ingesta de datos y el entrenamiento del modelo hasta la validación, implementación y seguimiento en el mundo real. Cada modo sirve para un propósito específico y está diseñado para ofrecerte la flexibilidad y eficiencia necesarias para diferentes tareas y casos de uso.
-
-
-
-
-
- Mira: Tutorial de Modos Ultralytics: Entrenar, Validar, Predecir, Exportar y Hacer Benchmarking.
-
-
-### Modos a Primera Vista
-
-Comprender los diferentes **modos** que soporta Ultralytics YOLOv8 es crítico para sacar el máximo provecho a tus modelos:
-
-- **Modo Entrenar (Train)**: Afina tu modelo en conjuntos de datos personalizados o pre-cargados.
-- **Modo Validar (Val)**: Un punto de control post-entrenamiento para validar el rendimiento del modelo.
-- **Modo Predecir (Predict)**: Libera el poder predictivo de tu modelo en datos del mundo real.
-- **Modo Exportar (Export)**: Prepara tu modelo para la implementación en varios formatos.
-- **Modo Seguir (Track)**: Extiende tu modelo de detección de objetos a aplicaciones de seguimiento en tiempo real.
-- **Modo Benchmark (Benchmark)**: Analiza la velocidad y precisión de tu modelo en diversos entornos de implementación.
-
-Esta guía completa tiene como objetivo proporcionarte una visión general y conocimientos prácticos de cada modo, ayudándote a aprovechar todo el potencial de YOLOv8.
-
-## [Entrenar (Train)](train.md)
-
-El modo Entrenar se utiliza para entrenar un modelo YOLOv8 en un conjunto de datos personalizado. En este modo, el modelo se entrena utilizando el conjunto de datos y los hiperparámetros especificados. El proceso de entrenamiento implica optimizar los parámetros del modelo para que pueda predecir con precisión las clases y ubicaciones de los objetos en una imagen.
-
-[Ejemplos de Entrenamiento](train.md){ .md-button }
-
-## [Validar (Val)](val.md)
-
-El modo Validar se usa para validar un modelo YOLOv8 después de haber sido entrenado. En este modo, el modelo se evalúa en un conjunto de validación para medir su precisión y rendimiento de generalización. Este modo se puede usar para ajustar los hiperparámetros del modelo y mejorar su rendimiento.
-
-[Ejemplos de Validación](val.md){ .md-button }
-
-## [Predecir (Predict)](predict.md)
-
-El modo Predecir se utiliza para realizar predicciones usando un modelo YOLOv8 entrenado en imágenes o videos nuevos. En este modo, el modelo se carga desde un archivo de punto de control, y el usuario puede proporcionar imágenes o videos para realizar inferencias. El modelo predice las clases y ubicaciones de los objetos en las imágenes o videos de entrada.
-
-[Ejemplos de Predicción](predict.md){ .md-button }
-
-## [Exportar (Export)](export.md)
-
-El modo Exportar se utiliza para exportar un modelo YOLOv8 a un formato que se pueda usar para la implementación. En este modo, el modelo se convierte a un formato que puede ser utilizado por otras aplicaciones de software o dispositivos de hardware. Este modo es útil al implementar el modelo en entornos de producción.
-
-[Ejemplos de Exportación](export.md){ .md-button }
-
-## [Seguir (Track)](track.md)
-
-El modo Seguir se usa para rastrear objetos en tiempo real utilizando un modelo YOLOv8. En este modo, el modelo se carga desde un archivo de punto de control, y el usuario puede proporcionar un flujo de video en vivo para realizar seguimiento de objetos en tiempo real. Este modo es útil para aplicaciones como sistemas de vigilancia o coches autónomos.
-
-[Ejemplos de Seguimiento](track.md){ .md-button }
-
-## [Benchmark (Benchmark)](benchmark.md)
-
-El modo Benchmark se utiliza para perfilar la velocidad y precisión de varios formatos de exportación de YOLOv8. Los benchmarks proporcionan información sobre el tamaño del formato de exportación, sus métricas de `mAP50-95` (para detección de objetos, segmentación y pose) o métricas de `accuracy_top5` (para clasificación), y el tiempo de inferencia en milisegundos por imagen a través de varios formatos de exportación como ONNX, OpenVINO, TensorRT y otros. Esta información puede ayudar a los usuarios a elegir el formato de exportación óptimo para su caso de uso específico, basado en sus requerimientos de velocidad y precisión.
-
-[Ejemplos de Benchmarking](benchmark.md){ .md-button }
diff --git a/docs/es/modes/predict.md b/docs/es/modes/predict.md
deleted file mode 100644
index 6af71036815..00000000000
--- a/docs/es/modes/predict.md
+++ /dev/null
@@ -1,227 +0,0 @@
----
-comments: true
-description: Descubra cómo utilizar el modo predictivo de YOLOv8 para diversas tareas. Aprenda acerca de diferentes fuentes de inferencia como imágenes, videos y formatos de datos.
-keywords: Ultralytics, YOLOv8, modo predictivo, fuentes de inferencia, tareas de predicción, modo de transmisión, procesamiento de imágenes, procesamiento de videos, aprendizaje automático, IA
----
-
-# Predicción del Modelo con YOLO de Ultralytics
-
-
-
-## Introducción
-
-En el mundo del aprendizaje automático y la visión por computadora, el proceso de dar sentido a los datos visuales se denomina 'inferencia' o 'predicción'. YOLOv8 de Ultralytics ofrece una característica poderosa conocida como **modo predictivo** que está diseñada para inferencias de alto rendimiento y en tiempo real en una amplia gama de fuentes de datos.
-
-
-
-
-
- Ver: Cómo Extraer las Salidas del Modelo YOLOv8 de Ultralytics para Proyectos Personalizados.
-
-
-## Aplicaciones en el Mundo Real
-
-| Manufactura | Deportes | Seguridad |
-|:-----------------------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------------:|
-| ![Detección de Repuestos de Vehículos](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Detección de Jugadores de Fútbol](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Detección de Caídas de Personas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) |
-| Detección de Repuestos de Vehículos | Detección de Jugadores de Fútbol | Detección de Caídas de Personas |
-
-## ¿Por Qué Utilizar YOLO de Ultralytics para la Inferencia?
-
-Estas son algunas razones para considerar el modo predictivo de YOLOv8 para sus necesidades de inferencia:
-
-- **Versatilidad:** Capaz de realizar inferencias en imágenes, videos e incluso transmisiones en vivo.
-- **Rendimiento:** Diseñado para procesamiento en tiempo real y de alta velocidad sin sacrificar precisión.
-- **Facilidad de Uso:** Interfaces de Python y CLI intuitivas para una rápida implementación y pruebas.
-- **Alta Personalización:** Diversos ajustes y parámetros para afinar el comportamiento de inferencia del modelo según sus requisitos específicos.
-
-### Características Principales del Modo Predictivo
-
-El modo predictivo de YOLOv8 está diseñado para ser robusto y versátil, y cuenta con:
-
-- **Compatibilidad con Múltiples Fuentes de Datos:** Ya sea que sus datos estén en forma de imágenes individuales, una colección de imágenes, archivos de video o transmisiones de video en tiempo real, el modo predictivo le tiene cubierto.
-- **Modo de Transmisión:** Utilice la función de transmisión para generar un generador eficiente de memoria de objetos `Results`. Active esto configurando `stream=True` en el método de llamada del predictor.
-- **Procesamiento por Lotes:** La capacidad de procesar múltiples imágenes o fotogramas de video en un solo lote, acelerando aún más el tiempo de inferencia.
-- **Amigable para la Integración:** Se integra fácilmente con pipelines de datos existentes y otros componentes de software, gracias a su API flexible.
-
-Los modelos YOLO de Ultralytics devuelven ya sea una lista de objetos `Results` de Python, o un generador de objetos `Results` de Python eficiente en memoria cuando se pasa `stream=True` al modelo durante la inferencia:
-
-!!! Example "Predict"
-
- === "Devolver una lista con `stream=False`"
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado
-
- # Ejecutar inferencia por lotes en una lista de imágenes
- results = model(['im1.jpg', 'im2.jpg']) # devuelve una lista de objetos Results
-
- # Procesar lista de resultados
- for result in results:
- boxes = result.boxes # Objeto Boxes para salidas de bbox
- masks = result.masks # Objeto Masks para salidas de máscaras de segmentación
- keypoints = result.keypoints # Objeto Keypoints para salidas de postura
- probs = result.probs # Objeto Probs para salidas de clasificación
- ```
-
- === "Devolver un generador con `stream=True`"
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado
-
- # Ejecutar inferencia por lotes en una lista de imágenes
- results = model(['im1.jpg', 'im2.jpg'], stream=True) # devuelve un generador de objetos Results
-
- # Procesar generador de resultados
- for result in results:
- boxes = result.boxes # Objeto Boxes para salidas de bbox
- .masks = result.masks # Objeto Masks para salidas de máscaras de segmentación
- keypoints = result.keypoints # Objeto Keypoints para salidas de postura
- probs = result.probs # Objeto Probs para salidas de clasificación
- ```
-
-## Fuentes de Inferencia
-
-YOLOv8 puede procesar diferentes tipos de fuentes de entrada para la inferencia, como se muestra en la tabla a continuación. Las fuentes incluyen imágenes estáticas, transmisiones de video y varios formatos de datos. La tabla también indica si cada fuente se puede utilizar en modo de transmisión con el argumento `stream=True` ✅. El modo de transmisión es beneficioso para procesar videos o transmisiones en vivo ya que crea un generador de resultados en lugar de cargar todos los fotogramas en la memoria.
-
-!!! Tip "Consejo"
-
- Utilice `stream=True` para procesar videos largos o conjuntos de datos grandes para gestionar eficientemente la memoria. Cuando `stream=False`, los resultados de todos los fotogramas o puntos de datos se almacenan en la memoria, lo que puede aumentar rápidamente y causar errores de memoria insuficiente para entradas grandes. En contraste, `stream=True` utiliza un generador, que solo mantiene los resultados del fotograma o punto de datos actual en la memoria, reduciendo significativamente el consumo de memoria y previniendo problemas de falta de memoria.
-
-| Fuente | Argumento | Tipo | Notas |
-|---------------------|--------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------|
-| imagen | `'image.jpg'` | `str` o `Path` | Archivo único de imagen. |
-| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL a una imagen. |
-| captura de pantalla | `'screen'` | `str` | Captura una captura de pantalla. |
-| PIL | `Image.open('im.jpg')` | `PIL.Image` | Formato HWC con canales RGB. |
-| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. |
-| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. |
-| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Formato BCHW con canales RGB `float32 (0.0-1.0)`. |
-| CSV | `'sources.csv'` | `str` o `Path` | Archivo CSV que contiene rutas a imágenes, videos o directorios. |
-| video ✅ | `'video.mp4'` | `str` o `Path` | Archivo de video en formatos como MP4, AVI, etc. |
-| directorio ✅ | `'path/'` | `str` o `Path` | Ruta a un directorio que contiene imágenes o videos. |
-| glob ✅ | `'path/*.jpg'` | `str` | Patrón glob para coincidir con múltiples archivos. Utilice el carácter `*` como comodín. |
-| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL a un video de YouTube. |
-| transmisión ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL para protocolos de transmisión como RTSP, RTMP, TCP o una dirección IP. |
-| multi-transmisión ✅ | `'list.streams'` | `str` o `Path` | Archivo de texto `*.streams` con una URL de transmisión por fila, es decir, 8 transmisiones se ejecutarán con tamaño de lote 8. |
-
-A continuación se muestran ejemplos de código para usar cada tipo de fuente:
-
-!!! Example "Fuentes de predicción"
-
- === "imagen"
- Ejecute inferencia en un archivo de imagen.
- ```python
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8n preentrenado
- model = YOLO('yolov8n.pt')
-
- # Definir la ruta al archivo de imagen
- source = 'ruta/a/imagen.jpg'
-
- # Ejecutar inferencia en la fuente
- results = model(source) # lista de objetos Results
- ```
-
- === "captura de pantalla"
- Ejecute inferencia en el contenido actual de la pantalla como captura de pantalla.
- ```python
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8n preentrenado
- model = YOLO('yolov8n.pt')
-
- # Definir captura de pantalla actual como fuente
- source = 'screen'
-
- # Ejecutar inferencia en la fuente
- results = model(source) # lista de objetos Results
- ```
-
- === "URL"
- Ejecute inferencia en una imagen o video alojados remotamente a través de URL.
- ```python
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8n preentrenado
- model = YOLO('yolov8n.pt')
-
- # Definir URL remota de imagen o video
- source = 'https://ultralytics.com/images/bus.jpg'
-
- # Ejecutar inferencia en la fuente
- results = model(source) # lista de objetos Results
- ```
-
- === "PIL"
- Ejecute inferencia en una imagen abierta con la Biblioteca de Imágenes de Python (PIL).
- ```python
- from PIL import Image
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8n preentrenado
- model = YOLO('yolov8n.pt')
-
- # Abrir una imagen usando PIL
- source = Image.open('ruta/a/imagen.jpg')
-
- # Ejecutar inferencia en la fuente
- results = model(source) # lista de objetos Results
- ```
-
- === "OpenCV"
- Ejecute inferencia en una imagen leída con OpenCV.
- ```python
- import cv2
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8n preentrenado
- model = YOLO('yolov8n.pt')
-
- # Leer una imagen usando OpenCV
- source = cv2.imread('ruta/a/imagen.jpg')
-
- # Ejecutar inferencia en la fuente
- results = model(source) # lista de objetos Results
- ```
-
- === "numpy"
- Ejecute inferencia en una imagen representada como un array de numpy.
- ```python
- import numpy as np
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8n preentrenado
- model = YOLO('yolov8n.pt')
-
- # Crear un array aleatorio de numpy con forma HWC (640, 640, 3) con valores en rango [0, 255] y tipo uint8
- source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')
-
- # Ejecutar inferencia en la fuente
- results = model(source) # lista de objetos Results
- ```
-
- === "torch"
- Ejecute inferencia en una imagen representada como un tensor de PyTorch.
- ```python
- import torch
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8n preentrenado
- model = YOLO('yolov8n.pt')
-
- # Crear un tensor aleatorio de torch con forma BCHW (1, 3, 640, 640) con valores en rango [0, 1] y tipo float32
- source = torch.rand(1, 3, 640, 640, dtype=torch.float32)
-
- # Ejecutar inferencia en la fuente
- results = model(source) # lista de objetos Results
- ```
diff --git a/docs/es/modes/track.md b/docs/es/modes/track.md
deleted file mode 100644
index e7b514d18af..00000000000
--- a/docs/es/modes/track.md
+++ /dev/null
@@ -1,200 +0,0 @@
----
-comments: true
-description: Aprende a utilizar Ultralytics YOLO para el seguimiento de objetos en flujos de video. Guías para usar diferentes rastreadores y personalizar la configuración del rastreador.
-keywords: Ultralytics, YOLO, seguimiento de objetos, flujos de video, BoT-SORT, ByteTrack, guía de Python, guía de CLI
----
-
-# Seguimiento de Múltiples Objetos con Ultralytics YOLO
-
-
-
-El seguimiento de objetos en el ámbito del análisis de video es una tarea crítica que no solo identifica la ubicación y clase de objetos dentro del cuadro, sino que también mantiene una ID única para cada objeto detectado a medida que avanza el video. Las aplicaciones son ilimitadas, desde vigilancia y seguridad hasta análisis deportivos en tiempo real.
-
-## ¿Por Qué Elegir Ultralytics YOLO para el Seguimiento de Objetos?
-
-La salida de los rastreadores de Ultralytics es consistente con la detección de objetos estándar, pero con el valor añadido de las IDs de objetos. Esto facilita el seguimiento de objetos en flujos de video y la realización de análisis posteriores. Aquí tienes algunas razones por las que deberías considerar usar Ultralytics YOLO para tus necesidades de seguimiento de objetos:
-
-- **Eficiencia:** Procesa flujos de video en tiempo real sin comprometer la precisión.
-- **Flexibilidad:** Soporta múltiples algoritmos de seguimiento y configuraciones.
-- **Facilidad de Uso:** API simple de Python y opciones CLI para una rápida integración y despliegue.
-- **Personalización:** Fácil de usar con modelos YOLO entrenados a medida, permitiendo la integración en aplicaciones específicas del dominio.
-
-
-
-
-
- Ver: Detección de Objetos y Seguimiento con Ultralytics YOLOv8.
-
-
-## Aplicaciones en el Mundo Real
-
-| Transporte | Venta al por Menor | Acuicultura |
-|:------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------:|
-| ![Seguimiento de Vehículos](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Seguimiento de Personas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Seguimiento de Peces](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) |
-| Seguimiento de Vehículos | Seguimiento de Personas | Seguimiento de Peces |
-
-## Características a Simple Vista
-
-Ultralytics YOLO extiende sus características de detección de objetos para proporcionar un seguimiento de objetos robusto y versátil:
-
-- **Seguimiento en Tiempo Real:** Rastrea sin problemas los objetos en videos de alta frecuencia de cuadros.
-- **Soporte de Múltiples Rastreadores:** Elige entre una variedad de algoritmos de seguimiento establecidos.
-- **Configuraciones de Rastreador Personalizables:** Adapta el algoritmo de seguimiento para satisfacer requisitos específicos ajustando diversos parámetros.
-
-## Rastreadores Disponibles
-
-Ultralytics YOLO soporta los siguientes algoritmos de seguimiento. Pueden ser habilitados pasando el archivo de configuración YAML relevante como `tracker=tracker_type.yaml`:
-
-* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Usa `botsort.yaml` para habilitar este rastreador.
-* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Usa `bytetrack.yaml` para habilitar este rastreador.
-
-El rastreador predeterminado es BoT-SORT.
-
-## Seguimiento
-
-Para ejecutar el rastreador en flujos de video, usa un modelo Detect, Segment o Pose entrenado tales como YOLOv8n, YOLOv8n-seg y YOLOv8n-pose.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo oficial o personalizado
- model = YOLO('yolov8n.pt') # Cargar un modelo oficial Detect
- model = YOLO('yolov8n-seg.pt') # Cargar un modelo oficial Segment
- model = YOLO('yolov8n-pose.pt') # Cargar un modelo oficial Pose
- model = YOLO('path/to/best.pt') # Cargar un modelo entrenado a medida
-
- # Realizar el seguimiento con el modelo
- results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Seguimiento con el rastreador predeterminado
- results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Seguimiento con el rastreador ByteTrack
- ```
-
- === "CLI"
-
- ```bash
- # Realizar seguimiento con varios modelos usando la interfaz de línea de comandos
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Detect
- yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Segment
- yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Pose
- yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Modelo entrenado a medida
-
- # Realizar seguimiento usando el rastreador ByteTrack
- yolo track model=path/to/best.pt tracker="bytetrack.yaml"
- ```
-
-Como se puede ver en el uso anterior, el seguimiento está disponible para todos los modelos Detect, Segment y Pose ejecutados en videos o fuentes de transmisión.
-
-## Configuración
-
-### Argumentos de Seguimiento
-
-La configuración de seguimiento comparte propiedades con el modo Predict, como `conf`, `iou` y `show`. Para configuraciones adicionales, consulta la página del modelo [Predict](https://docs.ultralytics.com/modes/predict/).
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Configurar los parámetros de seguimiento y ejecutar el rastreador
- model = YOLO('yolov8n.pt')
- results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
- ```
-
- === "CLI"
-
- ```bash
- # Configurar parámetros de seguimiento y ejecutar el rastreador usando la interfaz de línea de comandos
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
- ```
-
-### Selección de Rastreador
-
-Ultralytics también te permite usar un archivo de configuración de rastreador modificado. Para hacerlo, simplemente haz una copia de un archivo de configuración de rastreador (por ejemplo, `custom_tracker.yaml`) de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) y modifica cualquier configuración (excepto el `tracker_type`) según tus necesidades.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar el modelo y ejecutar el rastreador con un archivo de configuración personalizado
- model = YOLO('yolov8n.pt')
- results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
- ```
-
- === "CLI"
-
- ```bash
- # Cargar el modelo y ejecutar el rastreador con un archivo de configuración personalizado usando la interfaz de línea de comandos
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
- ```
-
-Para obtener una lista completa de los argumentos de seguimiento, consulta la página [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
-
-## Ejemplos en Python
-
-### Bucle de Seguimiento Persistente
-
-Aquí hay un script en Python que utiliza OpenCV (`cv2`) y YOLOv8 para ejecutar el seguimiento de objetos en fotogramas de video. Este script aún asume que ya has instalado los paquetes necesarios (`opencv-python` y `ultralytics`). El argumento `persist=True` le indica al rastreador que la imagen o fotograma actual es el siguiente en una secuencia y que espera rastros de la imagen anterior en la imagen actual.
-
-!!! Example "Bucle de transmisión en vivo con seguimiento"
-
- ```python
- import cv2
- from ultralytics import YOLO
-
- # Cargar el modelo YOLOv8
- model = YOLO('yolov8n.pt')
-
- # Abrir el archivo de video
- video_path = "path/to/video.mp4"
- cap = cv2.VideoCapture(video_path)
-
- # Bucle a través de los fotogramas del video
- while cap.isOpened():
- # Leer un fotograma del video
- success, frame = cap.read()
-
- if success:
- # Ejecutar seguimiento YOLOv8 en el fotograma, persistiendo los rastreos entre fotogramas
- results = model.track(frame, persist=True)
-
- # Visualizar los resultados en el fotograma
- annotated_frame = results[0].plot()
-
- # Mostrar el fotograma anotado
- cv2.imshow("Seguimiento YOLOv8", annotated_frame)
-
- # Romper el bucle si se presiona 'q'
- if cv2.waitKey(1) & 0xFF == ord("q"):
- break
- else:
- # Romper el bucle si se alcanza el final del video
- break
-
- # Liberar el objeto de captura de video y cerrar la ventana de visualización
- cap.release()
- cv2.destroyAllWindows()
- ```
-
-Toma en cuenta el cambio de `model(frame)` a `model.track(frame)`, que habilita el seguimiento de objetos en lugar de simplemente la detección. Este script modificado ejecutará el rastreador en cada fotograma del video, visualizará los resultados y los mostrará en una ventana. El bucle puede ser terminado presionando 'q'.
-
-## Contribuir con Nuevos Rastreadores
-
-¿Eres experto en seguimiento de múltiples objetos y has implementado o adaptado exitosamente un algoritmo de seguimiento con Ultralytics YOLO? Te invitamos a contribuir en nuestra sección de Rastreadores en [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Tus aplicaciones en el mundo real y soluciones podrían ser invaluables para los usuarios que trabajan en tareas de seguimiento.
-
-Al contribuir en esta sección, ayudarás a ampliar el alcance de las soluciones de seguimiento disponibles dentro del marco de trabajo de Ultralytics YOLO, añadiendo otra capa de funcionalidad y utilidad para la comunidad.
-
-Para iniciar tu contribución, por favor consulta nuestra [Guía de Contribución](https://docs.ultralytics.com/help/contributing) para obtener instrucciones completas sobre cómo enviar una Solicitud de Extracción (PR) 🛠️. ¡Estamos emocionados de ver lo que traes a la mesa!
-
-Juntos, vamos a mejorar las capacidades de seguimiento del ecosistema Ultralytics YOLO 🙏!
diff --git a/docs/es/modes/train.md b/docs/es/modes/train.md
deleted file mode 100644
index 6cb798aa532..00000000000
--- a/docs/es/modes/train.md
+++ /dev/null
@@ -1,206 +0,0 @@
----
-comments: true
-description: Guía paso a paso para entrenar modelos YOLOv8 con Ultralytics YOLO incluyendo ejemplos de entrenamiento con una sola GPU y múltiples GPUs
-keywords: Ultralytics, YOLOv8, YOLO, detección de objetos, modo de entrenamiento, conjunto de datos personalizado, entrenamiento GPU, multi-GPU, hiperparámetros, ejemplos CLI, ejemplos Python
----
-
-# Entrenamiento de Modelos con Ultralytics YOLO
-
-
-
-## Introducción
-
-Entrenar un modelo de aprendizaje profundo implica alimentarlo con datos y ajustar sus parámetros para que pueda hacer predicciones precisas. El modo de entrenamiento en Ultralytics YOLOv8 está diseñado para un entrenamiento efectivo y eficiente de modelos de detección de objetos, aprovechando al máximo las capacidades del hardware moderno. Esta guía tiene como objetivo cubrir todos los detalles que necesita para comenzar a entrenar sus propios modelos utilizando el robusto conjunto de características de YOLOv8.
-
-
-
-
-
- Ver: Cómo Entrenar un modelo YOLOv8 en Tu Conjunto de Datos Personalizado en Google Colab.
-
-
-## ¿Por Qué Elegir Ultralytics YOLO para Entrenamiento?
-
-Aquí hay algunas razones convincentes para optar por el modo Entrenamiento de YOLOv8:
-
-- **Eficiencia:** Aprovecha al máximo tu hardware, ya sea en una configuración de una sola GPU o escalando entre múltiples GPUs.
-- **Versatilidad:** Entrena con conjuntos de datos personalizados además de los ya disponibles como COCO, VOC e ImageNet.
-- **Amigable al Usuario:** Interfaces CLI y Python simples pero potentes para una experiencia de entrenamiento sencilla.
-- **Flexibilidad de Hiperparámetros:** Una amplia gama de hiperparámetros personalizables para ajustar el rendimiento del modelo.
-
-### Características Clave del Modo Entrenamiento
-
-Las siguientes son algunas características notables del modo Entrenamiento de YOLOv8:
-
-- **Descarga Automática de Conjuntos de Datos:** Conjuntos de datos estándar como COCO, VOC e ImageNet se descargan automáticamente en el primer uso.
-- **Soporte Multi-GPU:** Escala tus esfuerzos de entrenamiento sin problemas en múltiples GPUs para acelerar el proceso.
-- **Configuración de Hiperparámetros:** La opción de modificar hiperparámetros a través de archivos de configuración YAML o argumentos CLI.
-- **Visualización y Monitoreo:** Seguimiento en tiempo real de métricas de entrenamiento y visualización del proceso de aprendizaje para una mejor comprensión.
-
-!!! Tip "Consejo"
-
- * Los conjuntos de datos de YOLOv8 como COCO, VOC, ImageNet y muchos otros se descargan automáticamente en el primer uso, es decir, `yolo train data=coco.yaml`
-
-## Ejemplos de Uso
-
-Entrena YOLOv8n en el conjunto de datos COCO128 durante 100 épocas con un tamaño de imagen de 640. El dispositivo de entrenamiento se puede especificar usando el argumento `device`. Si no se pasa ningún argumento, se usará la GPU `device=0` si está disponible; de lo contrario, se usará `device=cpu`. Consulta la sección de Argumentos a continuación para una lista completa de argumentos de entrenamiento.
-
-!!! Example "Ejemplo de Entrenamiento con una sola GPU y CPU"
-
- El dispositivo se determina automáticamente. Si hay una GPU disponible, se usará; de lo contrario, el entrenamiento comenzará en la CPU.
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.yaml') # construir un modelo nuevo desde YAML
- model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
- model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos
-
- # Entrenar el modelo
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
- ```
-
- === "CLI"
-
- ```bash
- # Construir un modelo nuevo desde YAML y comenzar el entrenamiento desde cero
- yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
-
- # Comenzar el entrenamiento desde un modelo preentrenado *.pt
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
-
- # Construir un modelo nuevo desde YAML, transferir pesos preentrenados a él y comenzar el entrenamiento
- yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
- ```
-
-### Entrenamiento Multi-GPU
-
-El entrenamiento Multi-GPU permite una utilización más eficiente de los recursos de hardware disponibles, distribuyendo la carga de entrenamiento en varias GPUs. Esta característica está disponible tanto a través de la API de Python como de la interfaz de línea de comandos. Para habilitar el entrenamiento Multi-GPU, especifica los IDs de los dispositivos GPU que deseas usar.
-
-!!! Example "Ejemplo de Entrenamiento Multi-GPU"
-
- Para entrenar con 2 GPUs, dispositivos CUDA 0 y 1, usa los siguientes comandos. Amplía a GPUs adicionales según sea necesario.
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
-
- # Entrenar el modelo con 2 GPUs
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
- ```
-
- === "CLI"
-
- ```bash
- # Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
- ```
-
-### Entrenamiento con Apple M1 y M2 MPS
-
-Con el soporte para los chips Apple M1 y M2 integrados en los modelos Ultralytics YOLO, ahora es posible entrenar tus modelos en dispositivos que utilizan el potente marco de Metal Performance Shaders (MPS). El MPS ofrece una forma de alto rendimiento para ejecutar tareas de cálculo y procesamiento de imágenes en el silicio personalizado de Apple.
-
-Para habilitar el entrenamiento en chips Apple M1 y M2, debes especificar 'mps' como tu dispositivo al iniciar el proceso de entrenamiento. A continuación se muestra un ejemplo de cómo podrías hacer esto en Python y a través de la línea de comandos:
-
-!!! Example "Ejemplo de Entrenamiento MPS"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
-
- # Entrenar el modelo con 2 GPUs
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
- ```
-
- === "CLI"
-
- ```bash
- # Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
- ```
-
-Al aprovechar el poder computacional de los chips M1/M2, esto permite un procesamiento más eficiente de las tareas de entrenamiento. Para obtener una guía más detallada y opciones de configuración avanzadas, consulta la [documentación de PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html).
-
-## Registros (Logging)
-
-Al entrenar un modelo YOLOv8, puedes encontrar valioso llevar un registro del rendimiento del modelo con el tiempo. Aquí es donde entra en juego el registro. Ultralytics' YOLO ofrece soporte para tres tipos de registradores: Comet, ClearML y TensorBoard.
-
-Para usar un registrador, selecciónalo en el menú desplegable en el fragmento de código anterior y ejecútalo. El registrador elegido se instalará e inicializará.
-
-### Comet
-
-[Comet](https://www.comet.ml/site/) es una plataforma que permite a los científicos de datos y desarrolladores rastrear, comparar, explicar y optimizar experimentos y modelos. Ofrece funcionalidades como métricas en tiempo real, diferencias de código y seguimiento de hiperparámetros.
-
-Para usar Comet:
-
-!!! Example "Ejemplo"
-
- === "Python"
- ```python
- # pip install comet_ml
- import comet_ml
-
- comet_ml.init()
- ```
-
-Recuerda iniciar sesión en tu cuenta de Comet en su sitio web y obtener tu clave API. Necesitarás agregar esto a tus variables de entorno o tu script para registrar tus experimentos.
-
-### ClearML
-
-[ClearML](https://www.clear.ml/) es una plataforma de código abierto que automatiza el seguimiento de experimentos y ayuda con la compartición eficiente de recursos. Está diseñado para ayudar a los equipos a gestionar, ejecutar y reproducir su trabajo de ML de manera más eficiente.
-
-Para usar ClearML:
-
-!!! Example "Ejemplo"
-
- === "Python"
- ```python
- # pip install clearml
- import clearml
-
- clearml.browser_login()
- ```
-
-Después de ejecutar este script, necesitarás iniciar sesión en tu cuenta de ClearML en el navegador y autenticar tu sesión.
-
-### TensorBoard
-
-[TensorBoard](https://www.tensorflow.org/tensorboard) es una herramienta de visualización para TensorFlow. Te permite visualizar tu grafo TensorFlow, trazar métricas cuantitativas sobre la ejecución de tu grafo y mostrar datos adicionales como imágenes que lo atraviesan.
-
-Para usar TensorBoard en [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb):
-
-!!! Example "Ejemplo"
-
- === "CLI"
- ```bash
- load_ext tensorboard
- tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs'
- ```
-
-Para usar TensorBoard localmente, ejecuta el siguiente comando y visualiza los resultados en http://localhost:6006/.
-
-!!! Example "Ejemplo"
-
- === "CLI"
- ```bash
- tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs'
- ```
-
-Esto cargará TensorBoard y lo dirigirá al directorio donde se guardan tus registros de entrenamiento.
-
-Después de configurar tu registrador, puedes proceder con tu entrenamiento de modelo. Todas las métricas de entrenamiento se registrarán automáticamente en la plataforma elegida y podrás acceder a estos registros para monitorear el rendimiento de tu modelo con el tiempo, comparar diferentes modelos e identificar áreas de mejora.
diff --git a/docs/es/modes/val.md b/docs/es/modes/val.md
deleted file mode 100644
index ee81404ddba..00000000000
--- a/docs/es/modes/val.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-comments: true
-description: Guía para validar modelos YOLOv8. Aprenda a evaluar el rendimiento de sus modelos YOLO utilizando configuraciones y métricas de validación con ejemplos en Python y CLI.
-keywords: Ultralytics, Documentación YOLO, YOLOv8, validación, evaluación de modelos, hiperparámetros, precisión, métricas, Python, CLI
----
-
-# Validación de modelos con Ultralytics YOLO
-
-
-
-## Introducción
-
-La validación es un paso crítico en el flujo de trabajo de aprendizaje automático, permitiéndole evaluar la calidad de sus modelos entrenados. El modo Val en Ultralytics YOLOv8 proporciona un robusto conjunto de herramientas y métricas para evaluar el rendimiento de sus modelos de detección de objetos. Esta guía sirve como un recurso completo para comprender cómo utilizar efectivamente el modo Val para asegurar que sus modelos sean precisos y confiables.
-
-## ¿Por qué validar con Ultralytics YOLO?
-
-Estas son las ventajas de usar el modo Val de YOLOv8:
-
-- **Precisión:** Obtenga métricas precisas como mAP50, mAP75 y mAP50-95 para evaluar de manera integral su modelo.
-- **Comodidad:** Utilice funciones integradas que recuerdan los ajustes de entrenamiento, simplificando el proceso de validación.
-- **Flexibilidad:** Valide su modelo con el mismo conjunto de datos o diferentes conjuntos de datos y tamaños de imagen.
-- **Ajuste de Hiperparámetros:** Use las métricas de validación para ajustar su modelo y mejorar el rendimiento.
-
-### Características principales del modo Val
-
-Estas son las funcionalidades notables ofrecidas por el modo Val de YOLOv8:
-
-- **Configuraciones Automatizadas:** Los modelos recuerdan sus configuraciones de entrenamiento para una validación sencilla.
-- **Soporte de Múltiples Métricas:** Evalúe su modelo basado en una gama de métricas de precisión.
-- **CLI y API de Python:** Elija entre la interfaz de línea de comandos o API de Python basada en su preferencia para validación.
-- **Compatibilidad de Datos:** Funciona sin problemas con conjuntos de datos utilizados durante la fase de entrenamiento así como con conjuntos de datos personalizados.
-
-!!! Tip "Consejo"
-
- * Los modelos YOLOv8 recuerdan automáticamente sus ajustes de entrenamiento, así que puede validar un modelo en el mismo tamaño de imagen y en el conjunto de datos original fácilmente con solo `yolo val model=yolov8n.pt` o `model('yolov8n.pt').val()`
-
-## Ejemplos de Uso
-
-Valide la precisión del modelo YOLOv8n entrenado en el conjunto de datos COCO128. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # cargar un modelo oficial
- model = YOLO('ruta/a/best.pt') # cargar un modelo personalizado
-
- # Validar el modelo
- metrics = model.val() # no se necesitan argumentos, el conjunto de datos y ajustes se recuerdan
- metrics.box.map # map50-95
- metrics.box.map50 # map50
- metrics.box.map75 # map75
- metrics.box.maps # una lista que contiene map50-95 de cada categoría
- ```
- === "CLI"
-
- ```bash
- yolo detect val model=yolov8n.pt # val model oficial
- yolo detect val model=ruta/a/best.pt # val model personalizado
- ```
-
-## Argumentos
-
-Los ajustes de validación para modelos YOLO se refieren a los diversos hiperparámetros y configuraciones utilizados para evaluar el rendimiento del modelo en un conjunto de datos de validación. Estos ajustes pueden afectar el rendimiento, la velocidad y la precisión del modelo. Algunos ajustes comunes de validación YOLO incluyen el tamaño del lote, la frecuencia con la que se realiza la validación durante el entrenamiento y las métricas utilizadas para evaluar el rendimiento del modelo. Otros factores que pueden afectar el proceso de validación incluyen el tamaño y la composición del conjunto de datos de validación y la tarea específica para la que se utiliza el modelo. Es importante ajustar y experimentar cuidadosamente con estos ajustes para asegurarse de que el modelo esté funcionando bien en el conjunto de datos de validación y para detectar y prevenir el sobreajuste.
-
-| Clave | Valor | Descripción |
-|---------------|---------|---------------------------------------------------------------------------------------------------|
-| `data` | `None` | ruta al archivo de datos, por ejemplo coco128.yaml |
-| `imgsz` | `640` | tamaño de las imágenes de entrada como entero |
-| `batch` | `16` | número de imágenes por lote (-1 para AutoBatch) |
-| `save_json` | `False` | guardar resultados en archivo JSON |
-| `save_hybrid` | `False` | guardar versión híbrida de las etiquetas (etiquetas + predicciones adicionales) |
-| `conf` | `0.001` | umbral de confianza del objeto para detección |
-| `iou` | `0.6` | umbral de Intersección sobre Unión (IoU) para NMS |
-| `max_det` | `300` | número máximo de detecciones por imagen |
-| `half` | `True` | usar precisión de punto flotante de media preción (FP16) |
-| `device` | `None` | dispositivo en el que se ejecuta, por ejemplo dispositivo cuda=0/1/2/3 o dispositivo=cpu |
-| `dnn` | `False` | utilizar OpenCV DNN para inferencia ONNX |
-| `plots` | `False` | mostrar gráficos durante el entrenamiento |
-| `rect` | `False` | val rectangular con cada lote compilado para el mínimo relleno |
-| `split` | `val` | división del conjunto de datos a utilizar para la validación, por ejemplo 'val', 'test' o 'train' |
-|
diff --git a/docs/es/quickstart.md b/docs/es/quickstart.md
deleted file mode 100644
index ab6dfaf8fa7..00000000000
--- a/docs/es/quickstart.md
+++ /dev/null
@@ -1,198 +0,0 @@
----
-comments: true
-description: Explore diversos métodos para instalar Ultralytics usando pip, conda, git y Docker. Aprende cómo usar Ultralytics con la interfaz de línea de comandos o dentro de tus proyectos de Python.
-keywords: instalación de Ultralytics, pip install Ultralytics, instalación de Docker Ultralytics, interfaz de línea de comandos de Ultralytics, interfaz de Python de Ultralytics
----
-
-## Instalar Ultralytics
-
-Ultralytics ofrece varios métodos de instalación incluyendo pip, conda y Docker. Instala YOLOv8 a través del paquete `ultralytics` de pip para la última versión estable o clonando el [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics) para obtener la versión más actualizada. Docker se puede utilizar para ejecutar el paquete en un contenedor aislado, evitando la instalación local.
-
-!!! Example "Instalar"
-
- === "Instalación con Pip (recomendado)"
- Instala el paquete `ultralytics` usando pip o actualiza una instalación existente ejecutando `pip install -U ultralytics`. Visita el Índice de Paquetes de Python (PyPI) para más detalles sobre el paquete `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
-
- [![Versión en PyPI](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Descargas](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
-
- ```bash
- # Instalar el paquete ultralytics desde PyPI
- pip install ultralytics
- ```
-
- También puedes instalar el paquete `ultralytics` directamente del [repositorio](https://github.com/ultralytics/ultralytics) en GitHub. Esto puede ser útil si quieres la última versión de desarrollo. Asegúrate de tener la herramienta de línea de comandos Git instalada en tu sistema. El comando `@main` instala la rama `main` y puede modificarse a otra rama, es decir, `@my-branch`, o eliminarse por completo para volver por defecto a la rama `main`.
-
- ```bash
- # Instalar el paquete ultralytics desde GitHub
- pip install git+https://github.com/ultralytics/ultralytics.git@main
- ```
-
-
- === "Instalación con Conda"
- Conda es un gestor de paquetes alternativo a pip que también puede utilizarse para la instalación. Visita Anaconda para más detalles en [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). El repositorio de paquetes de alimentación de Ultralytics para actualizar el paquete de conda está en [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
-
-
- [![Receta de Conda](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Descargas de Conda](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Versión de Conda](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Plataformas de Conda](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics)
-
- ```bash
- # Instalar el paquete ultralytics usando conda
- conda install -c conda-forge ultralytics
- ```
-
- !!! Note "Nota"
-
- Si estás instalando en un entorno CUDA, la mejor práctica es instalar `ultralytics`, `pytorch` y `pytorch-cuda` en el mismo comando para permitir que el gestor de paquetes de conda resuelva cualquier conflicto, o en su defecto instalar `pytorch-cuda` al final para permitir que sobrescriba el paquete específico de CPU `pytorch` si es necesario.
- ```bash
- # Instalar todos los paquetes juntos usando conda
- conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
- ```
-
- ### Imagen Docker de Conda
-
- Las imágenes Docker de Conda de Ultralytics también están disponibles en [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Estas imágenes están basadas en [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) y son una manera simple de comenzar a usar `ultralytics` en un entorno Conda.
-
- ```bash
- # Establecer el nombre de la imagen como una variable
- t=ultralytics/ultralytics:latest-conda
-
- # Descargar la última imagen de ultralytics de Docker Hub
- sudo docker pull $t
-
- # Ejecutar la imagen de ultralytics en un contenedor con soporte para GPU
- sudo docker run -it --ipc=host --gpus all $t # todas las GPUs
- sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # especificar GPUs
- ```
-
- === "Clonar con Git"
- Clona el repositorio `ultralytics` si estás interesado en contribuir al desarrollo o deseas experimentar con el código fuente más reciente. Después de clonar, navega al directorio e instala el paquete en modo editable `-e` usando pip.
- ```bash
- # Clonar el repositorio ultralytics
- git clone https://github.com/ultralytics/ultralytics
-
- # Navegar al directorio clonado
- cd ultralytics
-
- # Instalar el paquete en modo editable para desarrollo
- pip install -e .
- ```
-
-Consulta el archivo [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) de `ultralytics` para ver una lista de dependencias. Ten en cuenta que todos los ejemplos anteriores instalan todas las dependencias requeridas.
-
-
-
-!!! Tip "Consejo"
-
- Los requisitos de PyTorch varían según el sistema operativo y los requisitos de CUDA, por lo que se recomienda instalar primero PyTorch siguiendo las instrucciones en [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
-
-
-
-
-
-## Usar Ultralytics con CLI
-
-La interfaz de línea de comandos (CLI) de Ultralytics permite el uso de comandos simples de una sola línea sin la necesidad de un entorno de Python. La CLI no requiere personalización ni código Python. Puedes simplemente ejecutar todas las tareas desde el terminal con el comando `yolo`. Consulta la [Guía de CLI](/../usage/cli.md) para aprender más sobre el uso de YOLOv8 desde la línea de comandos.
-
-!!! Example "Ejemplo"
-
- === "Sintaxis"
-
- Los comandos `yolo` de Ultralytics usan la siguiente sintaxis:
- ```bash
- yolo TAREA MODO ARGUMENTOS
-
- Donde TAREA (opcional) es uno de [detectar, segmentar, clasificar]
- MODO (requerido) es uno de [train, val, predict, export, track]
- ARGUMENTOS (opcionales) son cualquier número de pares personalizados 'arg=valor' como 'imgsz=320' que sobrescriben los valores por defecto.
- ```
- Ver todos los ARGUMENTOS en la guía completa [Configuration Guide](/../usage/cfg.md) o con `yolo cfg`
-
- === "Entrenar"
-
- Entrenar un modelo de detección durante 10 épocas con una tasa de aprendizaje inicial de 0.01
- ```bash
- yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
- ```
-
- === "Predecir"
-
- Predecir un video de YouTube usando un modelo de segmentación preentrenado con un tamaño de imagen de 320:
- ```bash
- yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
- ```
-
- === "Validar"
-
- Validar un modelo de detección preentrenado con un tamaño de lote de 1 y un tamaño de imagen de 640:
- ```bash
- yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
- ```
-
- === "Exportar"
-
- Exportar un modelo de clasificación YOLOv8n a formato ONNX con un tamaño de imagen de 224 por 128 (no se requiere TAREA)
- ```bash
- yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
- ```
-
- === "Especial"
-
- Ejecutar comandos especiales para ver la versión, ver configuraciones, ejecutar chequeos y más:
- ```bash
- yolo help
- yolo checks
- yolo version
- yolo settings
- yolo copy-cfg
- yolo cfg
- ```
-
-!!! Warning "Advertencia"
-
- Los argumentos deben pasarse como pares `arg=valor`, separados por un signo igual `=` y delimitados por espacios ` ` entre pares. No utilices prefijos de argumentos `--` ni comas `,` entre los argumentos.
-
- - `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` ❌
-
-[Guía de CLI](/../usage/cli.md){.md-button .md-button--primary}
-
-## Usar Ultralytics con Python
-
-La interfaz de Python de YOLOv8 permite una integración perfecta en tus proyectos de Python, facilitando la carga, ejecución y procesamiento de la salida del modelo. Diseñada con sencillez y facilidad de uso en mente, la interfaz de Python permite a los usuarios implementar rápidamente la detección de objetos, segmentación y clasificación en sus proyectos. Esto hace que la interfaz de Python de YOLOv8 sea una herramienta invaluable para cualquier persona que busque incorporar estas funcionalidades en sus proyectos de Python.
-
-Por ejemplo, los usuarios pueden cargar un modelo, entrenarlo, evaluar su rendimiento en un conjunto de validación e incluso exportarlo al formato ONNX con solo unas pocas líneas de código. Consulta la [Guía de Python](/../usage/python.md) para aprender más sobre el uso de YOLOv8 dentro de tus proyectos de Python.
-
-!!! Example "Ejemplo"
-
- ```python
- from ultralytics import YOLO
-
- # Crear un nuevo modelo YOLO desde cero
- model = YOLO('yolov8n.yaml')
-
- # Cargar un modelo YOLO preentrenado (recomendado para entrenamiento)
- model = YOLO('yolov8n.pt')
-
- # Entrenar el modelo usando el conjunto de datos 'coco128.yaml' durante 3 épocas
- results = model.train(data='coco128.yaml', epochs=3)
-
- # Evaluar el rendimiento del modelo en el conjunto de validación
- results = model.val()
-
- # Realizar detección de objetos en una imagen usando el modelo
- results = model('https://ultralytics.com/images/bus.jpg')
-
- # Exportar el modelo al formato ONNX
- success = model.export(format='onnx')
- ```
-
-[Guía de Python](/../usage/python.md){.md-button .md-button--primary}
diff --git a/docs/es/tasks/classify.md b/docs/es/tasks/classify.md
deleted file mode 100644
index 74e73abe4ee..00000000000
--- a/docs/es/tasks/classify.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-comments: true
-description: Aprenda sobre los modelos de clasificación de imágenes YOLOv8 Classify. Obtenga información detallada sobre la Lista de Modelos Preentrenados y cómo Entrenar, Validar, Predecir y Exportar modelos.
-keywords: Ultralytics, YOLOv8, Clasificación de imágenes, Modelos preentrenados, YOLOv8n-cls, Entrenamiento, Validación, Predicción, Exportación de modelos
----
-
-# Clasificación de Imágenes
-
-
-
-La clasificación de imágenes es la tarea más sencilla de las tres y consiste en clasificar una imagen completa en una de un conjunto de clases predefinidas.
-
-La salida de un clasificador de imágenes es una única etiqueta de clase y una puntuación de confianza. La clasificación de imágenes es útil cuando solo necesita saber a qué clase pertenece una imagen y no necesita conocer dónde están ubicados los objetos de esa clase o cuál es su forma exacta.
-
-!!! Tip "Consejo"
-
- Los modelos YOLOv8 Classify utilizan el sufijo `-cls`, por ejemplo, `yolov8n-cls.pt` y están preentrenados en [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-Los modelos Classify preentrenados YOLOv8 se muestran aquí. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último [lanzamiento](https://github.com/ultralytics/assets/releases) de Ultralytics en el primer uso.
-
-| Modelo | Tamaño (píxeles) | Exactitud top1 | Exactitud top5 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | Parámetros (M) | FLOPs (B) en 640 |
-|----------------------------------------------------------------------------------------------|--------------------------|------------------------|------------------------|------------------------------------|-----------------------------------------|------------------------|--------------------------|
-| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
-
-- Los valores de **Exactitud** son las precisiones de los modelos en el conjunto de datos de validación de [ImageNet](https://www.image-net.org/).
- Para reproducir usar `yolo val classify data=path/to/ImageNet device=0`
-- **Velocidad** promediada sobre imágenes de validación de ImageNet usando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
- Para reproducir usar `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
-
-## Entrenamiento
-
-Entrena el modelo YOLOv8n-cls en el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen de 64. Para obtener una lista completa de argumentos disponibles, consulte la página de [Configuración](/../usage/cfg.md).
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-cls.yaml') # construir un nuevo modelo desde YAML
- model = YOLO('yolov8n-cls.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
- model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construir desde YAML y transferir pesos
-
- # Entrenar el modelo
- results = model.train(data='mnist160', epochs=100, imgsz=64)
- ```
-
- === "CLI"
-
- ```bash
- # Construir un nuevo modelo desde YAML y empezar entrenamiento desde cero
- yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
-
- # Empezar entrenamiento desde un modelo *.pt preentrenado
- yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
-
- # Construir un nuevo modelo desde YAML, transferir pesos preentrenados e iniciar entrenamiento
- yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
- ```
-
-### Formato del conjunto de datos
-
-El formato del conjunto de datos de clasificación YOLO puede encontrarse en detalle en la [Guía de Conjuntos de Datos](../../../datasets/classify/index.md).
-
-## Validación
-
-Validar la exactitud del modelo YOLOv8n-cls entrenado en el conjunto de datos MNIST160. No es necesario pasar ningún argumento ya que el `modelo` retiene su `data` y argumentos como atributos del modelo.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial
- model = YOLO('path/to/best.pt') # cargar un modelo personalizado
-
- # Validar el modelo
- metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan
- metrics.top1 # precisión top1
- metrics.top5 # precisión top5
- ```
- === "CLI"
-
- ```bash
- yolo classify val model=yolov8n-cls.pt # validar modelo oficial
- yolo classify val model=path/to/best.pt # validar modelo personalizado
- ```
-
-## Predicción
-
-Usar un modelo YOLOv8n-cls entrenado para realizar predicciones en imágenes.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial
- model = YOLO('path/to/best.pt') # cargar un modelo personalizado
-
- # Predecir con el modelo
- results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
- ```
- === "CLI"
-
- ```bash
- yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial
- yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado
- ```
-
-Ver detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/).
-
-## Exportación
-
-Exportar un modelo YOLOv8n-cls a un formato diferente como ONNX, CoreML, etc.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial
- model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado
-
- # Exportar el modelo
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n-cls.pt format=onnx # exportar modelo oficial
- yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado
- ```
-
-Los formatos de exportación disponibles para YOLOv8-cls se encuentran en la tabla a continuación. Puede predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-cls.onnx`. Ejemplos de uso se muestran para su modelo después de que se completa la exportación.
-
-| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
-|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------|
-| [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` |
-
-Vea detalles completos de `exportación` en la página de [Exportación](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/es/tasks/detect.md b/docs/es/tasks/detect.md
deleted file mode 100644
index 7b31d62cf2a..00000000000
--- a/docs/es/tasks/detect.md
+++ /dev/null
@@ -1,184 +0,0 @@
----
-comments: true
-description: Documentación oficial de YOLOv8 de Ultralytics. Aprende a entrenar, validar, predecir y exportar modelos en varios formatos. Incluyendo estadísticas detalladas de rendimiento.
-keywords: YOLOv8, Ultralytics, detección de objetos, modelos preentrenados, entrenamiento, validación, predicción, exportación de modelos, COCO, ImageNet, PyTorch, ONNX, CoreML
----
-
-# Detección de Objetos
-
-
-
-La detección de objetos es una tarea que implica identificar la ubicación y clase de objetos en una imagen o flujo de video.
-
-La salida de un detector de objetos es un conjunto de cajas delimitadoras que encierran a los objetos en la imagen, junto con etiquetas de clase y puntajes de confianza para cada caja. La detección de objetos es una buena opción cuando necesitas identificar objetos de interés en una escena, pero no necesitas saber exactamente dónde se encuentra el objeto o su forma exacta.
-
-
-
-
-
- Ver: Detección de Objetos con Modelo Preentrenado YOLOv8 de Ultralytics.
-
-
-!!! Tip "Consejo"
-
- Los modelos YOLOv8 Detect son los modelos predeterminados de YOLOv8, es decir, `yolov8n.pt` y están preentrenados en [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
-
-## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-Los modelos preentrenados de YOLOv8 Detect se muestran aquí. Los modelos de Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos de Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso.
-
-| 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/v8.1.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
-| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
-| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
-| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
-| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
-
-- Los valores de **mAPval** son para un solo modelo a una sola escala en el conjunto de datos [COCO val2017](https://cocodataset.org).
- Reproduce utilizando `yolo val detect data=coco.yaml device=0`
-- La **Velocidad** es el promedio sobre las imágenes de COCO val utilizando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
- Reproduce utilizando `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
-
-## Entrenamiento
-
-Entrena a YOLOv8n en el conjunto de datos COCO128 durante 100 épocas a tamaño de imagen 640. Para una lista completa de argumentos disponibles, consulta la página [Configuración](/../usage/cfg.md).
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.yaml') # construye un nuevo modelo desde YAML
- model = YOLO('yolov8n.pt') # carga un modelo preentrenado (recomendado para entrenamiento)
- model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construye desde YAML y transfiere los pesos
-
- # Entrenar el modelo
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
- ```
- === "CLI"
-
- ```bash
- # Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero
- yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
-
- # Comenzar entrenamiento desde un modelo *.pt preentrenado
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
-
- # Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento
- yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
- ```
-
-### Formato del conjunto de datos
-
-El formato del conjunto de datos de detección de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../../datasets/detect/index.md). Para convertir tu conjunto de datos existente desde otros formatos (como COCO, etc.) al formato YOLO, por favor usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics.
-
-## Validación
-
-Valida la precisión del modelo YOLOv8n entrenado en el conjunto de datos COCO128. No es necesario pasar ningún argumento, ya que el `modelo` retiene sus datos de `entrenamiento` y argumentos como atributos del modelo.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # cargar un modelo oficial
- model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
-
- # Validar el modelo
- metrics = model.val() # sin argumentos necesarios, el conjunto de datos y configuraciones se recuerdan
- metrics.box.map # map50-95
- metrics.box.map50 # map50
- metrics.box.map75 # map75
- metrics.box.maps # una lista contiene map50-95 de cada categoría
- ```
- === "CLI"
-
- ```bash
- yolo detect val model=yolov8n.pt # validar modelo oficial
- yolo detect val model=ruta/a/mejor.pt # validar modelo personalizado
- ```
-
-## Predicción
-
-Utiliza un modelo YOLOv8n entrenado para realizar predicciones en imágenes.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # cargar un modelo oficial
- model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
-
- # Predecir con el modelo
- results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
- ```
- === "CLI"
-
- ```bash
- yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial
- yolo detect predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado
- ```
-
-Consulta los detalles completos del modo `predict` en la página [Predicción](https://docs.ultralytics.com/modes/predict/).
-
-## Exportación
-
-Exporta un modelo YOLOv8n a un formato diferente como ONNX, CoreML, etc.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n.pt') # cargar un modelo oficial
- model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado
-
- # Exportar el modelo
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n.pt format=onnx # exportar modelo oficial
- yolo export model=ruta/a/mejor.pt format=onnx # exportar modelo entrenado personalizado
- ```
-
-Los formatos de exportación de YOLOv8 disponibles se encuentran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n.onnx`. Ejemplos de uso se muestran para tu modelo después de que la exportación se completa.
-
-| Formato | Argumento `format` | Modelo | Metadata | Argumentos |
-|--------------------------------------------------------------------|--------------------|----------------------------|----------|------------------------------------------------------------------------|
-| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
-| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimizar` |
-| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `conjunto de operaciones` |
-| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `modelo_yolov8n_openvino/` | ✅ | `imgsz`, `mitad` |
-| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `espacio de trabajo` |
-| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `mitad`, `int8`, `nms` |
-| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `modelo_guardado_yolov8n/` | ✅ | `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`, `mitad`, `int8` |
-| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
-| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `modelo_web_yolov8n/` | ✅ | `imgsz` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `modelo_yolov8n_paddle/` | ✅ | `imgsz` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `modelo_ncnn_yolov8n/` | ✅ | `imgsz`, `mitad` |
-
-Consulta los detalles completos de la `exportación` en la página [Exportar](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/es/tasks/index.md b/docs/es/tasks/index.md
deleted file mode 100644
index 04d1b5adce7..00000000000
--- a/docs/es/tasks/index.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-comments: true
-description: Aprenda sobre las tareas fundamentales de visión por computadora que YOLOv8 puede realizar, incluyendo detección, segmentación, clasificación y estimación de pose. Comprenda sus usos en sus proyectos de IA.
-keywords: Ultralytics, YOLOv8, Detección, Segmentación, Clasificación, Estimación de Pose, Marco de IA, Tareas de Visión por Computadora
----
-
-# Tareas de Ultralytics YOLOv8
-
-
-
-
-YOLOv8 es un marco de trabajo de IA que soporta múltiples **tareas** de visión por computadora. El marco puede usarse para realizar [detección](detect.md), [segmentación](segment.md), [clasificación](classify.md) y estimación de [pose](pose.md). Cada una de estas tareas tiene un objetivo y caso de uso diferente.
-
-!!! Note "Nota"
-
- 🚧 Nuestra documentación multilenguaje está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏
-
-
-
-
-
- Mire: Explore las Tareas de Ultralytics YOLO: Detección de Objetos, Segmentación, Seguimiento y Estimación de Pose.
-
-
-## [Detección](detect.md)
-
-La detección es la tarea principal soportada por YOLOv8. Implica detectar objetos en una imagen o cuadro de video y dibujar cuadros delimitadores alrededor de ellos. Los objetos detectados se clasifican en diferentes categorías basadas en sus características. YOLOv8 puede detectar múltiples objetos en una sola imagen o cuadro de video con alta precisión y velocidad.
-
-[Ejemplos de Detección](detect.md){ .md-button }
-
-## [Segmentación](segment.md)
-
-La segmentación es una tarea que implica segmentar una imagen en diferentes regiones basadas en el contenido de la imagen. A cada región se le asigna una etiqueta basada en su contenido. Esta tarea es útil en aplicaciones tales como segmentación de imágenes y imágenes médicas. YOLOv8 utiliza una variante de la arquitectura U-Net para realizar la segmentación.
-
-[Ejemplos de Segmentación](segment.md){ .md-button }
-
-## [Clasificación](classify.md)
-
-La clasificación es una tarea que implica clasificar una imagen en diferentes categorías. YOLOv8 puede usarse para clasificar imágenes basadas en su contenido. Utiliza una variante de la arquitectura EfficientNet para realizar la clasificación.
-
-[Ejemplos de Clasificación](classify.md){ .md-button }
-
-## [Pose](pose.md)
-
-La detección de pose/puntos clave es una tarea que implica detectar puntos específicos en una imagen o cuadro de video. Estos puntos se conocen como puntos clave y se utilizan para rastrear el movimiento o la estimación de la pose. YOLOv8 puede detectar puntos clave en una imagen o cuadro de video con alta precisión y velocidad.
-
-[Ejemplos de Pose](pose.md){ .md-button }
-
-## Conclusión
-
-YOLOv8 soporta múltiples tareas, incluyendo detección, segmentación, clasificación y detección de puntos clave. Cada una de estas tareas tiene diferentes objetivos y casos de uso. Al entender las diferencias entre estas tareas, puede elegir la tarea adecuada para su aplicación de visión por computadora.
diff --git a/docs/es/tasks/pose.md b/docs/es/tasks/pose.md
deleted file mode 100644
index 50e8ea698c1..00000000000
--- a/docs/es/tasks/pose.md
+++ /dev/null
@@ -1,185 +0,0 @@
----
-comments: true
-description: Aprende a utilizar Ultralytics YOLOv8 para tareas de estimación de pose. Encuentra modelos preentrenados, aprende a entrenar, validar, predecir y exportar tus propios modelos.
-keywords: Ultralytics, YOLO, YOLOv8, estimación de pose, detección de puntos clave, detección de objetos, modelos preentrenados, aprendizaje automático, inteligencia artificial
----
-
-# Estimación de Pose
-
-
-
-La estimación de pose es una tarea que implica identificar la ubicación de puntos específicos en una imagen, comúnmente referidos como puntos clave. Estos puntos clave pueden representar varias partes del objeto, como articulaciones, puntos de referencia u otras características distintivas. La ubicación de los puntos clave generalmente se representa como un conjunto de coordenadas 2D `[x, y]` o 3D `[x, y, visible]`.
-
-La salida de un modelo de estimación de pose es un conjunto de puntos que representan los puntos clave en un objeto de la imagen, generalmente junto con las puntuaciones de confianza para cada punto. La estimación de pose es una buena opción cuando se necesita identificar partes específicas de un objeto en una escena y su ubicación relativa entre ellas.
-
-
-
-
-
- Ver: Estimación de Pose con Ultralytics YOLOv8.
-
-
-!!! Tip "Consejo"
-
- Los modelos _pose_ YOLOv8 utilizan el sufijo `-pose`, por ejemplo, `yolov8n-pose.pt`. Estos modelos están entrenados en el conjunto de datos [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) y son adecuados para una variedad de tareas de estimación de pose.
-
-## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-Aquí se muestran los modelos preentrenados de YOLOv8 Pose. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso.
-
-| Modelo | tamaño (píxeles) | mAPpose 50-95 | mAPpose 50 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | parámetros (M) | FLOPs (B) |
-|------------------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------|------------------------------------|-----------------------------------------|------------------------|-------------------|
-| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
-
-- Los valores de **mAPval** son para un solo modelo a una sola escala en el conjunto de datos [COCO Keypoints val2017](https://cocodataset.org).
- Reproducir con `yolo val pose data=coco-pose.yaml device=0`
-- **Velocidad** promediada sobre imágenes COCO val usando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
- Reproducir con `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`
-
-## Entrenar
-
-Entrena un modelo YOLOv8-pose en el conjunto de datos COCO128-pose.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-pose.yaml') # construir un nuevo modelo desde YAML
- model = YOLO('yolov8n-pose.pt') # cargar un modelo preentrenado (recomendado para entrenar)
- model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construir desde YAML y transferir los pesos
-
- # Entrenar el modelo
- results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
- ```
- === "CLI"
-
- ```bash
- # Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero
- yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
-
- # Empezar entrenamiento desde un modelo *.pt preentrenado
- yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
-
- # Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento
- yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
- ```
-
-### Formato del conjunto de datos
-
-El formato del conjunto de datos de pose de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../../datasets/pose/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato de YOLO, usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics.
-
-## Validar
-
-Valida la precisión del modelo YOLOv8n-pose entrenado en el conjunto de datos COCO128-pose. No es necesario pasar ningún argumento ya que el `modelo` mantiene sus `datos` de entrenamiento y argumentos como atributos del modelo.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial
- model = YOLO('path/to/best.pt') # cargar un modelo personalizado
-
- # Validar el modelo
- metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan
- metrics.box.map # map50-95
- metrics.box.map50 # map50
- metrics.box.map75 # map75
- metrics.box.maps # una lista contiene map50-95 de cada categoría
- ```
- === "CLI"
-
- ```bash
- yolo pose val model=yolov8n-pose.pt # modelo oficial de val
- yolo pose val model=path/to/best.pt # modelo personalizado de val
- ```
-
-## Predecir
-
-Usa un modelo YOLOv8n-pose entrenado para realizar predicciones en imágenes.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial
- model = YOLO('path/to/best.pt') # cargar un modelo personalizado
-
- # Predecir con el modelo
- results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
- ```
- === "CLI"
-
- ```bash
- yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial
- yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado
- ```
-
-Consulta los detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/).
-
-## Exportar
-
-Exporta un modelo YOLOv8n Pose a un formato diferente como ONNX, CoreML, etc.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial
- model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado
-
- # Exportar el modelo
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n-pose.pt format=onnx # exportar modelo oficial
- yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado
- ```
-
-Los formatos de exportación de YOLOv8-pose disponibles se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-pose.onnx`. Los ejemplos de uso se muestran para tu modelo después de que la exportación se completa.
-
-| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
-|--------------------------------------------------------------------|--------------------|--------------------------------|-----------|---------------------------------------------------------------|
-| [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`, `dinámico`, `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`, `dinámico`, `simplify`, `espacio de trabajo` |
-| [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` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` |
-
-Consulta los detalles completos del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/es/tasks/segment.md b/docs/es/tasks/segment.md
deleted file mode 100644
index b152d5a7178..00000000000
--- a/docs/es/tasks/segment.md
+++ /dev/null
@@ -1,188 +0,0 @@
----
-comments: true
-description: Aprende a utilizar modelos de segmentación de instancias con Ultralytics YOLO. Instrucciones sobre entrenamiento, validación, predicción de imágenes y exportación de modelos.
-keywords: yolov8, segmentación de instancias, Ultralytics, conjunto de datos COCO, segmentación de imágenes, detección de objetos, entrenamiento de modelos, validación de modelos, predicción de imágenes, exportación de modelos.
----
-
-# Segmentación de Instancias
-
-
-
-La segmentación de instancias va un paso más allá de la detección de objetos e implica identificar objetos individuales en una imagen y segmentarlos del resto de la imagen.
-
-La salida de un modelo de segmentación de instancias es un conjunto de máscaras o contornos que delimitan cada objeto en la imagen, junto con etiquetas de clase y puntajes de confianza para cada objeto. La segmentación de instancias es útil cuando necesitas saber no solo dónde están los objetos en una imagen, sino también cuál es su forma exacta.
-
-
-
-
-
- Mira: Ejecuta la Segmentación con el Modelo Ultralytics YOLOv8 Preentrenado en Python.
-
-
-!!! Tip "Consejo"
-
- Los modelos YOLOv8 Segment utilizan el sufijo `-seg`, es decir, `yolov8n-seg.pt` y están preentrenados en el [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
-
-## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-Aquí se muestran los modelos Segment preentrenados YOLOv8. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-Los [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en su primer uso.
-
-| Modelo | Tamaño (píxeles) | mAPcaja 50-95 | mAPmáscara 50-95 | Velocidad CPU ONNX (ms) | Velocidad A100 TensorRT (ms) | Parámetros (M) | FLOPs (B) |
-|----------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------------|------------------------------------|-----------------------------------------|------------------------|-------------------|
-| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
-
-- Los valores **mAPval** son para un único modelo a una única escala en el conjunto de datos [COCO val2017](https://cocodataset.org).
- Reproducir utilizando `yolo val segment data=coco.yaml device=0`
-- La **Velocidad** promediada sobre imágenes de COCO val utilizando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
- Reproducir utilizando `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
-
-## Entrenamiento
-
-Entrena el modelo YOLOv8n-seg en el conjunto de datos COCO128-seg durante 100 épocas con tamaño de imagen de 640. Para una lista completa de argumentos disponibles, consulta la página de [Configuración](/../usage/cfg.md).
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-seg.yaml') # construir un nuevo modelo desde YAML
- model = YOLO('yolov8n-seg.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
- model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos
-
- # Entrenar el modelo
- results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
- ```
- === "CLI"
-
- ```bash
- # Construir un nuevo modelo desde YAML y comenzar a entrenar desde cero
- yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
-
- # Comenzar a entrenar desde un modelo *.pt preentrenado
- yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
-
- # Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar a entrenar
- yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
- ```
-
-### Formato del conjunto de datos
-
-El formato del conjunto de datos de segmentación YOLO puede encontrarse detallado en la [Guía de Conjuntos de Datos](../../../datasets/segment/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato YOLO, utiliza la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics.
-
-## Validación
-
-Valida la precisión del modelo YOLOv8n-seg entrenado en el conjunto de datos COCO128-seg. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial
- model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
-
- # Validar el modelo
- metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan
- metrics.box.map # map50-95(B)
- metrics.box.map50 # map50(B)
- metrics.box.map75 # map75(B)
- metrics.box.maps # una lista contiene map50-95(B) de cada categoría
- metrics.seg.map # map50-95(M)
- metrics.seg.map50 # map50(M)
- metrics.seg.map75 # map75(M)
- metrics.seg.maps # una lista contiene map50-95(M) de cada categoría
- ```
- === "CLI"
-
- ```bash
- yolo segment val model=yolov8n-seg.pt # validar el modelo oficial
- yolo segment val model=ruta/a/mejor.pt # validar el modelo personalizado
- ```
-
-## Predicción
-
-Usa un modelo YOLOv8n-seg entrenado para realizar predicciones en imágenes.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial
- model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
-
- # Predecir con el modelo
- results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
- ```
- === "CLI"
-
- ```bash
- yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo oficial
- yolo segment predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo personalizado
- ```
-
-Consulta todos los detalles del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/).
-
-## Exportación
-
-Exporta un modelo YOLOv8n-seg a un formato diferente como ONNX, CoreML, etc.
-
-!!! Example "Ejemplo"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Cargar un modelo
- model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial
- model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado
-
- # Exportar el modelo
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n-seg.pt format=onnx # exportar el modelo oficial
- yolo export model=ruta/a/mejor.pt format=onnx # exportar el modelo entrenado personalizado
- ```
-
-Los formatos disponibles para exportar YOLOv8-seg se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n-seg.onnx`. Se muestran ejemplos de uso para tu modelo después de que se completa la exportación.
-
-| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
-|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------|
-| [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` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` |
-
-Consulta todos los detalles del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/fr/datasets/index.md b/docs/fr/datasets/index.md
deleted file mode 100644
index 21889ea0aa0..00000000000
--- a/docs/fr/datasets/index.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-comments: true
-description: Explorez divers ensembles de données de vision par ordinateur pris en charge par Ultralytics pour la détection d'objets, la segmentation, l'estimation de la pose, la classification d'images et le suivi multi-objets.
-keywords: vision par ordinateur, ensembles de données, Ultralytics, YOLO, détection d'objets, segmentation d'instance, estimation de la pose, classification d'images, suivi multi-objets
----
-
-# Aperçu des ensembles de données
-
-Ultralytics fournit un soutien pour divers ensembles de données pour faciliter les tâches de vision par ordinateur telles que la détection, la segmentation d'instance, l'estimation de la pose, la classification et le suivi multi-objets. Ci-dessous se trouve une liste des principaux ensembles de données Ultralytics, suivie d'un résumé de chaque tâche de vision par ordinateur et des ensembles de données respectifs.
-
-!!! Note "Note"
-
- 🚧 Notre documentation multilingue est actuellement en cours de construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏
-
-## [Ensembles de données de détection](../../datasets/detect/index.md)
-
-La détection d'objets par boîte englobante est une technique de vision par ordinateur qui consiste à détecter et localiser des objets dans une image en dessinant une boîte englobante autour de chaque objet.
-
-- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées.
-- [COCO](../../datasets/detect/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et l'annotation avec plus de 200K images étiquetées.
-- [COCO8](../../datasets/detect/coco8.md) : Contient les 4 premières images de COCO train et COCO val, adaptées pour des tests rapides.
-- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md) : Un ensemble de données d'images de têtes de blé recueillies dans le monde entier pour les tâches de détection et de localisation d'objets.
-- [Objects365](../../datasets/detect/objects365.md) : Un ensemble de données de grande qualité et à grande échelle pour la détection d'objets avec 365 catégories d'objets et plus de 600K images annotées.
-- [OpenImagesV7](../../datasets/detect/open-images-v7.md) : Un ensemble de données complet de Google avec 1.7M d'images d'entraînement et 42k images de validation.
-- [SKU-110K](../../datasets/detect/sku-110k.md) : Un ensemble de données mettant en vedette la détection d'objets denses dans les environnements de vente au détail avec plus de 11K images et 1.7 million de boîtes englobantes.
-- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo.
-- [VOC](../../datasets/detect/voc.md) : L'ensemble de données de classes d'objets visuels Pascal (VOC) pour la détection d'objets et la segmentation avec 20 classes d'objets et plus de 11K images.
-- [xView](../../datasets/detect/xview.md) : Un ensemble de données pour la détection d'objets dans l'imagerie aérienne avec 60 catégories d'objets et plus d'un million d'objets annotés.
-
-## [Ensembles de données de segmentation d'instance](../../datasets/segment/index.md)
-
-La segmentation d'instance est une technique de vision par ordinateur qui consiste à identifier et localiser des objets dans une image au niveau des pixels.
-
-- [COCO](../../datasets/segment/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et les tâches d'annotation avec plus de 200K images étiquetées.
-- [COCO8-seg](../../datasets/segment/coco8-seg.md) : Un ensemble de données plus petit pour les tâches de segmentation d'instance, contenant un sous-ensemble de 8 images COCO avec des annotations de segmentation.
-
-## [Estimation de pose](../../datasets/pose/index.md)
-
-L'estimation de la pose est une technique utilisée pour déterminer la pose de l'objet par rapport à la caméra ou au système de coordonnées mondial.
-
-- [COCO](../../datasets/pose/coco.md) : Un ensemble de données de grande échelle avec des annotations de poses humaines conçu pour les tâches d'estimation de la pose.
-- [COCO8-pose](../../datasets/pose/coco8-pose.md) : Un ensemble de données plus petit pour les tâches d'estimation de la pose, contenant un sous-ensemble de 8 images COCO avec des annotations de pose humaine.
-- [Tiger-pose](../../datasets/pose/tiger-pose.md) : Un ensemble de données compact composé de 263 images centrées sur les tigres, annotées avec 12 points par tigre pour les tâches d'estimation de la pose.
-
-## [Classification](../../datasets/classify/index.md)
-
-La classification d'images est une tâche de vision par ordinateur qui implique de catégoriser une image dans une ou plusieurs classes ou catégories prédéfinies en fonction de son contenu visuel.
-
-- [Caltech 101](../../datasets/classify/caltech101.md) : Un ensemble de données contenant des images de 101 catégories d'objets pour les tâches de classification d'images.
-- [Caltech 256](../../datasets/classify/caltech256.md) : Une version étendue de Caltech 101 avec 256 catégories d'objets et des images plus complexes.
-- [CIFAR-10](../../datasets/classify/cifar10.md) : Un ensemble de données de 60K images couleur 32x32 réparties en 10 classes, avec 6K images par classe.
-- [CIFAR-100](../../datasets/classify/cifar100.md) : Une version étendue de CIFAR-10 avec 100 catégories d'objets et 600 images par classe.
-- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md) : Un ensemble de données composé de 70 000 images en niveaux de gris de 10 catégories de mode pour les tâches de classification d'images.
-- [ImageNet](../../datasets/classify/imagenet.md) : Un ensemble de données à grande échelle pour la détection d'objets et la classification d'images avec plus de 14 millions d'images et 20 000 catégories.
-- [ImageNet-10](../../datasets/classify/imagenet10.md) : Un sous-ensemble plus petit d'ImageNet avec 10 catégories pour des expériences et des tests plus rapides.
-- [Imagenette](../../datasets/classify/imagenette.md) : Un sous-ensemble plus petit d'ImageNet qui contient 10 classes facilement distinctes pour un entraînement et des tests plus rapides.
-- [Imagewoof](../../datasets/classify/imagewoof.md) : Un sous-ensemble d'ImageNet plus difficile contenant 10 catégories de races de chiens pour les tâches de classification d'images.
-- [MNIST](../../datasets/classify/mnist.md) : Un ensemble de données de 70 000 images en niveaux de gris de chiffres manuscrits pour les tâches de classification d'images.
-
-## [Boîtes Englobantes Orientées (OBB)](../../datasets/obb/index.md)
-
-Les Boîtes Englobantes Orientées (OBB) sont une méthode en vision par ordinateur pour détecter des objets inclinés dans les images en utilisant des boîtes englobantes rotatives, souvent appliquée à l'imagerie aérienne et satellite.
-
-- [DOTAv2](../../datasets/obb/dota-v2.md) : Un ensemble de données d'imagerie aérienne populaire avec 1.7 million d'instances et 11 268 images.
-
-## [Suivi Multi-Objets](../../datasets/track/index.md)
-
-Le suivi multi-objets est une technique de vision par ordinateur qui consiste à détecter et suivre plusieurs objets dans le temps dans une séquence vidéo.
-
-- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées pour les tâches de suivi multi-objets.
-- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo.
-
-## Contribuer de Nouveaux Ensembles de Données
-
-Contribuer un nouvel ensemble de données implique plusieurs étapes pour s'assurer qu'il s'aligne bien avec l'infrastructure existante. Voici les étapes nécessaires :
-
-### Étapes pour Contribuer un Nouvel Ensemble de Données
-
-1. **Collecter des Images** : Rassemblez les images qui appartiennent à l'ensemble de données. Celles-ci pourraient être collectées à partir de différentes sources, telles que des bases de données publiques ou votre propre collection.
-
-2. **Annoter des Images** : Annotez ces images avec des boîtes englobantes, des segments ou des points clés, en fonction de la tâche.
-
-3. **Exporter des Annotations** : Convertissez ces annotations au format de fichier YOLO `*.txt` pris en charge par Ultralytics.
-
-4. **Organiser l'Ensemble de Données** : Rangez votre ensemble de données dans la bonne structure de dossiers. Vous devriez avoir des répertoires de niveau supérieur `train/` et `val/`, et à l'intérieur de chacun, un sous-répertoire `images/` et `labels/`.
-
- ```
- dataset/
- ├── train/
- │ ├── images/
- │ └── labels/
- └── val/
- ├── images/
- └── labels/
- ```
-
-5. **Créer un Fichier `data.yaml`** : Dans le répertoire racine de votre ensemble de données, créez un fichier `data.yaml` qui décrit l'ensemble de données, les classes et les autres informations nécessaires.
-
-6. **Optimiser les Images (Optionnel)** : Si vous souhaitez réduire la taille de l'ensemble de données pour un traitement plus efficace, vous pouvez optimiser les images en utilisant le code ci-dessous. Ceci n'est pas requis, mais recommandé pour des tailles d'ensemble de données plus petites et des vitesses de téléchargement plus rapides.
-
-7. **Zipper l'Ensemble de Données** : Compressez le dossier complet de l'ensemble de données dans un fichier zip.
-
-8. **Documenter et PR** : Créez une page de documentation décrivant votre ensemble de données et comment il s'intègre dans le cadre existant. Après cela, soumettez une Pull Request (PR). Référez-vous aux [lignes directrices de contribution Ultralytics](https://docs.ultralytics.com/help/contributing) pour plus de détails sur la manière de soumettre une PR.
-
-### Exemple de Code pour Optimiser et Zipper un Ensemble de Données
-
-!!! Example "Optimiser et Zipper un Ensemble de Données"
-
- === "Python"
-
- ```python
- from pathlib import Path
- from ultralytics.data.utils import compress_one_image
- from ultralytics.utils.downloads import zip_directory
-
- # Définir le répertoire de l'ensemble de données
- path = Path('chemin/vers/ensemble-de-données')
-
- # Optimiser les images dans l'ensemble de données (optionnel)
- for f in path.rglob('*.jpg'):
- compress_one_image(f)
-
- # Zipper l'ensemble de données dans 'chemin/vers/ensemble-de-données.zip'
- zip_directory(path)
- ```
-
-En suivant ces étapes, vous pouvez contribuer un nouvel ensemble de données qui s'intègre bien avec la structure existante d'Ultralytics.
diff --git a/docs/fr/index.md b/docs/fr/index.md
deleted file mode 100644
index 960c4e275eb..00000000000
--- a/docs/fr/index.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-comments: true
-description: Découvrez un guide complet du modèle Ultralytics YOLOv8, un modèle de détection d'objets et de segmentation d'images à haute vitesse et haute précision. Tutoriels d'installation, de prédiction, d'entraînement et plus encore.
-keywords: Ultralytics, YOLOv8, détection d'objets, segmentation d'images, apprentissage automatique, apprentissage profond, vision par ordinateur, installation de YOLOv8, prédiction avec YOLOv8, entraînement de YOLOv8, histoire de YOLO, licences de YOLO
----
-
-
-
-Présentation d'[Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), la dernière version du modèle réputé de détection d'objets en temps réel et de segmentation d'images. YOLOv8 est construit sur des avancées de pointe en apprentissage profond et vision par ordinateur, offrant des performances inégalées en termes de vitesse et de précision. Sa conception épurée le rend adapté à diverses applications et facilement adaptable à différentes plateformes matérielles, des appareils de bord aux API cloud.
-
-Explorez les Docs YOLOv8, une ressource complète conçue pour vous aider à comprendre et à utiliser ses fonctionnalités et capacités. Que vous soyez un praticien chevronné de l'apprentissage automatique ou nouveau dans le domaine, ce hub vise à maximiser le potentiel de YOLOv8 dans vos projets.
-
-!!! Note "Note"
-
- 🚧 Notre documentation multilingue est actuellement en construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏
-
-## Par où commencer
-
-- **Installer** `ultralytics` avec pip et démarrer en quelques minutes [:material-clock-fast: Commencer](quickstart.md){ .md-button }
-- **Prédire** de nouvelles images et vidéos avec YOLOv8 [:octicons-image-16: Prédire sur Images](modes/predict.md){ .md-button }
-- **Entraîner** un nouveau modèle YOLOv8 sur votre propre ensemble de données customisé [:fontawesome-solid-brain: Entraîner un modèle](modes/train.md){ .md-button }
-- **Explorer** les tâches YOLOv8 comme la segmentation, la classification, l'estimation de pose et le suivi [:material-magnify-expand: Explorer les tâches](tasks/index.md){ .md-button }
-
-
-
-
-
- Regarder : Comment entraîner un modèle YOLOv8 sur votre ensemble de données customisé dans Google Colab.
-
-
-## YOLO : Un bref historique
-
-[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), un modèle populaire de détection d'objets et de segmentation d'images, a été développé par Joseph Redmon et Ali Farhadi à l'Université de Washington. Lancé en 2015, YOLO a rapidement gagné en popularité pour sa vitesse et sa précision élevées.
-
-- [YOLOv2](https://arxiv.org/abs/1612.08242), publié en 2016, a amélioré le modèle original en intégrant la normalisation par lots, les boîtes d'ancrage et les clusters de dimensions.
-- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lancé en 2018, a davantage amélioré la performance du modèle en utilisant un réseau dorsal plus efficace, des ancres multiples et un pool pyramidal spatial.
-- [YOLOv4](https://arxiv.org/abs/2004.10934) a été publié en 2020, introduisant des innovations telles que l'augmentation de données Mosaic, une nouvelle tête de détection sans ancre et une nouvelle fonction de perte.
-- [YOLOv5](https://github.com/ultralytics/yolov5) a encore amélioré la performance du modèle et a ajouté des fonctionnalités nouvelles telles que l'optimisation des hyperparamètres, le suivi intégré des expériences et l'export automatique vers des formats d'exportation populaires.
-- [YOLOv6](https://github.com/meituan/YOLOv6) a été rendu open-source par [Meituan](https://about.meituan.com/) en 2022 et est utilisé dans de nombreux robots de livraison autonomes de l'entreprise.
-- [YOLOv7](https://github.com/WongKinYiu/yolov7) a ajouté des tâches supplémentaires telles que l'estimation de pose sur le jeu de données de points clés COCO.
-- [YOLOv8](https://github.com/ultralytics/ultralytics) est la dernière version de YOLO par Ultralytics. En tant que modèle de pointe et dernier cri (state-of-the-art, SOTA), YOLOv8 s'appuie sur le succès des versions précédentes, introduisant de nouvelles fonctionnalités et améliorations pour des performances, une flexibilité et une efficacité renforcées. YOLOv8 prend en charge une gamme complète de tâches d'intelligence artificielle visuelle, y compris la [détection](tasks/detect.md), la [segmentation](tasks/segment.md), l'[estimation de pose](tasks/pose.md), le [suivi](modes/track.md) et la [classification](tasks/classify.md). Cette polyvalence permet aux utilisateurs de tirer parti des capacités de YOLOv8 dans diverses applications et domaines.
-
-## Licences YOLO : Comment est licencié Ultralytics YOLO ?
-
-Ultralytics offre deux options de licence pour répondre aux différents cas d'utilisation :
-
-- **Licence AGPL-3.0** : Cette licence open source [approuvée par OSI](https://opensource.org/licenses/) est idéale pour les étudiants et les passionnés, favorisant la collaboration ouverte et le partage des connaissances. Voir le fichier [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) pour plus de détails.
-- **Licence Enterprise** : Conçue pour un usage commercial, cette licence permet l'intégration transparente des logiciels et modèles d'IA Ultralytics dans des biens et services commerciaux, en contournant les exigences open source de l'AGPL-3.0. Si votre scénario implique l'incorporation de nos solutions dans une offre commerciale, n'hésitez pas à contacter [Ultralytics Licensing](https://ultralytics.com/license).
-
-Notre stratégie de licence est conçue pour garantir que toute amélioration de nos projets open source soit restituée à la communauté. Nous tenons les principes de l'open source à cœur ❤️, et notre mission est de garantir que nos contributions puissent être utilisées et développées de manière bénéfique pour tous.
diff --git a/docs/fr/models/fast-sam.md b/docs/fr/models/fast-sam.md
deleted file mode 100644
index f741b83bd91..00000000000
--- a/docs/fr/models/fast-sam.md
+++ /dev/null
@@ -1,193 +0,0 @@
----
-comments: true
-description: Découvrez FastSAM, une solution basée sur les réseaux de neurones à convolution (CNN) pour la segmentation d'objets en temps réel dans les images. Interaction utilisateur améliorée, efficacité computationnelle et adaptabilité à différentes tâches de vision.
-keywords: FastSAM, apprentissage automatique, solution basée sur les CNN, segmentation d'objets, solution en temps réel, Ultralytics, tâches de vision, traitement d'images, applications industrielles, interaction utilisateur
----
-
-# Fast Segment Anything Model (FastSAM)
-
-Le Fast Segment Anything Model (FastSAM) est une solution basée sur les réseaux de neurones à convolution (CNN) en temps réel pour la tâche Segment Anything. Cette tâche est conçue pour segmenter n'importe quel objet dans une image en fonction de différentes interactions utilisateur possibles. FastSAM réduit considérablement les demandes computationnelles tout en maintenant des performances compétitives, ce qui en fait un choix pratique pour diverses tâches de vision.
-
-![Vue d'ensemble de l'architecture du Fast Segment Anything Model (FastSAM)](https://user-images.githubusercontent.com/26833433/248551984-d98f0f6d-7535-45d0-b380-2e1440b52ad7.jpg)
-
-## Vue d'ensemble
-
-FastSAM est conçu pour remédier aux limitations du [Segment Anything Model (SAM)](sam.md), un modèle Transformer lourd nécessitant des ressources computationnelles importantes. FastSAM découpe la tâche de segmentation en deux étapes séquentielles : la segmentation de toutes les instances et la sélection guidée par une invitation. La première étape utilise [YOLOv8-seg](../tasks/segment.md) pour produire les masques de segmentation de toutes les instances de l'image. Dans la deuxième étape, il génère la région d'intérêt correspondant à l'invitation.
-
-## Fonctionnalités clés
-
-1. **Solution en temps réel :** En exploitant l'efficacité computationnelle des CNN, FastSAM fournit une solution en temps réel pour la tâche Segment Anything, ce qui en fait une solution précieuse pour les applications industrielles nécessitant des résultats rapides.
-
-2. **Efficacité et performances :** FastSAM offre une réduction significative des demandes computationnelles et des ressources sans compromettre la qualité des performances. Il atteint des performances comparables à SAM, mais avec une réduction drastique des ressources computationnelles, ce qui permet une application en temps réel.
-
-3. **Segmentation guidée par une invitation :** FastSAM peut segmenter n'importe quel objet dans une image, guidé par différentes invitations d'interaction utilisateur possibles, offrant ainsi flexibilité et adaptabilité dans différents scénarios.
-
-4. **Basé sur YOLOv8-seg :** FastSAM est basé sur [YOLOv8-seg](../tasks/segment.md), un détecteur d'objets équipé d'une branche de segmentation d'instances. Cela lui permet de produire efficacement les masques de segmentation de toutes les instances dans une image.
-
-5. **Résultats concurrentiels sur les bancs d'essai :** Dans la tâche de proposition d'objets sur MS COCO, FastSAM obtient des scores élevés à une vitesse significativement plus rapide que [SAM](sam.md) sur une seule NVIDIA RTX 3090, démontrant ainsi son efficacité et sa capacité.
-
-6. **Applications pratiques :** Cette approche propose une nouvelle solution pratique pour un grand nombre de tâches de vision à une vitesse très élevée, des dizaines ou des centaines de fois plus rapide que les méthodes actuelles.
-
-7. **Faisabilité de la compression du modèle :** FastSAM démontre la faisabilité d'une voie qui peut réduire considérablement l'effort computationnel en introduisant une contrainte artificielle dans la structure, ouvrant ainsi de nouvelles possibilités pour l'architecture de modèles de grande taille pour les tâches de vision générales.
-
-## Modèles disponibles, tâches prises en charge et modes d'exploitation
-
-Ce tableau présente les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge et leur compatibilité avec différents modes d'exploitation tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Exportation](../modes/export.md), indiqués par des emojis ✅ pour les modes pris en charge et des emojis ❌ pour les modes non pris en charge.
-
-| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Exportation |
-|----------------|---------------------|-------------------------------------------------|-----------|------------|--------------|-------------|
-| FastSAM-s | `FastSAM-s.pt` | [Segmentation d'instances](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-| FastSAM-x | `FastSAM-x.pt` | [Segmentation d'instances](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-
-## Exemples d'utilisation
-
-Les modèles FastSAM sont faciles à intégrer dans vos applications Python. Ultralytics propose une API Python conviviale et des commandes CLI pour simplifier le développement.
-
-### Utilisation de la prédiction
-
-Pour effectuer une détection d'objets sur une image, utilisez la méthode `Predict` comme indiqué ci-dessous :
-
-!!! Example "Exemple"
-
- === "Python"
- ```python
- from ultralytics import FastSAM
- from ultralytics.models.fastsam import FastSAMPrompt
-
- # Définir une source d'inférence
- source = 'chemin/vers/bus.jpg'
-
- # Créer un modèle FastSAM
- model = FastSAM('FastSAM-s.pt') # ou FastSAM-x.pt
-
- # Effectuer une inférence sur une image
- everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
-
- # Préparer un objet Processus Invitation
- prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
-
- # Invitation Everything
- ann = prompt_process.everything_prompt()
-
- # Bbox shape par défaut [0,0,0,0] -> [x1,y1,x2,y2]
- ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
-
- # Invitation Text
- ann = prompt_process.text_prompt(text='une photo d\'un chien')
-
- # Invitation Point
- # points par défaut [[0,0]] [[x1,y1],[x2,y2]]
- # point_label par défaut [0] [1,0] 0:fond, 1:premier plan
- ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
- prompt_process.plot(annotations=ann, output='./')
- ```
-
- === "CLI"
- ```bash
- # Charger un modèle FastSAM et segmenter tout avec
- yolo segment predict model=FastSAM-s.pt source=chemin/vers/bus.jpg imgsz=640
- ```
-
-Cet exemple démontre la simplicité du chargement d'un modèle pré-entraîné et de l'exécution d'une prédiction sur une image.
-
-### Utilisation de la validation
-
-La validation du modèle sur un ensemble de données peut être effectuée de la manière suivante :
-
-!!! Example "Exemple"
-
- === "Python"
- ```python
- from ultralytics import FastSAM
-
- # Créer un modèle FastSAM
- model = FastSAM('FastSAM-s.pt') # ou FastSAM-x.pt
-
- # Valider le modèle
- results = model.val(data='coco8-seg.yaml')
- ```
-
- === "CLI"
- ```bash
- # Charger un modèle FastSAM et le valider sur l'ensemble de données d'exemple COCO8 avec une taille d'image de 640 pixels
- yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
- ```
-
-Veuillez noter que FastSAM ne prend en charge que la détection et la segmentation d'une seule classe d'objet. Cela signifie qu'il reconnaîtra et segmentera tous les objets comme étant de la même classe. Par conséquent, lors de la préparation de l'ensemble de données, vous devez convertir tous les identifiants de catégorie d'objet en 0.
-
-## Utilisation officielle de FastSAM
-
-FastSAM est également disponible directement à partir du dépôt [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM). Voici un bref aperçu des étapes typiques que vous pourriez suivre pour utiliser FastSAM :
-
-### Installation
-
-1. Clonez le dépôt FastSAM :
- ```shell
- git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
- ```
-
-2. Créez et activez un environnement Conda avec Python 3.9 :
- ```shell
- conda create -n FastSAM python=3.9
- conda activate FastSAM
- ```
-
-3. Accédez au dépôt cloné et installez les packages requis :
- ```shell
- cd FastSAM
- pip install -r requirements.txt
- ```
-
-4. Installez le modèle CLIP :
- ```shell
- pip install git+https://github.com/openai/CLIP.git
- ```
-
-### Exemple d'utilisation
-
-1. Téléchargez un [point de contrôle de modèle](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing).
-
-2. Utilisez FastSAM pour l'inférence. Exemples de commandes :
-
- - Segmentez tout dans une image :
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
- ```
-
- - Segmentez des objets spécifiques à l'aide de l'invitation de texte :
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "le chien jaune"
- ```
-
- - Segmentez des objets dans un rectangle englobant (fournir les coordonnées du rectangle au format xywh) :
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
- ```
-
- - Segmentez des objets à proximité de points spécifiques :
- ```shell
- python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
- ```
-
-De plus, vous pouvez essayer FastSAM via une [démonstration Colab](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) ou sur la [démonstration Web HuggingFace](https://huggingface.co/spaces/An-619/FastSAM) pour une expérience visuelle.
-
-## Citations et remerciements
-
-Nous tenons à remercier les auteurs de FastSAM pour leurs contributions importantes dans le domaine de la segmentation d'instances en temps réel :
-
-!!! 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}
- }
- ```
-
-Le document original FastSAM peut être consulté sur [arXiv](https://arxiv.org/abs/2306.12156). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). Nous apprécions leurs efforts pour faire avancer le domaine et rendre leur travail accessible à la communauté dans son ensemble.
diff --git a/docs/fr/models/index.md b/docs/fr/models/index.md
deleted file mode 100644
index abf329dd8e1..00000000000
--- a/docs/fr/models/index.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-comments: true
-description: Explorez la gamme diversifiée de modèles de la famille YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS et RT-DETR pris en charge par Ultralytics. Commencez avec des exemples pour l'utilisation CLI et Python.
-keywords: Ultralytics, documentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modèles, architectures, Python, CLI
----
-
-# Modèles pris en charge par Ultralytics
-
-Bienvenue dans la documentation des modèles d'Ultralytics ! Nous offrons un soutien pour une large gamme de modèles, chacun étant adapté à des tâches spécifiques comme [la détection d'objets](../tasks/detect.md), [la segmentation d'instance](../tasks/segment.md), [la classification d'images](../tasks/classify.md), [l'estimation de pose](../tasks/pose.md), et [le suivi multi-objets](../modes/track.md). Si vous êtes intéressé à contribuer avec votre architecture de modèle à Ultralytics, consultez notre [Guide de Contribution](../../help/contributing.md).
-
-!!! Note "Remarque"
-
- 🚧 Notre documentation dans différentes langues est actuellement en construction, et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏
-
-## Modèles en vedette
-
-Voici quelques-uns des modèles clés pris en charge :
-
-1. **[YOLOv3](yolov3.md)** : La troisième itération de la famille de modèles YOLO, initialement par Joseph Redmon, connue pour ses capacités de détection d'objets en temps réel efficaces.
-2. **[YOLOv4](yolov4.md)** : Une mise à jour native darknet de YOLOv3, publiée par Alexey Bochkovskiy en 2020.
-3. **[YOLOv5](yolov5.md)** : Une version améliorée de l'architecture YOLO par Ultralytics, offrant de meilleures performances et compromis de vitesse par rapport aux versions précédentes.
-4. **[YOLOv6](yolov6.md)** : Publié par [Meituan](https://about.meituan.com/) en 2022, et utilisé dans beaucoup de ses robots de livraison autonomes.
-5. **[YOLOv7](yolov7.md)** : Modèles YOLO mis à jour publiés en 2022 par les auteurs de YOLOv4.
-6. **[YOLOv8](yolov8.md) NOUVEAU 🚀**: La dernière version de la famille YOLO, présentant des capacités améliorées telles que la segmentation d'instance, l'estimation de pose/points clés et la classification.
-7. **[Segment Anything Model (SAM)](sam.md)** : Le modèle Segment Anything Model (SAM) de Meta.
-8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)** : MobileSAM pour applications mobiles, développé par l'Université de Kyung Hee.
-9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)** : FastSAM par le Image & Video Analysis Group, Institute of Automation, Chinese Academy of Sciences.
-10. **[YOLO-NAS](yolo-nas.md)** : Modèles de Recherche d'Architecture Neuronale YOLO (NAS).
-11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)** : Modèles du Transformateur de Détection en Temps Réel (RT-DETR) de PaddlePaddle de Baidu.
-
-
-
-
-
- Regardez : Exécutez les modèles YOLO d'Ultralytics en seulement quelques lignes de code.
-
-
-## Pour Commencer : Exemples d'Utilisation
-
-Cet exemple fournit des exemples simples d'entraînement et d'inférence YOLO. Pour une documentation complète sur ces [modes](../modes/index.md) et d'autres, consultez les pages de documentation [Prédire](../modes/predict.md), [Entraîner](../modes/train.md), [Val](../modes/val.md) et [Exporter](../modes/export.md).
-
-Notez que l'exemple ci-dessous concerne les modèles [Detect](../tasks/detect.md) YOLOv8 pour la détection d'objets. Pour des tâches supplémentaires prises en charge, voir les documentations [Segmenter](../tasks/segment.md), [Classifier](../tasks/classify.md) et [Poser](../tasks/pose.md).
-
-!!! Example "Exemple"
-
- === "Python"
-
- Des modèles pré-entraînés PyTorch `*.pt` ainsi que des fichiers de configuration `*.yaml` peuvent être passés aux classes `YOLO()`, `SAM()`, `NAS()` et `RTDETR()` pour créer une instance de modèle en Python :
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné sur COCO
- model = YOLO('yolov8n.pt')
-
- # Afficher les informations du modèle (optionnel)
- model.info()
-
- # Entraîner le modèle sur le jeu de données exemple COCO8 pendant 100 époques
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # Exécuter l'inférence avec le modèle YOLOv8n sur l'image 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- Des commandes CLI sont disponibles pour exécuter directement les modèles :
-
- ```bash
- # Charger un modèle YOLOv8n pré-entraîné sur COCO et l'entraîner sur le jeu de données exemple COCO8 pendant 100 époques
- yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # Charger un modèle YOLOv8n pré-entraîné sur COCO et exécuter l'inférence sur l'image 'bus.jpg'
- yolo predict model=yolov8n.pt source=path/to/bus.jpg
- ```
-
-## Contribution de Nouveaux Modèles
-
-Vous êtes intéressé à contribuer votre modèle à Ultralytics ? Génial ! Nous sommes toujours ouverts à l'expansion de notre portefeuille de modèles.
-
-1. **Forkez le Référentiel** : Commencez par forker le [référentiel GitHub d'Ultralytics](https://github.com/ultralytics/ultralytics).
-
-2. **Clonez Votre Fork** : Clonez votre fork sur votre machine locale et créez une nouvelle branche pour travailler dessus.
-
-3. **Implémentez Votre Modèle** : Ajoutez votre modèle en suivant les normes et directives de codage fournies dans notre [Guide de Contribution](../../help/contributing.md).
-
-4. **Testez Rigoureusement** : Assurez-vous de tester votre modèle de manière rigoureuse, à la fois isolément et comme partie du pipeline.
-
-5. **Créez une Pull Request** : Une fois que vous êtes satisfait de votre modèle, créez une pull request au répertoire principal pour examen.
-
-6. **Revue de Code & Fusion** : Après examen, si votre modèle répond à nos critères, il sera fusionné dans le répertoire principal.
-
-Pour des étapes détaillées, consultez notre [Guide de Contribution](../../help/contributing.md).
diff --git a/docs/fr/models/mobile-sam.md b/docs/fr/models/mobile-sam.md
deleted file mode 100644
index d011b039d30..00000000000
--- a/docs/fr/models/mobile-sam.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-comments: true
-description: En savoir plus sur MobileSAM, son implémentation, la comparaison avec SAM d'origine, et comment le télécharger et le tester dans le cadre de l'environnement Ultralytics. Améliorez vos applications mobiles dès aujourd'hui.
-keywords: MobileSAM, Ultralytics, SAM, applications mobiles, Arxiv, GPU, API, encodeur d'image, décodeur de masque, téléchargement de modèle, méthode de test
----
-
-![Logo MobileSAM](https://github.com/ChaoningZhang/MobileSAM/blob/master/assets/logo2.png?raw=true)
-
-# Segmenter N'importe Quoi sur Mobile (MobileSAM)
-
-Le document MobileSAM est maintenant disponible sur [arXiv](https://arxiv.org/pdf/2306.14289.pdf).
-
-Une démonstration de MobileSAM exécutée sur un processeur CPU est accessible via ce [lien de démonstration](https://huggingface.co/spaces/dhkim2810/MobileSAM). Les performances sur un CPU Mac i5 prennent environ 3 secondes. Sur la démo de Hugging Face, l'interface ainsi que les CPU moins performants contribuent à une réponse plus lente, mais cela continue de fonctionner efficacement.
-
-MobileSAM est implémenté dans divers projets, notamment [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling), et [Segment Anything en 3D](https://github.com/Jumpat/SegmentAnythingin3D).
-
-MobileSAM est entraîné sur un seul GPU avec un ensemble de données de 100 000 images (1% des images originales) en moins d'une journée. Le code de cet entraînement sera disponible à l'avenir.
-
-## Modèles Disponibles, Tâches Prises en Charge et Modes d'Utilisation
-
-Ce tableau présente les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge, et leur compatibilité avec les différents modes d'utilisation tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Export](../modes/export.md), indiqués par les emojis ✅ pour les modes pris en charge et ❌ pour les modes non pris en charge.
-
-| Type de Modèle | Poids Pré-entraînés | Tâches Prises en Charge | Inférence | Validation | Entraînement | Export |
-|----------------|---------------------|-------------------------------------------------|-----------|------------|--------------|--------|
-| MobileSAM | `mobile_sam.pt` | [Segmentation d'Instances](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-
-## Passage de SAM à MobileSAM
-
-Étant donné que MobileSAM conserve le même pipeline que SAM d'origine, nous avons incorporé le pré-traitement, le post-traitement et toutes les autres interfaces de l'original. Par conséquent, ceux qui utilisent actuellement SAM d'origine peuvent passer à MobileSAM avec un effort minimal.
-
-MobileSAM a des performances comparables à celles de SAM d'origine et conserve le même pipeline à l'exception d'un changement dans l'encodeur d'image. Plus précisément, nous remplaçons l'encodeur d'image lourd original ViT-H (632M) par un encodeur Tiny-ViT plus petit (5M). Sur un seul GPU, MobileSAM fonctionne à environ 12 ms par image : 8 ms sur l'encodeur d'image et 4 ms sur le décodeur de masque.
-
-Le tableau suivant présente une comparaison des encodeurs d'image basés sur ViT :
-
-| Encodeur d'Image | SAM d'Origine | MobileSAM |
-|------------------|---------------|-----------|
-| Paramètres | 611M | 5M |
-| Vitesse | 452 ms | 8 ms |
-
-SAM d'origine et MobileSAM utilisent tous deux le même décodeur de masque basé sur une instruction :
-
-| Décodeur de Masque | SAM d'Origine | MobileSAM |
-|--------------------|---------------|-----------|
-| Paramètres | 3.876M | 3.876M |
-| Vitesse | 4 ms | 4 ms |
-
-Voici une comparaison du pipeline complet :
-
-| Pipeline Complet (Enc+Dec) | SAM d'Origine | MobileSAM |
-|----------------------------|---------------|-----------|
-| Paramètres | 615M | 9.66M |
-| Vitesse | 456 ms | 12 ms |
-
-Les performances de MobileSAM et de SAM d'origine sont démontrées en utilisant à la fois un point et une boîte comme instructions.
-
-![Image avec un Point comme Instruction](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-![Image avec une Boîte comme Instruction](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
-
-Avec ses performances supérieures, MobileSAM est environ 5 fois plus petit et 7 fois plus rapide que FastSAM actuel. Plus de détails sont disponibles sur la [page du projet MobileSAM](https://github.com/ChaoningZhang/MobileSAM).
-
-## Test de MobileSAM dans Ultralytics
-
-Tout comme SAM d'origine, nous proposons une méthode de test simple dans Ultralytics, comprenant des modes pour les instructions Point et Boîte.
-
-### Téléchargement du modèle
-
-Vous pouvez télécharger le modèle [ici](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt).
-
-### Instruction Point
-
-!!! Example "Exemple"
-
- === "Python"
- ```python
- from ultralytics import SAM
-
- # Chargement du modèle
- model = SAM('mobile_sam.pt')
-
- # Prédiction d'un segment à partir d'une instruction Point
- model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
- ```
-
-### Instruction Boîte
-
-!!! Example "Exemple"
-
- === "Python"
- ```python
- from ultralytics import SAM
-
- # Chargement du modèle
- model = SAM('mobile_sam.pt')
-
- # Prédiction d'un segment à partir d'une instruction Boîte
- model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
- ```
-
-Nous avons mis en œuvre `MobileSAM` et `SAM` en utilisant la même API. Pour plus d'informations sur l'utilisation, veuillez consulter la [page SAM](sam.md).
-
-## Citations et Remerciements
-
-Si vous trouvez MobileSAM utile dans vos travaux de recherche ou de développement, veuillez envisager de citer notre document :
-
-!!! 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/docs/fr/models/rtdetr.md b/docs/fr/models/rtdetr.md
deleted file mode 100644
index 13439be5a16..00000000000
--- a/docs/fr/models/rtdetr.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-comments: true
-description: Découvrez les fonctionnalités et les avantages de RT-DETR de Baidu, un détecteur d'objets en temps réel efficace et adaptable grâce aux Vision Transformers, incluant des modèles pré-entraînés.
-keywords: RT-DETR, Baidu, Vision Transformers, détection d'objets, performance en temps réel, CUDA, TensorRT, sélection de requêtes informée par IoU, Ultralytics, API Python, PaddlePaddle
----
-
-# RT-DETR de Baidu : un détecteur d'objets en temps réel basé sur les Vision Transformers
-
-## Présentation
-
-Le Real-Time Detection Transformer (RT-DETR), développé par Baidu, est un détecteur d'objets de pointe de bout en bout qui offre des performances en temps réel tout en maintenant une grande précision. Il exploite la puissance des Vision Transformers (ViT) pour traiter efficacement les caractéristiques multiscalaires en dissociant l'interaction intra-échelle et la fusion inter-échelles. RT-DETR est hautement adaptable, permettant un ajustement flexible de la vitesse d'inférence en utilisant différentes couches de décodeur sans nécessiter de nouvelle formation. Le modèle est performant sur des infrastructures accélérées telles que CUDA avec TensorRT, surpassant de nombreux autres détecteurs d'objets en temps réel.
-
-![Exemple d'image du modèle](https://user-images.githubusercontent.com/26833433/238963168-90e8483f-90aa-4eb6-a5e1-0d408b23dd33.png)
-**Vue d'ensemble du RT-DETR de Baidu.** Le diagramme d'architecture du modèle RT-DETR montre les trois dernières étapes du réseau {S3, S4, S5} comme entrée de l'encodeur. L'encodeur hybride efficace transforme les caractéristiques multiscalaires en une séquence de caractéristiques d'image grâce à l'interaction à l'intérieur de l'échelle (AIFI - *Adeptation of Intra-scale Feature Interaction*) et au module de fusion inter-échelles (CCFM - *Cross-scale Context-aware Feature Fusion Module*). La sélection de requêtes informée par IoU est utilisée pour sélectionner un nombre fixe de caractéristiques d'image pour servir de requêtes d'objets initiales pour le décodeur. Enfin, le décodeur avec des têtes de prédictions auxiliaires optimise de manière itérative les requêtes d'objets pour générer des boîtes et des scores de confiance ([source](https://arxiv.org/pdf/2304.08069.pdf)).
-
-### Fonctionnalités principales
-
-- **Encodeur hybride efficace :** RT-DETR de Baidu utilise un encodeur hybride efficace qui traite les caractéristiques multiscalaires en dissociant l'interaction intra-échelle et la fusion inter-échelles. Cette conception unique basée sur les Vision Transformers réduit les coûts de calcul et permet une détection d'objets en temps réel.
-- **Sélection de requêtes informée par IoU :** RT-DETR de Baidu améliore l'initialisation des requêtes d'objets en utilisant une sélection de requêtes informée par IoU. Cela permet au modèle de se concentrer sur les objets les plus pertinents de la scène, améliorant ainsi la précision de la détection.
-- **Vitesse d'inférence adaptable :** RT-DETR de Baidu prend en charge des ajustements flexibles de la vitesse d'inférence en utilisant différentes couches de décodeur sans nécessiter de nouvelle formation. Cette adaptabilité facilite l'application pratique dans différents scénarios de détection d'objets en temps réel.
-
-## Modèles pré-entraînés
-
-L'API Python Ultralytics fournit des modèles pré-entraînés RT-DETR de PaddlePaddle avec différentes échelles :
-
-- RT-DETR-L : 53,0 % de précision moyenne (AP) sur COCO val2017, 114 images par seconde (FPS) sur GPU T4
-- RT-DETR-X : 54,8 % de précision moyenne (AP) sur COCO val2017, 74 images par seconde (FPS) sur GPU T4
-
-## Exemples d'utilisation
-
-Cet exemple présente des exemples simples d'entraînement et d'inférence avec RT-DETRR. Pour une documentation complète sur ceux-ci et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md).
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import RTDETR
-
- # Charger un modèle RT-DETR-l pré-entraîné sur COCO
- model = RTDETR('rtdetr-l.pt')
-
- # Afficher des informations sur le modèle (facultatif)
- model.info()
-
- # Entraîner le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 époques
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # Effectuer une inférence avec le modèle RT-DETR-l sur l'image 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- ```bash
- # Charger un modèle RT-DETR-l pré-entraîné sur COCO et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 époques
- yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
-
- # Charger un modèle RT-DETR-l pré-entraîné sur COCO et effectuer une inférence sur l'image 'bus.jpg'
- yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
- ```
-
-## Tâches et modes pris en charge
-
-Ce tableau présente les types de modèles, les poids pré-entraînés spécifiques, les tâches prises en charge par chaque modèle et les différents modes ([Train](../modes/train.md), [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)) pris en charge, indiqués par des emojis ✅.
-
-| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Export |
-|---------------------|---------------------|------------------------------------------|-----------|------------|--------------|--------|
-| RT-DETR Large | `rtdetr-l.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| RT-DETR Extra-Large | `rtdetr-x.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-## Citations et Remerciements
-
-Si vous utilisez RT-DETR de Baidu dans votre travail de recherche ou de développement, veuillez citer l'[article 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}
- }
- ```
-
-Nous tenons à remercier Baidu et l'équipe [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) pour la création et la maintenance de cette précieuse ressource pour la communauté de la vision par ordinateur. Leur contribution au domaine avec le développement du détecteur d'objets en temps réel basé sur les Vision Transformers, RT-DETR, est grandement appréciée.
-
-*keywords: RT-DETR, Transformer, ViT, Vision Transformers, RT-DETR de Baidu, PaddlePaddle, Modèles PaddlePaddle RT-DETR pré-entraînés, utilisation de RT-DETR de Baidu, API Python Ultralytics, détection d'objets en temps réel*
diff --git a/docs/fr/models/sam.md b/docs/fr/models/sam.md
deleted file mode 100644
index 9dfed8a57bc..00000000000
--- a/docs/fr/models/sam.md
+++ /dev/null
@@ -1,226 +0,0 @@
----
-comments: true
-description: Découvrez le modèle Segment Anything (SAM) de pointe d'Ultralytics permettant la segmentation d'images en temps réel. Apprenez-en davantage sur sa segmentation promptable, ses performances hors échantillon et comment l'utiliser.
-keywords: Ultralytics, segmentation d'image, Segment Anything Model, SAM, SA-1B dataset, performances en temps réel, transfert hors échantillon, détection d'objets, analyse d'images, apprentissage automatique
----
-
-# Segment Anything Model (SAM)
-
-Bienvenue à la pointe de la segmentation d'image avec le modèle Segment Anything, ou SAM. Ce modèle révolutionnaire a changé la donne en introduisant la segmentation d'image promptable avec des performances en temps réel, établissant de nouvelles normes dans le domaine.
-
-## Introduction à SAM : Le modèle Segment Anything
-
-Le modèle Segment Anything, ou SAM, est un modèle de segmentation d'image de pointe qui permet une segmentation promptable, offrant une polyvalence inégalée dans les tâches d'analyse d'image. SAM forme le cœur de l'initiative Segment Anything, un projet innovant qui introduit un modèle, une tâche et un jeu de données novateurs pour la segmentation d'images.
-
-La conception avancée de SAM lui permet de s'adapter à de nouvelles distributions et tâches d'images sans connaissance préalable, une fonctionnalité connue sous le nom de transfert hors échantillon. Entraîné sur le vaste ensemble de données [SA-1B](https://ai.facebook.com/datasets/segment-anything/), qui contient plus d'un milliard de masques répartis sur 11 millions d'images soigneusement sélectionnées, SAM a affiché des performances hors échantillon impressionnantes, dépassant les résultats entièrement supervisés précédents dans de nombreux cas.
-
-![Image d'échantillon de jeu de données](https://user-images.githubusercontent.com/26833433/238056229-0e8ffbeb-f81a-477e-a490-aff3d82fd8ce.jpg)
-Exemple d'images avec des masques superposés provenant de notre nouveau jeu de données, SA-1B. SA-1B contient 11 millions d'images diverses, haute résolution, autorisées et protégeant la vie privée, ainsi que 1,1 milliard de masques de segmentation de haute qualité. Ces masques ont été annotés entièrement automatiquement par SAM, et comme le confirment des évaluations humaines et de nombreux tests, leur qualité et leur diversité sont élevées. Les images sont regroupées par nombre de masques par image pour la visualisation (il y a environ 100 masques par image en moyenne).
-
-## Caractéristiques clés du modèle Segment Anything (SAM)
-
-- **Tâche de segmentation promptable :** SAM a été conçu en gardant à l'esprit une tâche de segmentation promptable, ce qui lui permet de générer des masques de segmentation valides à partir de n'importe quelle indication donnée, telle que des indices spatiaux ou des indices textuels identifiant un objet.
-- **Architecture avancée :** Le modèle Segment Anything utilise un puissant encodeur d'images, un encodeur de prompt et un décodeur de masques léger. Cette architecture unique permet une invitation flexible, un calcul de masques en temps réel et une prise en compte de l'ambiguïté dans les tâches de segmentation.
-- **Le jeu de données SA-1B :** Introduit par le projet Segment Anything, le jeu de données SA-1B comprend plus d'un milliard de masques sur 11 millions d'images. En tant que plus grand jeu de données de segmentation à ce jour, il offre à SAM une source de données d'entraînement diversifiée et à grande échelle.
-- **Performances hors échantillon :** SAM affiche des performances hors échantillon exceptionnelles dans diverses tâches de segmentation, ce qui en fait un outil prêt à l'emploi pour des applications diverses nécessitant un minimum d'ingénierie de prompt.
-
-Pour une analyse approfondie du modèle Segment Anything et du jeu de données SA-1B, veuillez visiter le [site web Segment Anything](https://segment-anything.com) et consulter l'article de recherche [Segment Anything](https://arxiv.org/abs/2304.02643).
-
-## Modèles disponibles, tâches prises en charge et modes d'exploitation
-
-Ce tableau présente les modèles disponibles avec leurs poids pré-entraînés spécifiques, les tâches qu'ils prennent en charge et leur compatibilité avec différents modes d'exploitation tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Exportation](../modes/export.md), indiqués par des emojis ✅ pour les modes pris en charge et des emojis ❌ pour les modes non pris en charge.
-
-| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Exportation |
-|----------------|---------------------|------------------------------------------------|-----------|------------|--------------|-------------|
-| SAM de base | `sam_b.pt` | [Segmentation d'instance](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-| SAM large | `sam_l.pt` | [Segmentation d'instance](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
-
-## Comment utiliser SAM : Polyvalence et puissance dans la segmentation d'images
-
-Le modèle Segment Anything peut être utilisé pour une multitude de tâches secondaires qui vont au-delà de ses données d'entraînement. Cela comprend la détection des contours, la génération de propositions d'objets, la segmentation d'instances et la prédiction préliminaire texte-à-masque. Grâce à l'ingénierie de prompts, SAM peut s'adapter rapidement à de nouvelles tâches et distributions de données de manière sans apprentissage, ce qui en fait un outil polyvalent et puissant pour tous vos besoins en matière de segmentation d'images.
-
-### Exemple de prédiction SAM
-
-!!! Example "Segmentation avec des prompts"
-
- Segmenter l'image avec des prompts donnés.
-
- === "Python"
-
- ```python
- from ultralytics import SAM
-
- # Charger un modèle
- model = SAM('sam_b.pt')
-
- # Afficher les informations sur le modèle (facultatif)
- model.info()
-
- # Exécuter l'inférence avec un prompt de zones de délimitation
- model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
-
- # Exécuter l'inférence avec un prompt de points
- model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
- ```
-
-!!! Example "Segmenter tout"
-
- Segmenter toute l'image.
-
- === "Python"
-
- ```python
- from ultralytics import SAM
-
- # Charger un modèle
- model = SAM('sam_b.pt')
-
- # Afficher les informations sur le modèle (facultatif)
- model.info()
-
- # Exécuter l'inférence
- model('path/to/image.jpg')
- ```
-
- === "CLI"
-
- ```bash
- # Exécuter l'inférence avec un modèle SAM
- yolo predict model=sam_b.pt source=path/to/image.jpg
- ```
-
-- La logique ici est de segmenter toute l'image si vous ne passez aucun prompt (bboxes/points/masks).
-
-!!! Example "Exemple SAMPredictor"
-
- De cette manière, vous pouvez définir l'image une fois et exécuter l'inférence des prompts plusieurs fois sans exécuter l'encodeur d'image plusieurs fois.
-
- === "Inférence avec des prompts"
-
- ```python
- from ultralytics.models.sam import Predictor as SAMPredictor
-
- # Créer un SAMPredictor
- overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
- predictor = SAMPredictor(overrides=overrides)
-
- # Définir l'image
- predictor.set_image("ultralytics/assets/zidane.jpg") # définir avec un fichier image
- predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # définir avec np.ndarray
- results = predictor(bboxes=[439, 437, 524, 709])
- results = predictor(points=[900, 370], labels=[1])
-
- # Réinitialiser l'image
- predictor.reset_image()
- ```
-
- Segmenter toute l'image avec des arguments supplémentaires.
-
- === "Segmenter tout"
-
- ```python
- from ultralytics.models.sam import Predictor as SAMPredictor
-
- # Créer un SAMPredictor
- overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
- predictor = SAMPredictor(overrides=overrides)
-
- # Segmenter avec des arguments supplémentaires
- results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
- ```
-
-- Plus d'arguments supplémentaires pour `Segmenter tout` voir la référence [`Predictor/generate`](../../../reference/models/sam/predict.md).
-
-## Comparaison de SAM avec YOLOv8
-
-Nous comparons ici le plus petit modèle SAM de Meta, SAM-b, avec le plus petit modèle de segmentation d'Ultralytics, [YOLOv8n-seg](../tasks/segment.md) :
-
-| Modèle | Taille | Paramètres | Vitesse (CPU) |
-|--------------------------------------------------------------|-----------------------------------|-----------------------------|-------------------------------------|
-| SAM-b - Meta's SAM-b | 358 Mo | 94,7 M | 51096 ms/im |
-| [MobileSAM](mobile-sam.md) | 40,7 Mo | 10,1 M | 46122 ms/im |
-| [FastSAM-s](fast-sam.md) with YOLOv8 backbone | 23,7 Mo | 11,8 M | 115 ms/im |
-| YOLOv8n-seg - Ultralytics [YOLOv8n-seg](../tasks/segment.md) | **6,7 Mo** (53,4 fois plus petit) | **3,4 M** (27,9 fois moins) | **59 ms/im** (866 fois plus rapide) |
-
-Cette comparaison montre les différences d'ordre de grandeur dans les tailles et les vitesses des modèles. Alors que SAM présente des fonctionnalités uniques pour la segmentation automatique, il ne rivalise pas directement avec les modèles de segmentation YOLOv8, qui sont plus petits, plus rapides et plus efficaces.
-
-Tests effectués sur un MacBook Apple M2 de 2023 avec 16 Go de RAM. Pour reproduire ce test :
-
-!!! Example "Exemple"
-
- === "Python"
- ```python
- from ultralytics import FastSAM, SAM, YOLO
-
- # Profiler SAM-b
- modèle = SAM('sam_b.pt')
- modèle.info()
- modèle('ultralytics/assets')
-
- # Profiler MobileSAM
- modèle = SAM('mobile_sam.pt')
- modèle.info()
- modèle('ultralytics/assets')
-
- # Profiler FastSAM-s
- modèle = FastSAM('FastSAM-s.pt')
- modèle.info()
- modèle('ultralytics/assets')
-
- # Profiler YOLOv8n-seg
- modèle = YOLO('yolov8n-seg.pt')
- modèle.info()
- modèle('ultralytics/assets')
- ```
-
-## Annotation automatique : Un moyen rapide d'obtenir des jeux de données de segmentation
-
-L'annotation automatique est une fonctionnalité clé de SAM, permettant aux utilisateurs de générer un [jeu de données de segmentation](https://docs.ultralytics.com/datasets/segment) à l'aide d'un modèle de détection pré-entraîné. Cette fonctionnalité permet une annotation rapide et précise d'un grand nombre d'images, en contournant la nécessité d'une annotation manuelle chronophage.
-
-### Générez votre jeu de données de segmentation à l'aide d'un modèle de détection
-
-Pour annoter automatiquement votre jeu de données avec le framework Ultralytics, utilisez la fonction `auto_annotate` comme indiqué ci-dessous :
-
-!!! Example "Exemple"
-
- === "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 | Chemin d'accès à un dossier contenant les images à annoter. | |
-| det_model | str, optionnel | Modèle de détection pré-entraîné YOLO. Par défaut, 'yolov8x.pt'. | 'yolov8x.pt' |
-| sam_model | str, optionnel | Modèle de segmentation pré-entraîné SAM. Par défaut, 'sam_b.pt'. | 'sam_b.pt' |
-| device | str, optionnel | Appareil sur lequel exécuter les modèles. Par défaut, une chaîne vide (CPU ou GPU, si disponible). | |
-| output_dir | str, None, optionnel | Répertoire pour enregistrer les résultats annotés. Par défaut, un dossier 'labels' dans le même répertoire que 'data'. | None |
-
-La fonction `auto_annotate` prend en compte le chemin de vos images, avec des arguments optionnels pour spécifier les modèles de détection et de segmentation SAM pré-entraînés, l'appareil sur lequel exécuter les modèles et le répertoire de sortie pour enregistrer les résultats annotés.
-
-L'annotation automatique avec des modèles pré-entraînés peut réduire considérablement le temps et les efforts nécessaires pour créer des jeux de données de segmentation de haute qualité. Cette fonctionnalité est particulièrement bénéfique pour les chercheurs et les développeurs travaillant avec de grandes collections d'images, car elle leur permet de se concentrer sur le développement et l'évaluation des modèles plutôt que sur l'annotation manuelle.
-
-## Citations et remerciements
-
-Si vous trouvez SAM utile dans vos travaux de recherche ou de développement, veuillez envisager de citer notre article :
-
-!!! 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}
- }
- ```
-
-Nous tenons à exprimer notre gratitude à Meta AI pour la création et la maintenance de cette ressource précieuse pour la communauté de la vision par ordinateur.
-
-*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, segmentation d'image, segmentation promptable, performances hors échantillon, jeu de données SA-1B, architecture avancée, annotation automatique, Ultralytics, modèles pré-entraînés, SAM de base, SAM large, segmentation d'instance, vision par ordinateur, IA, intelligence artificielle, apprentissage automatique, annotation de données, masques de segmentation, modèle de détection, modèle de détection YOLO, bibtex, Meta AI.*
diff --git a/docs/fr/models/yolo-nas.md b/docs/fr/models/yolo-nas.md
deleted file mode 100644
index 21b6979a037..00000000000
--- a/docs/fr/models/yolo-nas.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-comments: true
-description: Découvrez une documentation détaillée sur YOLO-NAS, un modèle de détection d'objets supérieur. Apprenez-en davantage sur ses fonctionnalités, les modèles pré-entraînés, son utilisation avec l'API Python d'Ultralytics, et bien plus encore.
-keywords: YOLO-NAS, Deci AI, détection d'objets, apprentissage profond, recherche architecturale neuronale, API Python d'Ultralytics, modèle YOLO, modèles pré-entraînés, quantification, optimisation, COCO, Objects365, Roboflow 100
----
-
-# YOLO-NAS
-
-## Aperçu
-
-Développé par Deci AI, YOLO-NAS est un modèle de détection d'objets révolutionnaire. Il est le fruit d'une technologie avancée de recherche architecturale neuronale, minutieusement conçu pour pallier les limitations des précédents modèles YOLO. Avec des améliorations significatives en matière de prise en charge de la quantification et de compromis entre précision et latence, YOLO-NAS représente une avancée majeure en matière de détection d'objets.
-
-![Exemple de modèle](https://learnopencv.com/wp-content/uploads/2023/05/yolo-nas_COCO_map_metrics.png)
-**Aperçu de YOLO-NAS**. YOLO-NAS utilise des blocs adaptés à la quantification et une quantification sélective pour des performances optimales. Le modèle, une fois converti en version quantifiée INT8, présente une baisse de précision minimale, ce qui constitue une amélioration significative par rapport aux autres modèles. Ces avancées aboutissent à une architecture supérieure offrant des capacités de détection d'objets inégalées et des performances exceptionnelles.
-
-### Fonctionnalités clés
-
-- **Bloc de base compatible avec la quantification:** YOLO-NAS introduit un nouveau bloc de base adapté à la quantification, ce qui permet de pallier l'une des principales limitations des précédents modèles YOLO.
-- **Entraînement sophistiqué et quantification:** YOLO-NAS utilise des schémas d'entraînement avancés et une quantification après l'entraînement pour améliorer les performances.
-- **Optimisation AutoNAC et pré-entraînement:** YOLO-NAS utilise l'optimisation AutoNAC et est pré-entraîné sur des ensembles de données renommés tels que COCO, Objects365 et Roboflow 100. Ce pré-entraînement le rend extrêmement adapté aux tâches de détection d'objets ultérieures dans des environnements de production.
-
-## Modèles pré-entraînés
-
-Découvrez la puissance de la détection d'objets de nouvelle génération avec les modèles YOLO-NAS pré-entraînés fournis par Ultralytics. Ces modèles sont conçus pour offrir des performances exceptionnelles en termes de vitesse et de précision. Choisissez parmi une variété d'options adaptées à vos besoins spécifiques :
-
-| Modèle | mAP | Latence (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 |
-
-Chaque variante de modèle est conçue pour offrir un équilibre entre la précision moyenne (mAP) et la latence, vous permettant ainsi d'optimiser vos tâches de détection d'objets en termes de performance et de vitesse.
-
-## Exemples d'utilisation
-
-Ultralytics a rendu les modèles YOLO-NAS faciles à intégrer dans vos applications Python grâce à notre package Python `ultralytics`. Le package fournit une interface conviviale pour simplifier le processus.
-
-Les exemples suivants montrent comment utiliser les modèles YOLO-NAS avec le package `ultralytics` pour l'inférence et la validation :
-
-### Exemples d'inférence et de validation
-
-Dans cet exemple, nous validons YOLO-NAS-s sur l'ensemble de données COCO8.
-
-!!! Example "Exemple"
-
- Cet exemple fournit un code simple pour l'inférence et la validation de YOLO-NAS. Pour gérer les résultats de l'inférence, consultez le mode [Predict](../modes/predict.md). Pour utiliser YOLO-NAS avec des modes supplémentaires, consultez [Val](../modes/val.md) et [Export](../modes/export.md). L'entraînement n'est pas pris en charge pour YOLO-NAS avec le package `ultralytics`.
-
- === "Python"
-
- Il est possible de passer des modèles pré-entraînés `*.pt` de PyTorch à la classe `NAS()` pour créer une instance de modèle en Python :
-
- ```python
- from ultralytics import NAS
-
- # Charger un modèle YOLO-NAS-s pré-entraîné sur COCO
- model = NAS('yolo_nas_s.pt')
-
- # Afficher les informations sur le modèle (facultatif)
- model.info()
-
- # Valider le modèle sur l'ensemble de données COCO8
- results = model.val(data='coco8.yaml')
-
- # Effectuer une inférence avec le modèle YOLO-NAS-s sur l'image 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- Des commandes CLI sont disponibles pour exécuter directement les modèles :
-
- ```bash
- # Charger un modèle YOLO-NAS-s pré-entraîné sur COCO et valider ses performances sur l'ensemble de données COCO8
- yolo val model=yolo_nas_s.pt data=coco8.yaml
-
- # Charger un modèle YOLO-NAS-s pré-entraîné sur COCO et effectuer une inférence sur l'image 'bus.jpg'
- yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
- ```
-
-## Tâches et modes pris en charge
-
-Nous proposons trois variantes des modèles YOLO-NAS : Small (s), Medium (m) et Large (l). Chaque variante est conçue pour répondre à des besoins computationnels et de performances différents :
-
-- **YOLO-NAS-s** : Optimisé pour les environnements où les ressources computationnelles sont limitées mais l'efficacité est primordiale.
-- **YOLO-NAS-m** : Offre une approche équilibrée, adaptée à la détection d'objets polyvalente avec une précision accrue.
-- **YOLO-NAS-l** : Adapté aux scénarios nécessitant la plus haute précision, où les ressources computationnelles sont moins contraignantes.
-
-Voici un aperçu détaillé de chaque modèle, comprenant des liens vers leurs poids pré-entraînés, les tâches qu'ils prennent en charge et leur compatibilité avec différents modes opérationnels.
-
-| Type de modèle | Poids pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Export |
-|----------------|-----------------------------------------------------------------------------------------------|------------------------------------------|-----------|------------|--------------|--------|
-| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_s.pt) | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_m.pt) | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolo_nas_l.pt) | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
-
-## Citations et remerciements
-
-Si vous utilisez YOLO-NAS dans vos travaux de recherche ou de développement, veuillez citer 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},
- }
- ```
-
-Nous exprimons notre gratitude à l'équipe [Super-Gradients](https://github.com/Deci-AI/super-gradients/) de Deci AI pour ses efforts dans la création et la maintenance de cette précieuse ressource pour la communauté de la vision par ordinateur. Nous sommes convaincus que YOLO-NAS, avec son architecture innovante et ses capacités de détection d'objets supérieures, deviendra un outil essentiel pour les développeurs et les chercheurs.
-
-*keywords: YOLO-NAS, Deci AI, détection d'objets, apprentissage profond, recherche architecturale neuronale, API Python d'Ultralytics, modèle YOLO, SuperGradients, modèles pré-entraînés, bloc de base compatible avec la quantification, schémas d'entraînement avancés, quantification après l'entraînement, optimisation AutoNAC, COCO, Objects365, Roboflow 100*
diff --git a/docs/fr/models/yolov3.md b/docs/fr/models/yolov3.md
deleted file mode 100644
index ca17b1df734..00000000000
--- a/docs/fr/models/yolov3.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-comments: true
-description: Obtenez un aperçu des modèles YOLOv3, YOLOv3-Ultralytics et YOLOv3u. Apprenez-en davantage sur leurs fonctionnalités clés, leur utilisation et les tâches prises en charge pour la détection d'objets.
-keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Détection d'objets, Inférence, Entraînement, Ultralytics
----
-
-# YOLOv3, YOLOv3-Ultralytics et YOLOv3u
-
-## Aperçu
-
-Ce document présente un aperçu de trois modèles de détection d'objets étroitement liés, à savoir [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) et [YOLOv3u](https://github.com/ultralytics/ultralytics).
-
-1. **YOLOv3**: Il s'agit de la troisième version de l'algorithme de détection d'objets You Only Look Once (YOLO). Initiée par Joseph Redmon, YOLOv3 a amélioré ses prédécesseurs en introduisant des fonctionnalités telles que des prédictions à plusieurs échelles et trois tailles différentes de noyaux de détection.
-
-2. **YOLOv3-Ultralytics**: Il s'agit de l'implémentation par Ultralytics du modèle YOLOv3. Il reproduit l'architecture d'origine de YOLOv3 et offre des fonctionnalités supplémentaires, telles que la prise en charge de plusieurs modèles pré-entraînés et des options de personnalisation plus faciles.
-
-3. **YOLOv3u**: Il s'agit d'une version mise à jour de YOLOv3-Ultralytics qui intègre la nouvelle tête de détection sans ancrage et sans objectivité utilisée dans les modèles YOLOv8. YOLOv3u conserve la même architecture de base et de cou de YOLOv3, mais avec la nouvelle tête de détection de YOLOv8.
-
-![Ultralytics YOLOv3](https://raw.githubusercontent.com/ultralytics/assets/main/yolov3/banner-yolov3.png)
-
-## Caractéristiques clés
-
-- **YOLOv3**: A introduit l'utilisation de trois échelles différentes pour la détection, en tirant parti de trois tailles différentes de noyaux de détection : 13x13, 26x26 et 52x52. Cela a considérablement amélioré la précision de la détection pour les objets de différentes tailles. De plus, YOLOv3 a ajouté des fonctionnalités telles que des prédictions multi-étiquettes pour chaque boîte englobante et un meilleur réseau d'extraction de caractéristiques.
-
-- **YOLOv3-Ultralytics**: L'implémentation d'Ultralytics de YOLOv3 offre les mêmes performances que le modèle d'origine, mais propose également un support supplémentaire pour plus de modèles pré-entraînés, des méthodes d'entraînement supplémentaires et des options de personnalisation plus faciles. Cela le rend plus polyvalent et convivial pour les applications pratiques.
-
-- **YOLOv3u**: Ce modèle mis à jour intègre la nouvelle tête de détection sans ancrage et sans objectivité de YOLOv8. En éliminant le besoin de boîtes d'ancrage prédéfinies et de scores d'objectivité, cette conception de tête de détection peut améliorer la capacité du modèle à détecter des objets de différentes tailles et formes. Cela rend YOLOv3u plus robuste et précis pour les tâches de détection d'objets.
-
-## Tâches et modes pris en charge
-
-Les modèles de la série YOLOv3, notamment YOLOv3, YOLOv3-Ultralytics et YOLOv3u, sont spécialement conçus pour les tâches de détection d'objets. Ces modèles sont réputés pour leur efficacité dans divers scénarios réels, alliant précision et rapidité. Chaque variante propose des fonctionnalités et des optimisations uniques, les rendant adaptés à une gamme d'applications.
-
-Les trois modèles prennent en charge un ensemble complet de modes, garantissant ainsi leur polyvalence à différentes étapes du déploiement et du développement du modèle. Ces modes comprennent [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Export](../modes/export.md), offrant aux utilisateurs un ensemble complet d'outils pour une détection d'objets efficace.
-
-| Type de modèle | Tâches prises en charge | Inférence | Validation | Entraînement | Export |
-|--------------------|------------------------------------------|-----------|------------|--------------|--------|
-| YOLOv3 | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv3-Ultralytics | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv3u | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-Ce tableau offre un aperçu rapide des capacités de chaque variante de YOLOv3, mettant en évidence leur polyvalence et leur pertinence pour diverses tâches et modes opérationnels dans les flux de travail de détection d'objets.
-
-## Exemples d'utilisation
-
-Cet exemple présente des exemples simples d'entraînement et d'inférence de YOLOv3. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation sur [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md).
-
-!!! Example "Exemple"
-
- === "Python"
-
- Les modèles pré-entraînés PyTorch `*.pt`, ainsi que les fichiers de configuration `*.yaml`, peuvent être transmis à la classe `YOLO()` pour créer une instance de modèle en Python :
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv3n pré-entraîné avec COCO
- model = YOLO('yolov3n.pt')
-
- # Afficher les informations sur le modèle (facultatif)
- model.info()
-
- # Entraîner le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 époques
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # Exécuter l'inférence avec le modèle YOLOv3n sur l'image 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- Des commandes CLI sont disponibles pour exécuter directement les modèles :
-
- ```bash
- # Charger un modèle YOLOv3n pré-entraîné avec COCO et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 époques
- yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # Charger un modèle YOLOv3n pré-entraîné avec COCO et exécuter l'inférence sur l'image 'bus.jpg'
- yolo predict model=yolov3n.pt source=path/to/bus.jpg
- ```
-
-## Citations et remerciements
-
-Si vous utilisez YOLOv3 dans le cadre de vos recherches, veuillez citer les articles originaux sur YOLO et le référentiel YOLOv3 d'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}
- }
- ```
-
-Merci à Joseph Redmon et Ali Farhadi pour le développement du YOLOv3 original.
diff --git a/docs/fr/models/yolov4.md b/docs/fr/models/yolov4.md
deleted file mode 100644
index 0221483eeb5..00000000000
--- a/docs/fr/models/yolov4.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-comments: true
-description: Découvrez notre guide détaillé sur YOLOv4, un détecteur d'objets en temps réel de pointe. Comprenez ses points forts architecturaux, ses fonctionnalités innovantes et des exemples d'application.
-keywords: ultralytics, YOLOv4, détection d'objets, réseau neuronal, détection en temps réel, détecteur d'objets, apprentissage automatique
----
-
-# YOLOv4: Détection d'Objets Rapide et Précise
-
-Bienvenue sur la page de documentation d'Ultralytics pour YOLOv4, un détecteur d'objets en temps réel de pointe lancé en 2020 par Alexey Bochkovskiy sur [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). YOLOv4 est conçu pour offrir un équilibre optimal entre vitesse et précision, en en faisant un excellent choix pour de nombreuses applications.
-
-![Schéma d'architecture de YOLOv4](https://user-images.githubusercontent.com/26833433/246185689-530b7fe8-737b-4bb0-b5dd-de10ef5aface.png)
-**Schéma d'architecture de YOLOv4**. Présentant la conception détaillée du réseau de YOLOv4, comprenant les composants backbone, neck et head, ainsi que leurs couches interconnectées pour une détection d'objets en temps réel optimale.
-
-## Introduction
-
-YOLOv4 signifie You Only Look Once version 4. Il s'agit d'un modèle de détection d'objets en temps réel développé pour remédier aux limitations des versions précédentes de YOLO comme [YOLOv3](yolov3.md) et d'autres modèles de détection d'objets. Contrairement à d'autres détecteurs d'objets basés sur des réseaux neuronaux convolutifs (CNN), YOLOv4 n'est pas seulement applicable aux systèmes de recommandation, mais aussi à la gestion de processus autonomes et à la réduction de l'entrée humaine. Son utilisation sur des unités de traitement graphique (GPU) conventionnelles permet une utilisation massive à un prix abordable, et il est conçu pour fonctionner en temps réel sur un GPU conventionnel tout en ne nécessitant qu'un seul de ces GPU pour l'entraînement.
-
-## Architecture
-
-YOLOv4 utilise plusieurs fonctionnalités innovantes qui travaillent ensemble pour optimiser ses performances. Celles-ci incluent les connexions résiduelles pondérées (WRC), les connexions partielles à travers les étapes (CSP), la normalisation mini-batch traversée (CmBN), l'entraînement auto-antagoniste (SAT), l'activation Mish, l'augmentation des données en mosaïque, la régularisation DropBlock et la perte CIoU. Ces fonctionnalités sont combinées pour obtenir des résultats de pointe.
-
-Un détecteur d'objets typique est composé de plusieurs parties, notamment l'entrée, le backbone, le neck et le head. Le backbone de YOLOv4 est pré-entraîné sur ImageNet et est utilisé pour prédire les classes et les boîtes englobantes des objets. Le backbone peut provenir de plusieurs modèles, notamment VGG, ResNet, ResNeXt ou DenseNet. La partie "neck" du détecteur est utilisée pour collecter des cartes de caractéristiques à partir de différentes étapes et comprend généralement plusieurs chemins "bottom-up" et plusieurs chemins "top-down". La partie "head" est ce qui est utilisé pour faire les détections et classifications finales des objets.
-
-## Ensemble de Bonus
-
-YOLOv4 utilise également des méthodes appelées "ensemble de bonus", qui sont des techniques permettant d'améliorer la précision du modèle lors de l'entraînement sans augmenter le coût de l'inférence. L'augmentation de données est une technique commune de l'ensemble de bonus utilisée dans la détection d'objets, qui augmente la variabilité des images d'entrée pour améliorer la robustesse du modèle. Quelques exemples d'augmentation de données incluent les distorsions photométriques (ajustement de la luminosité, du contraste, de la teinte, de la saturation et du bruit d'une image) et les distorsions géométriques (ajout d'échelle aléatoire, de recadrage, de retournement et de rotation). Ces techniques aident le modèle à mieux généraliser à différents types d'images.
-
-## Fonctionnalités et Performances
-
-YOLOv4 est conçu pour une vitesse et une précision optimales dans la détection d'objets. L'architecture de YOLOv4 comprend CSPDarknet53 en tant que backbone, PANet en tant que neck et YOLOv3 en tant que detection head. Ce design permet à YOLOv4 de réaliser une détection d'objets à une vitesse impressionnante, ce qui le rend adapté aux applications en temps réel. YOLOv4 excelle également en précision, atteignant des résultats de pointe dans les benchmarks de détection d'objets.
-
-## Exemples d'Utilisation
-
-Au moment de la rédaction de ce document, Ultralytics ne prend pas en charge les modèles YOLOv4. Par conséquent, les utilisateurs intéressés par l'utilisation de YOLOv4 devront consulter directement le référentiel GitHub de YOLOv4 pour les instructions d'installation et d'utilisation.
-
-Voici un bref aperçu des étapes typiques que vous pourriez suivre pour utiliser YOLOv4 :
-
-1. Rendez-vous sur le référentiel GitHub de YOLOv4 : [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
-
-2. Suivez les instructions fournies dans le fichier README pour l'installation. Cela implique généralement de cloner le référentiel, d'installer les dépendances nécessaires et de configurer les variables d'environnement nécessaires.
-
-3. Une fois l'installation terminée, vous pouvez entraîner et utiliser le modèle selon les instructions d'utilisation fournies dans le référentiel. Cela implique généralement la préparation de votre ensemble de données, la configuration des paramètres du modèle, l'entraînement du modèle, puis l'utilisation du modèle entraîné pour effectuer la détection d'objets.
-
-Veuillez noter que les étapes spécifiques peuvent varier en fonction de votre cas d'utilisation spécifique et de l'état actuel du référentiel YOLOv4. Il est donc fortement recommandé de se référer directement aux instructions fournies dans le référentiel GitHub de YOLOv4.
-
-Nous regrettons tout inconvénient que cela pourrait causer et nous nous efforcerons de mettre à jour ce document avec des exemples d'utilisation pour Ultralytics une fois que le support de YOLOv4 sera implémenté.
-
-## Conclusion
-
-YOLOv4 est un modèle de détection d'objets puissant et efficace qui concilie vitesse et précision. Son utilisation de fonctionnalités uniques et de techniques "ensemble de bonus" lors de l'entraînement lui permet de réaliser d'excellentes performances dans les tâches de détection d'objets en temps réel. YOLOv4 peut être entraîné et utilisé par n'importe qui disposant d'un GPU conventionnel, le rendant accessible et pratique pour un large éventail d'applications.
-
-## Citations et Remerciements
-
-Nous tenons à remercier les auteurs de YOLOv4 pour leurs contributions importantes dans le domaine de la détection d'objets en temps réel :
-
-!!! 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}
- }
- ```
-
-L'article original de YOLOv4 peut être consulté sur [arXiv](https://arxiv.org/abs/2004.10934). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/AlexeyAB/darknet). Nous apprécions leurs efforts pour faire progresser le domaine et rendre leur travail accessible à la communauté élargie.
diff --git a/docs/fr/models/yolov5.md b/docs/fr/models/yolov5.md
deleted file mode 100644
index 83bdd04d800..00000000000
--- a/docs/fr/models/yolov5.md
+++ /dev/null
@@ -1,113 +0,0 @@
----
-comments: true
-description: Découvrez YOLOv5u, une version améliorée du modèle YOLOv5 offrant un meilleur compromis entre précision et vitesse, ainsi que de nombreux modèles pré-entraînés pour diverses tâches de détection d'objets.
-keywords: YOLOv5u, détection d'objets, modèles pré-entraînés, Ultralytics, inférence, validation, YOLOv5, YOLOv8, sans ancre, sans objectivité, applications temps réel, apprentissage automatique
----
-
-# YOLOv5
-
-## Présentation
-
-YOLOv5u représente une avancée dans les méthodologies de détection d'objets. Originaire de l'architecture fondamentale du modèle [YOLOv5](https://github.com/ultralytics/yolov5) développé par Ultralytics, YOLOv5u intègre la division sans ancre et sans objectivité, une fonctionnalité précédemment introduite dans les modèles [YOLOv8](yolov8.md). Cette adaptation affine l'architecture du modèle, ce qui conduit à un meilleur compromis entre précision et vitesse dans les tâches de détection d'objets. Compte tenu des résultats empiriques et des fonctionnalités dérivées, YOLOv5u offre une alternative efficace pour ceux qui recherchent des solutions robustes à la fois pour la recherche et les applications pratiques.
-
-![YOLOv5 Ultralytics](https://raw.githubusercontent.com/ultralytics/assets/main/yolov5/v70/splash.png)
-
-## Principales fonctionnalités
-
-- **Division sans ancre Ultralytics :** Les modèles de détection d'objets traditionnels reposent sur des boîtes d'ancrage prédéfinies pour prédire les emplacements des objets. Cependant, YOLOv5u modernise cette approche. En adoptant une division sans ancre Ultralytics, il garantit un mécanisme de détection plus flexible et adaptatif, ce qui améliore les performances dans divers scénarios.
-
-- **Bon compromis entre précision et vitesse optimisée :** La vitesse et la précision sont souvent opposées. Mais YOLOv5u remet en question ce compromis. Il offre un équilibre calibré, garantissant des détections en temps réel sans compromettre la précision. Cette fonctionnalité est particulièrement précieuse pour les applications qui demandent des réponses rapides, comme les véhicules autonomes, la robotique et l'analyse vidéo en temps réel.
-
-- **Variété de modèles pré-entraînés :** Comprendre que différentes tâches nécessitent différents ensembles d'outils, YOLOv5u propose une pléthore de modèles pré-entraînés. Que vous vous concentriez sur l'inférence, la validation ou l'entraînement, un modèle sur mesure vous attend. Cette variété garantit que vous n'utilisez pas une solution universelle, mais un modèle spécifiquement ajusté à votre défi unique.
-
-## Tâches et modes pris en charge
-
-Les modèles YOLOv5u, avec divers poids pré-entraînés, excellent dans les tâches de [détection d'objets](../tasks/detect.md). Ils prennent en charge une gamme complète de modes, ce qui les rend adaptés à diverses applications, du développement au déploiement.
-
-| Type de modèle | Poids pré-entraînés | Tâche | Inférence | Validation | Entraînement | Export |
-|----------------|-----------------------------------------------------------------------------------------------------------------------------|------------------------------------------|-----------|------------|--------------|--------|
-| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-Ce tableau fournit un aperçu détaillé des variantes de modèles YOLOv5u, mettant en évidence leur applicabilité dans les tâches de détection d'objets et leur prise en charge de divers modes opérationnels tels que [Inférence](../modes/predict.md), [Validation](../modes/val.md), [Entraînement](../modes/train.md) et [Exportation](../modes/export.md). Cette prise en charge complète garantit que les utilisateurs peuvent exploiter pleinement les capacités des modèles YOLOv5u dans un large éventail de scénarios de détection d'objets.
-
-## Métriques de performance
-
-!!! Performance
-
- === "Détection"
-
- Consultez la [documentation sur la détection](https://docs.ultralytics.com/tasks/detect/) pour des exemples d'utilisation avec ces modèles formés sur [COCO](https://docs.ultralytics.com/datasets/detect/coco/), qui comprennent 80 classes pré-entraînées.
-
- | Modèle | YAML | taille (pixels) | mAPval 50-95 | Vitesse CPU ONNX (ms) | Vitesse A100 TensorRT (ms) | params (M) | FLOPs (B) |
- |-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
- | [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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 |
-
-## Exemples d'utilisation
-
-Cet exemple présente des exemples simples d'entraînement et d'inférence YOLOv5. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md).
-
-!!! Example "Exemple"
-
- === "Python"
-
- Les modèles PyTorch pré-entraînés `*.pt` ainsi que les fichiers de configuration `*.yaml` peuvent être passés à la classe `YOLO()` pour créer une instance de modèle en python :
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv5n pré-entraîné sur COCO
- model = YOLO('yolov5n.pt')
-
- # Afficher les informations sur le modèle (facultatif)
- model.info()
-
- # Former le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 époques
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # Exécuter l'inférence avec le modèle YOLOv5n sur l'image 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- Des commandes CLI sont disponibles pour exécuter directement les modèles :
-
- ```bash
- # Charger un modèle YOLOv5n pré-entraîné sur COCO et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 époques
- yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # Charger un modèle YOLOv5n pré-entraîné sur COCO et exécuter l'inférence sur l'image 'bus.jpg'
- yolo predict model=yolov5n.pt source=path/to/bus.jpg
- ```
-
-## Citations et remerciements
-
-Si vous utilisez YOLOv5 ou YOLOv5u dans vos recherches, veuillez citer le référentiel Ultralytics YOLOv5 comme suit :
-
-!!! 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}
- }
- ```
-
-Veuillez noter que les modèles YOLOv5 sont fournis sous les licences [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) et [Enterprise](https://ultralytics.com/license).
diff --git a/docs/fr/models/yolov6.md b/docs/fr/models/yolov6.md
deleted file mode 100644
index 3d4cc36be13..00000000000
--- a/docs/fr/models/yolov6.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-comments: true
-description: Explorez Meituan YOLOv6, un modèle de détection d'objets à la pointe de la technologie offrant un équilibre entre vitesse et précision. Plongez-vous dans les fonctionnalités, les modèles pré-entraînés et l'utilisation de Python.
-keywords: Meituan YOLOv6, détection d'objets, Ultralytics, YOLOv6 docs, Bi-directional Concatenation, Anchor-Aided Training, modèles pré-entraînés, applications en temps réel
----
-
-# Meituan YOLOv6
-
-## Vue d'ensemble
-
-[Meituan](https://about.meituan.com/) YOLOv6 est un détecteur d'objets de pointe qui offre un équilibre remarquable entre vitesse et précision, ce qui en fait un choix populaire pour les applications en temps réel. Ce modèle introduit plusieurs améliorations remarquables sur son architecture et son schéma d'entraînement, notamment la mise en œuvre d'un module de concaténation bidirectionnelle (BiC), d'une stratégie d'entraînement assistée par ancrage (AAT) et d'une conception améliorée de l'épine dorsale et du cou pour une précision de pointe sur l'ensemble de données COCO.
-
-![Meituan YOLOv6](https://user-images.githubusercontent.com/26833433/240750495-4da954ce-8b3b-41c4-8afd-ddb74361d3c2.png)
-![Exemple d'image du modèle](https://user-images.githubusercontent.com/26833433/240750557-3e9ec4f0-0598-49a8-83ea-f33c91eb6d68.png)
-**Aperçu de YOLOv6.** Diagramme de l'architecture du modèle montrant les composants du réseau redessinés et les stratégies d'entraînement qui ont conduit à d'importantes améliorations des performances. (a) L'épine dorsale de YOLOv6 (N et S sont indiqués). Notez que pour M/L, RepBlocks est remplacé par CSPStackRep. (b) La structure d'un module BiC. (c) Un bloc SimCSPSPPF. ([source](https://arxiv.org/pdf/2301.05586.pdf)).
-
-### Caractéristiques principales
-
-- **Module de concaténation bidirectionnelle (BiC) :** YOLOv6 introduit un module BiC dans le cou du détecteur, améliorant les signaux de localisation et offrant des gains de performance avec une dégradation de vitesse négligeable.
-- **Stratégie d'entraînement assistée par ancrage (AAT) :** Ce modèle propose AAT pour profiter des avantages des paradigmes basés sur ancrage et sans ancrage sans compromettre l'efficacité de l'inférence.
-- **Conception améliorée de l'épine dorsale et du cou :** En approfondissant YOLOv6 pour inclure une autre étape dans l'épine dorsale et le cou, ce modèle atteint des performances de pointe sur l'ensemble de données COCO avec une entrée haute résolution.
-- **Stratégie d'autodistillation :** Une nouvelle stratégie d'autodistillation est mise en œuvre pour améliorer les performances des modèles plus petits de YOLOv6, en améliorant la branche de régression auxiliaire pendant l'entraînement et en la supprimant lors de l'inférence afin d'éviter une baisse notable de la vitesse.
-
-## Métriques de performance
-
-YOLOv6 propose différents modèles pré-entraînés avec différentes échelles :
-
-- YOLOv6-N : 37,5 % de précision sur COCO val2017 à 1187 FPS avec le GPU NVIDIA Tesla T4.
-- YOLOv6-S : 45,0 % de précision à 484 FPS.
-- YOLOv6-M : 50,0 % de précision à 226 FPS.
-- YOLOv6-L : 52,8 % de précision à 116 FPS.
-- YOLOv6-L6 : Précision de pointe en temps réel.
-
-YOLOv6 propose également des modèles quantifiés pour différentes précisions et des modèles optimisés pour les plates-formes mobiles.
-
-## Exemples d'utilisation
-
-Cet exemple fournit des exemples simples d'entraînement et d'inférence de YOLOv6. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md).
-
-!!! Example "Exemple"
-
- === "Python"
-
- Les modèles pré-entraînés PyTorch `*.pt`, ainsi que les fichiers de configuration `*.yaml`, peuvent être utilisés pour créer une instance de modèle en python en utilisant la classe `YOLO()` :
-
- ```python
- from ultralytics import YOLO
-
- # Créer un modèle YOLOv6n à partir de zéro
- model = YOLO('yolov6n.yaml')
-
- # Afficher les informations sur le modèle (facultatif)
- model.info()
-
- # Entraîner le modèle sur l'ensemble de données d'exemple COCO8 pendant 100 epochs
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # Effectuer une inférence avec le modèle YOLOv6n sur l'image 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- Des commandes CLI sont disponibles pour exécuter directement les modèles :
-
- ```bash
- # Créer un modèle YOLOv6n à partir de zéro et l'entraîner sur l'ensemble de données d'exemple COCO8 pendant 100 epochs
- yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
-
- # Créer un modèle YOLOv6n à partir de zéro et effectuer une inférence sur l'image 'bus.jpg'
- yolo predict model=yolov6n.yaml source=path/to/bus.jpg
- ```
-
-## Tâches et modes pris en charge
-
-La série YOLOv6 propose une gamme de modèles, chacun optimisé pour la [détection d'objets](../tasks/detect.md) haute performance. Ces modèles répondent à des besoins computationnels et des exigences de précision variables, ce qui les rend polyvalents pour une large gamme d'applications.
-
-| Type de modèle | Modèles pré-entraînés | Tâches prises en charge | Inférence | Validation | Entraînement | Export |
-|----------------|-----------------------|------------------------------------------|-----------|------------|--------------|--------|
-| YOLOv6-N | `yolov6-n.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-S | `yolov6-s.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-M | `yolov6-m.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-L | `yolov6-l.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv6-L6 | `yolov6-l6.pt` | [Détection d'objets](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-
-Ce tableau fournit un aperçu détaillé des variantes du modèle YOLOv6, mettant en évidence leurs capacités dans les tâches de détection d'objets et leur compatibilité avec différents modes opérationnels tels que l'[Inférence](../modes/predict.md), la [Validation](../modes/val.md), l'[Entraînement](../modes/train.md) et l'[Export](../modes/export.md). Cette prise en charge complète permet aux utilisateurs de tirer pleinement parti des capacités des modèles YOLOv6 dans un large éventail de scénarios de détection d'objets.
-
-## Citations et remerciements
-
-Nous tenons à remercier les auteurs pour leur contribution importante dans le domaine de la détection d'objets en temps réel :
-
-!!! 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}
- }
- ```
-
- Le document original de YOLOv6 peut être consulté sur [arXiv](https://arxiv.org/abs/2301.05586). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/meituan/YOLOv6). Nous apprécions leurs efforts pour faire avancer le domaine et rendre leur travail accessible à la communauté plus large.
diff --git a/docs/fr/models/yolov7.md b/docs/fr/models/yolov7.md
deleted file mode 100644
index b2ec7495e6b..00000000000
--- a/docs/fr/models/yolov7.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-comments: true
-description: Découvrez le YOLOv7, un détecteur d'objets en temps réel. Comprenez sa vitesse supérieure, son impressionnante précision et son accent unique sur l'optimisation bag-of-freebies entraînable.
-keywords: YOLOv7, détecteur d'objets en temps réel, état de l'art, Ultralytics, jeu de données MS COCO, ré-paramétrisation du modèle, affectation des étiquettes dynamiques, mise à l'échelle étendue, mise à l'échelle composée
----
-
-# YOLOv7 : Bag-of-Freebies Entraînable
-
-YOLOv7 est un détecteur d'objets en temps réel à la pointe de la technologie qui surpasse tous les détecteurs d'objets connus en termes de vitesse et de précision, dans une plage de 5 FPS à 160 FPS. Il présente la précision la plus élevée (56,8% AP) parmi tous les détecteurs d'objets en temps réel connus avec un FPS de 30 ou plus sur GPU V100. De plus, YOLOv7 surpasse les autres détecteurs d'objets tels que YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 et bien d'autres en termes de vitesse et de précision. Le modèle est entraîné à partir de zéro sur le jeu de données MS COCO, sans utiliser d'autres jeux de données ou de poids pré-entraînés. Le code source de YOLOv7 est disponible sur GitHub.
-
-![Comparaison de YOLOv7 avec les détecteurs d'objets SOTA](https://github.com/ultralytics/ultralytics/assets/26833433/5e1e0420-8122-4c79-b8d0-2860aa79af92)
-**Comparaison des détecteurs d'objets de pointe.
-** À partir des résultats du Tableau 2, nous savons que la méthode proposée présente le meilleur compromis vitesse-précision dans l'ensemble. Si nous comparons YOLOv7-tiny-SiLU avec YOLOv5-N (r6.1), notre méthode est 127 FPS plus rapide et plus précise de 10,7% en AP. De plus, YOLOv7 atteint 51,4% d'AP à une fréquence d'images de 161 FPS, tandis que PPYOLOE-L avec la même AP atteint seulement 78 FPS. En termes d'utilisation des paramètres, YOLOv7 consomme 41% de moins que PPYOLOE-L. Si nous comparons YOLOv7-X avec une vitesse d'inférence de 114 FPS à YOLOv5-L (r6.1) avec une vitesse d'inférence de 99 FPS, YOLOv7-X peut améliorer l'AP de 3,9%. Si YOLOv7-X est comparé à YOLOv5-X (r6.1) de taille similaire, la vitesse d'inférence de YOLOv7-X est de 31 FPS plus rapide. De plus, en termes de nombre de paramètres et de calculs, YOLOv7-X réduit de 22% les paramètres et de 8% les calculs par rapport à YOLOv5-X (r6.1), mais améliore l'AP de 2,2% ([Source](https://arxiv.org/pdf/2207.02696.pdf)).
-
-## Aperçu
-
-La détection d'objets en temps réel est un composant important de nombreux systèmes de vision par ordinateur, notamment le suivi multi-objets, la conduite autonome, la robotique et l'analyse d'images médicales. Ces dernières années, le développement de la détection d'objets en temps réel s'est concentré sur la conception d'architectures efficaces et l'amélioration de la vitesse d'inférence des CPU, des GPU et des unités de traitement neuronal (NPU) dans différentes configurations. YOLOv7 prend en charge les GPU mobiles et les appareils GPU, de l'edge au cloud.
-
-Contrairement aux détecteurs d'objets en temps réel traditionnels qui se concentrent sur l'optimisation de l'architecture, YOLOv7 introduit une approche axée sur l'optimisation du processus d'entraînement. Cela comprend des modules et des méthodes d'optimisation conçus pour améliorer la précision de la détection d'objets sans augmenter le coût de l'inférence, un concept connu sous le nom de "bag-of-freebies entraînable".
-
-## Fonctionnalités Principales
-
-YOLOv7 propose plusieurs fonctionnalités principales :
-
-1. **Ré-paramétrisation du Modèle** : YOLOv7 propose un modèle re-paramétré planifié, qui est une stratégie applicable aux couches de différents réseaux avec le concept de propagation des gradients.
-
-2. **Affectation Dynamique des Étiquettes** : La formation du modèle avec des couches de sortie multiples présente un nouveau problème : "Comment attribuer des cibles dynamiques aux sorties des différentes branches ?" Pour résoudre ce problème, YOLOv7 introduit une nouvelle méthode d'affectation des étiquettes appelée affectation des étiquettes guidée en cascade de grossières à fines.
-
-3. **Mise à l'Échelle Étendue et Composée** : YOLOv7 propose des méthodes de "mise à l'échelle étendue" et de "mise à l'échelle composée" pour le détecteur d'objets en temps réel, qui permettent d'utiliser efficacement les paramètres et les calculs.
-
-4. **Efficacité** : La méthode proposée par YOLOv7 permet de réduire efficacement environ 40% des paramètres et 50% des calculs du détecteur d'objets en temps réel de pointe, tout en offrant une vitesse d'inférence plus rapide et une plus grande précision de détection.
-
-## Exemples d'Utilisation
-
-Au moment de la rédaction de cet article, Ultralytics ne prend pas en charge les modèles YOLOv7. Par conséquent, tout utilisateur intéressé par l'utilisation de YOLOv7 devra se référer directement au dépôt GitHub de YOLOv7 pour obtenir les instructions d'installation et d'utilisation.
-
-Voici un bref aperçu des étapes typiques que vous pourriez suivre pour utiliser YOLOv7 :
-
-1. Rendez-vous sur le dépôt GitHub de YOLOv7 : [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
-
-2. Suivez les instructions fournies dans le fichier README pour l'installation. Cela implique généralement de cloner le dépôt, d'installer les dépendances nécessaires et de configurer les variables d'environnement nécessaires.
-
-3. Une fois l'installation terminée, vous pouvez entraîner et utiliser le modèle selon les instructions d'utilisation fournies dans le dépôt. Cela implique généralement la préparation de votre ensemble de données, la configuration des paramètres du modèle, l'entraînement du modèle, puis l'utilisation du modèle entraîné pour effectuer la détection d'objets.
-
-Veuillez noter que les étapes spécifiques peuvent varier en fonction de votre cas d'utilisation spécifique et de l'état actuel du dépôt YOLOv7. Par conséquent, il est fortement recommandé de vous reporter directement aux instructions fournies dans le dépôt GitHub de YOLOv7.
-
-Nous nous excusons pour tout inconvénient que cela pourrait causer et nous nous efforcerons de mettre à jour ce document avec des exemples d'utilisation pour Ultralytics une fois la prise en charge de YOLOv7 mise en place.
-
-## Citations et Remerciements
-
-Nous tenons à remercier les auteurs de YOLOv7 pour leurs contributions significatives dans le domaine de la détection d'objets en temps réel :
-
-!!! 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}
- }
- ```
-
-Le document original de YOLOv7 peut être consulté sur [arXiv](https://arxiv.org/pdf/2207.02696.pdf). Les auteurs ont rendu leur travail accessible au public, et le code source peut être consulté sur [GitHub](https://github.com/WongKinYiu/yolov7). Nous apprécions leurs efforts pour faire avancer le domaine et rendre leur travail accessible à la communauté élargie.
diff --git a/docs/fr/models/yolov8.md b/docs/fr/models/yolov8.md
deleted file mode 100644
index 14223788b74..00000000000
--- a/docs/fr/models/yolov8.md
+++ /dev/null
@@ -1,162 +0,0 @@
----
-comments: true
-description: Explorez les fonctionnalités passionnantes de YOLOv8, la dernière version de notre détecteur d'objets en temps réel ! Découvrez comment les architectures avancées, les modèles pré-entraînés et un équilibre optimal entre précision et vitesse font de YOLOv8 le choix parfait pour vos tâches de détection d'objets.
-keywords: YOLOv8, Ultralytics, détecteur d'objets en temps réel, modèles pré-entraînés, documentation, détection d'objets, série YOLO, architectures avancées, précision, vitesse
----
-
-# YOLOv8
-
-## Aperçu
-
-YOLOv8 est la dernière itération de la série YOLO de détecteurs d'objets en temps réel, offrant des performances de pointe en termes de précision et de vitesse. S'appuyant sur les avancées des versions précédentes de YOLO, YOLOv8 introduit de nouvelles fonctionnalités et optimisations qui en font un choix idéal pour diverses tâches de détection d'objets dans une large gamme d'applications.
-
-![Ultralytics YOLOv8](https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/yolo-comparison-plots.png)
-
-## Principales fonctionnalités
-
-- **Architectures avancées pour le tronc et le cou:** YOLOv8 utilise des architectures de tronc et de cou de pointe, ce qui permet une meilleure extraction des caractéristiques et des performances de détection d'objets améliorées.
-- **Tête Ultralytics sans ancre:** YOLOv8 adopte une tête Ultralytics sans ancre, ce qui contribue à une meilleure précision et à un processus de détection plus efficace par rapport aux approches basées sur les ancres.
-- **Équilibre optimal entre précision et vitesse optimisé:** En mettant l'accent sur le maintien d'un équilibre optimal entre précision et vitesse, YOLOv8 convient aux tâches de détection d'objets en temps réel dans divers domaines d'application.
-- **Variété de modèles pré-entraînés:** YOLOv8 propose une gamme de modèles pré-entraînés pour répondre à différentes tâches et exigences de performance, ce qui facilite la recherche du modèle adapté à votre cas d'utilisation spécifique.
-
-## Tâches et modes pris en charge
-
-La série YOLOv8 propose une gamme diversifiée de modèles, chacun spécialisé dans des tâches spécifiques en vision par ordinateur. Ces modèles sont conçus pour répondre à diverses exigences, de la détection d'objets à des tâches plus complexes telles que la segmentation d'instance, la détection de pose/points clés et la classification.
-
-Chaque variante de la série YOLOv8 est optimisée pour sa tâche respective, garantissant des performances et une précision élevées. De plus, ces modèles sont compatibles avec divers modes opérationnels, notamment l'[Inférence](../modes/predict.md), la [Validation](../modes/val.md), l'[Entraînement](../modes/train.md) et l'[Exportation](../modes/export.md), ce qui facilite leur utilisation à différentes étapes du déploiement et du développement.
-
-| Modèle | Noms de fichiers | Tâche | Inférence | Validation | Entraînement | Exportation |
-|-------------|----------------------------------------------------------------------------------------------------------------|------------------------------------------------|-----------|------------|--------------|-------------|
-| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Détection](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Segmentation d'instance](../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/Points clés](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ |
-| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Classification](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ |
-
-Ce tableau donne un aperçu des variantes des modèles YOLOv8, mettant en évidence leur applicabilité dans des tâches spécifiques et leur compatibilité avec différents modes opérationnels tels que l'inférence, la validation, l'entraînement et l'exportation. Il met en avant la polyvalence et la robustesse de la série YOLOv8, ce qui les rend adaptés à une variété d'applications en vision par ordinateur.
-
-## Métriques de performance
-
-!!! Performance
-
- === "Détection (COCO)"
-
- Consultez la [doc de détection](https://docs.ultralytics.com/tasks/detect/) pour des exemples d'utilisation avec ces modèles entraînés sur [COCO](https://docs.ultralytics.com/datasets/detect/coco/), qui comprennent 80 classes pré-entrainées.
-
- | Modèle | taille (pixels) | mAPval 50-95 | Vitesse CPU ONNX (ms) | Vitesse A100 TensorRT (ms) | paramètres (M) | FLOPs (B) |
- | ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------- | ------------------------------------ | ------------------ | ----------------- |
- | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt) | 640 | 37,3 | 80,4 | 0,99 | 3,2 | 8,7 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s.pt) | 640 | 44,9 | 128,4 | 1,20 | 11,2 | 28,6 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m.pt) | 640 | 50,2 | 234,7 | 1,83 | 25,9 | 78,9 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l.pt) | 640 | 52,9 | 375,2 | 2,39 | 43,7 | 165,2 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x.pt) | 640 | 53,9 | 479,1 | 3,53 | 68,2 | 257,8 |
-
- === "Détection (Open Images V7)"
-
- Consultez la [doc de détection](https://docs.ultralytics.com/tasks/detect/) pour des exemples d'utilisation avec ces modèles entraînés sur [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), qui comprennent 600 classes pré-entrainées.
-
- | Modèle | taille (pixels) | mAPval 50-95 | Vitesse CPU ONNX (ms) | Vitesse A100 TensorRT (ms) | paramètres (M) | FLOPs (B) |
- | ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------- | ------------------------------------ | ------------------ | ----------------- |
- | [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n-oiv7.pt) | 640 | 18,4 | 142,4 | 1,21 | 3,5 | 10,5 |
- | [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8s-oiv7.pt) | 640 | 27,7 | 183,1 | 1,40 | 11,4 | 29,7 |
- | [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8m-oiv7.pt) | 640 | 33,6 | 408,5 | 2,26 | 26,2 | 80,6 |
- | [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8l-oiv7.pt) | 640 | 34,9 | 596,9 | 2,43 | 44,1 | 167,4 |
- | [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8x-oiv7.pt) | 640 | 36,3 | 860,6 | 3,56 | 68,7 | 260,6 |
-
- === "Segmentation (COCO)"
-
- Consultez la [doc de segmentation](https://docs.ultralytics.com/tasks/segment/) pour des exemples d'utilisation avec ces modèles entraînés sur [COCO](https://docs.ultralytics.com/datasets/segment/coco/), qui comprennent 80 classes pré-entrainées.
-
- | Modèle | taille (pixels) | mAPbox 50-95 | mAPmask 50-95 | Vitesse CPU ONNX (ms) | Vitesse A100 TensorRT (ms) | paramètres (M) | FLOPs (B) |
- | -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------- | ------------------------------------ | ------------------ | ----------------- |
- | [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-seg.pt) | 640 | 53,4 | 43,4 | 712,1 | 4,02 | 71,8 | 344,1 |
-
- === "Classification (ImageNet)"
-
- Consultez la [doc de classification](https://docs.ultralytics.com/tasks/classify/) pour des exemples d'utilisation avec ces modèles entraînés sur [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), qui comprennent 1000 classes pré-entrainées.
-
- | Modèle | taille (pixels) | acc top1 | acc top5 | Vitesse CPU ONNX (ms) | Vitesse A100 TensorRT (ms) | paramètres (M) | FLOPs (B) at 640 |
- | -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------- | ------------------------------------ | ------------------ | ------------------------ |
- | [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78,4 | 94,3 | 232,0 | 1,01 | 57,4 | 154,8 |
-
- === "Pose (COCO)"
-
- Consultez la [doc d'estimation de pose](https://docs.ultralytics.com/tasks/segment/) pour des exemples d'utilisation avec ces modèles entraînés sur [COCO](https://docs.ultralytics.com/datasets/pose/coco/), qui comprennent 1 classe pré-entrainée, 'person'.
-
- | Modèle | taille (pixels) | mAPpose 50-95 | mAPpose 50 | Vitesse CPU ONNX (ms) | Vitesse A100 TensorRT (ms) | paramètres (M) | FLOPs (B) |
- | ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------- | ------------------------------------ | ------------------ | ----------------- |
- | [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-pose-p6.pt) | 1280 | 71,6 | 91,2 | 4088,7 | 10,04 | 99,1 | 1066,4 |
-
-## Exemples d'utilisation
-
-Cet exemple fournit des exemples simples d'entraînement et d'inférence avec YOLOv8. Pour une documentation complète sur ces exemples et d'autres [modes](../modes/index.md), consultez les pages de documentation [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) et [Export](../modes/export.md).
-
-Veuillez noter que l'exemple ci-dessous concerne les modèles de détection YOLOv8. Pour d'autres tâches prises en charge, consultez la documentation de [Segmentation](../tasks/segment.md), [Classification](../tasks/classify.md) et [Pose/Points clés](../tasks/pose.md).
-
-!!! Example "Exemple"
-
- === "Python"
-
- Les modèles pré-entraînés PyTorch `*.pt` ainsi que les fichiers de configuration `*.yaml` peuvent être utilisés pour créer une instance de modèle en python en passant aux classes `YOLO()` :
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné sur COCO
- model = YOLO('yolov8n.pt')
-
- # Afficher les informations du modèle (facultatif)
- model.info()
-
- # Entraîner le modèle sur l'exemple de jeu de données COCO8 pendant 100 époques
- results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
-
- # Effectuer une inférence avec le modèle YOLOv8n sur l'image 'bus.jpg'
- results = model('path/to/bus.jpg')
- ```
-
- === "CLI"
-
- Des commandes CLI sont disponibles pour exécuter directement les modèles :
-
- ```bash
- # Charger un modèle YOLOv8n pré-entraîné sur COCO et l'entraîner sur l'exemple de jeu de données COCO8 pendant 100 époques
- yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
-
- # Charger un modèle YOLOv8n pré-entraîné sur COCO et effectuer une inférence sur l'image 'bus.jpg'
- yolo predict model=yolov8n.pt source=path/to/bus.jpg
- ```
-
-## Citations et remerciements
-
-Si vous utilisez le modèle YOLOv8 ou tout autre logiciel de ce référentiel dans votre travail, veuillez le citer selon le format suivant :
-
-!!! 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}
- }
- ```
-
-Veuillez noter que le DOI est en attente et sera ajouté à la citation dès qu'il sera disponible. Les modèles YOLOv8 sont fournis sous licence [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) et [Enterprise](https://ultralytics.com/license).
diff --git a/docs/fr/modes/benchmark.md b/docs/fr/modes/benchmark.md
deleted file mode 100644
index 5708aa40b29..00000000000
--- a/docs/fr/modes/benchmark.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-comments: true
-description: Apprenez comment profiler la vitesse et l'exactitude de YOLOv8 à travers divers formats d'exportation ; obtenez des insights sur les métriques mAP50-95, accuracy_top5 et plus.
-keywords: Ultralytics, YOLOv8, benchmarking, profilage de vitesse, profilage de précision, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formats d'exportation YOLO
----
-
-# Benchmarking de Modèles avec Ultralytics YOLO
-
-
-
-## Introduction
-
-Une fois votre modèle entraîné et validé, l'étape logique suivante est d'évaluer ses performances dans divers scénarios du monde réel. Le mode benchmark dans Ultralytics YOLOv8 répond à cet objectif en fournissant un cadre robuste pour évaluer la vitesse et l'exactitude de votre modèle sur une gamme de formats d'exportation.
-
-## Pourquoi le Benchmarking est-il Crucial ?
-
-- **Décisions Éclairées :** Obtenez des insights sur les arbitrages entre la vitesse et l'exactitude.
-- **Allocation des Ressources :** Comprenez comment les différents formats d'exportation se comportent sur différents matériels.
-- **Optimisation :** Découvrez quel format d'exportation offre la meilleure performance pour votre cas d'utilisation spécifique.
-- **Efficacité des Coûts :** Utilisez les ressources matérielles plus efficacement en vous basant sur les résultats des benchmarks.
-
-### Mesures Clés en Mode Benchmark
-
-- **mAP50-95 :** Pour la détection d'objets, la segmentation et l'estimation de pose.
-- **accuracy_top5 :** Pour la classification d'images.
-- **Temps d'Inférence :** Temps pris pour chaque image en millisecondes.
-
-### Formats d'Exportation Supportés
-
-- **ONNX :** Pour une performance optimale sur CPU.
-- **TensorRT :** Pour une efficacité maximale sur GPU.
-- **OpenVINO :** Pour l'optimisation du matériel Intel.
-- **CoreML, TensorFlow SavedModel, et Plus :** Pour des besoins variés de déploiement.
-
-!!! astuce "Conseil"
-
- * Exportez vers ONNX ou OpenVINO pour un gain de vitesse CPU jusqu'à 3x.
- * Exportez vers TensorRT pour un gain de vitesse GPU jusqu'à 5x.
-
-## Exemples d'Utilisation
-
-Exécutez les benchmarks YOLOv8n sur tous les formats d'exportation supportés, y compris ONNX, TensorRT, etc. Consultez la section Arguments ci-dessous pour une liste complète des arguments d'exportation.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics.utils.benchmarks import benchmark
-
- # Benchmark sur 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
-
-Des arguments tels que `model`, `data`, `imgsz`, `half`, `device` et `verbose` offrent aux utilisateurs la flexibilité d'ajuster précisément les benchmarks à leurs besoins spécifiques et de comparer facilement les performances de différents formats d'exportation.
-
-| Clé | Valeur | Description |
-|-----------|---------|---------------------------------------------------------------------------------------|
-| `model` | `None` | chemin vers le fichier modèle, par ex. yolov8n.pt, yolov8n.yaml |
-| `data` | `None` | chemin vers le YAML référençant le dataset de benchmarking (sous l'étiquette `val`) |
-| `imgsz` | `640` | taille de l'image comme scalaire ou liste (h, w), par ex. (640, 480) |
-| `half` | `False` | quantification FP16 |
-| `int8` | `False` | quantification INT8 |
-| `device` | `None` | appareil sur lequel exécuter, par ex. appareil cuda=0 ou device=0,1,2,3 ou device=cpu |
-| `verbose` | `False` | ne pas continuer en cas d'erreur (bool), ou seuil de plancher val (float) |
-
-## Formats d'Exportation
-
-Les benchmarks tenteront de s'exécuter automatiquement sur tous les formats d'exportation possibles ci-dessous.
-
-| Format | Argument `format` | Modèle | Métadonnées | 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` |
-| [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` |
-
-Consultez les détails complets sur `export` dans la page [Export](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/fr/modes/export.md b/docs/fr/modes/export.md
deleted file mode 100644
index e37d6e932e3..00000000000
--- a/docs/fr/modes/export.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-comments: true
-description: Guide étape par étape sur l'exportation de vos modèles YOLOv8 vers divers formats tels que ONNX, TensorRT, CoreML et plus encore pour le déploiement. Explorez maintenant !.
-keywords: YOLO, YOLOv8, Ultralytics, Exportation de modèle, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exporter un modèle
----
-
-# Exportation de modèle avec Ultralytics YOLO
-
-
-
-## Introduction
-
-L'objectif ultime de l'entraînement d'un modèle est de le déployer pour des applications dans le monde réel. Le mode d'exportation de Ultralytics YOLOv8 offre une large gamme d'options pour exporter votre modèle entraîné dans différents formats, le rendant déployable sur diverses plateformes et appareils. Ce guide complet vise à vous guider à travers les nuances de l'exportation de modèles, en montrant comment atteindre une compatibilité et des performances maximales.
-
-
-
-
-
- Regardez : Comment exporter un modèle Ultralytics YOLOv8 entraîné personnalisé et effectuer une inférence en direct sur webcam.
-
-
-## Pourquoi choisir le mode d'exportation YOLOv8 ?
-
-- **Polyvalence :** Exportation vers plusieurs formats, y compris ONNX, TensorRT, CoreML et plus encore.
-- **Performance :** Gagnez jusqu'à 5 fois la vitesse d'une GPU avec TensorRT et 3 fois la vitesse d'une CPU avec ONNX ou OpenVINO.
-- **Compatibilité :** Rendez votre modèle universellement déployable sur de nombreux environnements matériels et logiciels.
-- **Facilité d'utilisation :** Interface en ligne de commande (CLI) et API Python simples pour une exportation rapide et directe du modèle.
-
-### Caractéristiques clés du mode d'exportation
-
-Voici quelques-unes des fonctionnalités remarquables :
-
-- **Exportation en un clic :** Commandes simples pour exporter vers différents formats.
-- **Exportation groupée :** Exportez des modèles capables d'inférence par lot.
-- **Inférence optimisée :** Les modèles exportés sont optimisés pour des temps d'inférence plus rapides.
-- **Vidéos tutorielles :** Guides détaillés et tutoriels pour une expérience d'exportation fluide.
-
-!!! astuce "Conseil"
-
- * Exportez vers ONNX ou OpenVINO pour une accélération de la CPU jusqu'à 3 fois.
- * Exportez vers TensorRT pour une accélération de la GPU jusqu'à 5 fois.
-
-## Exemples d'utilisation
-
-Exportez un modèle YOLOv8n vers un format différent tel que ONNX ou TensorRT. Voir la section Arguments ci-dessous pour une liste complète des arguments d'exportation.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n.pt') # chargez un modèle officiel
- model = YOLO('path/to/best.pt') # chargez un modèle entraîné personnalisé
-
- # Exporter le modèle
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n.pt format=onnx # exporter modèle officiel
- yolo export model=path/to/best.pt format=onnx # exporter modèle entraîné personnalisé
- ```
-
-## Arguments
-
-Les paramètres d'exportation pour les modèles YOLO se réfèrent aux diverses configurations et options utilisées pour sauvegarder ou exporter le modèle pour utilisation dans d'autres environnements ou plateformes. Ces paramètres peuvent affecter la performance, la taille et la compatibilité du modèle avec différents systèmes. Certains paramètres d'exportation YOLO courants incluent le format du fichier modèle exporté (par exemple, ONNX, TensorFlow SavedModel), le dispositif sur lequel le modèle sera exécuté (par exemple, CPU, GPU), et la présence de fonctionnalités supplémentaires telles que des masques ou des étiquettes multiples par boîte. D'autres facteurs qui peuvent affecter le processus d'exportation incluent la tâche spécifique pour laquelle le modèle est utilisé et les exigences ou contraintes de l'environnement ou de la plateforme cible. Il est important de considérer et de configurer ces paramètres avec soin pour s'assurer que le modèle exporté est optimisé pour le cas d'utilisation visé et peut être utilisé efficacement dans l'environnement cible.
-
-| Clé | Valeur | Description |
-|-------------|-----------------|----------------------------------------------------------------------------------|
-| `format` | `'torchscript'` | format vers lequel exporter |
-| `imgsz` | `640` | taille d'image sous forme scalaire ou liste (h, w), par ex. (640, 480) |
-| `keras` | `False` | utilisez Keras pour l'exportation TensorFlow SavedModel |
-| `optimize` | `False` | TorchScript : optimisation pour mobile |
-| `half` | `False` | quantification FP16 |
-| `int8` | `False` | quantification INT8 |
-| `dynamic` | `False` | ONNX/TensorRT : axes dynamiques |
-| `simplify` | `False` | ONNX/TensorRT : simplifier le modèle |
-| `opset` | `None` | ONNX : version de l'ensemble d'opérations (facultatif, par défaut à la dernière) |
-| `workspace` | `4` | TensorRT : taille de l'espace de travail (GB) |
-| `nms` | `False` | CoreML : ajout de la NMS |
-
-## Formats d'exportation
-
-Les formats d'exportation disponibles pour YOLOv8 sont dans le tableau ci-dessous. Vous pouvez exporter vers n'importe quel format en utilisant l'argument `format`, par ex. `format='onnx'` ou `format='engine'`.
-
-| Format | Argument `format` | Modèle | Métadonnées | 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` |
-| [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/docs/fr/modes/index.md b/docs/fr/modes/index.md
deleted file mode 100644
index 9975e0437fe..00000000000
--- a/docs/fr/modes/index.md
+++ /dev/null
@@ -1,73 +0,0 @@
----
-comments: true
-description: De l'entraînement au suivi, exploitez au mieux YOLOv8 d'Ultralytics. Obtenez des aperçus et des exemples pour chaque mode pris en charge, y compris la validation, l'exportation et le benchmarking.
-keywords: Ultralytics, YOLOv8, Machine Learning, Détection d'objets, Entraînement, Validation, Prédiction, Exportation, Suivi, Benchmarking
----
-
-# Modes Ultralytics YOLOv8
-
-
-
-## Introduction
-
-Ultralytics YOLOv8 n'est pas simplement un autre modèle de détection d'objets ; c'est un cadre polyvalent conçu pour couvrir l'intégralité du cycle de vie des modèles d'apprentissage automatique — de l'ingestion de données et l'entraînement des modèles à la validation, le déploiement et le suivi en conditions réelles. Chaque mode remplit un objectif spécifique et est conçu pour vous offrir la flexibilité et l'efficacité nécessaires pour différentes tâches et cas d'utilisation.
-
-
-
-
-
- Regardez : Tutoriel sur les modes Ultralytics : Entraînement, Validation, Prédiction, Exportation & Benchmark.
-
-
-### Aperçu des Modes
-
-Comprendre les différents **modes** pris en charge par Ultralytics YOLOv8 est crucial pour tirer le maximum de vos modèles :
-
-- **Mode d'entraînement (Train)** : Affinez votre modèle sur des jeux de données personnalisés ou préchargés.
-- **Mode de validation (Val)** : Un contrôle post-entraînement pour évaluer la performance du modèle.
-- **Mode de prédiction (Predict)** : Déployez la puissance prédictive de votre modèle sur des données du monde réel.
-- **Mode d'exportation (Export)** : Préparez votre modèle au déploiement dans différents formats.
-- **Mode de suivi (Track)** : Étendez votre modèle de détection d'objets à des applications de suivi en temps réel.
-- **Mode benchmark (Benchmark)** : Analysez la vitesse et la précision de votre modèle dans divers environnements de déploiement.
-
-Ce guide complet vise à vous donner un aperçu et des informations pratiques sur chaque mode, en vous aidant à exploiter tout le potentiel de YOLOv8.
-
-## [Entraînement (Train)](train.md)
-
-Le mode d'entraînement est utilisé pour entraîner un modèle YOLOv8 sur un jeu de données personnalisé. Dans ce mode, le modèle est entraîné en utilisant le jeu de données et les hyperparamètres spécifiés. Le processus d'entraînement implique l'optimisation des paramètres du modèle afin qu'il puisse prédire avec précision les classes et les emplacements des objets dans une image.
-
-[Exemples d'entraînement](train.md){ .md-button }
-
-## [Validation (Val)](val.md)
-
-Le mode de validation est utilisé pour valider un modèle YOLOv8 après qu'il ait été entraîné. Dans ce mode, le modèle est évalué sur un ensemble de validation pour mesurer sa précision et sa capacité de généralisation. Ce mode peut être utilisé pour ajuster les hyperparamètres du modèle afin d'améliorer ses performances.
-
-[Exemples de validation](val.md){ .md-button }
-
-## [Prédiction (Predict)](predict.md)
-
-Le mode de prédiction est utilisé pour faire des prédictions à l'aide d'un modèle YOLOv8 entraîné sur de nouvelles images ou vidéos. Dans ce mode, le modèle est chargé à partir d'un fichier de checkpoint, et l'utilisateur peut fournir des images ou vidéos pour effectuer l'inférence. Le modèle prédit les classes et les emplacements des objets dans les images ou vidéos fournies.
-
-[Exemples de prédiction](predict.md){ .md-button }
-
-## [Exportation (Export)](export.md)
-
-Le mode d'exportation est utilisé pour exporter un modèle YOLOv8 dans un format pouvant être utilisé pour le déploiement. Dans ce mode, le modèle est converti dans un format pouvant être utilisé par d'autres applications logicielles ou dispositifs matériels. Ce mode est pratique pour déployer le modèle dans des environnements de production.
-
-[Exemples d'exportation](export.md){ .md-button }
-
-## [Suivi (Track)](track.md)
-
-Le mode de suivi est utilisé pour suivre des objets en temps réel à l'aide d'un modèle YOLOv8. Dans ce mode, le modèle est chargé à partir d'un fichier de checkpoint, et l'utilisateur peut fournir un flux vidéo en direct pour effectuer le suivi d'objets en temps réel. Ce mode est utile pour des applications telles que les systèmes de surveillance ou les voitures autonomes.
-
-[Exemples de suivi](track.md){ .md-button }
-
-## [Benchmark (Benchmark)](benchmark.md)
-
-Le mode benchmark est utilisé pour profiler la vitesse et la précision de divers formats d'exportation pour YOLOv8. Les benchmarks fournissent des informations sur la taille du format exporté, ses métriques `mAP50-95` (pour la détection d'objets, la segmentation et la pose) ou `accuracy_top5` (pour la classification), et le temps d'inférence en millisecondes par image pour différents formats d'exportation comme ONNX, OpenVINO, TensorRT et autres. Ces informations peuvent aider les utilisateurs à choisir le format d'export optimal pour leur cas d'utilisation spécifique en fonction de leurs exigences de vitesse et de précision.
-
-[Exemples de benchmark](benchmark.md){ .md-button }
diff --git a/docs/fr/modes/predict.md b/docs/fr/modes/predict.md
deleted file mode 100644
index 1a4a8f6e5fa..00000000000
--- a/docs/fr/modes/predict.md
+++ /dev/null
@@ -1,227 +0,0 @@
----
-comments: true
-description: Découvrez comment utiliser le mode de prédiction YOLOv8 pour diverses tâches. Apprenez sur différentes sources d'inférence comme des images, vidéos et formats de données.
-keywords: Ultralytics, YOLOv8, mode de prédiction, sources d'inférence, tâches de prédiction, mode streaming, traitement d'images, traitement vidéo, apprentissage automatique, IA
----
-
-# Prédiction de Modèle avec Ultralytics YOLO
-
-
-
-## Introduction
-
-Dans l'univers de l'apprentissage automatique et de la vision par ordinateur, le processus de donner du sens aux données visuelles est appelé 'inférence' ou 'prédiction'. Ultralytics YOLOv8 propose une fonctionnalité puissante connue sous le nom de **mode de prédiction** adapté pour l'inférence en temps réel et haute performance sur une large gamme de sources de données.
-
-
-
-
-
- Regardez : Comment Extraire les Sorties du Modèle Ultralytics YOLOv8 pour des Projets Personnalisés.
-
-
-## Applications Réelles
-
-| Fabrication | Sports | Sécurité |
-|:---------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------:|
-| ![Détection des Pièces de Véhicules](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Détection des Joueurs de Football](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Détection de Chutes de Personnes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) |
-| Détection des Pièces de Véhicules | Détection des Joueurs de Football | Détection de Chutes de Personnes |
-
-## Pourquoi Utiliser Ultralytics YOLO pour l'Inférence ?
-
-Voici pourquoi vous devriez considérer le mode de prédiction YOLOv8 pour vos besoins variés en inférence :
-
-- **Polyvalence :** Capable de faire des inférences sur des images, des vidéos et même des flux en direct.
-- **Performance :** Conçu pour le traitement en temps réel à grande vitesse sans sacrifier la précision.
-- **Facilité d'Utilisation :** Interfaces Python et CLI intuitives pour un déploiement et des tests rapides.
-- **Très Personnalisable :** Divers paramètres et réglages pour ajuster le comportement d'inférence du modèle selon vos besoins spécifiques.
-
-### Caractéristiques Clés du Mode de Prédiction
-
-Le mode de prédiction YOLOv8 est conçu pour être robuste et polyvalent, avec des fonctionnalités telles que :
-
-- **Compatibilité avec Plusieurs Sources de Données :** Que vos données soient sous forme d'images individuelles, d'une collection d'images, de fichiers vidéo ou de flux vidéo en temps réel, le mode de prédiction répond à vos besoins.
-- **Mode Streaming :** Utilisez la fonctionnalité de streaming pour générer un générateur efficace en termes de mémoire d'objets `Results`. Activez-le en réglant `stream=True` dans la méthode d'appel du prédicteur.
-- **Traitement par Lots :** La capacité de traiter plusieurs images ou trames vidéo dans un seul lot, accélérant ainsi le temps d'inférence.
-- **Facile à Intégrer :** S'intègre facilement dans les pipelines de données existants et autres composants logiciels, grâce à son API souple.
-
-Les modèles YOLO d'Ultralytics renvoient soit une liste d'objets `Results` Python, soit un générateur Python efficace en termes de mémoire d'objets `Results` lorsque `stream=True` est passé au modèle pendant l'inférence :
-
-!!! Example "Prédire"
-
- === "Renvoie une liste avec `stream=False`"
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n.pt') # modèle YOLOv8n pré-entraîné
-
- # Exécuter une inférence par lots sur une liste d'images
- results = model(['im1.jpg', 'im2.jpg']) # renvoie une liste d'objets Results
-
- # Traiter la liste des résultats
- for result in results:
- boxes = result.boxes # Objet Boxes pour les sorties bbox
- masks = result.masks # Objet Masks pour les masques de segmentation
- keypoints = result.keypoints # Objet Keypoints pour les sorties de pose
- probs = result.probs # Objet Probs pour les sorties de classification
- ```
-
- === "Renvoie un générateur avec `stream=True`"
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n.pt') # modèle YOLOv8n pré-entraîné
-
- # Exécuter une inférence par lots sur une liste d'images
- results = model(['im1.jpg', 'im2.jpg'], stream=True) # renvoie un générateur d'objets Results
-
- # Traiter le générateur de résultats
- for result in results:
- boxes = result.boxes # Objet Boxes pour les sorties bbox
- masks = result.masks # Objet Masks pour les masques de segmentation
- keypoints = result.keypoints # Objet Keypoints pour les sorties de pose
- probs = result.probs # Objet Probs pour les sorties de classification
- ```
-
-## Sources d'Inférence
-
-YOLOv8 peut traiter différents types de sources d'entrée pour l'inférence, comme illustré dans le tableau ci-dessous. Les sources incluent des images statiques, des flux vidéos et divers formats de données. Le tableau indique également si chaque source peut être utilisée en mode streaming avec l'argument `stream=True` ✅. Le mode streaming est bénéfique pour traiter des vidéos ou des flux en direct car il crée un générateur de résultats au lieu de charger tous les cadres en mémoire.
-
-!!! astuce "Astuce"
-
- Utilisez `stream=True` pour traiter des vidéos longues ou des jeux de données volumineux afin de gérer efficacement la mémoire. Quand `stream=False`, les résultats pour tous les cadres ou points de données sont stockés en mémoire, ce qui peut rapidement s'accumuler et provoquer des erreurs de mémoire insuffisante pour de grandes entrées. En revanche, `stream=True` utilise un générateur, qui ne garde que les résultats du cadre ou point de données actuel en mémoire, réduisant considérablement la consommation de mémoire et prévenant les problèmes de mémoire insuffisante.
-
-| Source | Argument | Type | Notes |
-|-----------------|--------------------------------------------|-----------------|------------------------------------------------------------------------------------------------------------------------------|
-| image | `'image.jpg'` | `str` ou `Path` | Fichier image unique. |
-| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL vers une image. |
-| capture d'écran | `'screen'` | `str` | Prendre une capture d'écran. |
-| PIL | `Image.open('im.jpg')` | `PIL.Image` | Format HWC avec canaux RGB. |
-| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Format HWC avec canaux BGR `uint8 (0-255)`. |
-| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Format HWC avec canaux BGR `uint8 (0-255)`. |
-| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Format BCHW avec canaux RGB `float32 (0.0-1.0)`. |
-| CSV | `'sources.csv'` | `str` ou `Path` | Fichier CSV contenant des chemins vers des images, vidéos ou répertoires. |
-| vidéo ✅ | `'video.mp4'` | `str` ou `Path` | Fichier vidéo dans des formats comme MP4, AVI, etc. |
-| répertoire ✅ | `'chemin/'` | `str` ou `Path` | Chemin vers un répertoire contenant des images ou des vidéos. |
-| motif global ✅ | `'chemin/*.jpg'` | `str` | Motif glob pour faire correspondre plusieurs fichiers. Utilisez le caractère `*` comme joker. |
-| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL vers une vidéo YouTube. |
-| flux ✅ | `'rtsp://exemple.com/media.mp4'` | `str` | URL pour des protocoles de streaming comme RTSP, RTMP, TCP, ou une adresse IP. |
-| multi-flux ✅ | `'liste.streams'` | `str` ou `Path` | Fichier texte `*.streams` avec une URL de flux par ligne, c'est-à-dire que 8 flux s'exécuteront avec une taille de lot de 8. |
-
-Ci-dessous des exemples de code pour utiliser chaque type de source :
-
-!!! Example "Sources de prédiction"
-
- === "image"
- Exécutez une inférence sur un fichier image.
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné
- model = YOLO('yolov8n.pt')
-
- # Définir le chemin vers le fichier image
- source = 'chemin/vers/image.jpg'
-
- # Exécuter une inférence sur la source
- results = model(source) # liste d'objets Results
- ```
-
- === "capture d'écran"
- Exécutez une inférence sur le contenu actuel de l'écran sous forme de capture d'écran.
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné
- model = YOLO('yolov8n.pt')
-
- # Définir la capture d'écran actuelle comme source
- source = 'screen'
-
- # Exécuter une inférence sur la source
- results = model(source) # liste d'objets Results
- ```
-
- === "URL"
- Exécutez une inférence sur une image ou vidéo hébergée à distance via URL.
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné
- model = YOLO('yolov8n.pt')
-
- # Définir l'URL d'une image ou vidéo distante
- source = 'https://ultralytics.com/images/bus.jpg'
-
- # Exécuter une inférence sur la source
- results = model(source) # liste d'objets Results
- ```
-
- === "PIL"
- Exécutez une inférence sur une image ouverte avec la bibliothèque Python Imaging Library (PIL).
- ```python
- from PIL import Image
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné
- model = YOLO('yolov8n.pt')
-
- # Ouvrir une image avec PIL
- source = Image.open('chemin/vers/image.jpg')
-
- # Exécuter une inférence sur la source
- results = model(source) # liste d'objets Results
- ```
-
- === "OpenCV"
- Exécutez une inférence sur une image lue avec OpenCV.
- ```python
- import cv2
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné
- model = YOLO('yolov8n.pt')
-
- # Lire une image avec OpenCV
- source = cv2.imread('chemin/vers/image.jpg')
-
- # Exécuter une inférence sur la source
- results = model(source) # liste d'objets Results
- ```
-
- === "numpy"
- Exécutez une inférence sur une image représentée sous forme de tableau numpy.
- ```python
- import numpy as np
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné
- model = YOLO('yolov8n.pt')
-
- # Créer un tableau numpy aléatoire de forme HWC (640, 640, 3) avec des valeurs dans l'intervalle [0, 255] et de type uint8
- source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')
-
- # Exécuter une inférence sur la source
- results = model(source) # liste d'objets Results
- ```
-
- === "torch"
- Exécutez une inférence sur une image représentée sous forme de tenseur PyTorch.
- ```python
- import torch
- from ultralytics import YOLO
-
- # Charger un modèle YOLOv8n pré-entraîné
- model = YOLO('yolov8n.pt')
-
- # Créer un tenseur aléatoire torch de forme BCHW (1, 3, 640, 640) avec des valeurs dans l'intervalle [0, 1] et de type float32
- source = torch.rand(1, 3, 640, 640, dtype=torch.float32)
-
- # Exécuter une inférence sur la source
- results = model(source) # liste d'objets Results
- ```
diff --git a/docs/fr/modes/track.md b/docs/fr/modes/track.md
deleted file mode 100644
index 5da691c3033..00000000000
--- a/docs/fr/modes/track.md
+++ /dev/null
@@ -1,200 +0,0 @@
----
-comments: true
-description: Apprenez à utiliser Ultralytics YOLO pour le suivi d'objets dans les flux vidéo. Guides pour utiliser différents traceurs et personnaliser les configurations de traceurs.
-keywords: Ultralytics, YOLO, suivi d'objets, flux vidéo, BoT-SORT, ByteTrack, guide Python, guide CLI
----
-
-# Suivi Multi-Objets avec Ultralytics YOLO
-
-
-
-Le suivi d'objets dans le domaine de l'analyse vidéo est une tâche essentielle qui non seulement identifie l'emplacement et la classe des objets à l'intérieur de l'image, mais maintient également un identifiant unique pour chaque objet détecté au fur et à mesure que la vidéo progresse. Les applications sont illimitées, allant de la surveillance et de la sécurité à l'analytique sportive en temps réel.
-
-## Pourquoi Choisir Ultralytics YOLO pour le Suivi d'Objet ?
-
-La sortie des traceurs Ultralytics est cohérente avec la détection standard d'objets mais apporte la valeur ajoutée des identifiants d'objets. Cela facilite le suivi des objets dans les flux vidéo et effectue des analyses subséquentes. Voici pourquoi vous devriez envisager d'utiliser Ultralytics YOLO pour vos besoins de suivi d'objet :
-
-- **Efficacité :** Traitez les flux vidéo en temps réel sans compromettre la précision.
-- **Flexibilité :** Prend en charge de multiples algorithmes de suivi et configurations.
-- **Facilité d'Utilisation :** API Python simple et options CLI pour une intégration et un déploiement rapides.
-- **Personnalisabilité :** Facile à utiliser avec des modèles YOLO entraînés sur mesure, permettant une intégration dans des applications spécifiques au domaine.
-
-
-
-
-
- Regardez : Détection et suivi d'objets avec Ultralytics YOLOv8.
-
-
-## Applications dans le Monde Réel
-
-| Transport | Distribution | Aquaculture |
-|:------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------:|
-| ![Suivi de véhicules](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Suivi de personnes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Suivi de poissons](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) |
-| Suivi de Véhicules | Suivi de Personnes | Suivi de Poissons |
-
-## Caractéristiques en Bref
-
-Ultralytics YOLO étend ses fonctionnalités de détection d'objets pour fournir un suivi d'objets robuste et polyvalent :
-
-- **Suivi en Temps Réel :** Suivi fluide d'objets dans des vidéos à fréquence d'images élevée.
-- **Prise en Charge de Multiples Traceurs :** Choisissez parmi une variété d'algorithmes de suivi éprouvés.
-- **Configurations de Traceurs Personnalisables :** Adaptez l'algorithme de suivi pour répondre à des exigences spécifiques en réglant divers paramètres.
-
-## Traceurs Disponibles
-
-Ultralytics YOLO prend en charge les algorithmes de suivi suivants. Ils peuvent être activés en passant le fichier de configuration YAML correspondant tel que `tracker=tracker_type.yaml` :
-
-* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Utilisez `botsort.yaml` pour activer ce traceur.
-* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Utilisez `bytetrack.yaml` pour activer ce traceur.
-
-Le traceur par défaut est BoT-SORT.
-
-## Suivi
-
-Pour exécuter le traceur sur des flux vidéo, utilisez un modèle Detect, Segment ou Pose formé tel que YOLOv8n, YOLOv8n-seg et YOLOv8n-pose.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle officiel ou personnalisé
- model = YOLO('yolov8n.pt') # Charger un modèle Detect officiel
- model = YOLO('yolov8n-seg.pt') # Charger un modèle Segment officiel
- model = YOLO('yolov8n-pose.pt') # Charger un modèle Pose officiel
- model = YOLO('chemin/vers/best.pt') # Charger un modèle entraîné personnalisé
-
- # Effectuer le suivi avec le modèle
- results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Suivi avec le traceur par défaut
- results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Suivi avec le traceur ByteTrack
- ```
-
- === "CLI"
-
- ```bash
- # Effectuer le suivi avec divers modèles en utilisant l'interface en ligne de commande
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Detect officiel
- yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Segment officiel
- yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Pose officiel
- yolo track model=chemin/vers/best.pt source="https://youtu.be/LNwODJXcvt4" # Modèle entraîné personnalisé
-
- # Suivi en utilisant le traceur ByteTrack
- yolo track model=chemin/vers/best.pt tracker="bytetrack.yaml"
- ```
-
-Comme on peut le voir dans l'utilisation ci-dessus, le suivi est disponible pour tous les modèles Detect, Segment et Pose exécutés sur des vidéos ou des sources de diffusion.
-
-## Configuration
-
-### Arguments de Suivi
-
-La configuration du suivi partage des propriétés avec le mode Prédiction, telles que `conf`, `iou`, et `show`. Pour des configurations supplémentaires, référez-vous à la page [Predict](https://docs.ultralytics.com/modes/predict/) du modèle.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Configurer les paramètres de suivi et exécuter le traceur
- model = YOLO('yolov8n.pt')
- results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
- ```
-
- === "CLI"
-
- ```bash
- # Configurer les paramètres de suivi et exécuter le traceur en utilisant l'interface en ligne de commande
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
- ```
-
-### Sélection du Traceur
-
-Ultralytics vous permet également d'utiliser un fichier de configuration de traceur modifié. Pour cela, faites simplement une copie d'un fichier de configuration de traceur (par exemple, `custom_tracker.yaml`) à partir de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) et modifiez toute configuration (à l'exception du `tracker_type`) selon vos besoins.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger le modèle et exécuter le traceur avec un fichier de configuration personnalisé
- model = YOLO('yolov8n.pt')
- results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
- ```
-
- === "CLI"
-
- ```bash
- # Charger le modèle et exécuter le traceur avec un fichier de configuration personnalisé en utilisant l'interface en ligne de commande
- yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
- ```
-
-Pour une liste complète des arguments de suivi, référez-vous à la page [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
-
-## Exemples Python
-
-### Boucle de Persistance des Pistes
-
-Voici un script Python utilisant OpenCV (`cv2`) et YOLOv8 pour exécuter le suivi d'objet sur des images vidéo. Ce script suppose toujours que vous avez déjà installé les packages nécessaires (`opencv-python` et `ultralytics`). L'argument `persist=True` indique au traceur que l'image ou la trame actuelle est la suivante dans une séquence et s'attend à ce que les pistes de l'image précédente soient présentes dans l'image actuelle.
-
-!!! Example "Boucle for streaming avec suivi"
-
- ```python
- import cv2
- from ultralytics import YOLO
-
- # Charger le modèle YOLOv8
- model = YOLO('yolov8n.pt')
-
- # Ouvrir le fichier vidéo
- video_path = "chemin/vers/video.mp4"
- cap = cv2.VideoCapture(video_path)
-
- # Parcourir les images vidéo
- while cap.isOpened():
- # Lire une image de la vidéo
- success, frame = cap.read()
-
- if success:
- # Exécuter le suivi YOLOv8 sur l'image, en persistant les pistes entre les images
- results = model.track(frame, persist=True)
-
- # Visualiser les résultats sur l'image
- annotated_frame = results[0].plot()
-
- # Afficher l'image annotée
- cv2.imshow("Suivi YOLOv8", annotated_frame)
-
- # Interrompre la boucle si 'q' est pressée
- if cv2.waitKey(1) & 0xFF == ord("q"):
- break
- else:
- # Interrompre la boucle si la fin de la vidéo est atteinte
- break
-
- # Relâcher l'objet de capture vidéo et fermer la fenêtre d'affichage
- cap.release()
- cv2.destroyAllWindows()
- ```
-
-Veuillez noter le changement de `model(frame)` à `model.track(frame)`, qui active le suivi d'objet à la place de la simple détection. Ce script modifié exécutera le traceur sur chaque image de la vidéo, visualisera les résultats et les affichera dans une fenêtre. La boucle peut être quittée en appuyant sur 'q'.
-
-## Contribuer de Nouveaux Traceurs
-
-Êtes-vous compétent en suivi multi-objets et avez-vous réussi à implémenter ou adapter un algorithme de suivi avec Ultralytics YOLO ? Nous vous invitons à contribuer à notre section Traceurs sur [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) ! Vos applications et solutions dans le monde réel pourraient être inestimables pour les utilisateurs travaillant sur des tâches de suivi.
-
-En contribuant à cette section, vous aidez à élargir l'éventail des solutions de suivi disponibles au sein du cadre Ultralytics YOLO, ajoutant une autre couche de fonctionnalité et d'utilité pour la communauté.
-
-Pour initier votre contribution, veuillez vous référer à notre [Guide de Contribution](https://docs.ultralytics.com/help/contributing) pour des instructions complètes sur la soumission d'une Pull Request (PR) 🛠️. Nous sommes impatients de voir ce que vous apportez à la table !
-
-Ensemble, améliorons les capacités de suivi de l'écosystème Ultralytics YOLO 🙏 !
diff --git a/docs/fr/modes/train.md b/docs/fr/modes/train.md
deleted file mode 100644
index 652a91815f2..00000000000
--- a/docs/fr/modes/train.md
+++ /dev/null
@@ -1,206 +0,0 @@
----
-comments: true
-description: Guide étape par étape pour entraîner des modèles YOLOv8 avec Ultralytics YOLO incluant des exemples d'entraînement mono-GPU et multi-GPU
-keywords: Ultralytics, YOLOv8, YOLO, détection d'objet, mode entraînement, jeu de données personnalisé, entraînement GPU, multi-GPU, hyperparamètres, exemples CLI, exemples Python
----
-
-# Entraînement de modèles avec Ultralytics YOLO
-
-
-
-## Introduction
-
-L'entraînement d'un modèle d'apprentissage profond implique de lui fournir des données et d'ajuster ses paramètres afin qu'il puisse faire des prédictions précises. Le mode Entraînement de Ultralytics YOLOv8 est conçu pour un entraînement efficace et performant de modèles de détection d'objets, en utilisant pleinement les capacités du matériel moderne. Ce guide vise à couvrir tous les détails nécessaires pour commencer à entraîner vos propres modèles en utilisant l'ensemble robuste de fonctionnalités de YOLOv8.
-
-
-
-
-
- Regardez : Comment entraîner un modèle YOLOv8 sur votre jeu de données personnalisé dans Google Colab.
-
-
-## Pourquoi choisir Ultralytics YOLO pour l'entraînement ?
-
-Voici quelques raisons convaincantes de choisir le mode Entraînement de YOLOv8 :
-
-- **Efficacité :** Optimisez l'utilisation de votre matériel, que vous soyez sur une configuration mono-GPU ou que vous échelonnier sur plusieurs GPUs.
-- **Polyvalence :** Entraînez sur des jeux de données personnalisés en plus de ceux déjà disponibles comme COCO, VOC et ImageNet.
-- **Convivialité :** Interfaces CLI et Python simples mais puissantes pour une expérience d'entraînement directe.
-- **Flexibilité des hyperparamètres :** Un large éventail d'hyperparamètres personnalisables pour peaufiner les performances du modèle.
-
-### Principales caractéristiques du mode Entraînement
-
-Voici quelques caractéristiques remarquables du mode Entraînement de YOLOv8 :
-
-- **Téléchargement automatique de jeux de données :** Les jeux de données standards comme COCO, VOC et ImageNet sont téléchargés automatiquement lors de la première utilisation.
-- **Support multi-GPU :** Échelonnez vos efforts de formation de manière fluide sur plusieurs GPUs pour accélérer le processus.
-- **Configuration des hyperparamètres :** La possibilité de modifier les hyperparamètres via des fichiers de configuration YAML ou des arguments CLI.
-- **Visualisation et suivi :** Suivi en temps réel des métriques d'entraînement et visualisation du processus d'apprentissage pour de meilleures perspectives.
-
-!!! Tip "Astuce"
-
- * Les jeux de données YOLOv8 comme COCO, VOC, ImageNet et bien d'autres se téléchargent automatiquement lors de la première utilisation, par exemple `yolo train data=coco.yaml`
-
-## Exemples d'utilisation
-
-Entraînez YOLOv8n sur le jeu de données COCO128 pendant 100 époques avec une taille d'image de 640. Le dispositif d'entraînement peut être spécifié à l'aide de l'argument `device`. Si aucun argument n'est passé, le GPU `device=0` sera utilisé s'il est disponible, sinon `device=cpu` sera utilisé. Consultez la section Arguments ci-dessous pour obtenir une liste complète des arguments d'entraînement.
-
-!!! Example "Exemple d'entraînement mono-GPU et CPU"
-
- Le dispositif est déterminé automatiquement. Si un GPU est disponible, il sera utilisé, sinon l'entraînement commencera sur CPU.
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n.yaml') # construire un nouveau modèle à partir de YAML
- model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement)
- model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construire à partir de YAML et transférer les poids
-
- # Entraîner le modèle
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
- ```
-
- === "CLI"
-
- ```bash
- # Construire un nouveau modèle à partir de YAML et commencer l'entraînement à partir de zéro
- yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
-
- # Commencer l'entraînement à partir d'un modèle préentraîné *.pt
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
-
- # Construire un nouveau modèle à partir de YAML, transférer les poids préentraînés et commencer l'entraînement
- yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
- ```
-
-### Entraînement multi-GPU
-
-L'entraînement multi-GPU permet une utilisation plus efficace des ressources matérielles disponibles en répartissant la charge d'entraînement sur plusieurs GPUs. Cette fonctionnalité est disponible via l'API Python et l'interface de ligne de commande. Pour activer l'entraînement multi-GPU, spécifiez les ID des dispositifs GPU que vous souhaitez utiliser.
-
-!!! Example "Exemple d'entraînement multi-GPU"
-
- Pour s'entraîner avec 2 GPUs, les dispositifs CUDA 0 et 1, utilisez les commandes suivantes. Développez à des GPUs supplémentaires selon le besoin.
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement)
-
- # Entraîner le modèle avec 2 GPUs
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
- ```
-
- === "CLI"
-
- ```bash
- # Commencer l'entraînement à partir d'un modèle préentraîné *.pt en utilisant les GPUs 0 et 1
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
- ```
-
-### Entraînement MPS avec Apple M1 et M2
-
-Avec le support pour les puces Apple M1 et M2 intégré dans les modèles Ultralytics YOLO, il est maintenant possible d'entraîner vos modèles sur des dispositifs utilisant le puissant framework Metal Performance Shaders (MPS). Le MPS offre un moyen performant d'exécuter des tâches de calcul et de traitement d'image sur le silicium personnalisé d'Apple.
-
-Pour activer l'entraînement sur les puces Apple M1 et M2, vous devez spécifier 'mps' comme votre dispositif lors du lancement du processus d'entraînement. Voici un exemple de la manière dont vous pourriez le faire en Python et via la ligne de commande :
-
-!!! Example "Exemple d'entraînement MPS"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement)
-
- # Entraîner le modèle avec MPS
- results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
- ```
-
- === "CLI"
-
- ```bash
- # Commencer l'entraînement à partir d'un modèle préentraîné *.pt avec MPS
- yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
- ```
-
-Tout en exploitant la puissance de calcul des puces M1/M2, cela permet un traitement plus efficace des tâches d'entraînement. Pour des conseils plus détaillés et des options de configuration avancée, veuillez consulter la [documentation MPS de PyTorch](https://pytorch.org/docs/stable/notes/mps.html).
-
-## Journalisation
-
-Lors de l'entraînement d'un modèle YOLOv8, il peut être précieux de suivre la performance du modèle au fil du temps. C'est là que la journalisation entre en jeu. YOLO d'Ultralytics prend en charge trois types de journaux - Comet, ClearML et TensorBoard.
-
-Pour utiliser un journal, sélectionnez-le dans le menu déroulant ci-dessus et exécutez-le. Le journal choisi sera installé et initialisé.
-
-### Comet
-
-[Comet](https://www.comet.ml/site/) est une plateforme qui permet aux scientifiques de données et aux développeurs de suivre, comparer, expliquer et optimiser les expériences et les modèles. Elle offre des fonctionnalités telles que le suivi en temps réel des mesures, les différences de code et le suivi des hyperparamètres.
-
-Pour utiliser Comet :
-
-!!! Example "Exemple"
-
- === "Python"
- ```python
- # pip install comet_ml
- import comet_ml
-
- comet_ml.init()
- ```
-
-N'oubliez pas de vous connecter à votre compte Comet sur leur site web et d'obtenir votre clé API. Vous devrez ajouter cela à vos variables d'environnement ou à votre script pour enregistrer vos expériences.
-
-### ClearML
-
-[ClearML](https://www.clear.ml/) est une plateforme open source qui automatise le suivi des expériences et aide à partager efficacement les ressources. Elle est conçue pour aider les équipes à gérer, exécuter et reproduire leur travail en ML plus efficacement.
-
-Pour utiliser ClearML :
-
-!!! Example "Exemple"
-
- === "Python"
- ```python
- # pip install clearml
- import clearml
-
- clearml.browser_login()
- ```
-
-Après avoir exécuté ce script, vous devrez vous connecter à votre compte ClearML sur le navigateur et authentifier votre session.
-
-### TensorBoard
-
-[TensorBoard](https://www.tensorflow.org/tensorboard) est un ensemble d'outils de visualisation pour TensorFlow. Il vous permet de visualiser votre graphique TensorFlow, de tracer des mesures quantitatives sur l'exécution de votre graphique et de montrer des données supplémentaires comme des images qui le traversent.
-
-Pour utiliser TensorBoard dans [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb) :
-
-!!! Example "Exemple"
-
- === "CLI"
- ```bash
- load_ext tensorboard
- tensorboard --logdir ultralytics/runs # remplacer par le répertoire 'runs'
- ```
-
-Pour utiliser TensorBoard localement, exécutez la commande ci-dessous et consultez les résultats à l'adresse http://localhost:6006/.
-
-!!! Example "Exemple"
-
- === "CLI"
- ```bash
- tensorboard --logdir ultralytics/runs # remplacer par le répertoire 'runs'
- ```
-
-Cela chargera TensorBoard et le dirigera vers le répertoire où vos journaux d'entraînement sont sauvegardés.
-
-Après avoir configuré votre journal, vous pouvez ensuite poursuivre l'entraînement de votre modèle. Toutes les métriques d'entraînement seront automatiquement enregistrées sur votre plateforme choisie, et vous pourrez accéder à ces journaux pour surveiller les performances de votre modèle au fil du temps, comparer différents modèles et identifier les domaines d'amélioration.
diff --git a/docs/fr/modes/val.md b/docs/fr/modes/val.md
deleted file mode 100644
index f6f51bfb351..00000000000
--- a/docs/fr/modes/val.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-comments: true
-description: Guide de validation des modèles YOLOv8. Apprenez à évaluer la performance de vos modèles YOLO en utilisant les paramètres de validation et les métriques avec des exemples en Python et en CLI.
-keywords: Ultralytics, YOLO Docs, YOLOv8, validation, évaluation de modèle, hyperparamètres, précision, métriques, Python, CLI
----
-
-# Validation des modèles avec Ultralytics YOLO
-
-
-
-## Introduction
-
-La validation est une étape cruciale dans le pipeline d'apprentissage automatique, vous permettant d'évaluer la qualité de vos modèles entraînés. Le mode Val dans Ultralytics YOLOv8 offre une gamme robuste d'outils et de métriques pour évaluer la performance de vos modèles de détection d'objets. Ce guide sert de ressource complète pour comprendre comment utiliser efficacement le mode Val pour assurer que vos modèles sont à la fois précis et fiables.
-
-## Pourquoi valider avec Ultralytics YOLO ?
-
-Voici pourquoi l'utilisation du mode Val de YOLOv8 est avantageuse :
-
-- **Précision :** Obtenez des métriques précises telles que mAP50, mAP75 et mAP50-95 pour évaluer de manière exhaustive votre modèle.
-- **Convenance :** Utilisez des fonctionnalités intégrées qui se souviennent des paramètres d'entraînement, simplifiant ainsi le processus de validation.
-- **Flexibilité :** Validez votre modèle avec les mêmes jeux de données ou des jeux différents et des tailles d'image variées.
-- **Réglage des hyperparamètres :** Utilisez les métriques de validation pour peaufiner votre modèle pour de meilleures performances.
-
-### Caractéristiques clés du mode Val
-
-Voici les fonctionnalités notables offertes par le mode Val de YOLOv8 :
-
-- **Paramètres Automatisés :** Les modèles se souviennent de leurs configurations d'entraînement pour une validation simple.
-- **Support Multi-métrique :** Évaluez votre modèle en fonction d'une gamme de métriques de précision.
-- **CLI et API Python :** Choisissez entre l'interface en ligne de commande ou l'API Python en fonction de vos préférences pour la validation.
-- **Compatibilité des Données :** Fonctionne de manière transparente avec les jeux de données utilisés pendant la phase d'entraînement ainsi qu'avec les jeux personnalisés.
-
-!!! Tip "Conseil"
-
- * Les modèles YOLOv8 se souviennent automatiquement de leurs paramètres d'entraînement, vous pouvez donc facilement valider un modèle à la même taille d'image et sur le jeu de données original avec juste `yolo val model=yolov8n.pt` ou `model('yolov8n.pt').val()`
-
-## Exemples d'utilisation
-
-Validez la précision du modèle YOLOv8n entraîné sur le jeu de données COCO128. Aucun argument n'a besoin d'être passé car le `modèle` conserve ses `données` d'entraînement et arguments comme attributs du modèle. Consultez la section des arguments ci-dessous pour une liste complète des arguments d'exportation.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n.pt') # charger un modèle officiel
- model = YOLO('chemin/vers/meilleur.pt') # charger un modèle personnalisé
-
- # Valider le modèle
- metrics = model.val() # pas besoin d'arguments, jeu de données et paramètres mémorisés
- metrics.box.map # map50-95
- metrics.box.map50 # map50
- metrics.box.map75 # map75
- metrics.box.maps # une liste contenant map50-95 de chaque catégorie
- ```
- === "CLI"
-
- ```bash
- yolo detect val model=yolov8n.pt # val modèle officiel
- yolo detect val model=chemin/vers/meilleur.pt # val modèle personnalisé
- ```
-
-## Arguments
-
-Les paramètres de validation pour les modèles YOLO font référence aux divers hyperparamètres et configurations utilisés pour évaluer la performance du modèle sur un jeu de données de validation. Ces paramètres peuvent affecter la performance, la vitesse et la précision du modèle. Certains paramètres de validation YOLO courants incluent la taille du lot, la fréquence à laquelle la validation est effectuée pendant l'entraînement et les métriques utilisées pour évaluer la performance du modèle. D'autres facteurs pouvant affecter le processus de validation incluent la taille et la composition du jeu de données de validation et la tâche spécifique pour laquelle le modèle est utilisé. Il est important de régler et d'expérimenter soigneusement ces paramètres pour s'assurer que le modèle fonctionne bien sur le jeu de données de validation et pour détecter et prévenir le surajustement.
-
-| Clé | Valeur | Description |
-|---------------|---------|------------------------------------------------------------------------------------------------|
-| `data` | `None` | chemin vers le fichier de données, par exemple coco128.yaml |
-| `imgsz` | `640` | taille des images d'entrée en tant qu'entier |
-| `batch` | `16` | nombre d'images par lot (-1 pour AutoBatch) |
-| `save_json` | `False` | sauvegarder les résultats dans un fichier JSON |
-| `save_hybrid` | `False` | sauvegarder la version hybride des étiquettes (étiquettes + prédictions supplémentaires) |
-| `conf` | `0.001` | seuil de confiance de l'objet pour la détection |
-| `iou` | `0.6` | seuil d'intersection sur union (IoU) pour la NMS |
-| `max_det` | `300` | nombre maximum de détections par image |
-| `half` | `True` | utiliser la précision moitié (FP16) |
-| `device` | `None` | appareil sur lequel exécuter, par exemple cuda device=0/1/2/3 ou device=cpu |
-| `dnn` | `False` | utiliser OpenCV DNN pour l'inférence ONNX |
-| `plots` | `False` | afficher les graphiques lors de la formation |
-| `rect` | `False` | val rectangulaire avec chaque lot regroupé pour un minimum de rembourrage |
-| `split` | `val` | fraction du jeu de données à utiliser pour la validation, par exemple 'val', 'test' ou 'train' |
-|
diff --git a/docs/fr/quickstart.md b/docs/fr/quickstart.md
deleted file mode 100644
index 06286a30b55..00000000000
--- a/docs/fr/quickstart.md
+++ /dev/null
@@ -1,198 +0,0 @@
----
-comments: true
-description: Explorez diverses méthodes pour installer Ultralytics en utilisant pip, conda, git et Docker. Apprenez comment utiliser Ultralytics avec l'interface en ligne de commande ou au sein de vos projets Python.
-keywords: installation d'Ultralytics, pip install Ultralytics, Docker install Ultralytics, interface en ligne de commande Ultralytics, interface Python Ultralytics
----
-
-## Installer Ultralytics
-
-Ultralytics propose diverses méthodes d'installation, y compris pip, conda et Docker. Installez YOLOv8 via le package `ultralytics` avec pip pour obtenir la dernière version stable ou en clonant le [répertoire GitHub d'Ultralytics](https://github.com/ultralytics/ultralytics) pour la version la plus récente. Docker peut être utilisé pour exécuter le package dans un conteneur isolé, évitant l'installation locale.
-
-!!! Example "Installer"
-
- === "Installation avec Pip (recommandé)"
- Installez le package `ultralytics` en utilisant pip, ou mettez à jour une installation existante en exécutant `pip install -U ultralytics`. Visitez l'Index des Packages Python (PyPI) pour plus de détails sur le package `ultralytics` : [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
-
- [![Version PyPI](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Téléchargements](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
-
- ```bash
- # Installer le package ultralytics depuis PyPI
- pip install ultralytics
- ```
-
- Vous pouvez également installer le package `ultralytics` directement depuis le [répertoire GitHub](https://github.com/ultralytics/ultralytics). Cela peut être utile si vous voulez la version de développement la plus récente. Assurez-vous d'avoir l'outil en ligne de commande Git installé sur votre système. La commande `@main` installe la branche `main` et peut être modifiée pour une autre branche, p. ex. `@my-branch`, ou supprimée entièrement pour revenir par défaut à la branche `main`.
-
- ```bash
- # Installer le package ultralytics depuis GitHub
- pip install git+https://github.com/ultralytics/ultralytics.git@main
- ```
-
-
- === "Installation avec Conda"
- Conda est un gestionnaire de packages alternatif à pip qui peut également être utilisé pour l'installation. Visitez Anaconda pour plus de détails à [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Le répertoire feedstock d'Ultralytics pour la mise à jour du package conda est sur [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
-
-
- [![Recette Conda](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Téléchargements Conda](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Version Conda](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Plateformes Conda](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics)
-
- ```bash
- # Installer le package ultralytics en utilisant conda
- conda install -c conda-forge ultralytics
- ```
-
- !!! Note "Note"
-
- Si vous installez dans un environnement CUDA, la meilleure pratique est d'installer `ultralytics`, `pytorch` et `pytorch-cuda` dans la même commande pour permettre au gestionnaire de package conda de résoudre les conflits, ou bien d'installer `pytorch-cuda` en dernier pour lui permettre de remplacer le package `pytorch` spécifique aux CPU si nécessaire.
- ```bash
- # Installer tous les packages ensemble en utilisant conda
- conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
- ```
-
- ### Image Docker Conda
-
- Les images Docker Conda d'Ultralytics sont également disponibles sur [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Ces images sont basées sur [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) et constituent un moyen simple de commencer à utiliser `ultralytics` dans un environnement Conda.
-
- ```bash
- # Définir le nom de l'image comme variable
- t=ultralytics/ultralytics:latest-conda
-
- # Télécharger la dernière image ultralytics de Docker Hub
- sudo docker pull $t
-
- # Exécuter l'image ultralytics dans un conteneur avec support GPU
- sudo docker run -it --ipc=host --gpus all $t # tous les GPUs
- sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # spécifier les GPUs
- ```
-
- === "Clone Git"
- Clonez le répertoire `ultralytics` si vous êtes intéressé par la contribution au développement ou si vous souhaitez expérimenter avec le dernier code source. Après le clonage, naviguez dans le répertoire et installez le package en mode éditable `-e` en utilisant pip.
- ```bash
- # Cloner le répertoire ultralytics
- git clone https://github.com/ultralytics/ultralytics
-
- # Naviguer vers le répertoire cloné
- cd ultralytics
-
- # Installer le package en mode éditable pour le développement
- pip install -e .
- ```
-
-Voir le fichier [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) d'`ultralytics` pour une liste des dépendances. Notez que tous les exemples ci-dessus installent toutes les dépendances requises.
-
-
-
-!!! astuce "Conseil"
-
- Les prérequis de PyTorch varient selon le système d'exploitation et les exigences CUDA, donc il est recommandé d'installer PyTorch en premier en suivant les instructions sur [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
-
-
-
-
-
-## Utiliser Ultralytics avec CLI
-
-L'interface en ligne de commande (CLI) d'Ultralytics permet l'utilisation de commandes simples en une seule ligne sans nécessiter d'environnement Python. La CLI ne requiert pas de personnalisation ou de code Python. Vous pouvez simplement exécuter toutes les tâches depuis le terminal avec la commande `yolo`. Consultez le [Guide CLI](/../usage/cli.md) pour en savoir plus sur l'utilisation de YOLOv8 depuis la ligne de commande.
-
-!!! Example "Exemple"
-
- === "Syntaxe"
-
- Les commandes `yolo` d'Ultralytics utilisent la syntaxe suivante :
- ```bash
- yolo TÂCHE MODE ARGS
-
- Où TÂCHE (facultatif) est l'une de [detect, segment, classify]
- MODE (obligatoire) est l'un de [train, val, predict, export, track]
- ARGS (facultatif) sont n'importe quel nombre de paires personnalisées 'arg=valeur' comme 'imgsz=320' qui remplacent les valeurs par défaut.
- ```
- Voyez tous les ARGS dans le [Guide de Configuration](/../usage/cfg.md) complet ou avec `yolo cfg`
-
- === "Entraînement"
-
- Entraînez un modèle de détection pour 10 epochs avec un learning_rate initial de 0.01
- ```bash
- yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
- ```
-
- === "Prédiction"
-
- Prédisez une vidéo YouTube en utilisant un modèle de segmentation pré-entraîné à une taille d'image de 320 :
- ```bash
- yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
- ```
-
- === "Validation"
-
- Validez un modèle de détection pré-entraîné avec un batch-size de 1 et une taille d'image de 640 :
- ```bash
- yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
- ```
-
- === "Exportation"
-
- Exportez un modèle de classification YOLOv8n au format ONNX à une taille d'image de 224 par 128 (pas de TÂCHE requise)
- ```bash
- yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
- ```
-
- === "Spécial"
-
- Exécutez des commandes spéciales pour voir la version, afficher les paramètres, effectuer des vérifications et plus encore :
- ```bash
- yolo help
- yolo checks
- yolo version
- yolo settings
- yolo copy-cfg
- yolo cfg
- ```
-
-!!! Warning "Avertissement"
-
- Les arguments doivent être passés sous forme de paires `arg=val`, séparés par un signe égal `=` et délimités par des espaces ` ` entre les paires. N'utilisez pas de préfixes d'arguments `--` ou de virgules `,` entre les 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` ❌
-
-[Guide CLI](/../usage/cli.md){ .md-button }
-
-## Utiliser Ultralytics avec Python
-
-L'interface Python de YOLOv8 permet une intégration transparente dans vos projets Python, facilitant le chargement, l'exécution et le traitement de la sortie du modèle. Conçue avec simplicité et facilité d'utilisation à l'esprit, l'interface Python permet aux utilisateurs de mettre en œuvre rapidement la détection d'objets, la segmentation et la classification dans leurs projets. Cela fait de l'interface Python de YOLOv8 un outil inestimable pour quiconque cherche à intégrer ces fonctionnalités dans ses projets Python.
-
-Par exemple, les utilisateurs peuvent charger un modèle, l'entraîner, évaluer ses performances sur un set de validation, et même l'exporter au format ONNX avec seulement quelques lignes de code. Consultez le [Guide Python](/../usage/python.md) pour en savoir plus sur l'utilisation de YOLOv8 au sein de vos projets Python.
-
-!!! Example "Exemple"
-
- ```python
- from ultralytics import YOLO
-
- # Créer un nouveau modèle YOLO à partir de zéro
- model = YOLO('yolov8n.yaml')
-
- # Charger un modèle YOLO pré-entraîné (recommandé pour l'entraînement)
- model = YOLO('yolov8n.pt')
-
- # Entraîner le modèle en utilisant le jeu de données 'coco128.yaml' pour 3 epochs
- résultats = model.train(data='coco128.yaml', epochs=3)
-
- # Évaluer la performance du modèle sur le set de validation
- résultats = model.val()
-
- # Effectuer la détection d'objets sur une image en utilisant le modèle
- résultats = model('https://ultralytics.com/images/bus.jpg')
-
- # Exporter le modèle au format ONNX
- succès = model.export(format='onnx')
- ```
-
-[Guide Python](/../usage/python.md){.md-button .md-button--primary}
diff --git a/docs/fr/tasks/classify.md b/docs/fr/tasks/classify.md
deleted file mode 100644
index cc65044ee97..00000000000
--- a/docs/fr/tasks/classify.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-comments: true
-description: Apprenez-en davantage sur les modèles de classification d'images YOLOv8 Classify. Obtenez des informations détaillées sur la liste des modèles pré-entraînés et comment entraîner, valider, prédire et exporter des modèles.
-keywords: Ultralytics, YOLOv8, Classification d'images, Modèles pré-entraînés, YOLOv8n-cls, Entraînement, Validation, Prédiction, Exportation de modèles
----
-
-# Classification d'images
-
-
-
-La classification d'images est la tâche la plus simple des trois et consiste à classer une image entière dans l'une d'un ensemble de classes prédéfinies.
-
-Le résultat d'un classificateur d'images est une étiquette de classe unique et un score de confiance. La classification d'images est utile lorsque vous avez besoin de savoir seulement à quelle classe appartient une image et que vous n'avez pas besoin de connaître l'emplacement des objets de cette classe ou leur forme exacte.
-
-!!! Tip "Astuce"
-
- Les modèles YOLOv8 Classify utilisent le suffixe `-cls`, par exemple `yolov8n-cls.pt` et sont pré-entraînés sur [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-Les modèles Classify pré-entraînés YOLOv8 sont présentés ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur le dataset [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le dataset [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-Les [modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement depuis la dernière version Ultralytics [release](https://github.com/ultralytics/assets/releases) lors de la première utilisation.
-
-| Modèle | taille (pixels) | acc top1 | acc top5 | Vitesse CPU ONNX (ms) | Vitesse A100 TensorRT (ms) | params (M) | FLOPs (B) à 640 |
-|----------------------------------------------------------------------------------------------|-------------------------|------------------|------------------|----------------------------------|---------------------------------------|--------------------|-------------------------|
-| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.1.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/v8.1.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/v8.1.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/v8.1.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/v8.1.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
-
-- Les valeurs **acc** sont les précisions des modèles sur le jeu de données de validation d'[ImageNet](https://www.image-net.org/).
- Pour reproduire : `yolo val classify data=path/to/ImageNet device=0`
-- Les **vitesses** sont calculées sur les images de validation d'ImageNet à l'aide d'une instance [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
- Pour reproduire : `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
-
-## Entraînement
-
-Entraînez le modèle YOLOv8n-cls sur le dataset MNIST160 pendant 100 époques avec une taille d'image de 64. Pour une liste complète des arguments disponibles, consultez la page [Configuration](/../usage/cfg.md).
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n-cls.yaml') # construire un nouveau modèle à partir du YAML
- model = YOLO('yolov8n-cls.pt') # charger un modèle pré-entraîné (recommandé pour l'entraînement)
- model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construire à partir du YAML et transférer les poids
-
- # Entraîner le modèle
- results = model.train(data='mnist160', epochs=100, imgsz=64)
- ```
-
- === "CLI"
-
- ```bash
- # Construire un nouveau modèle à partir du YAML et commencer l'entraînement à partir de zéro
- yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
-
- # Commencer l'entraînement à partir d'un modèle *.pt pré-entraîné
- yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
-
- # Construire un nouveau modèle à partir du YAML, transférer les poids pré-entraînés et commencer l'entraînement
- yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
- ```
-
-### Format du dataset
-
-Le format du dataset de classification YOLO peut être trouvé en détails dans le [Guide des Datasets](../../../datasets/classify/index.md).
-
-## Validation
-
-Validez la précision du modèle YOLOv8n-cls entraîné sur le dataset MNIST160. Aucun argument n'est nécessaire car le `modèle` conserve ses données d'entraînement et arguments en tant qu'attributs du modèle.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n-cls.pt') # charger un modèle officiel
- model = YOLO('path/to/best.pt') # charger un modèle personnalisé
-
- # Valider le modèle
- metrics = model.val() # aucun argument nécessaire, les données et les paramètres sont mémorisés
- metrics.top1 # précision top 1
- metrics.top5 # précision top 5
- ```
- === "CLI"
-
- ```bash
- yolo classify val model=yolov8n-cls.pt # valider le modèle officiel
- yolo classify val model=path/to/best.pt # valider le modèle personnalisé
- ```
-
-## Prédiction
-
-Utilisez un modèle YOLOv8n-cls entraîné pour exécuter des prédictions sur des images.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n-cls.pt') # charger un modèle officiel
- model = YOLO('path/to/best.pt') # charger un modèle personnalisé
-
- # Prédire avec le modèle
- results = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image
- ```
- === "CLI"
-
- ```bash
- yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # prédiction avec le modèle officiel
- yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # prédiction avec le modèle personnalisé
- ```
-
-Voir les détails complets du mode `predict` sur la page [Prédire](https://docs.ultralytics.com/modes/predict/).
-
-## Exportation
-
-Exportez un modèle YOLOv8n-cls dans un format différent comme ONNX, CoreML, etc.
-
-!!! Example "Exemple"
-
- === "Python"
-
- ```python
- from ultralytics import YOLO
-
- # Charger un modèle
- model = YOLO('yolov8n-cls.pt') # charger un modèle officiel
- model = YOLO('path/to/best.pt') # charger un modèle entraîné personnalisé
-
- # Exporter le modèle
- model.export(format='onnx')
- ```
- === "CLI"
-
- ```bash
- yolo export model=yolov8n-cls.pt format=onnx # exporter le modèle officiel
- yolo export model=path/to/best.pt format=onnx # exporter le modèle entraîné personnalisé
- ```
-
-Les formats d'exportation disponibles pour YOLOv8-cls sont présentés dans le tableau ci-dessous. Vous pouvez prédire ou valider directement sur les modèles exportés, par exemple `yolo predict model=yolov8n-cls.onnx`. Des exemples d'utilisation sont présentés pour votre modèle une fois l'exportation terminée.
-
-| Format | Argument `format` | Modèle | Métadonnées | 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` |
-| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` |
-| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` |
-
-Voir les détails complets de l'`exportation` sur la page [Export](https://docs.ultralytics.com/modes/export/).
diff --git a/docs/fr/tasks/detect.md b/docs/fr/tasks/detect.md
deleted file mode 100644
index 75fa0272102..00000000000
--- a/docs/fr/tasks/detect.md
+++ /dev/null
@@ -1,184 +0,0 @@
----
-comments: true
-description: Documentation officielle pour YOLOv8 par Ultralytics. Apprenez comment entraîner, valider, prédire et exporter des modèles dans différents formats. Incluant des statistiques de performances détaillées.
-keywords: YOLOv8, Ultralytics, détection d'objets, modèles pré-entraînés, entraînement, validation, prédiction, exportation de modèles, COCO, ImageNet, PyTorch, ONNX, CoreML
----
-
-# Détection d'Objets
-
-
-
-La détection d'objets est une tâche qui implique l'identification de l'emplacement et de la classe des objets dans une image ou un flux vidéo.
-
-La sortie d'un détecteur d'objets est un ensemble de boîtes englobantes qui entourent les objets de l'image, accompagnées de libellés de classe et de scores de confiance pour chaque boîte. La détection d'objets est un bon choix lorsque vous avez besoin d'identifier des objets d'intérêt dans une scène, mais que vous n'avez pas besoin de connaître exactement où se trouve l'objet ou sa forme exacte.
-
-
-
-
-
- Regardez : Détection d'Objets avec le Modèle Pré-entraîné Ultralytics YOLOv8.
-
-
-!!! Tip "Conseil"
-
- Les modèles Detect YOLOv8 sont les modèles YOLOv8 par défaut, c.-à-d. `yolov8n.pt` et sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
-
-## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
-
-Les modèles pré-entraînés Detect YOLOv8 sont présentés ici. Les modèles Detect, Segment, et Pose sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le jeu de données [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
-
-[Les modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement à partir de la dernière [version](https://github.com/ultralytics/assets/releases) d'Ultralytics lors de la première utilisation.
-
-| Modèle | Taille (pixels) | mAPval