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

tests/test_solutions.py

@@ -1,15 +1,20 @@
 # 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.
 
 import cv2
 import pytest
 
 from tests import TMP
-from ultralytics import YOLO, solutions
-from ultralytics.utils import ASSETS_URL, WEIGHTS_DIR
+from ultralytics import solutions
+from ultralytics.utils import ASSETS_URL
 from ultralytics.utils.downloads import safe_download
 
-DEMO_VIDEO = "solutions_ci_demo.mp4"
-POSE_VIDEO = "solution_ci_pose_demo.mp4"
+DEMO_VIDEO = "solutions_ci_demo.mp4"  # for all the solutions, except workout and parking
+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
 
 
 @pytest.mark.slow
@@ -21,16 +26,23 @@ def test_major_solutions():
     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
-    heatmap_count = solutions.Heatmap(
+    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 queue manager
     queue = solutions.QueueManager(region=region_points, model="yolo11n.pt", show=False)  # Test speed estimation
-    line_analytics = solutions.Analytics(analytics_type="line", model="yolo11n.pt", show=False)  # line analytics
-    pie_analytics = solutions.Analytics(analytics_type="pie", model="yolo11n.pt", show=False)  # line analytics
-    bar_analytics = solutions.Analytics(analytics_type="bar", model="yolo11n.pt", show=False)  # line analytics
-    area_analytics = solutions.Analytics(analytics_type="area", model="yolo11n.pt", show=False)  # line analytics
-    trackzone = solutions.TrackZone(region=region_points, model="yolo11n.pt", show=False)  # Test trackzone
+    lineanalytics = solutions.Analytics(analytics_type="line", model="yolo11n.pt", show=False)  # line analytics
+    pieanalytics = solutions.Analytics(analytics_type="pie", model="yolo11n.pt", show=False)  # line analytics
+    baranalytics = solutions.Analytics(analytics_type="bar", model="yolo11n.pt", show=False)  # line analytics
+    areaanalytics = solutions.Analytics(analytics_type="area", model="yolo11n.pt", show=False)  # line analytics
+    trackzone = solutions.TrackZone(region=region_points, model="yolo11n.pt", show=False)  # trackzone
+    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)  # Visioneye
+    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()
@@ -38,16 +50,21 @@ def test_major_solutions():
             break
         frame_count += 1
         original_im0 = im0.copy()
-        _ = counter.count(original_im0.copy())
-        _ = heatmap.generate_heatmap(original_im0.copy())
-        _ = heatmap_count.generate_heatmap(original_im0.copy())
-        _ = speed.estimate_speed(original_im0.copy())
-        _ = queue.process_queue(original_im0.copy())
-        _ = line_analytics.process_data(original_im0.copy(), frame_count)
-        _ = pie_analytics.process_data(original_im0.copy(), frame_count)
-        _ = bar_analytics.process_data(original_im0.copy(), frame_count)
-        _ = area_analytics.process_data(original_im0.copy(), frame_count)
-        _ = trackzone.trackzone(original_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
@@ -59,33 +76,24 @@ def test_major_solutions():
         success, im0 = cap.read()
         if not success:
             break
-        _ = gym.monitor(im0)
+        _ = gym(im0)
     cap.release()
 
-
-@pytest.mark.slow
-def test_instance_segmentation():
-    """Test the instance segmentation solution."""
-    from ultralytics.utils.plotting import Annotator, colors
-
-    model = YOLO(WEIGHTS_DIR / "yolo11n-seg.pt")
-    names = model.names
-    cap = cv2.VideoCapture(TMP / DEMO_VIDEO)
+    # 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
+    )
     while cap.isOpened():
         success, im0 = cap.read()
         if not success:
             break
-        results = model.predict(im0)
-        annotator = Annotator(im0, line_width=2)
-        if results[0].masks is not None:
-            clss = results[0].boxes.cls.cpu().tolist()
-            masks = results[0].masks.xy
-            for mask, cls in zip(masks, clss):
-                color = colors(int(cls), True)
-                annotator.seg_bbox(mask=mask, mask_color=color, label=names[int(cls)])
+        _ = parkingmanager(im0)
     cap.release()
-    cv2.destroyAllWindows()
 
 
 @pytest.mark.slow

ultralytics/__init__.py

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

ultralytics/cfg/__init__.py

@@ -5,7 +5,7 @@ import subprocess
 import sys
 from pathlib import Path
 from types import SimpleNamespace
-from typing import Dict, List, Union
+from typing import Any, Dict, List, Union
 
 import cv2
 
@@ -35,14 +35,18 @@ from ultralytics.utils import (
 
 # Define valid solutions
 SOLUTION_MAP = {
-    "count": ("ObjectCounter", "count"),
-    "heatmap": ("Heatmap", "generate_heatmap"),
-    "queue": ("QueueManager", "process_queue"),
-    "speed": ("SpeedEstimator", "estimate_speed"),
-    "workout": ("AIGym", "monitor"),
-    "analytics": ("Analytics", "process_data"),
-    "trackzone": ("TrackZone", "trackzone"),
-    "inference": ("Inference", "inference"),
+    "count": "ObjectCounter",
+    "crop": "ObjectCropper",
+    "blur": "ObjectBlurrer",
+    "workout": "AIGym",
+    "heatmap": "Heatmap",
+    "isegment": "InstanceSegmentation",
+    "visioneye": "VisionEye",
+    "speed": "SpeedEstimator",
+    "queue": "QueueManager",
+    "analytics": "Analytics",
+    "inference": "Inference",
+    "trackzone": "TrackZone",
     "help": None,
 }
 
@@ -238,7 +242,7 @@ CFG_BOOL_KEYS = frozenset(
 )
 
 
-def cfg2dict(cfg):
+def cfg2dict(cfg: Union[str, Path, Dict, SimpleNamespace]) -> Dict:
     """
     Converts a configuration object to a dictionary.
 
@@ -273,7 +277,7 @@ def cfg2dict(cfg):
     return cfg
 
 
-def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, overrides: Dict = None):
+def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, overrides: Dict = None) -> SimpleNamespace:
     """
     Load and merge configuration data from a file or dictionary, with optional overrides.
 
@@ -321,7 +325,7 @@ def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, ove
     return IterableSimpleNamespace(**cfg)
 
 
-def check_cfg(cfg, hard=True):
+def check_cfg(cfg: Dict, hard: bool = True) -> None:
     """
     Checks configuration argument types and values for the Ultralytics library.
 
@@ -383,7 +387,7 @@ def check_cfg(cfg, hard=True):
                 cfg[k] = bool(v)
 
 
-def get_save_dir(args, name=None):
+def get_save_dir(args: SimpleNamespace, name: str = None) -> Path:
     """
     Returns the directory path for saving outputs, derived from arguments or default settings.
 
@@ -415,7 +419,7 @@ def get_save_dir(args, name=None):
     return Path(save_dir)
 
 
-def _handle_deprecation(custom):
+def _handle_deprecation(custom: Dict) -> Dict:
     """
     Handles deprecated configuration keys by mapping them to current equivalents with deprecation warnings.
 
@@ -453,7 +457,7 @@ def _handle_deprecation(custom):
     return custom
 
 
-def check_dict_alignment(base: Dict, custom: Dict, e=None):
+def check_dict_alignment(base: Dict, custom: Dict, e: Exception = None) -> None:
     """
     Checks alignment between custom and base configuration dictionaries, handling deprecated keys and providing error
     messages for mismatched keys.
@@ -507,7 +511,7 @@ def merge_equals_args(args: List[str]) -> List[str]:
         args (List[str]): A list of strings where each element represents an argument or fragment.
 
     Returns:
-        List[str]: A list of strings where the arguments around isolated '=' are merged and fragments with brackets are joined.
+        (List[str]): A list of strings where the arguments around isolated '=' are merged and fragments with brackets are joined.
 
     Examples:
         >>> args = ["arg1", "=", "value", "arg2=", "value2", "arg3", "=value3", "imgsz=[3,", "640,", "640]"]
@@ -634,9 +638,6 @@ def handle_yolo_solutions(args: List[str]) -> None:
             solutions: https://docs.ultralytics.com/solutions/, It can include solution name, source,
             and other configuration parameters.
 
-    Returns:
-        None: The function processes video frames and saves the output but doesn't return any value.
-
     Examples:
         Run people counting solution with default settings:
         >>> handle_yolo_solutions(["count"])
@@ -656,14 +657,17 @@ def handle_yolo_solutions(args: List[str]) -> None:
         - For 'analytics' solution, frame numbers are tracked for generating analytical graphs
         - Video processing can be interrupted by pressing 'q'
         - Processes video frames sequentially and saves output in .avi format
-        - If no source is specified, downloads and uses a default sample video\
+        - If no source is specified, downloads and uses a default sample video
         - The inference solution will be launched using the 'streamlit run' command.
         - The Streamlit app file is located in the Ultralytics package directory.
     """
-    from ultralytics import solutions
-    from ultralytics.utils.files import increment_path
-
-    full_args_dict = {**DEFAULT_SOL_DICT, **DEFAULT_CFG_DICT}  # arguments dictionary
+    full_args_dict = {
+        **DEFAULT_SOL_DICT,
+        **DEFAULT_CFG_DICT,
+        "blur_ratio": 0.5,
+        "vision_point": (20, 20),
+        "crop_dir": "cropped-detections",
+    }  # arguments dictionary
     overrides = {}
 
     # check dictionary alignment
@@ -680,21 +684,19 @@ def handle_yolo_solutions(args: List[str]) -> None:
     check_dict_alignment(full_args_dict, overrides)  # dict alignment
 
     # Get solution name
-    if args and args[0] in SOLUTION_MAP:
-        if args[0] != "help":
-            s_n = args.pop(0)  # Extract the solution name directly
-        else:
-            LOGGER.info(SOLUTIONS_HELP_MSG)
+    if args[0] == "help":
+        LOGGER.info(SOLUTIONS_HELP_MSG)
+        return  # Early return for 'help' case
+    elif args[0] in SOLUTION_MAP:
+        solution_name = args.pop(0)  # Extract the solution name directly
     else:
         LOGGER.warning(
-            f"⚠️ No valid solution provided. Using default 'count'. Available: {', '.join(SOLUTION_MAP.keys())}"
+            f"❌ '{args[0]}' is not a valid solution. 💡 Defaulting to 'count'.\n"
+            f"🚀 Available solutions: {', '.join(list(SOLUTION_MAP.keys())[:-1])}\n"
         )
-        s_n = "count"  # Default solution if none provided
-
-    if args and args[0] == "help":  # Add check for return if user call `yolo solutions help`
-        return
+        solution_name = "count"  # Default for invalid solution
 
-    if s_n == "inference":
+    if solution_name == "inference":
         checks.check_requirements("streamlit>=1.29.0")
         LOGGER.info("💡 Loading Ultralytics live inference app...")
         subprocess.run(
@@ -708,22 +710,21 @@ def handle_yolo_solutions(args: List[str]) -> None:
             ]
         )
     else:
-        cls, method = SOLUTION_MAP[s_n]  # solution class name, method name and default source
-        solution = getattr(solutions, cls)(IS_CLI=True, **overrides)  # get solution class i.e ObjectCounter
-        process = getattr(
-            solution, method
-        )  # get specific function of class for processing i.e, count from ObjectCounter
-
-        cap = cv2.VideoCapture(solution.CFG["source"])  # read the video file
+        from ultralytics import solutions
 
-        # extract width, height and fps of the video file, create save directory and initialize video writer
+        solution = getattr(solutions, SOLUTION_MAP[solution_name])(is_cli=True, **overrides)  # class i.e ObjectCounter
 
-        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
-        if s_n == "analytics":  # analytical graphs follow fixed shape for output i.e w=1920, h=1080
-            w, h = 1920, 1080
-        save_dir = increment_path(Path("runs") / "solutions" / "exp", exist_ok=False)
-        save_dir.mkdir(parents=True, exist_ok=True)  # create the output directory
-        vw = cv2.VideoWriter(str(save_dir / "solution.avi"), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
+        cap = cv2.VideoCapture(solution.CFG["source"])  # read the video file
+        if solution_name != "crop":
+            # extract width, height and fps of the video file, create save directory and initialize video writer
+            w, h, fps = (
+                int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS)
+            )
+            if solution_name == "analytics":  # analytical graphs follow fixed shape for output i.e w=1920, h=1080
+                w, h = 1280, 720
+            save_dir = get_save_dir(SimpleNamespace(project="runs/solutions", name="exp", exist_ok=False))
+            save_dir.mkdir(parents=True)  # create the output directory i.e. runs/solutions/exp
+            vw = cv2.VideoWriter(str(save_dir / f"{solution_name}.avi"), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
 
         try:  # Process video frames
             f_n = 0  # frame number, required for analytical graphs
@@ -731,15 +732,17 @@ def handle_yolo_solutions(args: List[str]) -> None:
                 success, frame = cap.read()
                 if not success:
                     break
-                frame = process(frame, f_n := f_n + 1) if s_n == "analytics" else process(frame)
-                vw.write(frame)
+                results = solution(frame, f_n := f_n + 1) if solution_name == "analytics" else solution(frame)
+                LOGGER.info(f"🚀 Results: {results}")
+                if solution_name != "crop":
+                    vw.write(results.plot_im)
                 if cv2.waitKey(1) & 0xFF == ord("q"):
                     break
         finally:
             cap.release()
 
 
-def parse_key_value_pair(pair: str = "key=value"):
+def parse_key_value_pair(pair: str = "key=value") -> tuple:
     """
     Parses a key-value pair string into separate key and value components.
 
@@ -773,7 +776,7 @@ def parse_key_value_pair(pair: str = "key=value"):
     return k, smart_value(v)
 
 
-def smart_value(v):
+def smart_value(v: str) -> Any:
     """
     Converts a string representation of a value to its appropriate Python type.
 
@@ -818,7 +821,7 @@ def smart_value(v):
             return v
 
 
-def entrypoint(debug=""):
+def entrypoint(debug: str = "") -> None:
     """
     Ultralytics entrypoint function for parsing and executing command-line arguments.
 
@@ -990,7 +993,7 @@ def entrypoint(debug=""):
 
 
 # Special modes --------------------------------------------------------------------------------------------------------
-def copy_default_cfg():
+def copy_default_cfg() -> None:
     """
     Copies the default configuration file and creates a new one with '_copy' appended to its name.
 

ultralytics/cfg/models/11/yolo11-cls-resnet18.yaml

@@ -5,7 +5,7 @@
 # Task docs: https://docs.ultralytics.com/tasks/classify
 
 # Parameters
-nc: 10 # number of classes
+nc: 1000 # number of classes
 
 # ResNet18 backbone
 backbone:

ultralytics/cfg/models/11/yolo11-cls.yaml

@@ -5,14 +5,14 @@
 # Task docs: https://docs.ultralytics.com/tasks/classify
 
 # Parameters
-nc: 80 # number of classes
+nc: 1000 # number of classes
 scales: # model compound scaling constants, i.e. 'model=yolo11n-cls.yaml' will call yolo11-cls.yaml with scale 'n'
   # [depth, width, max_channels]
-  n: [0.50, 0.25, 1024] # summary: 151 layers, 1633584 parameters, 1633584 gradients, 3.3 GFLOPs
-  s: [0.50, 0.50, 1024] # summary: 151 layers, 5545488 parameters, 5545488 gradients, 12.2 GFLOPs
-  m: [0.50, 1.00, 512] # summary: 187 layers, 10455696 parameters, 10455696 gradients, 39.7 GFLOPs
-  l: [1.00, 1.00, 512] # summary: 309 layers, 12937104 parameters, 12937104 gradients, 49.9 GFLOPs
-  x: [1.00, 1.50, 512] # summary: 309 layers, 28458544 parameters, 28458544 gradients, 111.1 GFLOPs
+  n: [0.50, 0.25, 1024] # summary: 151 layers, 1633584 parameters, 1633584 gradients, 0.5 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 151 layers, 5545488 parameters, 5545488 gradients, 1.6 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 187 layers, 10455696 parameters, 10455696 gradients, 5.0 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 309 layers, 12937104 parameters, 12937104 gradients, 6.2 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 309 layers, 28458544 parameters, 28458544 gradients, 13.7 GFLOPs
 
 # YOLO11n backbone
 backbone:

ultralytics/data/augment.py

@@ -1193,8 +1193,8 @@ class RandomPerspective:
         Args:
             labels (Dict): A dictionary containing image data and annotations.
                 Must include:
-                    'img' (ndarray): The input image.
-                    'cls' (ndarray): Class labels.
+                    'img' (np.ndarray): The input image.
+                    'cls' (np.ndarray): Class labels.
                     'instances' (Instances): Object instances with bounding boxes, segments, and keypoints.
                 May include:
                     'mosaic_border' (Tuple[int, int]): Border size for mosaic augmentation.

ultralytics/data/loaders.py

@@ -106,7 +106,7 @@ class LoadStreams:
         self.caps = [None] * n  # video capture objects
         self.imgs = [[] for _ in range(n)]  # images
         self.shape = [[] for _ in range(n)]  # image shapes
-        self.sources = [ops.clean_str(x) for x in sources]  # clean source names for later
+        self.sources = [ops.clean_str(x).replace(os.sep, "_") for x in sources]  # clean source names for later
         for i, s in enumerate(sources):  # index, source
             # Start thread to read frames from video stream
             st = f"{i + 1}/{n}: {s}... "

ultralytics/engine/exporter.py

@@ -590,7 +590,7 @@ class Exporter:
     @try_export
     def export_openvino(self, prefix=colorstr("OpenVINO:")):
         """YOLO OpenVINO export."""
-        check_requirements("openvino>=2024.0.0,<2025.0.0")
+        check_requirements("openvino>=2024.0.0,!=2025.0.0")
         import openvino as ov
 
         LOGGER.info(f"\n{prefix} starting export with openvino {ov.__version__}...")

ultralytics/engine/results.py

@@ -188,43 +188,50 @@ class Results(SimpleClass):
     """
     A class for storing and manipulating inference results.
 
-    This class encapsulates the functionality for handling detection, segmentation, pose estimation,
-    and classification results from YOLO models.
+    This class provides methods for accessing, manipulating, and visualizing inference results from various
+    Ultralytics models, including detection, segmentation, classification, and pose estimation.
 
     Attributes:
-        orig_img (numpy.ndarray): Original image as a numpy array.
+        orig_img (numpy.ndarray): The original image as a numpy array.
         orig_shape (Tuple[int, int]): Original image shape in (height, width) format.
-        boxes (Boxes | None): Object containing detection bounding boxes.
-        masks (Masks | None): Object containing detection masks.
-        probs (Probs | None): Object containing class probabilities for classification tasks.
-        keypoints (Keypoints | None): Object containing detected keypoints for each object.
-        obb (OBB | None): Object containing oriented bounding boxes.
-        speed (Dict[str, float | None]): Dictionary of preprocess, inference, and postprocess speeds.
-        names (Dict[int, str]): Dictionary mapping class IDs to class names.
-        path (str): Path to the image file.
-        _keys (Tuple[str, ...]): Tuple of attribute names for internal use.
+        boxes (Boxes | None): Detected bounding boxes.
+        masks (Masks | None): Segmentation masks.
+        probs (Probs | None): Classification probabilities.
+        keypoints (Keypoints | None): Detected keypoints.
+        obb (OBB | None): Oriented bounding boxes.
+        speed (Dict): Dictionary containing inference speed information.
+        names (Dict): Dictionary mapping class indices to class names.
+        path (str): Path to the input image file.
+        save_dir (str | None): Directory to save results.
 
     Methods:
-        update: Updates object attributes with new detection results.
-        cpu: Returns a copy of the Results object with all tensors on CPU memory.
-        numpy: Returns a copy of the Results object with all tensors as numpy arrays.
-        cuda: Returns a copy of the Results object with all tensors on GPU memory.
-        to: Returns a copy of the Results object with tensors on a specified device and dtype.
-        new: Returns a new Results object with the same image, path, and names.
-        plot: Plots detection results on an input image, returning an annotated image.
-        show: Shows annotated results on screen.
-        save: Saves annotated results to file.
-        verbose: Returns a log string for each task, detailing detections and classifications.
+        update: Updates the Results object with new detection data.
+        cpu: Returns a copy of the Results object with all tensors moved to CPU memory.
+        numpy: Converts all tensors in the Results object to numpy arrays.
+        cuda: Moves all tensors in the Results object to GPU memory.
+        to: Moves all tensors to the specified device and dtype.
+        new: Creates a new Results object with the same image, path, names, and speed attributes.
+        plot: Plots detection results on an input RGB image.
+        show: Displays the image with annotated inference results.
+        save: Saves annotated inference results image to file.
+        verbose: Returns a log string for each task in the results.
         save_txt: Saves detection results to a text file.
-        save_crop: Saves cropped detection images.
-        tojson: Converts detection results to JSON format.
+        save_crop: Saves cropped detection images to specified directory.
+        summary: Converts inference results to a summarized dictionary.
+        to_df: Converts detection results to a Pandas Dataframe.
+        to_json: Converts detection results to JSON format.
+        to_csv: Converts detection results to a CSV format.
+        to_xml: Converts detection results to XML format.
+        to_html: Converts detection results to HTML format.
+        to_sql: Converts detection results to an SQL-compatible format.
 
     Examples:
         >>> results = model("path/to/image.jpg")
+        >>> result = results[0]  # Get the first result
+        >>> boxes = result.boxes  # Get the boxes for the first result
+        >>> masks = result.masks  # Get the masks for the first result
         >>> for result in results:
-        ...     print(result.boxes)  # Print detection boxes
-        ...     result.show()  # Display the annotated image
-        ...     result.save(filename="result.jpg")  # Save annotated image
+        >>>     result.plot()  # Plot detection results
     """
 
     def __init__(
@@ -766,8 +773,8 @@ class Results(SimpleClass):
         optionally mask segments and keypoints.
 
         Args:
-            normalize (bool): Whether to normalize bounding box coordinates by image dimensions. Defaults to False.
-            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+            normalize (bool): Whether to normalize bounding box coordinates by image dimensions.
+            decimals (int): Number of decimal places to round the output values to.
 
         Returns:
             (List[Dict]): A list of dictionaries, each containing summarized information for a single
@@ -832,8 +839,8 @@ class Results(SimpleClass):
 
         Args:
             normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1. Defaults to False.
-            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+                If True, coordinates will be returned as float values between 0 and 1.
+            decimals (int): Number of decimal places to round the output values to.
 
         Returns:
             (DataFrame): A Pandas Dataframe containing all the information in results in an organized way.
@@ -858,8 +865,8 @@ class Results(SimpleClass):
 
         Args:
             normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1. Defaults to False.
-            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+                If True, coordinates will be returned as float values between 0 and 1.
+            decimals (int): Number of decimal places to round the output values to.
             *args (Any): Variable length argument list to be passed to pandas.DataFrame.to_csv().
             **kwargs (Any): Arbitrary keyword arguments to be passed to pandas.DataFrame.to_csv().
 
@@ -885,8 +892,8 @@ class Results(SimpleClass):
 
         Args:
             normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1. Defaults to False.
-            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+                If True, coordinates will be returned as float values between 0 and 1.
+            decimals (int): Number of decimal places to round the output values to.
             *args (Any): Variable length argument list to be passed to pandas.DataFrame.to_xml().
             **kwargs (Any): Arbitrary keyword arguments to be passed to pandas.DataFrame.to_xml().
 
@@ -903,6 +910,34 @@ class Results(SimpleClass):
         df = self.to_df(normalize=normalize, decimals=decimals)
         return '<?xml version="1.0" encoding="utf-8"?>\n<root></root>' if df.empty else df.to_xml(*args, **kwargs)
 
+    def to_html(self, normalize=False, decimals=5, index=False, *args, **kwargs):
+        """
+        Converts detection results to HTML format.
+
+        This method serializes the detection results into an HTML format. It includes information
+        about detected objects such as bounding boxes, class names, confidence scores, and optionally
+        segmentation masks and keypoints.
+
+        Args:
+            normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
+                If True, coordinates will be returned as float values between 0 and 1.
+            decimals (int): Number of decimal places to round the output values to.
+            index (bool): Whether to include the DataFrame index in the HTML output.
+            *args (Any): Variable length argument list to be passed to pandas.DataFrame.to_html().
+            **kwargs (Any): Arbitrary keyword arguments to be passed to pandas.DataFrame.to_html().
+
+        Returns:
+            (str): An HTML string containing all the information in results in an organized way.
+
+        Examples:
+            >>> results = model("path/to/image.jpg")
+            >>> for result in results:
+            >>>     html_result = result.to_html()
+            >>>     print(html_result)
+        """
+        df = self.to_df(normalize=normalize, decimals=decimals)
+        return "<table></table>" if df.empty else df.to_html(index=index, *args, **kwargs)
+
     def tojson(self, normalize=False, decimals=5):
         """Deprecated version of to_json()."""
         LOGGER.warning("WARNING ⚠️ 'result.tojson()' is deprecated, replace with 'result.to_json()'.")
@@ -918,8 +953,8 @@ class Results(SimpleClass):
 
         Args:
             normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1. Defaults to False.
-            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+                If True, coordinates will be returned as float values between 0 and 1.
+            decimals (int): Number of decimal places to round the output values to.
 
         Returns:
             (str): A JSON string containing the serialized detection results.
@@ -951,11 +986,11 @@ class Results(SimpleClass):
         and optionally segmentation masks, keypoints or oriented bounding boxes.
 
         Args:
-            table_name (str): Name of the SQL table where the data will be inserted. Defaults to "detection_results".
+            table_name (str): Name of the SQL table where the data will be inserted.
             normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1. Defaults to False.
-            decimals (int): Number of decimal places to round the bounding boxes values to. Defaults to 5.
-            db_path (str): Path to the SQLite database file. Defaults to "results.db".
+                If True, coordinates will be returned as float values between 0 and 1.
+            decimals (int): Number of decimal places to round the bounding boxes values to.
+            db_path (str): Path to the SQLite database file.
 
         Examples:
             >>> results = model("path/to/image.jpg")