dgenerate-ultralytics-headless 8.3.230__tar.gz → 8.3.232__tar.gz

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.230
+Version: 8.3.232
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -50,11 +50,9 @@ Requires-Dist: ipython; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: coverage[toml]; extra == "dev"
-Requires-Dist: mkdocs>=1.6.0; extra == "dev"
-Requires-Dist: mkdocs-material>=9.5.9; extra == "dev"
-Requires-Dist: mkdocstrings[python]; extra == "dev"
-Requires-Dist: mkdocs-ultralytics-plugin>=0.1.29; extra == "dev"
-Requires-Dist: mkdocs-macros-plugin>=1.0.5; extra == "dev"
+Requires-Dist: zensical>=0.0.9; extra == "dev"
+Requires-Dist: mkdocs-ultralytics-plugin>=0.2.3; extra == "dev"
+Requires-Dist: minijinja>=2.0.0; extra == "dev"
 Provides-Extra: export
 Requires-Dist: numpy<2.0.0; extra == "export"
 Requires-Dist: onnx>=1.12.0; platform_system != "Darwin" and extra == "export"

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/dgenerate_ultralytics_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.230
+Version: 8.3.232
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -50,11 +50,9 @@ Requires-Dist: ipython; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: coverage[toml]; extra == "dev"
-Requires-Dist: mkdocs>=1.6.0; extra == "dev"
-Requires-Dist: mkdocs-material>=9.5.9; extra == "dev"
-Requires-Dist: mkdocstrings[python]; extra == "dev"
-Requires-Dist: mkdocs-ultralytics-plugin>=0.1.29; extra == "dev"
-Requires-Dist: mkdocs-macros-plugin>=1.0.5; extra == "dev"
+Requires-Dist: zensical>=0.0.9; extra == "dev"
+Requires-Dist: mkdocs-ultralytics-plugin>=0.2.3; extra == "dev"
+Requires-Dist: minijinja>=2.0.0; extra == "dev"
 Provides-Extra: export
 Requires-Dist: numpy<2.0.0; extra == "export"
 Requires-Dist: onnx>=1.12.0; platform_system != "Darwin" and extra == "export"

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/dgenerate_ultralytics_headless.egg-info/requires.txt

@@ -19,11 +19,9 @@ ipython
 pytest
 pytest-cov
 coverage[toml]
-mkdocs>=1.6.0
-mkdocs-material>=9.5.9
-mkdocstrings[python]
-mkdocs-ultralytics-plugin>=0.1.29
-mkdocs-macros-plugin>=1.0.5
+zensical>=0.0.9
+mkdocs-ultralytics-plugin>=0.2.3
+minijinja>=2.0.0
 
 [export]
 numpy<2.0.0

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/pyproject.toml

@@ -83,11 +83,9 @@ dev = [
     "pytest",
     "pytest-cov",
     "coverage[toml]",
-    "mkdocs>=1.6.0",
-    "mkdocs-material>=9.5.9",
-    "mkdocstrings[python]",
-    "mkdocs-ultralytics-plugin>=0.1.29", # for meta descriptions and images, dates and authors
-    "mkdocs-macros-plugin>=1.0.5", # duplicating content (i.e. export tables) in multiple places
+    "zensical>=0.0.9",
+    "mkdocs-ultralytics-plugin>=0.2.3", # for meta descriptions and images, dates and authors
+    "minijinja>=2.0.0", # render docs macros without mkdocs-macros-plugin
 ]
 export = [
     "numpy<2.0.0", # TF 2.20 compatibility

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/__init__.py

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

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/data/augment.py

@@ -48,9 +48,6 @@ class BaseTransform:
 
         This constructor sets up the base transformation object, which can be extended for specific image processing
         tasks. It is designed to be compatible with both classification and semantic segmentation.
-
-        Examples:
-            >>> transform = BaseTransform()
         """
         pass
 
@@ -166,11 +163,6 @@ class Compose:
 
         Args:
             transforms (list[Callable]): A list of callable transform objects to be applied sequentially.
-
-        Examples:
-            >>> from ultralytics.data.augment import Compose, RandomHSV, RandomFlip
-            >>> transforms = [RandomHSV(), RandomFlip()]
-            >>> compose = Compose(transforms)
         """
         self.transforms = transforms if isinstance(transforms, list) else [transforms]
 
@@ -341,11 +333,6 @@ class BaseMixTransform:
             dataset (Any): The dataset object containing images and labels for mixing.
             pre_transform (Callable | None): Optional transform to apply before mixing.
             p (float): Probability of applying the mix transformation. Should be in the range [0.0, 1.0].
-
-        Examples:
-            >>> dataset = YOLODataset("path/to/data")
-            >>> pre_transform = Compose([RandomFlip(), RandomPerspective()])
-            >>> mix_transform = BaseMixTransform(dataset, pre_transform, p=0.5)
         """
         self.dataset = dataset
         self.pre_transform = pre_transform
@@ -508,11 +495,6 @@ class Mosaic(BaseMixTransform):
             imgsz (int): Image size (height and width) after mosaic pipeline of a single image.
             p (float): Probability of applying the mosaic augmentation. Must be in the range 0-1.
             n (int): The grid size, either 4 (for 2x2) or 9 (for 3x3).
-
-        Examples:
-            >>> from ultralytics.data.augment import Mosaic
-            >>> dataset = YourDataset(...)
-            >>> mosaic_aug = Mosaic(dataset, imgsz=640, p=0.5, n=4)
         """
         assert 0 <= p <= 1.0, f"The probability should be in range [0, 1], but got {p}."
         assert n in {4, 9}, "grid must be equal to 4 or 9."
@@ -866,11 +848,6 @@ class MixUp(BaseMixTransform):
             dataset (Any): The dataset to which MixUp augmentation will be applied.
             pre_transform (Callable | None): Optional transform to apply to images before MixUp.
             p (float): Probability of applying MixUp augmentation to an image. Must be in the range [0, 1].
-
-        Examples:
-            >>> from ultralytics.data.dataset import YOLODataset
-            >>> dataset = YOLODataset("path/to/data.yaml")
-            >>> mixup = MixUp(dataset, pre_transform=None, p=0.5)
         """
         super().__init__(dataset=dataset, pre_transform=pre_transform, p=p)
 
@@ -1069,10 +1046,6 @@ class RandomPerspective:
             border (tuple[int, int]): Tuple specifying mosaic border (top/bottom, left/right).
             pre_transform (Callable | None): Function/transform to apply to the image before starting the random
                 transformation.
-
-        Examples:
-            >>> transform = RandomPerspective(degrees=10.0, translate=0.1, scale=0.5, shear=5.0)
-            >>> result = transform(labels)  # Apply random perspective to labels
         """
         self.degrees = degrees
         self.translate = translate
@@ -1402,10 +1375,6 @@ class RandomHSV:
             hgain (float): Maximum variation for hue. Should be in the range [0, 1].
             sgain (float): Maximum variation for saturation. Should be in the range [0, 1].
             vgain (float): Maximum variation for value. Should be in the range [0, 1].
-
-        Examples:
-            >>> hsv_aug = RandomHSV(hgain=0.5, sgain=0.5, vgain=0.5)
-            >>> hsv_aug(image)
         """
         self.hgain = hgain
         self.sgain = sgain
@@ -1484,10 +1453,6 @@ class RandomFlip:
 
         Raises:
             AssertionError: If direction is not 'horizontal' or 'vertical', or if p is not between 0 and 1.
-
-        Examples:
-            >>> flip = RandomFlip(p=0.5, direction="horizontal")
-            >>> flip_with_idx = RandomFlip(p=0.7, direction="vertical", flip_idx=[1, 0, 3, 2, 5, 4])
         """
         assert direction in {"horizontal", "vertical"}, f"Support direction `horizontal` or `vertical`, got {direction}"
         assert 0 <= p <= 1.0, f"The probability should be in range [0, 1], but got {p}."
@@ -1590,19 +1555,6 @@ class LetterBox:
             stride (int): Stride of the model (e.g., 32 for YOLOv5).
             padding_value (int): Value for padding the image. Default is 114.
             interpolation (int): Interpolation method for resizing. Default is cv2.INTER_LINEAR.
-
-        Attributes:
-            new_shape (tuple[int, int]): Target size for the resized image.
-            auto (bool): Flag for using minimum rectangle resizing.
-            scale_fill (bool): Flag for stretching image without padding.
-            scaleup (bool): Flag for allowing upscaling.
-            stride (int): Stride value for ensuring image size is divisible by stride.
-            padding_value (int): Value used for padding the image.
-            interpolation (int): Interpolation method used for resizing.
-
-        Examples:
-            >>> letterbox = LetterBox(new_shape=(640, 640), auto=False, scale_fill=False, scaleup=True, stride=32)
-            >>> resized_img = letterbox(original_img)
         """
         self.new_shape = new_shape
         self.auto = auto
@@ -1840,9 +1792,9 @@ class Albumentations:
         >>> augmented_labels = transform(labels)
 
     Notes:
-        - The Albumentations package must be installed to use this class.
-        - If the package is not installed or an error occurs during initialization, the transform will be set to None.
-        - Spatial transforms are handled differently and require special processing for bounding boxes.
+        - Requires Albumentations version 1.0.3 or higher.
+        - Spatial transforms are handled differently to ensure bbox compatibility.
+        - Some transforms are applied with very low probability (0.01) by default.
     """
 
     def __init__(self, p: float = 1.0, transforms: list | None = None) -> None:
@@ -1856,30 +1808,9 @@ class Albumentations:
             p (float): Probability of applying the augmentations. Must be between 0 and 1.
             transforms (list, optional): List of custom Albumentations transforms. If None, uses default transforms.
 
-        Attributes:
-            p (float): Probability of applying the augmentations.
-            transform (albumentations.Compose): Composed Albumentations transforms.
-            contains_spatial (bool): Indicates if the transforms include spatial transformations.
-
         Raises:
             ImportError: If the Albumentations package is not installed.
             Exception: For any other errors during initialization.
-
-        Examples:
-            >>> transform = Albumentations(p=0.5)
-            >>> augmented = transform(image=image, bboxes=bboxes, class_labels=classes)
-            >>> augmented_image = augmented["image"]
-            >>> augmented_bboxes = augmented["bboxes"]
-
-            >>> # Custom transforms example
-            >>> import albumentations as A
-            >>> custom_transforms = [A.Blur(p=0.01), A.CLAHE(p=0.01)]
-            >>> transform = Albumentations(p=1.0, transforms=custom_transforms)
-
-        Notes:
-            - Requires Albumentations version 1.0.3 or higher.
-            - Spatial transforms are handled differently to ensure bbox compatibility.
-            - Some transforms are applied with very low probability (0.01) by default.
         """
         self.p = p
         self.transform = None
@@ -2080,22 +2011,6 @@ class Format:
             mask_overlap (bool): If True, allows mask overlap.
             batch_idx (bool): If True, keeps batch indexes.
             bgr (float): Probability of returning BGR images instead of RGB.
-
-        Attributes:
-            bbox_format (str): Format for bounding boxes.
-            normalize (bool): Whether bounding boxes are normalized.
-            return_mask (bool): Whether to return instance masks.
-            return_keypoint (bool): Whether to return keypoints.
-            return_obb (bool): Whether to return oriented bounding boxes.
-            mask_ratio (int): Downsample ratio for masks.
-            mask_overlap (bool): Whether masks can overlap.
-            batch_idx (bool): Whether to keep batch indexes.
-            bgr (float): The probability to return BGR images.
-
-        Examples:
-            >>> format = Format(bbox_format="xyxy", return_mask=True, return_keypoint=False)
-            >>> print(format.bbox_format)
-            xyxy
         """
         self.bbox_format = bbox_format
         self.normalize = normalize
@@ -2380,22 +2295,6 @@ class RandomLoadText:
             padding (bool): Whether to pad texts to max_samples. If True, the number of texts will always be equal to
                 max_samples.
             padding_value (str): The padding text to use when padding is True.
-
-        Attributes:
-            prompt_format (str): The format string for the prompt.
-            neg_samples (tuple[int, int]): The range for sampling negative texts.
-            max_samples (int): The maximum number of text samples.
-            padding (bool): Whether padding is enabled.
-            padding_value (str): The value used for padding.
-
-        Examples:
-            >>> random_load_text = RandomLoadText(prompt_format="Object: {}", neg_samples=(50, 100), max_samples=120)
-            >>> random_load_text.prompt_format
-            'Object: {}'
-            >>> random_load_text.neg_samples
-            (50, 100)
-            >>> random_load_text.max_samples
-            120
         """
         self.prompt_format = prompt_format
         self.neg_samples = neg_samples
@@ -2731,19 +2630,6 @@ class ClassifyLetterBox:
                 size) is created. If a tuple, it should be (height, width).
             auto (bool): If True, automatically calculates the short side based on stride.
             stride (int): The stride value, used when 'auto' is True.
-
-        Attributes:
-            h (int): Target height of the letterboxed image.
-            w (int): Target width of the letterboxed image.
-            auto (bool): Flag indicating whether to automatically calculate short side.
-            stride (int): Stride value for automatic short side calculation.
-
-        Examples:
-            >>> transform = ClassifyLetterBox(size=224)
-            >>> img = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-            >>> result = transform(img)
-            >>> print(result.shape)
-            (224, 224, 3)
         """
         super().__init__()
         self.h, self.w = (size, size) if isinstance(size, int) else size
@@ -2818,13 +2704,6 @@ class CenterCrop:
 
         Returns:
             (None): This method initializes the object and does not return anything.
-
-        Examples:
-            >>> transform = CenterCrop(224)
-            >>> img = np.random.rand(300, 300, 3)
-            >>> cropped_img = transform(img)
-            >>> print(cropped_img.shape)
-            (224, 224, 3)
         """
         super().__init__()
         self.h, self.w = (size, size) if isinstance(size, int) else size
@@ -2889,13 +2768,6 @@ class ToTensor:
 
         Args:
             half (bool): If True, converts the tensor to half precision (float16).
-
-        Examples:
-            >>> transform = ToTensor(half=True)
-            >>> img = np.random.rand(640, 640, 3)
-            >>> tensor_img = transform(img)
-            >>> print(tensor_img.dtype)
-            torch.float16
         """
         super().__init__()
         self.half = half

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/engine/exporter.py

@@ -1408,7 +1408,7 @@ class NMSModel(torch.nn.Module):
             box, score, cls, extra = box[mask], score[mask], cls[mask], extra[mask]
             nmsbox = box.clone()
             # `8` is the minimum value experimented to get correct NMS results for obb
-            multiplier = (8 if self.obb else 1) / max(len(self.model.names), 1)
+            multiplier = 8 if self.obb else 1 / max(len(self.model.names), 1)
             # Normalize boxes for NMS since large values for class offset causes issue with int8 quantization
             if self.args.format == "tflite":  # TFLite is already normalized
                 nmsbox *= multiplier

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/engine/model.py

@@ -100,11 +100,6 @@ class Model(torch.nn.Module):
             FileNotFoundError: If the specified model file does not exist or is inaccessible.
             ValueError: If the model file or configuration is invalid or unsupported.
             ImportError: If required dependencies for specific model types (like HUB SDK) are not installed.
-
-        Examples:
-            >>> model = Model("yolo11n.pt")
-            >>> model = Model("path/to/model.yaml", task="detect")
-            >>> model = Model("hub_model", verbose=True)
         """
         if isinstance(model, Model):
             self.__dict__ = model.__dict__  # accepts an already initialized Model

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/engine/results.py

@@ -53,12 +53,6 @@ class BaseTensor(SimpleClass):
         Args:
             data (torch.Tensor | np.ndarray): Prediction data such as bounding boxes, masks, or keypoints.
             orig_shape (tuple[int, int]): Original shape of the image in (height, width) format.
-
-        Examples:
-            >>> import torch
-            >>> data = torch.tensor([[1, 2, 3], [4, 5, 6]])
-            >>> orig_shape = (720, 1280)
-            >>> base_tensor = BaseTensor(data, orig_shape)
         """
         assert isinstance(data, (torch.Tensor, np.ndarray)), "data must be torch.Tensor or np.ndarray"
         self.data = data
@@ -252,12 +246,6 @@ class Results(SimpleClass, DataExportMixin):
             obb (torch.Tensor | None): A 2D tensor of oriented bounding box coordinates for each detection.
             speed (dict | None): A dictionary containing preprocess, inference, and postprocess speeds (ms/image).
 
-        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
-
         Notes:
             For the default pose model, keypoint indices for human body pose estimation are:
             0: Nose, 1: Left Eye, 2: Right Eye, 3: Left Ear, 4: Right Ear
@@ -872,19 +860,6 @@ class Boxes(BaseTensor):
             boxes (torch.Tensor | np.ndarray): A tensor or numpy array with detection boxes of shape (num_boxes, 6) or
                 (num_boxes, 7). Columns should contain [x1, y1, x2, y2, (optional) track_id, confidence, class].
             orig_shape (tuple[int, int]): The original image shape as (height, width). Used for normalization.
-
-        Attributes:
-            data (torch.Tensor): The raw tensor containing detection boxes and their associated data.
-            orig_shape (tuple[int, int]): The original image size, used for normalization.
-            is_track (bool): Indicates whether tracking IDs are included in the box data.
-
-        Examples:
-            >>> import torch
-            >>> boxes = torch.tensor([[100, 50, 150, 100, 0.9, 0]])
-            >>> orig_shape = (480, 640)
-            >>> detection_boxes = Boxes(boxes, orig_shape)
-            >>> print(detection_boxes.xyxy)
-            tensor([[100.,  50., 150., 100.]])
         """
         if boxes.ndim == 1:
             boxes = boxes[None, :]
@@ -1065,13 +1040,6 @@ class Masks(BaseTensor):
         Args:
             masks (torch.Tensor | np.ndarray): Detection masks with shape (num_masks, height, width).
             orig_shape (tuple): The original image shape as (height, width). Used for normalization.
-
-        Examples:
-            >>> import torch
-            >>> from ultralytics.engine.results import Masks
-            >>> masks = torch.rand(10, 160, 160)  # 10 masks of 160x160 resolution
-            >>> orig_shape = (720, 1280)  # Original image shape
-            >>> mask_obj = Masks(masks, orig_shape)
         """
         if masks.ndim == 2:
             masks = masks[None, :]
@@ -1168,11 +1136,6 @@ class Keypoints(BaseTensor):
                 - (num_objects, num_keypoints, 2) for x, y coordinates only
                 - (num_objects, num_keypoints, 3) for x, y coordinates and confidence scores
             orig_shape (tuple[int, int]): The original image dimensions (height, width).
-
-        Examples:
-            >>> kpts = torch.rand(1, 17, 3)  # 1 object, 17 keypoints (COCO format), x,y,conf
-            >>> orig_shape = (720, 1280)  # Original image height, width
-            >>> keypoints = Keypoints(kpts, orig_shape)
         """
         if keypoints.ndim == 2:
             keypoints = keypoints[None, :]
@@ -1283,24 +1246,6 @@ class Probs(BaseTensor):
             probs (torch.Tensor | np.ndarray): A 1D tensor or array of classification probabilities.
             orig_shape (tuple | None): The original image shape as (height, width). Not used in this class but kept for
                 consistency with other result classes.
-
-        Attributes:
-            data (torch.Tensor | np.ndarray): The raw tensor or array containing classification probabilities.
-            top1 (int): Index of the top 1 class.
-            top5 (list[int]): Indices of the top 5 classes.
-            top1conf (torch.Tensor | np.ndarray): Confidence of the top 1 class.
-            top5conf (torch.Tensor | np.ndarray): Confidences of the top 5 classes.
-
-        Examples:
-            >>> import torch
-            >>> probs = torch.tensor([0.1, 0.3, 0.2, 0.4])
-            >>> p = Probs(probs)
-            >>> print(p.top1)
-            3
-            >>> print(p.top1conf)
-            tensor(0.4000)
-            >>> print(p.top5)
-            [3, 1, 2, 0]
         """
         super().__init__(probs, orig_shape)
 
@@ -1419,20 +1364,8 @@ class OBB(BaseTensor):
                 the third last column contains track IDs, and the fifth column contains rotation.
             orig_shape (tuple[int, int]): Original image size, in the format (height, width).
 
-        Attributes:
-            data (torch.Tensor | np.ndarray): The raw OBB tensor.
-            orig_shape (tuple[int, int]): The original image shape.
-            is_track (bool): Whether the boxes include tracking IDs.
-
         Raises:
             AssertionError: If the number of values per box is not 7 or 8.
-
-        Examples:
-            >>> import torch
-            >>> boxes = torch.rand(3, 7)  # 3 boxes with 7 values each
-            >>> orig_shape = (640, 480)
-            >>> obb = OBB(boxes, orig_shape)
-            >>> print(obb.xywhr)  # Access the boxes in xywhr format
         """
         if boxes.ndim == 1:
             boxes = boxes[None, :]

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/models/sam/model.py

@@ -55,10 +55,6 @@ class SAM(Model):
 
         Raises:
             NotImplementedError: If the model file extension is not .pt or .pth.
-
-        Examples:
-            >>> sam = SAM("sam_b.pt")
-            >>> print(sam.is_sam2)
         """
         if model and Path(model).suffix not in {".pt", ".pth"}:
             raise NotImplementedError("SAM prediction requires pre-trained *.pt or *.pth model.")

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/models/sam/modules/blocks.py

@@ -156,13 +156,6 @@ class CXBlock(nn.Module):
             drop_path (float): Stochastic depth rate.
             layer_scale_init_value (float): Initial value for Layer Scale.
             use_dwconv (bool): Whether to use depthwise convolution.
-
-        Examples:
-            >>> block = CXBlock(dim=64, kernel_size=7, padding=3)
-            >>> x = torch.randn(1, 64, 32, 32)
-            >>> output = block(x)
-            >>> print(output.shape)
-            torch.Size([1, 64, 32, 32])
         """
         super().__init__()
         self.dwconv = nn.Conv2d(
@@ -231,12 +224,6 @@ class Fuser(nn.Module):
             num_layers (int): The number of times to replicate the layer.
             dim (int | None): The dimension for input projection, if used.
             input_projection (bool): Whether to use input projection.
-
-        Examples:
-            >>> layer = nn.Linear(64, 64)
-            >>> fuser = Fuser(layer, num_layers=3, dim=64, input_projection=True)
-            >>> input_tensor = torch.randn(1, 64)
-            >>> output = fuser(input_tensor)
         """
         super().__init__()
         self.proj = nn.Identity()
@@ -304,12 +291,6 @@ class SAM2TwoWayAttentionBlock(TwoWayAttentionBlock):
             activation (Type[nn.Module]): The activation function of the MLP block.
             attention_downsample_rate (int): The downsample rate for attention computations.
             skip_first_layer_pe (bool): Whether to skip the positional encoding in the first layer.
-
-        Examples:
-            >>> block = SAM2TwoWayAttentionBlock(embedding_dim=256, num_heads=8, mlp_dim=2048)
-            >>> sparse_inputs = torch.randn(1, 100, 256)
-            >>> dense_inputs = torch.randn(1, 256, 32, 32)
-            >>> sparse_outputs, dense_outputs = block(sparse_inputs, dense_inputs)
         """
         super().__init__(embedding_dim, num_heads, mlp_dim, activation, attention_downsample_rate, skip_first_layer_pe)
         self.mlp = MLP(embedding_dim, mlp_dim, embedding_dim, num_layers=2, act=activation)
@@ -364,17 +345,6 @@ class SAM2TwoWayTransformer(TwoWayTransformer):
             mlp_dim (int): Channel dimension internal to the MLP block.
             activation (Type[nn.Module]): Activation function to use in the MLP block.
             attention_downsample_rate (int): Downsampling rate for attention computations.
-
-        Examples:
-            >>> transformer = SAM2TwoWayTransformer(depth=5, embedding_dim=256, num_heads=8, mlp_dim=2048)
-            >>> transformer
-            SAM2TwoWayTransformer(
-              (layers): ModuleList(
-                (0-4): 5 x SAM2TwoWayAttentionBlock(...)
-              )
-              (final_attn_token_to_image): Attention(...)
-              (norm_final_attn): LayerNorm(...)
-            )
         """
         super().__init__(depth, embedding_dim, num_heads, mlp_dim, activation, attention_downsample_rate)
         self.layers = nn.ModuleList()
@@ -917,13 +887,6 @@ class Block(nn.Module):
             rel_pos_zero_init (bool): If True, initializes relative positional parameters to zero.
             window_size (int): Size of attention window. If 0, uses global attention.
             input_size (tuple[int, int] | None): Input resolution for calculating relative positional parameter size.
-
-        Examples:
-            >>> block = Block(dim=256, num_heads=8, window_size=7)
-            >>> x = torch.randn(1, 56, 56, 256)
-            >>> output = block(x)
-            >>> print(output.shape)
-            torch.Size([1, 56, 56, 256])
         """
         super().__init__()
         self.norm1 = norm_layer(dim)
@@ -1008,13 +971,6 @@ class REAttention(nn.Module):
             rel_pos_zero_init (bool): If True, initializes relative positional parameters to zero.
             input_size (tuple[int, int] | None): Input resolution for calculating relative positional parameter size.
                 Required if use_rel_pos is True.
-
-        Examples:
-            >>> attention = REAttention(dim=256, num_heads=8, input_size=(32, 32))
-            >>> x = torch.randn(1, 32, 32, 256)
-            >>> output = attention(x)
-            >>> print(output.shape)
-            torch.Size([1, 32, 32, 256])
         """
         super().__init__()
         self.num_heads = num_heads
@@ -1089,13 +1045,6 @@ class PatchEmbed(nn.Module):
             padding (tuple[int, int]): Padding applied to the input before convolution.
             in_chans (int): Number of input image channels.
             embed_dim (int): Dimensionality of the output patch embeddings.
-
-        Examples:
-            >>> patch_embed = PatchEmbed(kernel_size=(16, 16), stride=(16, 16), in_chans=3, embed_dim=768)
-            >>> x = torch.randn(1, 3, 224, 224)
-            >>> output = patch_embed(x)
-            >>> print(output.shape)
-            torch.Size([1, 768, 14, 14])
         """
         super().__init__()
 

{dgenerate_ultralytics_headless-8.3.230 → dgenerate_ultralytics_headless-8.3.232}/ultralytics/models/sam/modules/decoders.py

@@ -55,11 +55,6 @@ class MaskDecoder(nn.Module):
             activation (Type[nn.Module]): Type of activation to use when upscaling masks.
             iou_head_depth (int): Depth of the MLP used to predict mask quality.
             iou_head_hidden_dim (int): Hidden dimension of the MLP used to predict mask quality.
-
-        Examples:
-            >>> transformer = nn.TransformerEncoder(nn.TransformerEncoderLayer(d_model=256, nhead=8), num_layers=6)
-            >>> decoder = MaskDecoder(transformer_dim=256, transformer=transformer)
-            >>> print(decoder)
         """
         super().__init__()
         self.transformer_dim = transformer_dim
@@ -249,11 +244,6 @@ class SAM2MaskDecoder(nn.Module):
             pred_obj_scores (bool): Whether to predict object scores.
             pred_obj_scores_mlp (bool): Whether to use MLP for object score prediction.
             use_multimask_token_for_obj_ptr (bool): Whether to use multimask token for object pointer.
-
-        Examples:
-            >>> transformer = nn.TransformerEncoder(nn.TransformerEncoderLayer(d_model=256, nhead=8), num_layers=6)
-            >>> decoder = SAM2MaskDecoder(transformer_dim=256, transformer=transformer)
-            >>> print(decoder)
         """
         super().__init__()
         self.transformer_dim = transformer_dim