ultralytics 8.3.85__py3-none-any.whl → 8.3.87__py3-none-any.whl

ultralytics/cfg/datasets/open-images-v7.yaml

@@ -620,30 +620,33 @@ names:
 
 # Download script/URL (optional) ---------------------------------------------------------------------------------------
 download: |
-  from ultralytics.utils import LOGGER, SETTINGS, Path, is_ubuntu, get_ubuntu_version
+  import warnings
+
+  from ultralytics.utils import LOGGER, SETTINGS, Path, get_ubuntu_version, is_ubuntu
   from ultralytics.utils.checks import check_requirements, check_version
 
-  check_requirements('fiftyone')
-  if is_ubuntu() and check_version(get_ubuntu_version(), '>=22.04'):
+  check_requirements("fiftyone")
+  if is_ubuntu() and check_version(get_ubuntu_version(), ">=22.04"):
       # Ubuntu>=22.04 patch https://github.com/voxel51/fiftyone/issues/2961#issuecomment-1666519347
-      check_requirements('fiftyone-db-ubuntu2204')
-
+      check_requirements("fiftyone-db-ubuntu2204")
+    
   import fiftyone as fo
   import fiftyone.zoo as foz
-  import warnings
 
-  name = 'open-images-v7'
+  name = "open-images-v7"
   fo.config.dataset_zoo_dir = Path(SETTINGS["datasets_dir"]) / "fiftyone" / name
   fraction = 1.0  # fraction of full dataset to use
-  LOGGER.warning('WARNING ⚠️ Open Images V7 dataset requires at least **561 GB of free space. Starting download...')
-  for split in 'train', 'validation':  # 1743042 train, 41620 val images
-      train = split == 'train'
+  LOGGER.warning("WARNING ⚠️ Open Images V7 dataset requires at least **561 GB of free space. Starting download...")
+  for split in "train", "validation":  # 1743042 train, 41620 val images
+      train = split == "train"
 
       # Load Open Images dataset
-      dataset = foz.load_zoo_dataset(name,
-                                     split=split,
-                                     label_types=['detections'],
-                                     max_samples=round((1743042 if train else 41620) * fraction))
+      dataset = foz.load_zoo_dataset(
+          name,
+          split=split,
+          label_types=["detections"],
+          max_samples=round((1743042 if train else 41620) * fraction),
+      )
 
       # Define classes
       if train:
@@ -653,9 +656,11 @@ download: |
       # Export to YOLO format
       with warnings.catch_warnings():
           warnings.filterwarnings("ignore", category=UserWarning, module="fiftyone.utils.yolo")
-          dataset.export(export_dir=str(Path(SETTINGS['datasets_dir']) / name),
-                         dataset_type=fo.types.YOLOv5Dataset,
-                         label_field='ground_truth',
-                         split='val' if split == 'validation' else split,
-                         classes=classes,
-                         overwrite=train)
+          dataset.export(
+              export_dir=str(Path(SETTINGS["datasets_dir"]) / name),
+              dataset_type=fo.types.YOLOv5Dataset,
+              label_field="ground_truth",
+              split="val" if split == "validation" else split,
+              classes=classes,
+              overwrite=train,
+          )

ultralytics/cfg/datasets/xView.yaml

@@ -91,16 +91,16 @@ download: |
   from ultralytics.utils.ops import xyxy2xywhn
 
 
-  def convert_labels(fname=Path('xView/xView_train.geojson')):
-      # Convert xView geoJSON labels to YOLO format
+  def convert_labels(fname=Path("xView/xView_train.geojson")):
+      """Converts xView geoJSON labels to YOLO format, mapping classes to indices 0-59 and saving as text files."""
       path = fname.parent
-      with open(fname) as f:
-          print(f'Loading {fname}...')
+      with open(fname, encoding="utf-8") as f:
+          print(f"Loading {fname}...")
           data = json.load(f)
 
       # Make dirs
-      labels = Path(path / 'labels' / 'train')
-      os.system(f'rm -rf {labels}')
+      labels = Path(path / "labels" / "train")
+      os.system(f"rm -rf {labels}")
       labels.mkdir(parents=True, exist_ok=True)
 
       # xView classes 11-94 to 0-59
@@ -110,44 +110,46 @@ download: |
                            47, 48, 49, -1, 50, 51, -1, 52, -1, -1, -1, 53, 54, -1, 55, -1, -1, 56, -1, 57, -1, 58, 59]
 
       shapes = {}
-      for feature in tqdm(data['features'], desc=f'Converting {fname}'):
-          p = feature['properties']
-          if p['bounds_imcoords']:
-              id = p['image_id']
-              file = path / 'train_images' / id
+      for feature in tqdm(data["features"], desc=f"Converting {fname}"):
+          p = feature["properties"]
+          if p["bounds_imcoords"]:
+              id = p["image_id"]
+              file = path / "train_images" / id
               if file.exists():  # 1395.tif missing
                   try:
-                      box = np.array([int(num) for num in p['bounds_imcoords'].split(",")])
-                      assert box.shape[0] == 4, f'incorrect box shape {box.shape[0]}'
-                      cls = p['type_id']
+                      box = np.array([int(num) for num in p["bounds_imcoords"].split(",")])
+                      assert box.shape[0] == 4, f"incorrect box shape {box.shape[0]}"
+                      cls = p["type_id"]
                       cls = xview_class2index[int(cls)]  # xView class to 0-60
-                      assert 59 >= cls >= 0, f'incorrect class index {cls}'
+                      assert 59 >= cls >= 0, f"incorrect class index {cls}"
 
                       # Write YOLO label
                       if id not in shapes:
                           shapes[id] = Image.open(file).size
                       box = xyxy2xywhn(box[None].astype(np.float), w=shapes[id][0], h=shapes[id][1], clip=True)
-                      with open((labels / id).with_suffix('.txt'), 'a') as f:
+                      with open((labels / id).with_suffix(".txt"), "a", encoding="utf-8") as f:
                           f.write(f"{cls} {' '.join(f'{x:.6f}' for x in box[0])}\n")  # write label.txt
                   except Exception as e:
-                      print(f'WARNING: skipping one label for {file}: {e}')
+                      print(f"WARNING: skipping one label for {file}: {e}")
 
 
   # Download manually from https://challenge.xviewdataset.org
-  dir = Path(yaml['path'])  # dataset root dir
-  # urls = ['https://d307kc0mrhucc3.cloudfront.net/train_labels.zip',  # train labels
-  #         'https://d307kc0mrhucc3.cloudfront.net/train_images.zip',  # 15G, 847 train images
-  #         'https://d307kc0mrhucc3.cloudfront.net/val_images.zip']  # 5G, 282 val images (no labels)
+  dir = Path(yaml["path"])  # dataset root dir
+  # urls = [
+  #     "https://d307kc0mrhucc3.cloudfront.net/train_labels.zip",  # train labels
+  #     "https://d307kc0mrhucc3.cloudfront.net/train_images.zip",  # 15G, 847 train images
+  #     "https://d307kc0mrhucc3.cloudfront.net/val_images.zip",  # 5G, 282 val images (no labels)
+  # ]
   # download(urls, dir=dir)
 
   # Convert labels
-  convert_labels(dir / 'xView_train.geojson')
+  convert_labels(dir / "xView_train.geojson")
 
   # Move images
-  images = Path(dir / 'images')
+  images = Path(dir / "images")
   images.mkdir(parents=True, exist_ok=True)
-  Path(dir / 'train_images').rename(dir / 'images' / 'train')
-  Path(dir / 'val_images').rename(dir / 'images' / 'val')
+  Path(dir / "train_images").rename(dir / "images" / "train")
+  Path(dir / "val_images").rename(dir / "images" / "val")
 
   # Split
-  autosplit(dir / 'images' / 'train')
+  autosplit(dir / "images" / "train")

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/annotator.py

@@ -63,7 +63,7 @@ def auto_annotate(
             sam_results = sam_model(result.orig_img, bboxes=boxes, verbose=False, save=False, device=device)
             segments = sam_results[0].masks.xyn  # noqa
 
-            with open(f"{Path(output_dir) / Path(result.path).stem}.txt", "w") as f:
+            with open(f"{Path(output_dir) / Path(result.path).stem}.txt", "w", encoding="utf-8") as f:
                 for i, s in enumerate(segments):
                     if s.any():
                         segment = map(str, s.reshape(-1).tolist())

ultralytics/data/base.py

@@ -113,7 +113,7 @@ class BaseDataset(Dataset):
                     f += glob.glob(str(p / "**" / "*.*"), recursive=True)
                     # F = list(p.rglob('*.*'))  # pathlib
                 elif p.is_file():  # file
-                    with open(p) as t:
+                    with open(p, encoding="utf-8") as t:
                         t = t.read().strip().splitlines()
                         parent = str(p.parent) + os.sep
                         f += [x.replace("./", parent) if x.startswith("./") else x for x in t]  # local to global path

ultralytics/data/converter.py

@@ -323,7 +323,7 @@ def convert_coco(
                         )
 
             # Write
-            with open((fn / f).with_suffix(".txt"), "a") as file:
+            with open((fn / f).with_suffix(".txt"), "a", encoding="utf-8") as file:
                 for i in range(len(bboxes)):
                     if use_keypoints:
                         line = (*(keypoints[i]),)  # cls, box, keypoints
@@ -334,7 +334,8 @@ def convert_coco(
                     file.write(("%g " * len(line)).rstrip() % line + "\n")
 
         if lvis:
-            with open((Path(save_dir) / json_file.name.replace("lvis_v1_", "").replace(".json", ".txt")), "a") as f:
+            filename = Path(save_dir) / json_file.name.replace("lvis_v1_", "").replace(".json", ".txt")
+            with open(filename, "a", encoding="utf-8") as f:
                 f.writelines(f"{line}\n" for line in image_txt)
 
     LOGGER.info(f"{'LVIS' if lvis else 'COCO'} data converted successfully.\nResults saved to {save_dir.resolve()}")
@@ -411,7 +412,7 @@ def convert_segment_masks_to_yolo_seg(masks_dir, output_dir, classes):
                         yolo_format_data.append(yolo_format)
             # Save Ultralytics YOLO format data to file
             output_path = Path(output_dir) / f"{mask_path.stem}.txt"
-            with open(output_path, "w") as file:
+            with open(output_path, "w", encoding="utf-8") as file:
                 for item in yolo_format_data:
                     line = " ".join(map(str, item))
                     file.write(line + "\n")
@@ -605,7 +606,6 @@ def yolo_bbox2segment(im_dir, save_dir=None, sam_model="sam_b.pt", device=None):
     """
     from ultralytics import SAM
     from ultralytics.data import YOLODataset
-    from ultralytics.utils import LOGGER
     from ultralytics.utils.ops import xywh2xyxy
 
     # NOTE: add placeholder to pass class index check
@@ -639,7 +639,7 @@ def yolo_bbox2segment(im_dir, save_dir=None, sam_model="sam_b.pt", device=None):
                 continue
             line = (int(cls[i]), *s.reshape(-1))
             texts.append(("%g " * len(line)).rstrip() % line)
-        with open(txt_file, "a") as f:
+        with open(txt_file, "a", encoding="utf-8") as f:
             f.writelines(text + "\n" for text in texts)
     LOGGER.info(f"Generated segment labels saved in {save_dir}")
 
@@ -689,7 +689,7 @@ def create_synthetic_coco_dataset():
             # Read image filenames from label list file
             label_list_file = dir / f"{subset}.txt"
             if label_list_file.exists():
-                with open(label_list_file) as f:
+                with open(label_list_file, encoding="utf-8") as f:
                     image_files = [dir / line.strip() for line in f]
 
                 # Submit all tasks

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/data/split_dota.py

@@ -87,7 +87,7 @@ def load_yolo_dota(data_root, split="train"):
     annos = []
     for im_file, lb_file in zip(im_files, lb_files):
         w, h = exif_size(Image.open(im_file))
-        with open(lb_file) as f:
+        with open(lb_file, encoding="utf-8") as f:
             lb = [x.split() for x in f.read().strip().splitlines() if len(x)]
             lb = np.array(lb, dtype=np.float32)
         annos.append(dict(ori_size=(h, w), label=lb, filepath=im_file))
@@ -191,7 +191,7 @@ def crop_and_save(anno, windows, window_objs, im_dir, lb_dir, allow_background_i
             label[:, 1::2] /= pw
             label[:, 2::2] /= ph
 
-            with open(Path(lb_dir) / f"{new_name}.txt", "w") as f:
+            with open(Path(lb_dir) / f"{new_name}.txt", "w", encoding="utf-8") as f:
                 for lb in label:
                     formatted_coords = [f"{coord:.6g}" for coord in lb[1:]]
                     f.write(f"{int(lb[0])} {' '.join(formatted_coords)}\n")

ultralytics/data/utils.py

@@ -117,7 +117,7 @@ def verify_image_label(args):
         # Verify labels
         if os.path.isfile(lb_file):
             nf = 1  # label found
-            with open(lb_file) as f:
+            with open(lb_file, encoding="utf-8") as f:
                 lb = [x.split() for x in f.read().strip().splitlines() if len(x)]
                 if any(len(x) > 6 for x in lb) and (not keypoint):  # is segment
                     classes = np.array([x[0] for x in lb], dtype=np.float32)
@@ -195,7 +195,7 @@ def visualize_image_annotations(image_path, txt_path, label_map):
     img = np.array(Image.open(image_path))
     img_height, img_width = img.shape[:2]
     annotations = []
-    with open(txt_path) as file:
+    with open(txt_path, encoding="utf-8") as file:
         for line in file:
             class_id, x_center, y_center, width, height = map(float, line.split())
             x = (x_center - width / 2) * img_width
@@ -605,7 +605,7 @@ class HUBDatasetStats:
             self.hub_dir.mkdir(parents=True, exist_ok=True)  # makes dataset-hub/
             stats_path = self.hub_dir / "stats.json"
             LOGGER.info(f"Saving {stats_path.resolve()}...")
-            with open(stats_path, "w") as f:
+            with open(stats_path, "w", encoding="utf-8") as f:
                 json.dump(self.stats, f)  # save stats.json
         if verbose:
             LOGGER.info(json.dumps(self.stats, indent=2, sort_keys=False))
@@ -694,7 +694,7 @@ def autosplit(path=DATASETS_DIR / "coco8/images", weights=(0.9, 0.1, 0.0), annot
     LOGGER.info(f"Autosplitting images from {path}" + ", using *.txt labeled images only" * annotated_only)
     for i, img in TQDM(zip(indices, files), total=n):
         if not annotated_only or Path(img2label_paths([str(img)])[0]).exists():  # check label
-            with open(path.parent / txt[i], "a") as f:
+            with open(path.parent / txt[i], "a", encoding="utf-8") as f:
                 f.write(f"./{img.relative_to(path.parent).as_posix()}" + "\n")  # add image to txt file
 
 

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__}...")
@@ -1342,7 +1342,7 @@ class Exporter:
         )
 
         # Needed for imx models.
-        with open(f / "labels.txt", "w") as file:
+        with open(f / "labels.txt", "w", encoding="utf-8") as file:
             file.writelines([f"{name}\n" for _, name in self.model.names.items()])
 
         return f, None
@@ -1368,7 +1368,7 @@ class Exporter:
 
         # Label file
         tmp_file = Path(file).parent / "temp_meta.txt"
-        with open(tmp_file, "w") as f:
+        with open(tmp_file, "w", encoding="utf-8") as f:
             f.write(str(self.metadata))
 
         label_file = schema.AssociatedFileT()

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__(
@@ -717,7 +724,7 @@ class Results(SimpleClass):
 
         if texts:
             Path(txt_file).parent.mkdir(parents=True, exist_ok=True)  # make directory
-            with open(txt_file, "a") as f:
+            with open(txt_file, "a", encoding="utf-8") as f:
                 f.writelines(text + "\n" for text in texts)
 
     def save_crop(self, save_dir, file_name=Path("im.jpg")):
@@ -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")

ultralytics/engine/trainer.py

@@ -452,7 +452,8 @@ class BaseTrainer:
                 self.scheduler.last_epoch = self.epoch  # do not move
                 self.stop |= epoch >= self.epochs  # stop if exceeded epochs
             self.run_callbacks("on_fit_epoch_end")
-            self._clear_memory()
+            if self._get_memory(fraction=True) > 0.9:
+                self._clear_memory()  # clear if memory utilization > 90%
 
             # Early Stopping
             if RANK != -1:  # if DDP training
@@ -485,15 +486,20 @@ class BaseTrainer:
             max_num_obj=max_num_obj,
         )  # returns batch size
 
-    def _get_memory(self):
-        """Get accelerator memory utilization in GB."""
+    def _get_memory(self, fraction=False):
+        """Get accelerator memory utilization in GB or fraction."""
+        memory, total = 0, 0
         if self.device.type == "mps":
             memory = torch.mps.driver_allocated_memory()
+            if fraction:
+                total = torch.mps.get_mem_info()[0]
         elif self.device.type == "cpu":
-            memory = 0
+            pass
         else:
             memory = torch.cuda.memory_reserved()
-        return memory / (2**30)
+            if fraction:
+                total = torch.cuda.get_device_properties(self.device).total_memory
+        return ((memory / total) if total > 0 else 0) if fraction else (memory / 2**30)
 
     def _clear_memory(self):
         """Clear accelerator memory on different platforms."""
@@ -666,7 +672,7 @@ class BaseTrainer:
         n = len(metrics) + 2  # number of cols
         s = "" if self.csv.exists() else (("%s," * n % tuple(["epoch", "time"] + keys)).rstrip(",") + "\n")  # header
         t = time.time() - self.train_time_start
-        with open(self.csv, "a") as f:
+        with open(self.csv, "a", encoding="utf-8") as f:
             f.write(s + ("%.6g," * n % tuple([self.epoch + 1, t] + vals)).rstrip(",") + "\n")
 
     def plot_metrics(self):

ultralytics/engine/tuner.py

@@ -191,8 +191,9 @@ class Tuner:
             weights_dir = save_dir / "weights"
             try:
                 # Train YOLO model with mutated hyperparameters (run in subprocess to avoid dataloader hang)
-                cmd = ["yolo", "train", *(f"{k}={v}" for k, v in train_args.items())]
-                return_code = subprocess.run(" ".join(cmd), check=True, shell=True).returncode
+                launch = [__import__("sys").executable, "-m", "ultralytics.cfg.__init__"]  # workaround yolo not found
+                cmd = [*launch, "train", *(f"{k}={v}" for k, v in train_args.items())]
+                return_code = subprocess.run(cmd, check=True).returncode
                 ckpt_file = weights_dir / ("best.pt" if (weights_dir / "best.pt").exists() else "last.pt")
                 metrics = torch.load(ckpt_file)["train_metrics"]
                 assert return_code == 0, "training failed"
@@ -204,7 +205,7 @@ class Tuner:
             fitness = metrics.get("fitness", 0.0)
             log_row = [round(fitness, 5)] + [mutated_hyp[k] for k in self.space.keys()]
             headers = "" if self.tune_csv.exists() else (",".join(["fitness"] + list(self.space.keys())) + "\n")
-            with open(self.tune_csv, "a") as f:
+            with open(self.tune_csv, "a", encoding="utf-8") as f:
                 f.write(headers + ",".join(map(str, log_row)) + "\n")
 
             # Get best results

ultralytics/engine/validator.py

@@ -213,7 +213,7 @@ class BaseValidator:
                 )
             )
             if self.args.save_json and self.jdict:
-                with open(str(self.save_dir / "predictions.json"), "w") as f:
+                with open(str(self.save_dir / "predictions.json"), "w", encoding="utf-8") as f:
                     LOGGER.info(f"Saving {f.name}...")
                     json.dump(self.jdict, f)  # flatten and save
                 stats = self.eval_json(stats)  # update stats