ultralytics 8.2.67__py3-none-any.whl → 8.2.69__py3-none-any.whl

tests/test_cli.py

@@ -68,7 +68,6 @@ def test_fastsam(task="segment", model=WEIGHTS_DIR / "FastSAM-s.pt", data="coco8
     run(f"yolo segment predict model={model} source={source} imgsz=32 save save_crop save_txt")
 
     from ultralytics import FastSAM
-    from ultralytics.models.fastsam import FastSAMPrompt
     from ultralytics.models.sam import Predictor
 
     # Create a FastSAM model
@@ -81,21 +80,10 @@ def test_fastsam(task="segment", model=WEIGHTS_DIR / "FastSAM-s.pt", data="coco8
         # Remove small regions
         new_masks, _ = Predictor.remove_small_regions(everything_results[0].masks.data, min_area=20)
 
-        # Everything prompt
-        prompt_process = FastSAMPrompt(s, everything_results, device="cpu")
-        ann = prompt_process.everything_prompt()
-
-        # Bbox default shape [0,0,0,0] -> [x1,y1,x2,y2]
-        ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
-
-        # Text prompt
-        ann = prompt_process.text_prompt(text="a photo of a dog")
-
-        # Point prompt
-        # Points default [[0,0]] [[x1,y1],[x2,y2]]
-        # Point_label default [0] [1,0] 0:background, 1:foreground
-        ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
-        prompt_process.plot(annotations=ann, output="./")
+        # Run inference with bboxes and points and texts prompt at the same time
+        results = sam_model(
+            source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog"
+        )
 
 
 def test_mobilesam():

ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-__version__ = "8.2.67"
+__version__ = "8.2.69"
 
 import os
 

ultralytics/data/augment.py

@@ -2221,7 +2221,7 @@ class RandomLoadText:
         pos_labels = np.unique(cls).tolist()
 
         if len(pos_labels) > self.max_samples:
-            pos_labels = set(random.sample(pos_labels, k=self.max_samples))
+            pos_labels = random.sample(pos_labels, k=self.max_samples)
 
         neg_samples = min(min(num_classes, self.max_samples) - len(pos_labels), random.randint(*self.neg_samples))
         neg_labels = [i for i in range(num_classes) if i not in pos_labels]

ultralytics/hub/google/__init__.py

@@ -0,0 +1,159 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import concurrent.futures
+import statistics
+import time
+from typing import List, Optional, Tuple
+
+import requests
+
+
+class GCPRegions:
+    """
+    A class for managing and analyzing Google Cloud Platform (GCP) regions.
+
+    This class provides functionality to initialize, categorize, and analyze GCP regions based on their
+    geographical location, tier classification, and network latency.
+
+    Attributes:
+        regions (Dict[str, Tuple[int, str, str]]): A dictionary of GCP regions with their tier, city, and country.
+
+    Methods:
+        tier1: Returns a list of tier 1 GCP regions.
+        tier2: Returns a list of tier 2 GCP regions.
+        lowest_latency: Determines the GCP region(s) with the lowest network latency.
+
+    Examples:
+        >>> from ultralytics.hub.google import GCPRegions
+        >>> regions = GCPRegions()
+        >>> lowest_latency_region = regions.lowest_latency(verbose=True, attempts=3)
+        >>> print(f"Lowest latency region: {lowest_latency_region[0][0]}")
+    """
+
+    def __init__(self):
+        """Initializes the GCPRegions class with predefined Google Cloud Platform regions and their details."""
+        self.regions = {
+            "asia-east1": (1, "Taiwan", "China"),
+            "asia-east2": (2, "Hong Kong", "China"),
+            "asia-northeast1": (1, "Tokyo", "Japan"),
+            "asia-northeast2": (1, "Osaka", "Japan"),
+            "asia-northeast3": (2, "Seoul", "South Korea"),
+            "asia-south1": (2, "Mumbai", "India"),
+            "asia-south2": (2, "Delhi", "India"),
+            "asia-southeast1": (2, "Jurong West", "Singapore"),
+            "asia-southeast2": (2, "Jakarta", "Indonesia"),
+            "australia-southeast1": (2, "Sydney", "Australia"),
+            "australia-southeast2": (2, "Melbourne", "Australia"),
+            "europe-central2": (2, "Warsaw", "Poland"),
+            "europe-north1": (1, "Hamina", "Finland"),
+            "europe-southwest1": (1, "Madrid", "Spain"),
+            "europe-west1": (1, "St. Ghislain", "Belgium"),
+            "europe-west10": (2, "Berlin", "Germany"),
+            "europe-west12": (2, "Turin", "Italy"),
+            "europe-west2": (2, "London", "United Kingdom"),
+            "europe-west3": (2, "Frankfurt", "Germany"),
+            "europe-west4": (1, "Eemshaven", "Netherlands"),
+            "europe-west6": (2, "Zurich", "Switzerland"),
+            "europe-west8": (1, "Milan", "Italy"),
+            "europe-west9": (1, "Paris", "France"),
+            "me-central1": (2, "Doha", "Qatar"),
+            "me-west1": (1, "Tel Aviv", "Israel"),
+            "northamerica-northeast1": (2, "Montreal", "Canada"),
+            "northamerica-northeast2": (2, "Toronto", "Canada"),
+            "southamerica-east1": (2, "São Paulo", "Brazil"),
+            "southamerica-west1": (2, "Santiago", "Chile"),
+            "us-central1": (1, "Iowa", "United States"),
+            "us-east1": (1, "South Carolina", "United States"),
+            "us-east4": (1, "Northern Virginia", "United States"),
+            "us-east5": (1, "Columbus", "United States"),
+            "us-south1": (1, "Dallas", "United States"),
+            "us-west1": (1, "Oregon", "United States"),
+            "us-west2": (2, "Los Angeles", "United States"),
+            "us-west3": (2, "Salt Lake City", "United States"),
+            "us-west4": (2, "Las Vegas", "United States"),
+        }
+
+    def tier1(self) -> List[str]:
+        """Returns a list of GCP regions classified as tier 1 based on predefined criteria."""
+        return [region for region, info in self.regions.items() if info[0] == 1]
+
+    def tier2(self) -> List[str]:
+        """Returns a list of GCP regions classified as tier 2 based on predefined criteria."""
+        return [region for region, info in self.regions.items() if info[0] == 2]
+
+    @staticmethod
+    def _ping_region(region: str, attempts: int = 1) -> Tuple[str, float, float, float, float]:
+        """Pings a specified GCP region and returns latency statistics: mean, min, max, and standard deviation."""
+        url = f"https://{region}-docker.pkg.dev"
+        latencies = []
+        for _ in range(attempts):
+            try:
+                start_time = time.time()
+                _ = requests.head(url, timeout=5)
+                latency = (time.time() - start_time) * 1000  # convert latency to milliseconds
+                if latency != float("inf"):
+                    latencies.append(latency)
+            except requests.RequestException:
+                pass
+        if not latencies:
+            return region, float("inf"), float("inf"), float("inf"), float("inf")
+
+        std_dev = statistics.stdev(latencies) if len(latencies) > 1 else 0
+        return region, statistics.mean(latencies), std_dev, min(latencies), max(latencies)
+
+    def lowest_latency(
+        self,
+        top: int = 1,
+        verbose: bool = False,
+        tier: Optional[int] = None,
+        attempts: int = 1,
+    ) -> List[Tuple[str, float, float, float, float]]:
+        """
+        Determines the GCP regions with the lowest latency based on ping tests.
+
+        Args:
+            top (int): Number of top regions to return.
+            verbose (bool): If True, prints detailed latency information for all tested regions.
+            tier (int | None): Filter regions by tier (1 or 2). If None, all regions are tested.
+            attempts (int): Number of ping attempts per region.
+
+        Returns:
+            (List[Tuple[str, float, float, float, float]]): List of tuples containing region information and
+            latency statistics. Each tuple contains (region, mean_latency, std_dev, min_latency, max_latency).
+
+        Examples:
+            >>> regions = GCPRegions()
+            >>> results = regions.lowest_latency(top=3, verbose=True, tier=1, attempts=2)
+            >>> print(results[0][0])  # Print the name of the lowest latency region
+        """
+        if verbose:
+            print(f"Testing GCP regions for latency (with {attempts} {'retry' if attempts == 1 else 'attempts'})...")
+
+        regions_to_test = [k for k, v in self.regions.items() if v[0] == tier] if tier else list(self.regions.keys())
+        with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
+            results = list(executor.map(lambda r: self._ping_region(r, attempts), regions_to_test))
+
+        sorted_results = sorted(results, key=lambda x: x[1])
+
+        if verbose:
+            print(f"{'Region':<25} {'Location':<35} {'Tier':<5} {'Latency (ms)'}")
+            for region, mean, std, min_, max_ in sorted_results:
+                tier, city, country = self.regions[region]
+                location = f"{city}, {country}"
+                if mean == float("inf"):
+                    print(f"{region:<25} {location:<35} {tier:<5} {'Timeout'}")
+                else:
+                    print(f"{region:<25} {location:<35} {tier:<5} {mean:.0f} ± {std:.0f} ({min_:.0f} - {max_:.0f})")
+            print(f"\nLowest latency region{'s' if top > 1 else ''}:")
+            for region, mean, std, min_, max_ in sorted_results[:top]:
+                tier, city, country = self.regions[region]
+                location = f"{city}, {country}"
+                print(f"{region} ({location}, {mean:.0f} ± {std:.0f} ms ({min_:.0f} - {max_:.0f}))")
+
+        return sorted_results[:top]
+
+
+# Usage example
+if __name__ == "__main__":
+    regions = GCPRegions()
+    top_3_latency_tier1 = regions.lowest_latency(top=3, verbose=True, tier=1, attempts=3)

ultralytics/models/fastsam/__init__.py

@@ -2,7 +2,6 @@
 
 from .model import FastSAM
 from .predict import FastSAMPredictor
-from .prompt import FastSAMPrompt
 from .val import FastSAMValidator
 
-__all__ = "FastSAMPredictor", "FastSAM", "FastSAMPrompt", "FastSAMValidator"
+__all__ = "FastSAMPredictor", "FastSAM", "FastSAMValidator"

ultralytics/models/fastsam/model.py

@@ -28,6 +28,24 @@ class FastSAM(Model):
         assert Path(model).suffix not in {".yaml", ".yml"}, "FastSAM models only support pre-trained models."
         super().__init__(model=model, task="segment")
 
+    def predict(self, source, stream=False, bboxes=None, points=None, labels=None, texts=None, **kwargs):
+        """
+        Performs segmentation prediction on the given image or video source.
+
+        Args:
+            source (str): Path to the image or video file, or a PIL.Image object, or a numpy.ndarray object.
+            stream (bool, optional): If True, enables real-time streaming. Defaults to False.
+            bboxes (list, optional): List of bounding box coordinates for prompted segmentation. Defaults to None.
+            points (list, optional): List of points for prompted segmentation. Defaults to None.
+            labels (list, optional): List of labels for prompted segmentation. Defaults to None.
+            texts (list, optional): List of texts for prompted segmentation. Defaults to None.
+
+        Returns:
+            (list): The model predictions.
+        """
+        prompts = dict(bboxes=bboxes, points=points, labels=labels, texts=texts)
+        return super().predict(source, stream, prompts=prompts, **kwargs)
+
     @property
     def task_map(self):
         """Returns a dictionary mapping segment task to corresponding predictor and validator classes."""

ultralytics/models/fastsam/predict.py

@@ -1,8 +1,11 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 import torch
+from PIL import Image
 
 from ultralytics.models.yolo.segment import SegmentationPredictor
+from ultralytics.utils import DEFAULT_CFG, checks
 from ultralytics.utils.metrics import box_iou
+from ultralytics.utils.ops import scale_masks
 
 from .utils import adjust_bboxes_to_image_border
 
@@ -17,8 +20,16 @@ class FastSAMPredictor(SegmentationPredictor):
     class segmentation.
     """
 
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
+        super().__init__(cfg, overrides, _callbacks)
+        self.prompts = {}
+
     def postprocess(self, preds, img, orig_imgs):
         """Applies box postprocess for FastSAM predictions."""
+        bboxes = self.prompts.pop("bboxes", None)
+        points = self.prompts.pop("points", None)
+        labels = self.prompts.pop("labels", None)
+        texts = self.prompts.pop("texts", None)
         results = super().postprocess(preds, img, orig_imgs)
         for result in results:
             full_box = torch.tensor(
@@ -28,4 +39,107 @@ class FastSAMPredictor(SegmentationPredictor):
             idx = torch.nonzero(box_iou(full_box[None], boxes) > 0.9).flatten()
             if idx.numel() != 0:
                 result.boxes.xyxy[idx] = full_box
-        return results
+
+        return self.prompt(results, bboxes=bboxes, points=points, labels=labels, texts=texts)
+
+    def prompt(self, results, bboxes=None, points=None, labels=None, texts=None):
+        """
+        Internal function for image segmentation inference based on cues like bounding boxes, points, and masks.
+        Leverages SAM's specialized architecture for prompt-based, real-time segmentation.
+
+        Args:
+            results (Results | List[Results]): The original inference results from FastSAM models without any prompts.
+            bboxes (np.ndarray | List, optional): Bounding boxes with shape (N, 4), in XYXY format.
+            points (np.ndarray | List, optional): Points indicating object locations with shape (N, 2), in pixels.
+            labels (np.ndarray | List, optional): Labels for point prompts, shape (N, ). 1 = foreground, 0 = background.
+            texts (str | List[str], optional): Textual prompts, a list contains string objects.
+
+        Returns:
+            (List[Results]): The output results determined by prompts.
+        """
+        if bboxes is None and points is None and texts is None:
+            return results
+        prompt_results = []
+        if not isinstance(results, list):
+            results = [results]
+        for result in results:
+            masks = result.masks.data
+            if masks.shape[1:] != result.orig_shape:
+                masks = scale_masks(masks[None], result.orig_shape)[0]
+            # bboxes prompt
+            idx = torch.zeros(len(result), dtype=torch.bool, device=self.device)
+            if bboxes is not None:
+                bboxes = torch.as_tensor(bboxes, dtype=torch.int32, device=self.device)
+                bboxes = bboxes[None] if bboxes.ndim == 1 else bboxes
+                bbox_areas = (bboxes[:, 3] - bboxes[:, 1]) * (bboxes[:, 2] - bboxes[:, 0])
+                mask_areas = torch.stack([masks[:, b[1] : b[3], b[0] : b[2]].sum(dim=(1, 2)) for b in bboxes])
+                full_mask_areas = torch.sum(masks, dim=(1, 2))
+
+                union = bbox_areas[:, None] + full_mask_areas - mask_areas
+                idx[torch.argmax(mask_areas / union, dim=1)] = True
+            if points is not None:
+                points = torch.as_tensor(points, dtype=torch.int32, device=self.device)
+                points = points[None] if points.ndim == 1 else points
+                if labels is None:
+                    labels = torch.ones(points.shape[0])
+                labels = torch.as_tensor(labels, dtype=torch.int32, device=self.device)
+                assert len(labels) == len(
+                    points
+                ), f"Excepted `labels` got same size as `point`, but got {len(labels)} and {len(points)}"
+                point_idx = (
+                    torch.ones(len(result), dtype=torch.bool, device=self.device)
+                    if labels.sum() == 0  # all negative points
+                    else torch.zeros(len(result), dtype=torch.bool, device=self.device)
+                )
+                for p, l in zip(points, labels):
+                    point_idx[torch.nonzero(masks[:, p[1], p[0]], as_tuple=True)[0]] = True if l else False
+                idx |= point_idx
+            if texts is not None:
+                if isinstance(texts, str):
+                    texts = [texts]
+                crop_ims, filter_idx = [], []
+                for i, b in enumerate(result.boxes.xyxy.tolist()):
+                    x1, y1, x2, y2 = [int(x) for x in b]
+                    if masks[i].sum() <= 100:
+                        filter_idx.append(i)
+                        continue
+                    crop_ims.append(Image.fromarray(result.orig_img[y1:y2, x1:x2, ::-1]))
+                similarity = self._clip_inference(crop_ims, texts)
+                text_idx = torch.argmax(similarity, dim=-1)  # (M, )
+                if len(filter_idx):
+                    text_idx += (torch.tensor(filter_idx, device=self.device)[None] <= int(text_idx)).sum(0)
+                idx[text_idx] = True
+
+            prompt_results.append(result[idx])
+
+        return prompt_results
+
+    def _clip_inference(self, images, texts):
+        """
+        CLIP Inference process.
+
+        Args:
+            images (List[PIL.Image]): A list of source images and each of them should be PIL.Image type with RGB channel order.
+            texts (List[str]): A list of prompt texts and each of them should be string object.
+
+        Returns:
+            (torch.Tensor): The similarity between given images and texts.
+        """
+        try:
+            import clip
+        except ImportError:
+            checks.check_requirements("git+https://github.com/ultralytics/CLIP.git")
+            import clip
+        if (not hasattr(self, "clip_model")) or (not hasattr(self, "clip_preprocess")):
+            self.clip_model, self.clip_preprocess = clip.load("ViT-B/32", device=self.device)
+        images = torch.stack([self.clip_preprocess(image).to(self.device) for image in images])
+        tokenized_text = clip.tokenize(texts).to(self.device)
+        image_features = self.clip_model.encode_image(images)
+        text_features = self.clip_model.encode_text(tokenized_text)
+        image_features /= image_features.norm(dim=-1, keepdim=True)  # (N, 512)
+        text_features /= text_features.norm(dim=-1, keepdim=True)  # (M, 512)
+        return (image_features * text_features[:, None]).sum(-1)  # (M, N)
+
+    def set_prompts(self, prompts):
+        """Set prompts in advance."""
+        self.prompts = prompts

ultralytics/utils/ops.py

@@ -363,7 +363,7 @@ def scale_image(masks, im0_shape, ratio_pad=None):
         ratio_pad (tuple): the ratio of the padding to the original image.
 
     Returns:
-        masks (torch.Tensor): The masks that are being returned.
+        masks (np.ndarray): The masks that are being returned with shape [h, w, num].
     """
     # Rescale coordinates (xyxy) from im1_shape to im0_shape
     im1_shape = masks.shape

{ultralytics-8.2.67.dist-info → ultralytics-8.2.69.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.67
+Version: 8.2.69
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu

{ultralytics-8.2.67.dist-info → ultralytics-8.2.69.dist-info}/RECORD

@@ -1,6 +1,6 @@
 tests/__init__.py,sha256=9evx3lOdKZeY1iWXvH-FkMkgf8jLucWICoabzeD6aYg,626
 tests/conftest.py,sha256=3ZtD4VlMKK5jVJwIPCrNAcG63vywJzdLq7U2AfYR2VI,2919
-tests/test_cli.py,sha256=KOEdoSwIwyZ_qFn02XdSy2CxtLdJsz7XnXVWmn7oc0s,5129
+tests/test_cli.py,sha256=PqZVSKBjLeHwQzh_hVKucQibqTFtP-2ZS6ndZRpqUDI,4654
 tests/test_cuda.py,sha256=uD-ddNEcBMFQmQ9iE4fIGh0EIcGwEoDEUNVCEHicaWE,5133
 tests/test_engine.py,sha256=xW-UT9_9xZp-7-hSnbJgMw_ezTk6NqTOIiA59XZDmxA,4934
 tests/test_explorer.py,sha256=NcxSJeB6FxwkN09hQl7nnQL--HjfHB_WcZk0mEmBNHI,2215
@@ -8,7 +8,7 @@ tests/test_exports.py,sha256=Uezf3OatpPHlo5qoPw-2kqkZxuMCF9L4XF2riD4vmII,8225
 tests/test_integrations.py,sha256=xglcfMPjfVh346PV8WTpk6tBxraCXEFJEQyyJMr5tyU,6064
 tests/test_python.py,sha256=cLK8dyRf_4H_znFIm-krnOFMydwkxKlVZvHwl9vbck8,21780
 tests/test_solutions.py,sha256=EACnPXbeJe2aVTOKfqMk5jclKKCWCVgFEzjpR6y7Sh8,3304
-ultralytics/__init__.py,sha256=2hniA3cH39Y6I4NNtuSPQqQN11EFMMqlsBXvM7MQFig,694
+ultralytics/__init__.py,sha256=YWRj4FNGuxXRahBpsPRAOxm3h0rYMQTFTPqJcnwUEDE,694
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=fD3Llw12sIkJo4g667t6b051je9nEpwdBLGgbbVEzHY,32973
@@ -84,7 +84,7 @@ ultralytics/cfg/trackers/botsort.yaml,sha256=YrPmj18p1UU40kJH5NRdL_4S8f7knggkk_q
 ultralytics/cfg/trackers/bytetrack.yaml,sha256=QvHmtuwulK4X6j3T5VEqtCm0sbWWBUVmWPcCcM20qe0,688
 ultralytics/data/__init__.py,sha256=VGe-ATG7j35F4A4r8Jmzffjlhve4JAJPgRa5ahKTU18,616
 ultralytics/data/annotator.py,sha256=1Hyu6ubrBL8KmRrt1keGn-K4XTqQdAVyIwTsQiBtzLU,2489
-ultralytics/data/augment.py,sha256=iYkTgHkmYZByMCgmdarX2M6xihKsJN1SXC9g7vaUETE,119314
+ultralytics/data/augment.py,sha256=ExU4khJfJ_TeczkJRLNUDscN57SJvAjnm-reouJcxGI,119309
 ultralytics/data/base.py,sha256=C3teLnw97ZTbpJHT9P7yYWosAKocMzgJjRe1rxgfpls,13524
 ultralytics/data/build.py,sha256=AfMmz0sHIYmwry_90tEJFRk_kz0S3SolScVXqYHiT08,7261
 ultralytics/data/converter.py,sha256=7640xKuf7LPeoTwoCvgbIXM5xbzyq72Hu2Rf2lrgjRY,17554
@@ -109,11 +109,11 @@ ultralytics/hub/__init__.py,sha256=93bqI8x8-MfDYdKkQVduuocUiQj3WGnk1nIk0li08zA,5
 ultralytics/hub/auth.py,sha256=FID58NE6fh7Op_B45QOpWBw1qoBN0ponL16uvyb2dZ8,5399
 ultralytics/hub/session.py,sha256=UF_aVwyxnbP-OzpzKXGGhi4i6KGWjjhoj5Qsn46dFpE,16257
 ultralytics/hub/utils.py,sha256=tXfM3QbXBcf4Y6StgHI1pktT4OM7Ic9eF3xiBFHGlhY,9721
+ultralytics/hub/google/__init__.py,sha256=qyvvpGP-4NAtrn7GLqfqxP_aWuRP1T0OvJYafWKvL2Q,7512
 ultralytics/models/__init__.py,sha256=TT9iLCL_n9Y80dcUq0Fo-p-GRZCSU2vrWXM3CoMwqqE,265
-ultralytics/models/fastsam/__init__.py,sha256=0dt65jZ_5b7Q-mdXN8MSEkgnFRA0FIwlel_LS2RaOlU,254
-ultralytics/models/fastsam/model.py,sha256=c7GGwaa9AXssJFwrcuytFHpPOlgSrS3n0utyf4JSL2o,1055
-ultralytics/models/fastsam/predict.py,sha256=_bOSU75qLK1XESxl-XW1SOxriCaX7nsvl5x4exG_c4Q,1324
-ultralytics/models/fastsam/prompt.py,sha256=4d9e1fEuGpTPWRfu3rG6HT8Bc0rtqJtRpNrlHkmkKcY,15860
+ultralytics/models/fastsam/__init__.py,sha256=W0rRSJM3vdxcsneuiN6_ajkUw86k6-opUKdLxVhKOoQ,203
+ultralytics/models/fastsam/model.py,sha256=r5VZj-KLKaqZtEKTZxQik8vQI2N9uOF4xpV_gA-P8h0,2101
+ultralytics/models/fastsam/predict.py,sha256=ej1Z93W73hThBxuHTdb-LB-yElijKnAMxrTUMlXJ8Qs,7262
 ultralytics/models/fastsam/utils.py,sha256=dCSm6l5yua_PTT5aNvyOvn1Q0h42Ta_NovO7sTbsBxM,715
 ultralytics/models/fastsam/val.py,sha256=ILKmw3U8FYmmQsO9wk9-bJ9Pyp_ZthJM36b61L75s3Y,1967
 ultralytics/models/nas/__init__.py,sha256=d6-WTrYLXvbPs58ebA0-583ODi-VyzXc-t4aGIDQK6M,179
@@ -204,7 +204,7 @@ ultralytics/utils/files.py,sha256=TVfY0Wi5IsUc4YdsDzC0dAg-jAP5exYvwqB3VmXhDLY,67
 ultralytics/utils/instance.py,sha256=5daM5nkxBv9hr5QzyII8zmuFj24hHuNtcr4EMCHAtpY,15654
 ultralytics/utils/loss.py,sha256=mDHGmF-gjggAUVhI1dkCm7TtfZHCwz25XKm4M2xJKLs,33916
 ultralytics/utils/metrics.py,sha256=UXMhBnTtMcpTANxmQqcYkVnj8NeAt39gZez0g6jbrW0,53786
-ultralytics/utils/ops.py,sha256=CQeMDVV4f9QWvYPNvNJu7GJAW2-XG93D7ee7yFY0vsI,32688
+ultralytics/utils/ops.py,sha256=WJHyjyTH8xl5bRkBX0JB3K1sHAGONHx_joubUewE0A8,32709
 ultralytics/utils/patches.py,sha256=Oo3DkP7MbXnNGvPfoFSocAkVvaPh9kwMT_9RQUfjVhI,3594
 ultralytics/utils/plotting.py,sha256=5HRfiG2dklWZJheTxGTy0gFRk39utHcZbMJl7j2hnMI,55522
 ultralytics/utils/tal.py,sha256=hia39MhWPFpDWOTAXC_5vz-9cUdiRHZs-UcTnxD4Dlo,16112
@@ -222,9 +222,9 @@ ultralytics/utils/callbacks/neptune.py,sha256=5Z3ua5YBTUS56FH8VQKQG1aaIo9fH8GEyz
 ultralytics/utils/callbacks/raytune.py,sha256=ODVYzy-CoM4Uge0zjkh3Hnh9nF2M0vhDrSenXnvcizw,705
 ultralytics/utils/callbacks/tensorboard.py,sha256=QEgOVhUqY9akOs5TJIwz1Rvn6l32xWLpOxlwEyWF0B8,4136
 ultralytics/utils/callbacks/wb.py,sha256=9-fjQIdLjr3b73DTE3rHO171KvbH1VweJ-bmbv-rqTw,6747
-ultralytics-8.2.67.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.2.67.dist-info/METADATA,sha256=GXFnutNkySYV8dkdMktKgVCDUJKN6o1zuuBh5TKw2ig,41337
-ultralytics-8.2.67.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-ultralytics-8.2.67.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.2.67.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.2.67.dist-info/RECORD,,
+ultralytics-8.2.69.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.2.69.dist-info/METADATA,sha256=htZwlHV6f-WyWZpx2aAgEhKJYDRhK56EMOs0w0XwhZ4,41337
+ultralytics-8.2.69.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+ultralytics-8.2.69.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.2.69.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.2.69.dist-info/RECORD,,

{ultralytics-8.2.67.dist-info → ultralytics-8.2.69.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.1.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ultralytics/models/fastsam/prompt.py

@@ -1,352 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-
-import os
-from pathlib import Path
-
-import cv2
-import numpy as np
-import torch
-from PIL import Image
-from torch import Tensor
-
-from ultralytics.utils import TQDM, checks
-
-
-class FastSAMPrompt:
-    """
-    Fast Segment Anything Model class for image annotation and visualization.
-
-    Attributes:
-        device (str): Computing device ('cuda' or 'cpu').
-        results: Object detection or segmentation results.
-        source: Source image or image path.
-        clip: CLIP model for linear assignment.
-    """
-
-    def __init__(self, source, results, device="cuda") -> None:
-        """Initializes FastSAMPrompt with given source, results and device, and assigns clip for linear assignment."""
-        if isinstance(source, (str, Path)) and os.path.isdir(source):
-            raise ValueError("FastSAM only accepts image paths and PIL Image sources, not directories.")
-        self.device = device
-        self.results = results
-        self.source = source
-
-        # Import and assign clip
-        try:
-            import clip
-        except ImportError:
-            checks.check_requirements("git+https://github.com/ultralytics/CLIP.git")
-            import clip
-        self.clip = clip
-
-    @staticmethod
-    def _segment_image(image, bbox):
-        """Segments the given image according to the provided bounding box coordinates."""
-        image_array = np.array(image)
-        segmented_image_array = np.zeros_like(image_array)
-        x1, y1, x2, y2 = bbox
-        segmented_image_array[y1:y2, x1:x2] = image_array[y1:y2, x1:x2]
-        segmented_image = Image.fromarray(segmented_image_array)
-        black_image = Image.new("RGB", image.size, (255, 255, 255))
-        # transparency_mask = np.zeros_like((), dtype=np.uint8)
-        transparency_mask = np.zeros((image_array.shape[0], image_array.shape[1]), dtype=np.uint8)
-        transparency_mask[y1:y2, x1:x2] = 255
-        transparency_mask_image = Image.fromarray(transparency_mask, mode="L")
-        black_image.paste(segmented_image, mask=transparency_mask_image)
-        return black_image
-
-    @staticmethod
-    def _format_results(result, filter=0):
-        """Formats detection results into list of annotations each containing ID, segmentation, bounding box, score and
-        area.
-        """
-        annotations = []
-        n = len(result.masks.data) if result.masks is not None else 0
-        for i in range(n):
-            mask = result.masks.data[i] == 1.0
-            if torch.sum(mask) >= filter:
-                annotation = {
-                    "id": i,
-                    "segmentation": mask.cpu().numpy(),
-                    "bbox": result.boxes.data[i],
-                    "score": result.boxes.conf[i],
-                }
-                annotation["area"] = annotation["segmentation"].sum()
-                annotations.append(annotation)
-        return annotations
-
-    @staticmethod
-    def _get_bbox_from_mask(mask):
-        """Applies morphological transformations to the mask, displays it, and if with_contours is True, draws
-        contours.
-        """
-        mask = mask.astype(np.uint8)
-        contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        x1, y1, w, h = cv2.boundingRect(contours[0])
-        x2, y2 = x1 + w, y1 + h
-        if len(contours) > 1:
-            for b in contours:
-                x_t, y_t, w_t, h_t = cv2.boundingRect(b)
-                x1 = min(x1, x_t)
-                y1 = min(y1, y_t)
-                x2 = max(x2, x_t + w_t)
-                y2 = max(y2, y_t + h_t)
-        return [x1, y1, x2, y2]
-
-    def plot(
-        self,
-        annotations,
-        output,
-        bbox=None,
-        points=None,
-        point_label=None,
-        mask_random_color=True,
-        better_quality=True,
-        retina=False,
-        with_contours=True,
-    ):
-        """
-        Plots annotations, bounding boxes, and points on images and saves the output.
-
-        Args:
-            annotations (list): Annotations to be plotted.
-            output (str or Path): Output directory for saving the plots.
-            bbox (list, optional): Bounding box coordinates [x1, y1, x2, y2]. Defaults to None.
-            points (list, optional): Points to be plotted. Defaults to None.
-            point_label (list, optional): Labels for the points. Defaults to None.
-            mask_random_color (bool, optional): Whether to use random color for masks. Defaults to True.
-            better_quality (bool, optional): Whether to apply morphological transformations for better mask quality.
-                Defaults to True.
-            retina (bool, optional): Whether to use retina mask. Defaults to False.
-            with_contours (bool, optional): Whether to plot contours. Defaults to True.
-        """
-        import matplotlib.pyplot as plt
-
-        pbar = TQDM(annotations, total=len(annotations))
-        for ann in pbar:
-            result_name = os.path.basename(ann.path)
-            image = ann.orig_img[..., ::-1]  # BGR to RGB
-            original_h, original_w = ann.orig_shape
-            # For macOS only
-            # plt.switch_backend('TkAgg')
-            plt.figure(figsize=(original_w / 100, original_h / 100))
-            # Add subplot with no margin.
-            plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
-            plt.margins(0, 0)
-            plt.gca().xaxis.set_major_locator(plt.NullLocator())
-            plt.gca().yaxis.set_major_locator(plt.NullLocator())
-            plt.imshow(image)
-
-            if ann.masks is not None:
-                masks = ann.masks.data
-                if better_quality:
-                    if isinstance(masks[0], torch.Tensor):
-                        masks = np.array(masks.cpu())
-                    for i, mask in enumerate(masks):
-                        mask = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_CLOSE, np.ones((3, 3), np.uint8))
-                        masks[i] = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_OPEN, np.ones((8, 8), np.uint8))
-
-                self.fast_show_mask(
-                    masks,
-                    plt.gca(),
-                    random_color=mask_random_color,
-                    bbox=bbox,
-                    points=points,
-                    pointlabel=point_label,
-                    retinamask=retina,
-                    target_height=original_h,
-                    target_width=original_w,
-                )
-
-                if with_contours:
-                    contour_all = []
-                    temp = np.zeros((original_h, original_w, 1))
-                    for i, mask in enumerate(masks):
-                        mask = mask.astype(np.uint8)
-                        if not retina:
-                            mask = cv2.resize(mask, (original_w, original_h), interpolation=cv2.INTER_NEAREST)
-                        contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
-                        contour_all.extend(iter(contours))
-                    cv2.drawContours(temp, contour_all, -1, (255, 255, 255), 2)
-                    color = np.array([0 / 255, 0 / 255, 1.0, 0.8])
-                    contour_mask = temp / 255 * color.reshape(1, 1, -1)
-                    plt.imshow(contour_mask)
-
-            # Save the figure
-            save_path = Path(output) / result_name
-            save_path.parent.mkdir(exist_ok=True, parents=True)
-            plt.axis("off")
-            plt.savefig(save_path, bbox_inches="tight", pad_inches=0, transparent=True)
-            plt.close()
-            pbar.set_description(f"Saving {result_name} to {save_path}")
-
-    @staticmethod
-    def fast_show_mask(
-        annotation,
-        ax,
-        random_color=False,
-        bbox=None,
-        points=None,
-        pointlabel=None,
-        retinamask=True,
-        target_height=960,
-        target_width=960,
-    ):
-        """
-        Quickly shows the mask annotations on the given matplotlib axis.
-
-        Args:
-            annotation (array-like): Mask annotation.
-            ax (matplotlib.axes.Axes): Matplotlib axis.
-            random_color (bool, optional): Whether to use random color for masks. Defaults to False.
-            bbox (list, optional): Bounding box coordinates [x1, y1, x2, y2]. Defaults to None.
-            points (list, optional): Points to be plotted. Defaults to None.
-            pointlabel (list, optional): Labels for the points. Defaults to None.
-            retinamask (bool, optional): Whether to use retina mask. Defaults to True.
-            target_height (int, optional): Target height for resizing. Defaults to 960.
-            target_width (int, optional): Target width for resizing. Defaults to 960.
-        """
-        import matplotlib.pyplot as plt
-
-        n, h, w = annotation.shape  # batch, height, width
-
-        areas = np.sum(annotation, axis=(1, 2))
-        annotation = annotation[np.argsort(areas)]
-
-        index = (annotation != 0).argmax(axis=0)
-        if random_color:
-            color = np.random.random((n, 1, 1, 3))
-        else:
-            color = np.ones((n, 1, 1, 3)) * np.array([30 / 255, 144 / 255, 1.0])
-        transparency = np.ones((n, 1, 1, 1)) * 0.6
-        visual = np.concatenate([color, transparency], axis=-1)
-        mask_image = np.expand_dims(annotation, -1) * visual
-
-        show = np.zeros((h, w, 4))
-        h_indices, w_indices = np.meshgrid(np.arange(h), np.arange(w), indexing="ij")
-        indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
-
-        show[h_indices, w_indices, :] = mask_image[indices]
-        if bbox is not None:
-            x1, y1, x2, y2 = bbox
-            ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor="b", linewidth=1))
-        # Draw point
-        if points is not None:
-            plt.scatter(
-                [point[0] for i, point in enumerate(points) if pointlabel[i] == 1],
-                [point[1] for i, point in enumerate(points) if pointlabel[i] == 1],
-                s=20,
-                c="y",
-            )
-            plt.scatter(
-                [point[0] for i, point in enumerate(points) if pointlabel[i] == 0],
-                [point[1] for i, point in enumerate(points) if pointlabel[i] == 0],
-                s=20,
-                c="m",
-            )
-
-        if not retinamask:
-            show = cv2.resize(show, (target_width, target_height), interpolation=cv2.INTER_NEAREST)
-        ax.imshow(show)
-
-    @torch.no_grad()
-    def retrieve(self, model, preprocess, elements, search_text: str, device) -> Tensor:
-        """Processes images and text with a model, calculates similarity, and returns softmax score."""
-        preprocessed_images = [preprocess(image).to(device) for image in elements]
-        tokenized_text = self.clip.tokenize([search_text]).to(device)
-        stacked_images = torch.stack(preprocessed_images)
-        image_features = model.encode_image(stacked_images)
-        text_features = model.encode_text(tokenized_text)
-        image_features /= image_features.norm(dim=-1, keepdim=True)
-        text_features /= text_features.norm(dim=-1, keepdim=True)
-        probs = 100.0 * image_features @ text_features.T
-        return probs[:, 0].softmax(dim=0)
-
-    def _crop_image(self, format_results):
-        """Crops an image based on provided annotation format and returns cropped images and related data."""
-        image = Image.fromarray(cv2.cvtColor(self.results[0].orig_img, cv2.COLOR_BGR2RGB))
-        ori_w, ori_h = image.size
-        annotations = format_results
-        mask_h, mask_w = annotations[0]["segmentation"].shape
-        if ori_w != mask_w or ori_h != mask_h:
-            image = image.resize((mask_w, mask_h))
-        cropped_images = []
-        filter_id = []
-        for _, mask in enumerate(annotations):
-            if np.sum(mask["segmentation"]) <= 100:
-                filter_id.append(_)
-                continue
-            bbox = self._get_bbox_from_mask(mask["segmentation"])  # bbox from mask
-            cropped_images.append(self._segment_image(image, bbox))  # save cropped image
-
-        return cropped_images, filter_id, annotations
-
-    def box_prompt(self, bbox):
-        """Modifies the bounding box properties and calculates IoU between masks and bounding box."""
-        if self.results[0].masks is not None:
-            assert bbox[2] != 0 and bbox[3] != 0, "Bounding box width and height should not be zero"
-            masks = self.results[0].masks.data
-            target_height, target_width = self.results[0].orig_shape
-            h = masks.shape[1]
-            w = masks.shape[2]
-            if h != target_height or w != target_width:
-                bbox = [
-                    int(bbox[0] * w / target_width),
-                    int(bbox[1] * h / target_height),
-                    int(bbox[2] * w / target_width),
-                    int(bbox[3] * h / target_height),
-                ]
-            bbox[0] = max(round(bbox[0]), 0)
-            bbox[1] = max(round(bbox[1]), 0)
-            bbox[2] = min(round(bbox[2]), w)
-            bbox[3] = min(round(bbox[3]), h)
-
-            # IoUs = torch.zeros(len(masks), dtype=torch.float32)
-            bbox_area = (bbox[3] - bbox[1]) * (bbox[2] - bbox[0])
-
-            masks_area = torch.sum(masks[:, bbox[1] : bbox[3], bbox[0] : bbox[2]], dim=(1, 2))
-            orig_masks_area = torch.sum(masks, dim=(1, 2))
-
-            union = bbox_area + orig_masks_area - masks_area
-            iou = masks_area / union
-            max_iou_index = torch.argmax(iou)
-
-            self.results[0].masks.data = torch.tensor(np.array([masks[max_iou_index].cpu().numpy()]))
-        return self.results
-
-    def point_prompt(self, points, pointlabel):  # numpy
-        """Adjusts points on detected masks based on user input and returns the modified results."""
-        if self.results[0].masks is not None:
-            masks = self._format_results(self.results[0], 0)
-            target_height, target_width = self.results[0].orig_shape
-            h = masks[0]["segmentation"].shape[0]
-            w = masks[0]["segmentation"].shape[1]
-            if h != target_height or w != target_width:
-                points = [[int(point[0] * w / target_width), int(point[1] * h / target_height)] for point in points]
-            onemask = np.zeros((h, w))
-            for annotation in masks:
-                mask = annotation["segmentation"] if isinstance(annotation, dict) else annotation
-                for i, point in enumerate(points):
-                    if mask[point[1], point[0]] == 1 and pointlabel[i] == 1:
-                        onemask += mask
-                    if mask[point[1], point[0]] == 1 and pointlabel[i] == 0:
-                        onemask -= mask
-            onemask = onemask >= 1
-            self.results[0].masks.data = torch.tensor(np.array([onemask]))
-        return self.results
-
-    def text_prompt(self, text, clip_download_root=None):
-        """Processes a text prompt, applies it to existing results and returns the updated results."""
-        if self.results[0].masks is not None:
-            format_results = self._format_results(self.results[0], 0)
-            cropped_images, filter_id, annotations = self._crop_image(format_results)
-            clip_model, preprocess = self.clip.load("ViT-B/32", download_root=clip_download_root, device=self.device)
-            scores = self.retrieve(clip_model, preprocess, cropped_images, text, device=self.device)
-            max_idx = torch.argmax(scores)
-            max_idx += sum(np.array(filter_id) <= int(max_idx))
-            self.results[0].masks.data = torch.tensor(np.array([annotations[max_idx]["segmentation"]]))
-        return self.results
-
-    def everything_prompt(self):
-        """Returns the processed results from the previous methods in the class."""
-        return self.results