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

ultralytics/cfg/models/v9/yolov9e.yaml

@@ -3,7 +3,7 @@
 # YOLOv9e object detection model with P3/8 - P5/32 outputs
 # Model docs: https://docs.ultralytics.com/models/yolov9
 # Task docs: https://docs.ultralytics.com/tasks/detect
-# 1225 layers, 58206592 parameters, 193.0 GFLOPs
+# 721 layers, 58206592 parameters, 193.0 GFLOPs
 
 # Parameters
 nc: 80 # number of classes

ultralytics/cfg/models/v9/yolov9m.yaml

@@ -3,7 +3,7 @@
 # YOLOv9m object detection model with P3/8 - P5/32 outputs
 # Model docs: https://docs.ultralytics.com/models/yolov9
 # Task docs: https://docs.ultralytics.com/tasks/detect
-# 603 layers, 20216160 parameters, 77.9 GFLOPs
+# 348 layers, 20216160 parameters, 77.9 GFLOPs
 
 # Parameters
 nc: 80 # number of classes

ultralytics/cfg/models/v9/yolov9s.yaml

@@ -3,7 +3,7 @@
 # YOLOv9s object detection model with P3/8 - P5/32 outputs
 # Model docs: https://docs.ultralytics.com/models/yolov9
 # Task docs: https://docs.ultralytics.com/tasks/detect
-# 917 layers, 7318368 parameters, 27.6 GFLOPs
+# 544 layers, 7318368 parameters, 27.6 GFLOPs
 
 # Parameters
 nc: 80 # number of classes

ultralytics/cfg/models/v9/yolov9t.yaml

@@ -3,7 +3,7 @@
 # YOLOv9t object detection model with P3/8 - P5/32 outputs
 # Model docs: https://docs.ultralytics.com/models/yolov9
 # Task docs: https://docs.ultralytics.com/tasks/detect
-# 917 layers, 2128720 parameters, 8.5 GFLOPs
+# 544 layers, 2128720 parameters, 8.5 GFLOPs
 
 # Parameters
 nc: 80 # number of classes

ultralytics/data/annotator.py

@@ -18,31 +18,26 @@ def auto_annotate(
     output_dir=None,
 ):
     """
-    Automatically annotates images using a YOLO object detection model and a SAM segmentation model.
+    Automatically annotate images using a YOLO object detection model and a SAM segmentation model.
 
     This function processes images in a specified directory, detects objects using a YOLO model, and then generates
     segmentation masks using a SAM model. The resulting annotations are saved as text files.
 
     Args:
-        data (str): Path to a folder containing images to be annotated.
+        data (str | Path): Path to a folder containing images to be annotated.
         det_model (str): Path or name of the pre-trained YOLO detection model.
         sam_model (str): Path or name of the pre-trained SAM segmentation model.
         device (str): Device to run the models on (e.g., 'cpu', 'cuda', '0').
-        conf (float): Confidence threshold for detection model; default is 0.25.
-        iou (float): IoU threshold for filtering overlapping boxes in detection results; default is 0.45.
-        imgsz (int): Input image resize dimension; default is 640.
-        max_det (int): Limits detections per image to control outputs in dense scenes.
-        classes (list): Filters predictions to specified class IDs, returning only relevant detections.
-        output_dir (str | None): Directory to save the annotated results. If None, a default directory is created.
+        conf (float): Confidence threshold for detection model.
+        iou (float): IoU threshold for filtering overlapping boxes in detection results.
+        imgsz (int): Input image resize dimension.
+        max_det (int): Maximum number of detections per image.
+        classes (List[int] | None): Filter predictions to specified class IDs, returning only relevant detections.
+        output_dir (str | Path | None): Directory to save the annotated results. If None, a default directory is created.
 
     Examples:
         >>> from ultralytics.data.annotator import auto_annotate
         >>> auto_annotate(data="ultralytics/assets", det_model="yolo11n.pt", sam_model="mobile_sam.pt")
-
-    Notes:
-        - The function creates a new directory for output if not specified.
-        - Annotation results are saved as text files with the same names as the input images.
-        - Each line in the output text file represents a detected object with its class ID and segmentation points.
     """
     det_model = YOLO(det_model)
     sam_model = SAM(sam_model)
@@ -61,7 +56,7 @@ def auto_annotate(
         if class_ids:
             boxes = result.boxes.xyxy  # Boxes object for bbox outputs
             sam_results = sam_model(result.orig_img, bboxes=boxes, verbose=False, save=False, device=device)
-            segments = sam_results[0].masks.xyn  # noqa
+            segments = sam_results[0].masks.xyn
 
             with open(f"{Path(output_dir) / Path(result.path).stem}.txt", "w", encoding="utf-8") as f:
                 for i, s in enumerate(segments):

ultralytics/data/base.py

@@ -22,28 +22,45 @@ class BaseDataset(Dataset):
     """
     Base dataset class for loading and processing image data.
 
-    Args:
-        img_path (str): Path to the folder containing images.
-        imgsz (int, optional): Image size. Defaults to 640.
-        cache (bool, optional): Cache images to RAM or disk during training. Defaults to False.
-        augment (bool, optional): If True, data augmentation is applied. Defaults to True.
-        hyp (dict, optional): Hyperparameters to apply data augmentation. Defaults to None.
-        prefix (str, optional): Prefix to print in log messages. Defaults to ''.
-        rect (bool, optional): If True, rectangular training is used. Defaults to False.
-        batch_size (int, optional): Size of batches. Defaults to None.
-        stride (int, optional): Stride. Defaults to 32.
-        pad (float, optional): Padding. Defaults to 0.0.
-        single_cls (bool, optional): If True, single class training is used. Defaults to False.
-        classes (list): List of included classes. Default is None.
-        fraction (float): Fraction of dataset to utilize. Default is 1.0 (use all data).
+    This class provides core functionality for loading images, caching, and preparing data for training and inference
+    in object detection tasks.
 
     Attributes:
-        im_files (list): List of image file paths.
-        labels (list): List of label data dictionaries.
+        img_path (str): Path to the folder containing images.
+        imgsz (int): Target image size for resizing.
+        augment (bool): Whether to apply data augmentation.
+        single_cls (bool): Whether to treat all objects as a single class.
+        prefix (str): Prefix to print in log messages.
+        fraction (float): Fraction of dataset to utilize.
+        im_files (List[str]): List of image file paths.
+        labels (List[Dict]): List of label data dictionaries.
         ni (int): Number of images in the dataset.
-        ims (list): List of loaded images.
-        npy_files (list): List of numpy file paths.
+        rect (bool): Whether to use rectangular training.
+        batch_size (int): Size of batches.
+        stride (int): Stride used in the model.
+        pad (float): Padding value.
+        buffer (List): Buffer for mosaic images.
+        max_buffer_length (int): Maximum buffer size.
+        ims (List): List of loaded images.
+        im_hw0 (List): List of original image dimensions (h, w).
+        im_hw (List): List of resized image dimensions (h, w).
+        npy_files (List[Path]): List of numpy file paths.
+        cache (str): Cache images to RAM or disk during training.
         transforms (callable): Image transformation function.
+
+    Methods:
+        get_img_files: Read image files from the specified path.
+        update_labels: Update labels to include only specified classes.
+        load_image: Load an image from the dataset.
+        cache_images: Cache images to memory or disk.
+        cache_images_to_disk: Save an image as an *.npy file for faster loading.
+        check_cache_disk: Check image caching requirements vs available disk space.
+        check_cache_ram: Check image caching requirements vs available memory.
+        set_rectangle: Set the shape of bounding boxes as rectangles.
+        get_image_and_label: Get and return label information from the dataset.
+        update_labels_info: Custom label format method to be implemented by subclasses.
+        build_transforms: Build transformation pipeline to be implemented by subclasses.
+        get_labels: Get labels method to be implemented by subclasses.
     """
 
     def __init__(
@@ -62,7 +79,24 @@ class BaseDataset(Dataset):
         classes=None,
         fraction=1.0,
     ):
-        """Initialize BaseDataset with given configuration and options."""
+        """
+        Initialize BaseDataset with given configuration and options.
+
+        Args:
+            img_path (str): Path to the folder containing images.
+            imgsz (int, optional): Image size for resizing.
+            cache (bool | str, optional): Cache images to RAM or disk during training.
+            augment (bool, optional): If True, data augmentation is applied.
+            hyp (dict, optional): Hyperparameters to apply data augmentation.
+            prefix (str, optional): Prefix to print in log messages.
+            rect (bool, optional): If True, rectangular training is used.
+            batch_size (int, optional): Size of batches.
+            stride (int, optional): Stride used in the model.
+            pad (float, optional): Padding value.
+            single_cls (bool, optional): If True, single class training is used.
+            classes (List, optional): List of included classes.
+            fraction (float, optional): Fraction of dataset to utilize.
+        """
         super().__init__()
         self.img_path = img_path
         self.imgsz = imgsz
@@ -104,7 +138,18 @@ class BaseDataset(Dataset):
         self.transforms = self.build_transforms(hyp=hyp)
 
     def get_img_files(self, img_path):
-        """Read image files."""
+        """
+        Read image files from the specified path.
+
+        Args:
+            img_path (str | List[str]): Path or list of paths to image directories or files.
+
+        Returns:
+            (List[str]): List of image file paths.
+
+        Raises:
+            FileNotFoundError: If no images are found or the path doesn't exist.
+        """
         try:
             f = []  # image files
             for p in img_path if isinstance(img_path, list) else [img_path]:
@@ -130,7 +175,12 @@ class BaseDataset(Dataset):
         return im_files
 
     def update_labels(self, include_class: Optional[list]):
-        """Update labels to include only these classes (optional)."""
+        """
+        Update labels to include only specified classes.
+
+        Args:
+            include_class (List, optional): List of classes to include. If None, all classes are included.
+        """
         include_class_array = np.array(include_class).reshape(1, -1)
         for i in range(len(self.labels)):
             if include_class is not None:
@@ -149,7 +199,21 @@ class BaseDataset(Dataset):
                 self.labels[i]["cls"][:, 0] = 0
 
     def load_image(self, i, rect_mode=True):
-        """Loads 1 image from dataset index 'i', returns (im, resized hw)."""
+        """
+        Load an image from dataset index 'i'.
+
+        Args:
+            i (int): Index of the image to load.
+            rect_mode (bool, optional): Whether to use rectangular resizing.
+
+        Returns:
+            (np.ndarray): Loaded image.
+            (tuple): Original image dimensions (h, w).
+            (tuple): Resized image dimensions (h, w).
+
+        Raises:
+            FileNotFoundError: If the image file is not found.
+        """
         im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
         if im is None:  # not cached in RAM
             if fn.exists():  # load npy
@@ -187,7 +251,7 @@ class BaseDataset(Dataset):
         return self.ims[i], self.im_hw0[i], self.im_hw[i]
 
     def cache_images(self):
-        """Cache images to memory or disk."""
+        """Cache images to memory or disk for faster training."""
         b, gb = 0, 1 << 30  # bytes of cached images, bytes per gigabytes
         fcn, storage = (self.cache_images_to_disk, "Disk") if self.cache == "disk" else (self.load_image, "RAM")
         with ThreadPool(NUM_THREADS) as pool:
@@ -203,13 +267,21 @@ class BaseDataset(Dataset):
             pbar.close()
 
     def cache_images_to_disk(self, i):
-        """Saves an image as an *.npy file for faster loading."""
+        """Save an image as an *.npy file for faster loading."""
         f = self.npy_files[i]
         if not f.exists():
             np.save(f.as_posix(), cv2.imread(self.im_files[i]), allow_pickle=False)
 
     def check_cache_disk(self, safety_margin=0.5):
-        """Check image caching requirements vs available disk space."""
+        """
+        Check if there's enough disk space for caching images.
+
+        Args:
+            safety_margin (float, optional): Safety margin factor for disk space calculation.
+
+        Returns:
+            (bool): True if there's enough disk space, False otherwise.
+        """
         import shutil
 
         b, gb = 0, 1 << 30  # bytes of cached images, bytes per gigabytes
@@ -237,7 +309,15 @@ class BaseDataset(Dataset):
         return True
 
     def check_cache_ram(self, safety_margin=0.5):
-        """Check image caching requirements vs available memory."""
+        """
+        Check if there's enough RAM for caching images.
+
+        Args:
+            safety_margin (float, optional): Safety margin factor for RAM calculation.
+
+        Returns:
+            (bool): True if there's enough RAM, False otherwise.
+        """
         b, gb = 0, 1 << 30  # bytes of cached images, bytes per gigabytes
         n = min(self.ni, 30)  # extrapolate from 30 random images
         for _ in range(n):
@@ -259,7 +339,7 @@ class BaseDataset(Dataset):
         return True
 
     def set_rectangle(self):
-        """Sets the shape of bounding boxes for YOLO detections as rectangles."""
+        """Set the shape of bounding boxes for YOLO detections as rectangles."""
         bi = np.floor(np.arange(self.ni) / self.batch_size).astype(int)  # batch index
         nb = bi[-1] + 1  # number of batches
 
@@ -284,11 +364,19 @@ class BaseDataset(Dataset):
         self.batch = bi  # batch index of image
 
     def __getitem__(self, index):
-        """Returns transformed label information for given index."""
+        """Return transformed label information for given index."""
         return self.transforms(self.get_image_and_label(index))
 
     def get_image_and_label(self, index):
-        """Get and return label information from the dataset."""
+        """
+        Get and return label information from the dataset.
+
+        Args:
+            index (int): Index of the image to retrieve.
+
+        Returns:
+            (dict): Label dictionary with image and metadata.
+        """
         label = deepcopy(self.labels[index])  # requires deepcopy() https://github.com/ultralytics/ultralytics/pull/1948
         label.pop("shape", None)  # shape is for rect, remove it
         label["img"], label["ori_shape"], label["resized_shape"] = self.load_image(index)
@@ -301,7 +389,7 @@ class BaseDataset(Dataset):
         return self.update_labels_info(label)
 
     def __len__(self):
-        """Returns the length of the labels list for the dataset."""
+        """Return the length of the labels list for the dataset."""
         return len(self.labels)
 
     def update_labels_info(self, label):

ultralytics/data/build.py

@@ -29,26 +29,37 @@ class InfiniteDataLoader(dataloader.DataLoader):
     """
     Dataloader that reuses workers.
 
-    Uses same syntax as vanilla DataLoader.
+    This dataloader extends the PyTorch DataLoader to provide infinite recycling of workers, which improves efficiency
+    for training loops that need to iterate through the dataset multiple times.
+
+    Attributes:
+        batch_sampler (_RepeatSampler): A sampler that repeats indefinitely.
+        iterator (Iterator): The iterator from the parent DataLoader.
+
+    Methods:
+        __len__: Returns the length of the batch sampler's sampler.
+        __iter__: Creates a sampler that repeats indefinitely.
+        __del__: Ensures workers are properly terminated.
+        reset: Resets the iterator, useful when modifying dataset settings during training.
     """
 
     def __init__(self, *args, **kwargs):
-        """Dataloader that infinitely recycles workers, inherits from DataLoader."""
+        """Initialize the InfiniteDataLoader with the same arguments as DataLoader."""
         super().__init__(*args, **kwargs)
         object.__setattr__(self, "batch_sampler", _RepeatSampler(self.batch_sampler))
         self.iterator = super().__iter__()
 
     def __len__(self):
-        """Returns the length of the batch sampler's sampler."""
+        """Return the length of the batch sampler's sampler."""
         return len(self.batch_sampler.sampler)
 
     def __iter__(self):
-        """Creates a sampler that repeats indefinitely."""
+        """Create an iterator that yields indefinitely from the underlying iterator."""
         for _ in range(len(self)):
             yield next(self.iterator)
 
     def __del__(self):
-        """Ensure that workers are terminated."""
+        """Ensure that workers are properly terminated when the dataloader is deleted."""
         try:
             if not hasattr(self.iterator, "_workers"):
                 return
@@ -60,11 +71,7 @@ class InfiniteDataLoader(dataloader.DataLoader):
             pass
 
     def reset(self):
-        """
-        Reset iterator.
-
-        This is useful when we want to modify settings of dataset while training.
-        """
+        """Reset the iterator to allow modifications to the dataset during training."""
         self.iterator = self._get_iterator()
 
 
@@ -72,29 +79,32 @@ class _RepeatSampler:
     """
     Sampler that repeats forever.
 
-    Args:
+    This sampler wraps another sampler and yields its contents indefinitely, allowing for infinite iteration
+    over a dataset.
+
+    Attributes:
         sampler (Dataset.sampler): The sampler to repeat.
     """
 
     def __init__(self, sampler):
-        """Initializes an object that repeats a given sampler indefinitely."""
+        """Initialize the _RepeatSampler with a sampler to repeat indefinitely."""
         self.sampler = sampler
 
     def __iter__(self):
-        """Iterates over the 'sampler' and yields its contents."""
+        """Iterate over the sampler indefinitely, yielding its contents."""
         while True:
             yield from iter(self.sampler)
 
 
 def seed_worker(worker_id):  # noqa
-    """Set dataloader worker seed https://pytorch.org/docs/stable/notes/randomness.html#dataloader."""
+    """Set dataloader worker seed for reproducibility across worker processes."""
     worker_seed = torch.initial_seed() % 2**32
     np.random.seed(worker_seed)
     random.seed(worker_seed)
 
 
 def build_yolo_dataset(cfg, img_path, batch, data, mode="train", rect=False, stride=32, multi_modal=False):
-    """Build YOLO Dataset."""
+    """Build and return a YOLO dataset based on configuration parameters."""
     dataset = YOLOMultiModalDataset if multi_modal else YOLODataset
     return dataset(
         img_path=img_path,
@@ -116,7 +126,7 @@ def build_yolo_dataset(cfg, img_path, batch, data, mode="train", rect=False, str
 
 
 def build_grounding(cfg, img_path, json_file, batch, mode="train", rect=False, stride=32):
-    """Build YOLO Dataset."""
+    """Build and return a GroundingDataset based on configuration parameters."""
     return GroundingDataset(
         img_path=img_path,
         json_file=json_file,
@@ -137,7 +147,19 @@ def build_grounding(cfg, img_path, json_file, batch, mode="train", rect=False, s
 
 
 def build_dataloader(dataset, batch, workers, shuffle=True, rank=-1):
-    """Return an InfiniteDataLoader or DataLoader for training or validation set."""
+    """
+    Create and return an InfiniteDataLoader or DataLoader for training or validation.
+
+    Args:
+        dataset (Dataset): Dataset to load data from.
+        batch (int): Batch size for the dataloader.
+        workers (int): Number of worker threads for loading data.
+        shuffle (bool): Whether to shuffle the dataset.
+        rank (int): Process rank in distributed training. -1 for single-GPU training.
+
+    Returns:
+        (InfiniteDataLoader): A dataloader that can be used for training or validation.
+    """
     batch = min(batch, len(dataset))
     nd = torch.cuda.device_count()  # number of CUDA devices
     nw = min(os.cpu_count() // max(nd, 1), workers)  # number of workers
@@ -158,7 +180,24 @@ def build_dataloader(dataset, batch, workers, shuffle=True, rank=-1):
 
 
 def check_source(source):
-    """Check source type and return corresponding flag values."""
+    """
+    Check the type of input source and return corresponding flag values.
+
+    Args:
+        source (str | int | Path | List | Tuple | np.ndarray | PIL.Image | torch.Tensor): The input source to check.
+
+    Returns:
+        (tuple): A tuple containing:
+            - source: The processed source.
+            - webcam (bool): Whether the source is a webcam.
+            - screenshot (bool): Whether the source is a screenshot.
+            - from_img (bool): Whether the source is an image or list of images.
+            - in_memory (bool): Whether the source is an in-memory object.
+            - tensor (bool): Whether the source is a torch.Tensor.
+
+    Raises:
+        TypeError: If the source type is unsupported.
+    """
     webcam, screenshot, from_img, in_memory, tensor = False, False, False, False, False
     if isinstance(source, (str, int, Path)):  # int for local usb camera
         source = str(source)
@@ -185,16 +224,16 @@ def check_source(source):
 
 def load_inference_source(source=None, batch=1, vid_stride=1, buffer=False):
     """
-    Loads an inference source for object detection and applies necessary transformations.
+    Load an inference source for object detection and apply necessary transformations.
 
     Args:
-        source (str, Path, Tensor, PIL.Image, np.ndarray): The input source for inference.
-        batch (int, optional): Batch size for dataloaders. Default is 1.
-        vid_stride (int, optional): The frame interval for video sources. Default is 1.
-        buffer (bool, optional): Determined whether stream frames will be buffered. Default is False.
+        source (str | Path | torch.Tensor | PIL.Image | np.ndarray, optional): The input source for inference.
+        batch (int, optional): Batch size for dataloaders.
+        vid_stride (int, optional): The frame interval for video sources.
+        buffer (bool, optional): Whether stream frames will be buffered.
 
     Returns:
-        dataset (Dataset): A dataset object for the specified input source.
+        (Dataset): A dataset object for the specified input source with attached source_type attribute.
     """
     source, stream, screenshot, from_img, in_memory, tensor = check_source(source)
     source_type = source.source_type if in_memory else SourceTypes(stream, screenshot, from_img, tensor)

ultralytics/data/converter.py

@@ -21,7 +21,7 @@ def coco91_to_coco80_class():
     Converts 91-index COCO class IDs to 80-index COCO class IDs.
 
     Returns:
-        (list): A list of 91 class IDs where the index represents the 80-index class ID and the value is the
+        (List): A list of 91 class IDs where the index represents the 80-index class ID and the value is the
             corresponding 91-index class ID.
     """
     return [
@@ -228,7 +228,7 @@ def convert_coco(
     lvis=False,
 ):
     """
-    Converts COCO dataset annotations to a YOLO annotation format  suitable for training YOLO models.
+    Converts COCO dataset annotations to a YOLO annotation format suitable for training YOLO models.
 
     Args:
         labels_dir (str, optional): Path to directory containing COCO dataset annotation files.
@@ -589,9 +589,9 @@ def yolo_bbox2segment(im_dir, save_dir=None, sam_model="sam_b.pt", device=None):
     Args:
         im_dir (str | Path): Path to image directory to convert.
         save_dir (str | Path): Path to save the generated labels, labels will be saved
-            into `labels-segment` in the same directory level of `im_dir` if save_dir is None. Default: None.
-        sam_model (str): Segmentation model to use for intermediate segmentation data; optional.
-        device (int | str): The specific device to run SAM models. Default: None.
+            into `labels-segment` in the same directory level of `im_dir` if save_dir is None.
+        sam_model (str): Segmentation model to use for intermediate segmentation data.
+        device (int | str): The specific device to run SAM models.
 
     Notes:
         The input directory structure assumed for dataset: