ultralytics 8.3.101__py3-none-any.whl → 8.3.103__py3-none-any.whl

tests/test_exports.py

@@ -1,7 +1,9 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+import io
 import shutil
 import uuid
+from contextlib import redirect_stderr, redirect_stdout
 from itertools import product
 from pathlib import Path
 
@@ -167,12 +169,19 @@ def test_export_tflite_matrix(task, dynamic, int8, half, batch, nms):
 @pytest.mark.skipif(LINUX and ARM64, reason="CoreML not supported on aarch64 Linux")
 @pytest.mark.skipif(checks.IS_PYTHON_3_13, reason="CoreML not supported in Python 3.13")
 def test_export_coreml():
-    """Test YOLO exports to CoreML format, optimized for macOS only."""
-    if MACOS:
-        file = YOLO(MODEL).export(format="coreml", imgsz=32)
-        YOLO(file)(SOURCE, imgsz=32)  # model prediction only supported on macOS for nms=False models
-    else:
+    """Test YOLO exports to CoreML format and check for errors."""
+    # Capture stdout and stderr
+    stdout, stderr = io.StringIO(), io.StringIO()
+    with redirect_stdout(stdout), redirect_stderr(stderr):
         YOLO(MODEL).export(format="coreml", nms=True, imgsz=32)
+        if MACOS:
+            file = YOLO(MODEL).export(format="coreml", imgsz=32)
+            YOLO(file)(SOURCE, imgsz=32)  # model prediction only supported on macOS for nms=False models
+
+    # Check captured output for errors
+    output = stdout.getvalue() + stderr.getvalue()
+    assert "Error" not in output, f"CoreML export produced errors: {output}"
+    assert "You will not be able to run predict()" not in output, "CoreML export has predict() error"
 
 
 @pytest.mark.skipif(not checks.IS_PYTHON_MINIMUM_3_10, reason="TFLite export requires Python>=3.10")

tests/test_solutions.py

@@ -1,7 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-# This is file for Ultralytics Solutions tests: https://docs.ultralytics.com/solutions/,
-# It includes every solution excluding DistanceCalculation and Security Alarm System.
+# Tests Ultralytics Solutions: https://docs.ultralytics.com/solutions/,
+# including every solution excluding DistanceCalculation and Security Alarm System.
 
 import cv2
 import pytest
@@ -11,93 +11,157 @@ from ultralytics import solutions
 from ultralytics.utils import ASSETS_URL
 from ultralytics.utils.downloads import safe_download
 
-DEMO_VIDEO = "solutions_ci_demo.mp4"  # for all the solutions, except workout and parking
+# Pre-defined arguments values
+SHOW = False
+DEMO_VIDEO = "solutions_ci_demo.mp4"  # for all the solutions, except workout, object cropping and parking management
+CROP_VIDEO = "decelera_landscape_min.mov"  # for object cropping solution
 POSE_VIDEO = "solution_ci_pose_demo.mp4"  # only for workouts monitoring solution
 PARKING_VIDEO = "solution_ci_parking_demo.mp4"  # only for parking management solution
 PARKING_AREAS_JSON = "solution_ci_parking_areas.json"  # only for parking management solution
 PARKING_MODEL = "solutions_ci_parking_model.pt"  # only for parking management solution
+MODEL_FILE = "yolo11n.pt"  # model file used for solutions, except parking management and instance segmentation
+REGION = [(20, 400), (1080, 400), (1080, 360), (20, 360)]  # for object counting, speed estimation and queue management
 
+# Test configs for each solution : (name, class, needs_frame_count, video, kwargs)
+SOLUTIONS = [
+    (
+        "ObjectCounter",
+        solutions.ObjectCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "Heatmap",
+        solutions.Heatmap,
+        False,
+        DEMO_VIDEO,
+        {"colormap": cv2.COLORMAP_PARULA, "model": MODEL_FILE, "show": SHOW, "region": None},
+    ),
+    (
+        "HeatmapWithRegion",
+        solutions.Heatmap,
+        False,
+        DEMO_VIDEO,
+        {"colormap": cv2.COLORMAP_PARULA, "region": REGION, "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "SpeedEstimator",
+        solutions.SpeedEstimator,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "QueueManager",
+        solutions.QueueManager,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "LineAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "line", "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "PieAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "pie", "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "BarAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "bar", "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "AreaAnalytics",
+        solutions.Analytics,
+        True,
+        DEMO_VIDEO,
+        {"analytics_type": "area", "model": MODEL_FILE, "show": SHOW},
+    ),
+    ("TrackZone", solutions.TrackZone, False, DEMO_VIDEO, {"region": REGION, "model": MODEL_FILE, "show": SHOW}),
+    (
+        "ObjectCropper",
+        solutions.ObjectCropper,
+        False,
+        CROP_VIDEO,
+        {"crop_dir": str(TMP / "cropped-detections"), "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "ObjectBlurrer",
+        solutions.ObjectBlurrer,
+        False,
+        DEMO_VIDEO,
+        {"blur_ratio": 0.5, "model": MODEL_FILE, "show": SHOW},
+    ),
+    (
+        "InstanceSegmentation",
+        solutions.InstanceSegmentation,
+        False,
+        DEMO_VIDEO,
+        {"model": "yolo11n-seg.pt", "show": SHOW},
+    ),
+    ("VisionEye", solutions.VisionEye, False, DEMO_VIDEO, {"model": MODEL_FILE, "show": SHOW}),
+    (
+        "RegionCounter",
+        solutions.RegionCounter,
+        False,
+        DEMO_VIDEO,
+        {"region": REGION, "model": MODEL_FILE, "show": SHOW},
+    ),
+    ("AIGym", solutions.AIGym, False, POSE_VIDEO, {"kpts": [6, 8, 10], "show": SHOW}),
+    (
+        "ParkingManager",
+        solutions.ParkingManagement,
+        False,
+        PARKING_VIDEO,
+        {"model": str(TMP / PARKING_MODEL), "show": SHOW, "json_file": str(TMP / PARKING_AREAS_JSON)},
+    ),
+    (
+        "StreamlitInference",
+        solutions.Inference,
+        False,
+        None,  # streamlit application don't require video file
+        {},  # streamlit application don't accept arguments
+    ),
+]
 
-@pytest.mark.slow
-def test_major_solutions():
-    """Test the object counting, heatmap, speed estimation, trackzone and queue management solution."""
-    safe_download(url=f"{ASSETS_URL}/{DEMO_VIDEO}", dir=TMP)
-    cap = cv2.VideoCapture(str(TMP / DEMO_VIDEO))
-    assert cap.isOpened(), "Error reading video file"
-    region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360)]
-    counter = solutions.ObjectCounter(region=region_points, model="yolo11n.pt", show=False)  # Test object counter
-    heatmap = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, model="yolo11n.pt", show=False)  # Test heatmaps
-    heatmapcounter = solutions.Heatmap(
-        colormap=cv2.COLORMAP_PARULA, model="yolo11n.pt", show=False, region=region_points
-    )  # Test heatmaps with object counting
-    speed = solutions.SpeedEstimator(region=region_points, model="yolo11n.pt", show=False)  # Test speed estimation
-    queue = solutions.QueueManager(region=region_points, model="yolo11n.pt", show=False)  # Test queue management
-    lineanalytics = solutions.Analytics(analytics_type="line", model="yolo11n.pt", show=False)  # Line analytics
-    pieanalytics = solutions.Analytics(analytics_type="pie", model="yolo11n.pt", show=False)  # Pie analytics
-    baranalytics = solutions.Analytics(analytics_type="bar", model="yolo11n.pt", show=False)  # Bar analytics
-    areaanalytics = solutions.Analytics(analytics_type="area", model="yolo11n.pt", show=False)  # Area analytics
-    trackzone = solutions.TrackZone(region=region_points, model="yolo11n.pt", show=False)  # Track zone monitoring
-    objectcropper = solutions.ObjectCropper(
-        model="yolo11n.pt", show=False, crop_dir=str(TMP / "cropped-detections")
-    )  # Object cropping
-    objectblurrer = solutions.ObjectBlurrer(blur_ratio=0.5, model="yolo11n.pt", show=False)  # Object blurring
-    isegment = solutions.InstanceSegmentation(model="yolo11n-seg.pt", show=False)  # Instance segmentation
-    visioneye = solutions.VisionEye(model="yolo11n.pt", show=False)  # Vision Eye solution
-    regioncounter = solutions.RegionCounter(region=region_points, model="yolo11n.pt", show=False)  # Region counter
-    frame_count = 0  # Required for analytics
-    while cap.isOpened():
-        success, im0 = cap.read()
-        if not success:
-            break
-        frame_count += 1
-        original_im0 = im0.copy()
-        _ = counter(original_im0.copy())
-        _ = heatmap(original_im0.copy())
-        _ = heatmapcounter(original_im0.copy())
-        _ = speed(original_im0.copy())
-        _ = queue(original_im0.copy())
-        _ = lineanalytics(original_im0.copy(), frame_count)
-        _ = pieanalytics(original_im0.copy(), frame_count)
-        _ = baranalytics(original_im0.copy(), frame_count)
-        _ = areaanalytics(original_im0.copy(), frame_count)
-        _ = trackzone(original_im0.copy())
-        _ = objectcropper(original_im0.copy())
-        _ = isegment(original_im0.copy())
-        _ = objectblurrer(original_im0.copy())
-        _ = visioneye(original_im0.copy())
-        _ = regioncounter(original_im0.copy())
-    cap.release()
 
-    # Test workouts monitoring
-    safe_download(url=f"{ASSETS_URL}/{POSE_VIDEO}", dir=TMP)
-    cap = cv2.VideoCapture(str(TMP / POSE_VIDEO))
-    assert cap.isOpened(), "Error reading video file"
-    gym = solutions.AIGym(kpts=[5, 11, 13], show=False)
-    while cap.isOpened():
-        success, im0 = cap.read()
-        if not success:
-            break
-        _ = gym(im0)
-    cap.release()
+def process_video(solution, video_path, needs_frame_count=False):
+    """Process video with solution, feeding frames and optional frame count."""
+    cap = cv2.VideoCapture(video_path)
+    assert cap.isOpened(), f"Error reading video file {video_path}"
 
-    # Test parking management
-    safe_download(url=f"{ASSETS_URL}/{PARKING_VIDEO}", dir=TMP)
-    safe_download(url=f"{ASSETS_URL}/{PARKING_AREAS_JSON}", dir=TMP)
-    safe_download(url=f"{ASSETS_URL}/{PARKING_MODEL}", dir=TMP)
-    cap = cv2.VideoCapture(str(TMP / PARKING_VIDEO))
-    assert cap.isOpened(), "Error reading video file"
-    parkingmanager = solutions.ParkingManagement(
-        json_file=str(TMP / PARKING_AREAS_JSON), model=str(TMP / PARKING_MODEL), show=False
-    )
+    frame_count = 0
     while cap.isOpened():
         success, im0 = cap.read()
         if not success:
             break
-        _ = parkingmanager(im0)
+        frame_count += 1
+        im_copy = im0.copy()
+        args = [im_copy, frame_count] if needs_frame_count else [im_copy]
+        _ = solution(*args)
+
     cap.release()
 
 
 @pytest.mark.slow
-def test_streamlit_predict():
-    """Test streamlit predict live inference solution."""
-    solutions.Inference().inference()
+@pytest.mark.parametrize("name, solution_class, needs_frame_count, video, kwargs", SOLUTIONS)
+def test_solution(name, solution_class, needs_frame_count, video, kwargs):
+    """Test individual Ultralytics solution."""
+    safe_download(url=f"{ASSETS_URL}/{video}", dir=TMP)
+    if name == "ParkingManager":
+        safe_download(url=f"{ASSETS_URL}/{PARKING_AREAS_JSON}", dir=TMP)
+        safe_download(url=f"{ASSETS_URL}/{PARKING_MODEL}", dir=TMP)
+    solution = solution_class(**kwargs)
+    solution.inference() if name == "StreamlitInference" else process_video(
+        solution, str(TMP / video), needs_frame_count
+    )

ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.101"
+__version__ = "8.3.103"
 
 import os
 

ultralytics/cfg/__init__.py

@@ -700,7 +700,7 @@ def handle_yolo_solutions(args: List[str]) -> None:
         solution_name = "count"  # Default for invalid solution
 
     if solution_name == "inference":
-        checks.check_requirements("streamlit>=1.29.0")
+        checks.check_requirements("streamlit>=1.29.0,<1.44.0")
         LOGGER.info("💡 Loading Ultralytics live inference app...")
         subprocess.run(
             [  # Run subprocess with Streamlit custom argument

ultralytics/engine/exporter.py

@@ -115,18 +115,32 @@ def export_formats():
         ["PyTorch", "-", ".pt", True, True, []],
         ["TorchScript", "torchscript", ".torchscript", True, True, ["batch", "optimize", "nms"]],
         ["ONNX", "onnx", ".onnx", True, True, ["batch", "dynamic", "half", "opset", "simplify", "nms"]],
-        ["OpenVINO", "openvino", "_openvino_model", True, False, ["batch", "dynamic", "half", "int8", "nms"]],
-        ["TensorRT", "engine", ".engine", False, True, ["batch", "dynamic", "half", "int8", "simplify", "nms"]],
+        [
+            "OpenVINO",
+            "openvino",
+            "_openvino_model",
+            True,
+            False,
+            ["batch", "dynamic", "half", "int8", "nms", "fraction"],
+        ],
+        [
+            "TensorRT",
+            "engine",
+            ".engine",
+            False,
+            True,
+            ["batch", "dynamic", "half", "int8", "simplify", "nms", "fraction"],
+        ],
         ["CoreML", "coreml", ".mlpackage", True, False, ["batch", "half", "int8", "nms"]],
         ["TensorFlow SavedModel", "saved_model", "_saved_model", True, True, ["batch", "int8", "keras", "nms"]],
         ["TensorFlow GraphDef", "pb", ".pb", True, True, ["batch"]],
-        ["TensorFlow Lite", "tflite", ".tflite", True, False, ["batch", "half", "int8", "nms"]],
+        ["TensorFlow Lite", "tflite", ".tflite", True, False, ["batch", "half", "int8", "nms", "fraction"]],
         ["TensorFlow Edge TPU", "edgetpu", "_edgetpu.tflite", True, False, []],
         ["TensorFlow.js", "tfjs", "_web_model", True, False, ["batch", "half", "int8", "nms"]],
         ["PaddlePaddle", "paddle", "_paddle_model", True, True, ["batch"]],
         ["MNN", "mnn", ".mnn", True, True, ["batch", "half", "int8"]],
         ["NCNN", "ncnn", "_ncnn_model", True, True, ["batch", "half"]],
-        ["IMX", "imx", "_imx_model", True, True, ["int8"]],
+        ["IMX", "imx", "_imx_model", True, True, ["int8", "fraction"]],
         ["RKNN", "rknn", "_rknn_model", False, False, ["batch", "name"]],
     ]
     return dict(zip(["Format", "Argument", "Suffix", "CPU", "GPU", "Arguments"], zip(*x)))
@@ -144,7 +158,7 @@ def validate_args(format, passed_args, valid_args):
     Raises:
         AssertionError: If an unsupported argument is used, or if the format lacks supported argument listings.
     """
-    export_args = ["half", "int8", "dynamic", "keras", "nms", "batch"]
+    export_args = ["half", "int8", "dynamic", "keras", "nms", "batch", "fraction"]
 
     assert valid_args is not None, f"ERROR ❌️ valid arguments for '{format}' not listed."
     custom = {"batch": 1, "data": None, "device": None}  # exporter defaults
@@ -493,6 +507,7 @@ class Exporter:
         dataset = YOLODataset(
             data[self.args.split or "val"],
             data=data,
+            fraction=self.args.fraction,
             task=self.model.task,
             imgsz=self.imgsz[0],
             augment=False,
@@ -803,7 +818,7 @@ class Exporter:
             ts,
             inputs=[ct.ImageType("image", shape=self.im.shape, scale=scale, bias=bias)],  # expects ct.TensorType
             classifier_config=classifier_config,
-            minimum_deployment_target=ct.target.iOS16,
+            minimum_deployment_target=ct.target.iOS15,  # warning: >=16 causes pipeline errors
             convert_to="neuralnetwork" if mlmodel else "mlprogram",
         )
         bits, mode = (8, "kmeans") if self.args.int8 else (16, "linear") if self.args.half else (32, None)
@@ -1449,7 +1464,7 @@ class Exporter:
 
         # 3. Create NMS protobuf
         nms_spec = ct.proto.Model_pb2.Model()
-        nms_spec.specificationVersion = 5
+        nms_spec.specificationVersion = 9
         for i in range(2):
             decoder_output = model._spec.description.output[i].SerializeToString()
             nms_spec.description.input.add()
@@ -1502,7 +1517,7 @@ class Exporter:
         pipeline.spec.description.output[1].ParseFromString(nms_model._spec.description.output[1].SerializeToString())
 
         # Update metadata
-        pipeline.spec.specificationVersion = 5
+        pipeline.spec.specificationVersion = 9
         pipeline.spec.description.metadata.userDefined.update(
             {"IoU threshold": str(nms.iouThreshold), "Confidence threshold": str(nms.confidenceThreshold)}
         )

ultralytics/engine/tuner.py

@@ -93,8 +93,9 @@ class Tuner:
             "copy_paste": (0.0, 1.0),  # segment copy-paste (probability)
         }
         self.args = get_cfg(overrides=args)
+        self.args.exist_ok = self.args.resume  # resume w/ same tune_dir
         self.tune_dir = get_save_dir(self.args, name=self.args.name or "tune")
-        self.args.name = None  # reset to not affect training directory
+        self.args.name, self.args.exist_ok, self.args.resume = (None, False, False)  # reset to not affect training
         self.tune_csv = self.tune_dir / "tune_results.csv"
         self.callbacks = _callbacks or callbacks.get_default_callbacks()
         self.prefix = colorstr("Tuner: ")
@@ -173,7 +174,12 @@ class Tuner:
         t0 = time.time()
         best_save_dir, best_metrics = None, None
         (self.tune_dir / "weights").mkdir(parents=True, exist_ok=True)
-        for i in range(iterations):
+        start = 0
+        if self.tune_csv.exists():
+            x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=",", skiprows=1)
+            start = x.shape[0]
+            LOGGER.info(f"{self.prefix}Resuming tuning run {self.tune_dir} from iteration {start + 1}...")
+        for i in range(start, iterations):
             # Mutate hyperparameters
             mutated_hyp = self._mutate()
             LOGGER.info(f"{self.prefix}Starting iteration {i + 1}/{iterations} with hyperparameters: {mutated_hyp}")

ultralytics/hub/__init__.py

@@ -96,7 +96,21 @@ def export_fmts_hub():
 
 
 def export_model(model_id: str = "", format: str = "torchscript"):
-    """Export a model to the specified format."""
+    """
+    Export a model to a specified format for deployment via the Ultralytics HUB API.
+
+    Args:
+        model_id (str): The ID of the model to export. An empty string will use the default model.
+        format (str): The format to export the model to. Must be one of the supported formats returned by
+            export_fmts_hub().
+
+    Raises:
+        AssertionError: If the specified format is not supported or if the export request fails.
+
+    Examples:
+        >>> from ultralytics import hub
+        >>> hub.export_model(model_id="your_model_id", format="torchscript")
+    """
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
     r = requests.post(
         f"{HUB_API_ROOT}/v1/models/{model_id}/export", json={"format": format}, headers={"x-api-key": Auth().api_key}
@@ -106,7 +120,20 @@ def export_model(model_id: str = "", format: str = "torchscript"):
 
 
 def get_export(model_id: str = "", format: str = "torchscript"):
-    """Get an exported model dictionary with download URL."""
+    """
+    Retrieve an exported model in the specified format from Ultralytics HUB using the model ID.
+
+    Args:
+        model_id (str): The ID of the model to retrieve from Ultralytics HUB.
+        format (str): The export format to retrieve. Must be one of the supported formats returned by export_fmts_hub().
+
+    Raises:
+        AssertionError: If the specified format is not supported or if the API request fails.
+
+    Examples:
+        >>> from ultralytics import hub
+        >>> hub.get_export(model_id="your_model_id", format="torchscript")
+    """
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
     r = requests.post(
         f"{HUB_API_ROOT}/get-export",

ultralytics/hub/google/__init__.py

@@ -83,7 +83,24 @@ class GCPRegions:
 
     @staticmethod
     def _ping_region(region: str, attempts: int = 1) -> Tuple[str, float, float, float, float]:
-        """Pings a specified GCP region and returns latency statistics: mean, min, max, and standard deviation."""
+        """
+        Ping a specified GCP region and measure network latency statistics.
+
+        Args:
+                region (str): The GCP region identifier to ping (e.g., 'us-central1').
+                attempts (int): Number of ping attempts to make for calculating statistics.
+
+        Returns:
+                region (str): The GCP region identifier that was pinged.
+                mean_latency (float): Mean latency in milliseconds, or infinity if all pings failed.
+                min_latency (float): Minimum latency in milliseconds, or infinity if all pings failed.
+                max_latency (float): Maximum latency in milliseconds, or infinity if all pings failed.
+                std_dev (float): Standard deviation of latencies in milliseconds, or infinity if all pings failed.
+
+        Examples:
+                >>> region, mean, min_lat, max_lat, std = GCPRegions._ping_region("us-central1", attempts=3)
+                >>> print(f"Region {region} has mean latency: {mean:.2f}ms")
+        """
         url = f"https://{region}-docker.pkg.dev"
         latencies = []
         for _ in range(attempts):

ultralytics/models/fastsam/predict.py

@@ -33,7 +33,18 @@ class FastSAMPredictor(SegmentationPredictor):
     """
 
     def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
-        """Initialize the FastSAMPredictor with configuration and callbacks."""
+        """
+        Initialize the FastSAMPredictor with configuration and callbacks.
+
+        This initializes a predictor specialized for Fast SAM (Segment Anything Model) segmentation tasks. The predictor
+        extends SegmentationPredictor with custom post-processing for mask prediction and non-maximum suppression
+        optimized for single-class segmentation.
+
+        Args:
+            cfg (dict): Configuration for the predictor. Defaults to Ultralytics DEFAULT_CFG.
+            overrides (dict, optional): Configuration overrides.
+            _callbacks (list, optional): List of callback functions.
+        """
         super().__init__(cfg, overrides, _callbacks)
         self.prompts = {}
 

ultralytics/models/nas/predict.py

@@ -33,8 +33,26 @@ class NASPredictor(DetectionPredictor):
     """
 
     def postprocess(self, preds_in, img, orig_imgs):
-        """Postprocess predictions and returns a list of Results objects."""
-        # Convert boxes from xyxy to xywh format and concatenate with class scores
+        """
+        Postprocess NAS model predictions to generate final detection results.
+
+        This method takes raw predictions from a YOLO NAS model, converts bounding box formats, and applies
+        post-processing operations to generate the final detection results compatible with Ultralytics
+        result visualization and analysis tools.
+
+        Args:
+            preds_in (list): Raw predictions from the NAS model, typically containing bounding boxes and class scores.
+            img (torch.Tensor): Input image tensor that was fed to the model, with shape (B, C, H, W).
+            orig_imgs (list | torch.Tensor | np.ndarray): Original images before preprocessing, used for scaling
+                coordinates back to original dimensions.
+
+        Returns:
+            (list): List of Results objects containing the processed predictions for each image in the batch.
+
+        Examples:
+            >>> predictor = NAS("yolo_nas_s").predictor
+            >>> results = predictor.postprocess(raw_preds, img, orig_imgs)
+        """
         boxes = ops.xyxy2xywh(preds_in[0][0])
-        preds = torch.cat((boxes, preds_in[0][1]), -1).permute(0, 2, 1)
+        preds = torch.cat((boxes, preds_in[0][1]), -1).permute(0, 2, 1)  # concatenate with class scores
         return super().postprocess(preds, img, orig_imgs)

ultralytics/models/rtdetr/val.py

@@ -19,11 +19,35 @@ class RTDETRDataset(YOLODataset):
     """
 
     def __init__(self, *args, data=None, **kwargs):
-        """Initialize the RTDETRDataset class by inheriting from the YOLODataset class."""
+        """
+        Initialize the RTDETRDataset class by inheriting from the YOLODataset class.
+
+        This constructor sets up a dataset specifically optimized for the RT-DETR (Real-Time DEtection and TRacking)
+        model, building upon the base YOLODataset functionality.
+
+        Args:
+            *args (Any): Variable length argument list passed to the parent YOLODataset class.
+            data (Dict | None): Dictionary containing dataset information. If None, default values will be used.
+            **kwargs (Any): Additional keyword arguments passed to the parent YOLODataset class.
+        """
         super().__init__(*args, data=data, **kwargs)
 
     def load_image(self, i, rect_mode=False):
-        """Loads 1 image from dataset index 'i', returns (im, resized hw)."""
+        """
+        Load one image from dataset index 'i'.
+
+        Args:
+            i (int): Index of the image to load.
+            rect_mode (bool, optional): Whether to use rectangular mode for batch inference.
+
+        Returns:
+            im (numpy.ndarray): The loaded image.
+            resized_hw (tuple): Height and width of the resized image with shape (2,).
+
+        Examples:
+            >>> dataset = RTDETRDataset(...)
+            >>> image, hw = dataset.load_image(0)
+        """
         return super().load_image(i=i, rect_mode=rect_mode)
 
     def build_transforms(self, hyp=None):

ultralytics/models/sam/amg.py

@@ -22,7 +22,28 @@ def is_box_near_crop_edge(
 
 
 def batch_iterator(batch_size: int, *args) -> Generator[List[Any], None, None]:
-    """Yields batches of data from input arguments with specified batch size for efficient processing."""
+    """
+    Yield batches of data from input arguments with specified batch size for efficient processing.
+
+    This function takes a batch size and any number of iterables, then yields batches of elements from those
+    iterables. All input iterables must have the same length.
+
+    Args:
+        batch_size (int): Size of each batch to yield.
+        *args (Any): Variable length input iterables to batch. All iterables must have the same length.
+
+    Yields:
+        (List[Any]): A list of batched elements from each input iterable.
+
+    Examples:
+        >>> data = [1, 2, 3, 4, 5]
+        >>> labels = ["a", "b", "c", "d", "e"]
+        >>> for batch in batch_iterator(2, data, labels):
+        ...     print(batch)
+        [[1, 2], ['a', 'b']]
+        [[3, 4], ['c', 'd']]
+        [[5], ['e']]
+    """
     assert args and all(len(a) == len(args[0]) for a in args), "Batched iteration must have same-size inputs."
     n_batches = len(args[0]) // batch_size + int(len(args[0]) % batch_size != 0)
     for b in range(n_batches):