ultralytics 8.3.88__py3-none-any.whl → 8.3.89__py3-none-any.whl

ultralytics/models/yolo/obb/train.py

@@ -11,14 +11,11 @@ class OBBTrainer(yolo.detect.DetectionTrainer):
     """
     A class extending the DetectionTrainer class for training based on an Oriented Bounding Box (OBB) model.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.obb import OBBTrainer
-
-        args = dict(model="yolo11n-obb.pt", data="dota8.yaml", epochs=3)
-        trainer = OBBTrainer(overrides=args)
-        trainer.train()
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.obb import OBBTrainer
+        >>> args = dict(model="yolo11n-obb.pt", data="dota8.yaml", epochs=3)
+        >>> trainer = OBBTrainer(overrides=args)
+        >>> trainer.train()
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):

ultralytics/models/yolo/obb/val.py

@@ -14,14 +14,11 @@ class OBBValidator(DetectionValidator):
     """
     A class extending the DetectionValidator class for validation based on an Oriented Bounding Box (OBB) model.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.obb import OBBValidator
-
-        args = dict(model="yolo11n-obb.pt", data="dota8.yaml")
-        validator = OBBValidator(args=args)
-        validator(model=args["model"])
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.obb import OBBValidator
+        >>> args = dict(model="yolo11n-obb.pt", data="dota8.yaml")
+        >>> validator = OBBValidator(args=args)
+        >>> validator(model=args["model"])
     """
 
     def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
@@ -51,13 +48,11 @@ class OBBValidator(DetectionValidator):
             (torch.Tensor): The correct prediction matrix with shape (N, 10), which includes 10 IoU (Intersection over
                 Union) levels for each detection, indicating the accuracy of predictions compared to the ground truth.
 
-        Example:
-            ```python
-            detections = torch.rand(100, 7)  # 100 sample detections
-            gt_bboxes = torch.rand(50, 5)  # 50 sample ground truth boxes
-            gt_cls = torch.randint(0, 5, (50,))  # 50 ground truth class labels
-            correct_matrix = OBBValidator._process_batch(detections, gt_bboxes, gt_cls)
-            ```
+        Examples:
+            >>> detections = torch.rand(100, 7)  # 100 sample detections
+            >>> gt_bboxes = torch.rand(50, 5)  # 50 sample ground truth boxes
+            >>> gt_cls = torch.randint(0, 5, (50,))  # 50 ground truth class labels
+            >>> correct_matrix = OBBValidator._process_batch(detections, gt_bboxes, gt_cls)
 
         Note:
             This method relies on `batch_probiou` to calculate IoU between detections and ground truth bounding boxes.

ultralytics/models/yolo/pose/predict.py

@@ -8,15 +8,12 @@ class PosePredictor(DetectionPredictor):
     """
     A class extending the DetectionPredictor class for prediction based on a pose model.
 
-    Example:
-        ```python
-        from ultralytics.utils import ASSETS
-        from ultralytics.models.yolo.pose import PosePredictor
-
-        args = dict(model="yolo11n-pose.pt", source=ASSETS)
-        predictor = PosePredictor(overrides=args)
-        predictor.predict_cli()
-        ```
+    Examples:
+        >>> from ultralytics.utils import ASSETS
+        >>> from ultralytics.models.yolo.pose import PosePredictor
+        >>> args = dict(model="yolo11n-pose.pt", source=ASSETS)
+        >>> predictor = PosePredictor(overrides=args)
+        >>> predictor.predict_cli()
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):

ultralytics/models/yolo/pose/train.py

@@ -12,14 +12,11 @@ class PoseTrainer(yolo.detect.DetectionTrainer):
     """
     A class extending the DetectionTrainer class for training based on a pose model.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.pose import PoseTrainer
-
-        args = dict(model="yolo11n-pose.pt", data="coco8-pose.yaml", epochs=3)
-        trainer = PoseTrainer(overrides=args)
-        trainer.train()
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.pose import PoseTrainer
+        >>> args = dict(model="yolo11n-pose.pt", data="coco8-pose.yaml", epochs=3)
+        >>> trainer = PoseTrainer(overrides=args)
+        >>> trainer.train()
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):

ultralytics/models/yolo/pose/val.py

@@ -16,14 +16,11 @@ class PoseValidator(DetectionValidator):
     """
     A class extending the DetectionValidator class for validation based on a pose model.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.pose import PoseValidator
-
-        args = dict(model="yolo11n-pose.pt", data="coco8-pose.yaml")
-        validator = PoseValidator(args=args)
-        validator()
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.pose import PoseValidator
+        >>> args = dict(model="yolo11n-pose.pt", data="coco8-pose.yaml")
+        >>> validator = PoseValidator(args=args)
+        >>> validator()
     """
 
     def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
@@ -161,15 +158,13 @@ class PoseValidator(DetectionValidator):
             (torch.Tensor): A tensor with shape (N, 10) representing the correct prediction matrix for 10 IoU levels,
                 where N is the number of detections.
 
-        Example:
-            ```python
-            detections = torch.rand(100, 6)  # 100 predictions: (x1, y1, x2, y2, conf, class)
-            gt_bboxes = torch.rand(50, 4)  # 50 ground truth boxes: (x1, y1, x2, y2)
-            gt_cls = torch.randint(0, 2, (50,))  # 50 ground truth class indices
-            pred_kpts = torch.rand(100, 51)  # 100 predicted keypoints
-            gt_kpts = torch.rand(50, 51)  # 50 ground truth keypoints
-            correct_preds = _process_batch(detections, gt_bboxes, gt_cls, pred_kpts, gt_kpts)
-            ```
+        Examples:
+            >>> detections = torch.rand(100, 6)  # 100 predictions: (x1, y1, x2, y2, conf, class)
+            >>> gt_bboxes = torch.rand(50, 4)  # 50 ground truth boxes: (x1, y1, x2, y2)
+            >>> gt_cls = torch.randint(0, 2, (50,))  # 50 ground truth class indices
+            >>> pred_kpts = torch.rand(100, 51)  # 100 predicted keypoints
+            >>> gt_kpts = torch.rand(50, 51)  # 50 ground truth keypoints
+            >>> correct_preds = _process_batch(detections, gt_bboxes, gt_cls, pred_kpts, gt_kpts)
 
         Note:
             `0.53` scale factor used in area computation is referenced from https://github.com/jin-s13/xtcocoapi/blob/master/xtcocotools/cocoeval.py#L384.

ultralytics/models/yolo/segment/predict.py

@@ -9,15 +9,12 @@ class SegmentationPredictor(DetectionPredictor):
     """
     A class extending the DetectionPredictor class for prediction based on a segmentation model.
 
-    Example:
-        ```python
-        from ultralytics.utils import ASSETS
-        from ultralytics.models.yolo.segment import SegmentationPredictor
-
-        args = dict(model="yolo11n-seg.pt", source=ASSETS)
-        predictor = SegmentationPredictor(overrides=args)
-        predictor.predict_cli()
-        ```
+    Examples:
+        >>> from ultralytics.utils import ASSETS
+        >>> from ultralytics.models.yolo.segment import SegmentationPredictor
+        >>> args = dict(model="yolo11n-seg.pt", source=ASSETS)
+        >>> predictor = SegmentationPredictor(overrides=args)
+        >>> predictor.predict_cli()
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):

ultralytics/models/yolo/segment/train.py

@@ -12,14 +12,11 @@ class SegmentationTrainer(yolo.detect.DetectionTrainer):
     """
     A class extending the DetectionTrainer class for training based on a segmentation model.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.segment import SegmentationTrainer
-
-        args = dict(model="yolo11n-seg.pt", data="coco8-seg.yaml", epochs=3)
-        trainer = SegmentationTrainer(overrides=args)
-        trainer.train()
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.segment import SegmentationTrainer
+        >>> args = dict(model="yolo11n-seg.pt", data="coco8-seg.yaml", epochs=3)
+        >>> trainer = SegmentationTrainer(overrides=args)
+        >>> trainer.train()
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):

ultralytics/models/yolo/segment/val.py

@@ -18,14 +18,11 @@ class SegmentationValidator(DetectionValidator):
     """
     A class extending the DetectionValidator class for validation based on a segmentation model.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.segment import SegmentationValidator
-
-        args = dict(model="yolo11n-seg.pt", data="coco8-seg.yaml")
-        validator = SegmentationValidator(args=args)
-        validator()
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.segment import SegmentationValidator
+        >>> args = dict(model="yolo11n-seg.pt", data="coco8-seg.yaml")
+        >>> validator = SegmentationValidator(args=args)
+        >>> validator()
     """
 
     def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
@@ -184,13 +181,11 @@ class SegmentationValidator(DetectionValidator):
             - If `masks` is True, the function computes IoU between predicted and ground truth masks.
             - If `overlap` is True and `masks` is True, overlapping masks are taken into account when computing IoU.
 
-        Example:
-            ```python
-            detections = torch.tensor([[25, 30, 200, 300, 0.8, 1], [50, 60, 180, 290, 0.75, 0]])
-            gt_bboxes = torch.tensor([[24, 29, 199, 299], [55, 65, 185, 295]])
-            gt_cls = torch.tensor([1, 0])
-            correct_preds = validator._process_batch(detections, gt_bboxes, gt_cls)
-            ```
+        Examples:
+            >>> detections = torch.tensor([[25, 30, 200, 300, 0.8, 1], [50, 60, 180, 290, 0.75, 0]])
+            >>> gt_bboxes = torch.tensor([[24, 29, 199, 299], [55, 65, 185, 295]])
+            >>> gt_cls = torch.tensor([1, 0])
+            >>> correct_preds = validator._process_batch(detections, gt_bboxes, gt_cls)
         """
         if masks:
             if overlap:

ultralytics/models/yolo/world/train.py

@@ -25,14 +25,11 @@ class WorldTrainer(yolo.detect.DetectionTrainer):
     """
     A class to fine-tune a world model on a close-set dataset.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.world import WorldModel
-
-        args = dict(model="yolov8s-world.pt", data="coco8.yaml", epochs=3)
-        trainer = WorldTrainer(overrides=args)
-        trainer.train()
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.world import WorldModel
+        >>> args = dict(model="yolov8s-world.pt", data="coco8.yaml", epochs=3)
+        >>> trainer = WorldTrainer(overrides=args)
+        >>> trainer.train()
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):

ultralytics/models/yolo/world/train_world.py

@@ -11,31 +11,27 @@ class WorldTrainerFromScratch(WorldTrainer):
     """
     A class extending the WorldTrainer class for training a world model from scratch on open-set dataset.
 
-    Example:
-        ```python
-        from ultralytics.models.yolo.world.train_world import WorldTrainerFromScratch
-        from ultralytics import YOLOWorld
-
-        data = dict(
-            train=dict(
-                yolo_data=["Objects365.yaml"],
-                grounding_data=[
-                    dict(
-                        img_path="../datasets/flickr30k/images",
-                        json_file="../datasets/flickr30k/final_flickr_separateGT_train.json",
-                    ),
-                    dict(
-                        img_path="../datasets/GQA/images",
-                        json_file="../datasets/GQA/final_mixed_train_no_coco.json",
-                    ),
-                ],
-            ),
-            val=dict(yolo_data=["lvis.yaml"]),
-        )
-
-        model = YOLOWorld("yolov8s-worldv2.yaml")
-        model.train(data=data, trainer=WorldTrainerFromScratch)
-        ```
+    Examples:
+        >>> from ultralytics.models.yolo.world.train_world import WorldTrainerFromScratch
+        >>> from ultralytics import YOLOWorld
+        >>> data = dict(
+        ...     train=dict(
+        ...         yolo_data=["Objects365.yaml"],
+        ...         grounding_data=[
+        ...             dict(
+        ...                 img_path="../datasets/flickr30k/images",
+        ...                 json_file="../datasets/flickr30k/final_flickr_separateGT_train.json",
+        ...             ),
+        ...             dict(
+        ...                 img_path="../datasets/GQA/images",
+        ...                 json_file="../datasets/GQA/final_mixed_train_no_coco.json",
+        ...             ),
+        ...         ],
+        ...     ),
+        ...     val=dict(yolo_data=["lvis.yaml"]),
+        ... )
+        >>> model = YOLOWorld("yolov8s-worldv2.yaml")
+        >>> model.train(data=data, trainer=WorldTrainerFromScratch)
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):

ultralytics/nn/modules/__init__.py

@@ -2,19 +2,16 @@
 """
 Ultralytics modules.
 
-Example:
+Examples:
     Visualize a module with Netron.
-    ```python
-    from ultralytics.nn.modules import *
-    import torch
-    import os
-
-    x = torch.ones(1, 128, 40, 40)
-    m = Conv(128, 128)
-    f = f"{m._get_name()}.onnx"
-    torch.onnx.export(m, x, f)
-    os.system(f"onnxslim {f} {f} && open {f}")  # pip install onnxslim
-    ```
+    >>> from ultralytics.nn.modules import *
+    >>> import torch
+    >>> import os
+    >>> x = torch.ones(1, 128, 40, 40)
+    >>> m = Conv(128, 128)
+    >>> f = f"{m._get_name()}.onnx"
+    >>> torch.onnx.export(m, x, f)
+    >>> os.system(f"onnxslim {f} {f} && open {f}")  # pip install onnxslim
 """
 
 from .block import (

ultralytics/nn/tasks.py

@@ -713,12 +713,10 @@ def temporary_modules(modules=None, attributes=None):
         modules (dict, optional): A dictionary mapping old module paths to new module paths.
         attributes (dict, optional): A dictionary mapping old module attributes to new module attributes.
 
-    Example:
-        ```python
-        with temporary_modules({"old.module": "new.module"}, {"old.module.attribute": "new.module.attribute"}):
-            import old.module  # this will now import new.module
-            from old.module import attribute  # this will now import new.module.attribute
-        ```
+    Examples:
+        >>> with temporary_modules({"old.module": "new.module"}, {"old.module.attribute": "new.module.attribute"}):
+        >>> import old.module  # this will now import new.module
+        >>> from old.module import attribute  # this will now import new.module.attribute
 
     Note:
         The changes are only in effect inside the context manager and are undone once the context manager exits.
@@ -793,12 +791,9 @@ def torch_safe_load(weight, safe_only=False):
         weight (str): The file path of the PyTorch model.
         safe_only (bool): If True, replace unknown classes with SafeClass during loading.
 
-    Example:
-    ```python
-    from ultralytics.nn.tasks import torch_safe_load
-
-    ckpt, file = torch_safe_load("path/to/best.pt", safe_only=True)
-    ```
+    Examples:
+        >>> from ultralytics.nn.tasks import torch_safe_load
+        >>> ckpt, file = torch_safe_load("path/to/best.pt", safe_only=True)
 
     Returns:
         ckpt (dict): The loaded model checkpoint.

ultralytics/utils/__init__.py

@@ -427,14 +427,11 @@ class ThreadingLocked:
     Attributes:
         lock (threading.Lock): A lock object used to manage access to the decorated function.
 
-    Example:
-        ```python
-        from ultralytics.utils import ThreadingLocked
-
-        @ThreadingLocked()
-        def my_function():
-            # Your code here
-        ```
+    Examples:
+        >>> from ultralytics.utils import ThreadingLocked
+        >>> @ThreadingLocked()
+        >>> def my_function():
+        ...    # Your code here
     """
 
     def __init__(self):

ultralytics/utils/checks.py

@@ -60,12 +60,9 @@ def parse_requirements(file_path=ROOT.parent / "requirements.txt", package=""):
     Returns:
         (List[Dict[str, str]]): List of parsed requirements as dictionaries with `name` and `specifier` keys.
 
-    Example:
-        ```python
-        from ultralytics.utils.checks import parse_requirements
-
-        parse_requirements(package="ultralytics")
-        ```
+    Examples:
+        >>> from ultralytics.utils.checks import parse_requirements
+        >>> parse_requirements(package="ultralytics")
     """
     if package:
         requires = [x for x in metadata.distribution(package).requires if "extra == " not in x]
@@ -194,20 +191,18 @@ def check_version(
     Returns:
         (bool): True if requirement is met, False otherwise.
 
-    Example:
-        ```python
-        # Check if current version is exactly 22.04
-        check_version(current="22.04", required="==22.04")
+    Examples:
+        Check if current version is exactly 22.04
+        >>> check_version(current="22.04", required="==22.04")
 
-        # Check if current version is greater than or equal to 22.04
-        check_version(current="22.10", required="22.04")  # assumes '>=' inequality if none passed
+        Check if current version is greater than or equal to 22.04
+        >>> check_version(current="22.10", required="22.04")  # assumes '>=' inequality if none passed
 
-        # Check if current version is less than or equal to 22.04
-        check_version(current="22.04", required="<=22.04")
+        Check if current version is less than or equal to 22.04
+        >>> check_version(current="22.04", required="<=22.04")
 
-        # Check if current version is between 20.04 (inclusive) and 22.04 (exclusive)
-        check_version(current="21.10", required=">20.04,<22.04")
-        ```
+        Check if current version is between 20.04 (inclusive) and 22.04 (exclusive)
+        >>> check_version(current="21.10", required=">20.04,<22.04")
     """
     if not current:  # if current is '' or None
         LOGGER.warning(f"WARNING ⚠️ invalid check_version({current}, {required}) requested, please check values.")
@@ -362,19 +357,17 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
         install (bool): If True, attempt to auto-update packages that don't meet requirements.
         cmds (str): Additional commands to pass to the pip install command when auto-updating.
 
-    Example:
-        ```python
-        from ultralytics.utils.checks import check_requirements
+    Examples:
+        >>> from ultralytics.utils.checks import check_requirements
 
-        # Check a requirements.txt file
-        check_requirements("path/to/requirements.txt")
+        Check a requirements.txt file
+        >>> check_requirements("path/to/requirements.txt")
 
-        # Check a single package
-        check_requirements("ultralytics>=8.0.0")
+        Check a single package
+        >>> check_requirements("ultralytics>=8.0.0")
 
-        # Check multiple packages
-        check_requirements(["numpy", "ultralytics>=8.0.0"])
-        ```
+        Check multiple packages
+        >>> check_requirements(["numpy", "ultralytics>=8.0.0"])
     """
     prefix = colorstr("red", "bold", "requirements:")
     if isinstance(requirements, Path):  # requirements.txt file
@@ -657,14 +650,11 @@ def check_amp(model):
     Args:
         model (nn.Module): A YOLO11 model instance.
 
-    Example:
-        ```python
-        from ultralytics import YOLO
-        from ultralytics.utils.checks import check_amp
-
-        model = YOLO("yolo11n.pt").model.cuda()
-        check_amp(model)
-        ```
+    Examples:
+        >>> from ultralytics import YOLO
+        >>> from ultralytics.utils.checks import check_amp
+        >>> model = YOLO("yolo11n.pt").model.cuda()
+        >>> check_amp(model)
 
     Returns:
         (bool): Returns True if the AMP functionality works correctly with YOLO11 model, else False.

ultralytics/utils/downloads.py

@@ -48,10 +48,8 @@ def is_url(url, check=False):
         (bool): Returns True for a valid URL. If 'check' is True, also returns True if the URL exists online.
             Returns False otherwise.
 
-    Example:
-        ```python
-        valid = is_url("https://www.example.com")
-        ```
+    Examples:
+        >>> valid = is_url("https://www.example.com")
     """
     try:
         url = str(url)
@@ -73,12 +71,9 @@ def delete_dsstore(path, files_to_delete=(".DS_Store", "__MACOSX")):
         path (str, optional): The directory path where the ".DS_store" files should be deleted.
         files_to_delete (tuple): The files to be deleted.
 
-    Example:
-        ```python
-        from ultralytics.utils.downloads import delete_dsstore
-
-        delete_dsstore("path/to/dir")
-        ```
+    Examples:
+        >>> from ultralytics.utils.downloads import delete_dsstore
+        >>> delete_dsstore("path/to/dir")
 
     Note:
         ".DS_store" files are created by the Apple operating system and contain metadata about folders and files. They
@@ -105,12 +100,9 @@ def zip_directory(directory, compress=True, exclude=(".DS_Store", "__MACOSX"), p
     Returns:
         (Path): The path to the resulting zip file.
 
-    Example:
-        ```python
-        from ultralytics.utils.downloads import zip_directory
-
-        file = zip_directory("path/to/dir")
-        ```
+    Examples:
+        >>> from ultralytics.utils.downloads import zip_directory
+        >>> file = zip_directory("path/to/dir")
     """
     from zipfile import ZIP_DEFLATED, ZIP_STORED, ZipFile
 
@@ -151,12 +143,9 @@ def unzip_file(file, path=None, exclude=(".DS_Store", "__MACOSX"), exist_ok=Fals
     Returns:
         (Path): The path to the directory where the zipfile was extracted.
 
-    Example:
-        ```python
-        from ultralytics.utils.downloads import unzip_file
-
-        dir = unzip_file("path/to/file.zip")
-        ```
+    Examples:
+        >>> from ultralytics.utils.downloads import unzip_file
+        >>> directory = unzip_file("path/to/file.zip")
     """
     from zipfile import BadZipFile, ZipFile, is_zipfile
 
@@ -245,13 +234,10 @@ def get_google_drive_file_info(link):
         (str): Direct download URL for the Google Drive file.
         (str): Original filename of the Google Drive file. If filename extraction fails, returns None.
 
-    Example:
-        ```python
-        from ultralytics.utils.downloads import get_google_drive_file_info
-
-        link = "https://drive.google.com/file/d/1cqT-cJgANNrhIHCrEufUYhQ4RqiWG_lJ/view?usp=drive_link"
-        url, filename = get_google_drive_file_info(link)
-        ```
+    Examples:
+        >>> from ultralytics.utils.downloads import get_google_drive_file_info
+        >>> link = "https://drive.google.com/file/d/1cqT-cJgANNrhIHCrEufUYhQ4RqiWG_lJ/view?usp=drive_link"
+        >>> url, filename = get_google_drive_file_info(link)
     """
     file_id = link.split("/d/")[1].split("/view")[0]
     drive_url = f"https://drive.google.com/uc?export=download&id={file_id}"
@@ -305,13 +291,10 @@ def safe_download(
         exist_ok (bool, optional): Whether to overwrite existing contents during unzipping. Defaults to False.
         progress (bool, optional): Whether to display a progress bar during the download. Default: True.
 
-    Example:
-        ```python
-        from ultralytics.utils.downloads import safe_download
-
-        link = "https://ultralytics.com/assets/bus.jpg"
-        path = safe_download(link)
-        ```
+    Examples:
+        >>> from ultralytics.utils.downloads import safe_download
+        >>> link = "https://ultralytics.com/assets/bus.jpg"
+        >>> path = safe_download(link)
     """
     gdrive = url.startswith("https://drive.google.com/")  # check if the URL is a Google Drive link
     if gdrive:
@@ -391,10 +374,8 @@ def get_github_assets(repo="ultralytics/assets", version="latest", retry=False):
     Returns:
         (tuple): A tuple containing the release tag and a list of asset names.
 
-    Example:
-        ```python
-        tag, assets = get_github_assets(repo="ultralytics/assets", version="latest")
-        ```
+    Examples:
+        >>> tag, assets = get_github_assets(repo="ultralytics/assets", version="latest")
     """
     if version != "latest":
         version = f"tags/{version}"  # i.e. tags/v6.2
@@ -423,10 +404,8 @@ def attempt_download_asset(file, repo="ultralytics/assets", release="v8.3.0", **
     Returns:
         (str): The path to the downloaded file.
 
-    Example:
-        ```python
-        file_path = attempt_download_asset("yolo11n.pt", repo="ultralytics/assets", release="latest")
-        ```
+    Examples:
+        >>> file_path = attempt_download_asset("yolo11n.pt", repo="ultralytics/assets", release="latest")
     """
     from ultralytics.utils import SETTINGS  # scoped for circular import
 
@@ -478,10 +457,8 @@ def download(url, dir=Path.cwd(), unzip=True, delete=False, curl=False, threads=
         retry (int, optional): Number of retries in case of download failure. Defaults to 3.
         exist_ok (bool, optional): Whether to overwrite existing contents during unzipping. Defaults to False.
 
-    Example:
-        ```python
-        download("https://ultralytics.com/assets/example.zip", dir="path/to/dir", unzip=True)
-        ```
+    Examples:
+        >>> download("https://ultralytics.com/assets/example.zip", dir="path/to/dir", unzip=True)
     """
     dir = Path(dir)
     dir.mkdir(parents=True, exist_ok=True)  # make directory

ultralytics/utils/instance.py

@@ -200,14 +200,12 @@ class Instances:
         normalized (bool, optional): Whether the bounding box coordinates are normalized. Default is True.
 
     Examples:
-        ```python
-        # Create an Instances object
-        instances = Instances(
-            bboxes=np.array([[10, 10, 30, 30], [20, 20, 40, 40]]),
-            segments=[np.array([[5, 5], [10, 10]]), np.array([[15, 15], [20, 20]])],
-            keypoints=np.array([[[5, 5, 1], [10, 10, 1]], [[15, 15, 1], [20, 20, 1]]]),
-        )
-        ```
+        Create an Instances object
+        >>> instances = Instances(
+        ...     bboxes=np.array([[10, 10, 30, 30], [20, 20, 40, 40]]),
+        ...     segments=[np.array([[5, 5], [10, 10]]), np.array([[15, 15], [20, 20]])],
+        ...     keypoints=np.array([[[5, 5, 1], [10, 10, 1]], [[15, 15, 1], [20, 20, 1]]]),
+        ... )
 
     Note:
         The bounding box format is either 'xywh' or 'xyxy', and is determined by the `bbox_format` argument.