ultralytics 8.3.125__tar.gz → 8.3.127__tar.gz

{ultralytics-8.3.125/ultralytics.egg-info → ultralytics-8.3.127}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.125
+Version: 8.3.127
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -70,6 +70,7 @@ Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export"
 Provides-Extra: solutions
 Requires-Dist: shapely>=2.0.0; extra == "solutions"
 Requires-Dist: streamlit>=1.29.0; extra == "solutions"
+Requires-Dist: flask; extra == "solutions"
 Provides-Extra: logging
 Requires-Dist: wandb; extra == "logging"
 Requires-Dist: tensorboard; extra == "logging"

{ultralytics-8.3.125 → ultralytics-8.3.127}/pyproject.toml

@@ -105,6 +105,7 @@ export = [
 solutions = [
     "shapely>=2.0.0",    # shapely for point and polygon data matching
     "streamlit>=1.29.0",    # for live inference on web browser, i.e `yolo streamlit-predict`
+    "flask",  # for similarity search solution
 ]
 logging = [
     "wandb", # https://docs.ultralytics.com/integrations/weights-biases/

{ultralytics-8.3.125 → ultralytics-8.3.127}/tests/test_cuda.py

@@ -10,8 +10,18 @@ from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE, MODEL, SOURCE
 from ultralytics import YOLO
 from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
 from ultralytics.utils import ASSETS, WEIGHTS_DIR
+from ultralytics.utils.autodevice import GPUInfo
 from ultralytics.utils.checks import check_amp
 
+# Try to find idle devices if CUDA is available
+DEVICES = []
+if CUDA_IS_AVAILABLE:
+    gpu_info = GPUInfo()
+    gpu_info.print_status()
+    idle_gpus = gpu_info.select_idle_gpu(count=2, min_memory_mb=2048)
+    if idle_gpus:
+        DEVICES = idle_gpus
+
 
 def test_checks():
     """Validate CUDA settings against torch CUDA functions."""
@@ -19,16 +29,16 @@ def test_checks():
     assert torch.cuda.device_count() == CUDA_DEVICE_COUNT
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_amp():
     """Test AMP training checks."""
-    model = YOLO("yolo11n.pt").model.cuda()
+    model = YOLO("yolo11n.pt").model.to(f"cuda:{DEVICES[0]}")
     assert check_amp(model)
 
 
 @pytest.mark.slow
 @pytest.mark.skipif(True, reason="CUDA export tests disabled pending additional Ultralytics GPU server availability")
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 @pytest.mark.parametrize(
     "task, dynamic, int8, half, batch",
     [  # generate all combinations but exclude those where both int8 and half are True
@@ -40,16 +50,7 @@ def test_amp():
     ],
 )
 def test_export_engine_matrix(task, dynamic, int8, half, batch):
-    """
-    Test YOLO model export to TensorRT format for various configurations and run inference.
-
-    Args:
-        task (str): Task type like 'detect', 'segment', etc.
-        dynamic (bool): Whether to use dynamic input size.
-        int8 (bool): Whether to use INT8 precision.
-        half (bool): Whether to use FP16 precision.
-        batch (int): Batch size for export.
-    """
+    """Test YOLO model export to TensorRT format for various configurations and run inference."""
     file = YOLO(TASK2MODEL[task]).export(
         format="engine",
         imgsz=32,
@@ -60,105 +61,109 @@ def test_export_engine_matrix(task, dynamic, int8, half, batch):
         data=TASK2DATA[task],
         workspace=1,  # reduce workspace GB for less resource utilization during testing
         simplify=True,  # use 'onnxslim'
+        device=DEVICES[0],
     )
-    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
+    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32, device=DEVICES[0])  # exported model inference
     Path(file).unlink()  # cleanup
     Path(file).with_suffix(".cache").unlink() if int8 else None  # cleanup INT8 cache
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_train():
     """Test model training on a minimal dataset using available CUDA devices."""
-    device = 0 if CUDA_DEVICE_COUNT == 1 else [0, 1]
+    device = DEVICES if len(DEVICES) > 1 else DEVICES[0]
     YOLO(MODEL).train(data="coco8.yaml", imgsz=64, epochs=1, device=device)  # requires imgsz>=64
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_predict_multiple_devices():
     """Validate model prediction consistency across CPU and CUDA devices."""
     model = YOLO("yolo11n.pt")
+
+    # Test CPU
     model = model.cpu()
     assert str(model.device) == "cpu"
-    _ = model(SOURCE)  # CPU inference
+    _ = model(SOURCE)
     assert str(model.device) == "cpu"
 
-    model = model.to("cuda:0")
-    assert str(model.device) == "cuda:0"
-    _ = model(SOURCE)  # CUDA inference
-    assert str(model.device) == "cuda:0"
+    # Test CUDA
+    cuda_device = f"cuda:{DEVICES[0]}"
+    model = model.to(cuda_device)
+    assert str(model.device) == cuda_device
+    _ = model(SOURCE)
+    assert str(model.device) == cuda_device
 
+    # Test CPU again
     model = model.cpu()
     assert str(model.device) == "cpu"
-    _ = model(SOURCE)  # CPU inference
+    _ = model(SOURCE)
     assert str(model.device) == "cpu"
 
-    model = model.cuda()
-    assert str(model.device) == "cuda:0"
-    _ = model(SOURCE)  # CUDA inference
-    assert str(model.device) == "cuda:0"
+    # Test CUDA again
+    model = model.to(cuda_device)
+    assert str(model.device) == cuda_device
+    _ = model(SOURCE)
+    assert str(model.device) == cuda_device
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_autobatch():
     """Check optimal batch size for YOLO model training using autobatch utility."""
     from ultralytics.utils.autobatch import check_train_batch_size
 
-    check_train_batch_size(YOLO(MODEL).model.cuda(), imgsz=128, amp=True)
+    check_train_batch_size(YOLO(MODEL).model.to(f"cuda:{DEVICES[0]}"), imgsz=128, amp=True)
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_utils_benchmarks():
     """Profile YOLO models for performance benchmarks."""
     from ultralytics.utils.benchmarks import ProfileModels
 
     # Pre-export a dynamic engine model to use dynamic inference
-    YOLO(MODEL).export(format="engine", imgsz=32, dynamic=True, batch=1)
-    ProfileModels([MODEL], imgsz=32, half=False, min_time=1, num_timed_runs=3, num_warmup_runs=1).run()
+    YOLO(MODEL).export(format="engine", imgsz=32, dynamic=True, batch=1, device=DEVICES[0])
+    ProfileModels(
+        [MODEL],
+        imgsz=32,
+        half=False,
+        min_time=1,
+        num_timed_runs=3,
+        num_warmup_runs=1,
+        device=DEVICES[0],
+    ).run()
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_predict_sam():
-    """Test SAM model predictions using different prompts, including bounding boxes and point annotations."""
+    """Test SAM model predictions using different prompts."""
     from ultralytics import SAM
     from ultralytics.models.sam import Predictor as SAMPredictor
 
-    # Load a model
     model = SAM(WEIGHTS_DIR / "sam2.1_b.pt")
-
-    # Display model information (optional)
     model.info()
 
-    # Run inference
-    model(SOURCE, device=0)
-
-    # Run inference with bboxes prompt
-    model(SOURCE, bboxes=[439, 437, 524, 709], device=0)
-
-    # Run inference with no labels
-    model(ASSETS / "zidane.jpg", points=[900, 370], device=0)
-
-    # Run inference with 1D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[900, 370], labels=[1], device=0)
-
-    # Run inference with 2D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[[900, 370]], labels=[1], device=0)
-
-    # Run inference with multiple 2D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1], device=0)
-
-    # Run inference with 3D points and 2D labels (multiple points per object)
-    model(ASSETS / "zidane.jpg", points=[[[900, 370], [1000, 100]]], labels=[[1, 1]], device=0)
-
-    # Create SAMPredictor
-    overrides = dict(conf=0.25, task="segment", mode="predict", imgsz=1024, model=WEIGHTS_DIR / "mobile_sam.pt")
-    predictor = SAMPredictor(overrides=overrides)
-
-    # Set image
-    predictor.set_image(ASSETS / "zidane.jpg")  # set with image file
+    # Run inference with various prompts
+    model(SOURCE, device=DEVICES[0])
+    model(SOURCE, bboxes=[439, 437, 524, 709], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[900, 370], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[900, 370], labels=[1], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[[900, 370]], labels=[1], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[[[900, 370], [1000, 100]]], labels=[[1, 1]], device=DEVICES[0])
+
+    # Test predictor
+    predictor = SAMPredictor(
+        overrides=dict(
+            conf=0.25,
+            task="segment",
+            mode="predict",
+            imgsz=1024,
+            model=WEIGHTS_DIR / "mobile_sam.pt",
+            device=DEVICES[0],
+        )
+    )
+    predictor.set_image(ASSETS / "zidane.jpg")
     # predictor(bboxes=[439, 437, 524, 709])
     # predictor(points=[900, 370], labels=[1])
-
-    # Reset image
     predictor.reset_image()

{ultralytics-8.3.125 → ultralytics-8.3.127}/tests/test_solutions.py

@@ -174,3 +174,14 @@ def test_solution(name, solution_class, needs_frame_count, video, kwargs):
         video_path=str(TMP / video),
         needs_frame_count=needs_frame_count,
     )
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(checks.IS_PYTHON_3_8, reason="Disabled due to unsupported CLIP dependencies.")
+@pytest.mark.skipif(IS_RASPBERRYPI, reason="Disabled due to slow performance on Raspberry Pi.")
+def test_similarity_search():
+    """Test similarity search solution."""
+    from ultralytics import solutions
+
+    searcher = solutions.VisualAISearch()
+    _ = searcher("a dog sitting on a bench")  # Returns the results in format "- img name | similarity score"

{ultralytics-8.3.125 → ultralytics-8.3.127}/ultralytics/__init__.py

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

{ultralytics-8.3.125 → ultralytics-8.3.127}/ultralytics/cfg/default.yaml

@@ -17,7 +17,7 @@ imgsz: 640 # (int | list) input images size as int for train and val modes, or l
 save: True # (bool) save train checkpoints and predict results
 save_period: -1 # (int) Save checkpoint every x epochs (disabled if < 1)
 cache: False # (bool) True/ram, disk or False. Use cache for data loading
-device: # (int | str | list, optional) device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu
+device: # (int | str | list) device: CUDA device=0 or [0,1,2,3] or "cpu/mps" or -1 or [-1,-1] to auto-select idle GPUs
 workers: 8 # (int) number of worker threads for data loading (per RANK if DDP)
 project: # (str, optional) project name
 name: # (str, optional) experiment name, results saved to 'project/name' directory

{ultralytics-8.3.125 → ultralytics-8.3.127}/ultralytics/engine/trainer.py

@@ -105,6 +105,7 @@ class BaseTrainer:
         self.args = get_cfg(cfg, overrides)
         self.check_resume(overrides)
         self.device = select_device(self.args.device, self.args.batch)
+        self.args.device = str(self.device)  # ensure -1 is updated to selected CUDA device
         self.validator = None
         self.metrics = None
         self.plots = {}

{ultralytics-8.3.125 → ultralytics-8.3.127}/ultralytics/solutions/__init__.py

@@ -12,6 +12,7 @@ from .parking_management import ParkingManagement, ParkingPtsSelection
 from .queue_management import QueueManager
 from .region_counter import RegionCounter
 from .security_alarm import SecurityAlarm
+from .similarity_search import SearchApp, VisualAISearch
 from .speed_estimation import SpeedEstimator
 from .streamlit_inference import Inference
 from .trackzone import TrackZone
@@ -35,4 +36,6 @@ __all__ = (
     "Analytics",
     "Inference",
     "TrackZone",
+    "SearchApp",
+    "VisualAISearch",
 )

{ultralytics-8.3.125 → ultralytics-8.3.127}/ultralytics/solutions/config.py

@@ -48,6 +48,7 @@ class SolutionConfig:
         half (bool): Whether to use FP16 precision (requires a supported CUDA device).
         tracker (str): Path to tracking configuration YAML file (e.g., 'botsort.yaml').
         verbose (bool): Enable verbose logging output for debugging or diagnostics.
+        data (str): Path to image directory used for similarity search.
 
     Methods:
         update: Update the configuration with user-defined keyword arguments and raise error on invalid keys.
@@ -91,6 +92,7 @@ class SolutionConfig:
     half: bool = False
     tracker: str = "botsort.yaml"
     verbose: bool = True
+    data: str = "images"
 
     def update(self, **kwargs):
         """Update configuration parameters with new values provided as keyword arguments."""

ultralytics-8.3.127/ultralytics/solutions/similarity_search.py

@@ -0,0 +1,176 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+from PIL import Image
+
+from ultralytics.data.utils import IMG_FORMATS
+from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.utils.checks import check_requirements
+from ultralytics.utils.torch_utils import select_device
+
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"  # Avoid OpenMP conflict on some systems
+
+
+class VisualAISearch(BaseSolution):
+    """
+    VisualAISearch leverages OpenCLIP to generate high-quality image and text embeddings, aligning them in a shared
+    semantic space. It then uses FAISS to perform fast and scalable similarity-based retrieval, allowing users to search
+    large collections of images using natural language queries with high accuracy and speed.
+
+    Attributes:
+        data (str): Directory containing images.
+        device (str): Computation device, e.g., 'cpu' or 'cuda'.
+    """
+
+    def __init__(self, **kwargs):
+        """Initializes the VisualAISearch class with the FAISS index file and CLIP model."""
+        super().__init__(**kwargs)
+        check_requirements(["open-clip-torch", "faiss-cpu"])
+        import faiss
+        import open_clip
+
+        self.faiss = faiss
+        self.open_clip = open_clip
+
+        self.faiss_index = "faiss.index"
+        self.data_path_npy = "paths.npy"
+        self.model_name = "ViT-B-32-quickgelu"
+        self.data_dir = Path(self.CFG["data"])
+        self.device = select_device(self.CFG["device"])
+
+        if not self.data_dir.exists():
+            from ultralytics.utils import ASSETS_URL
+
+            self.LOGGER.warning(f"{self.data_dir} not found. Downloading images.zip from {ASSETS_URL}/images.zip")
+            from ultralytics.utils.downloads import safe_download
+
+            safe_download(url=f"{ASSETS_URL}/images.zip", unzip=True, retry=3)
+            self.data_dir = Path("images")
+
+        self.clip_model, _, self.preprocess = self.open_clip.create_model_and_transforms(
+            self.model_name, pretrained="openai"
+        )
+        self.clip_model = self.clip_model.to(self.device).eval()
+        self.tokenizer = self.open_clip.get_tokenizer(self.model_name)
+
+        self.index = None
+        self.image_paths = []
+
+        self.load_or_build_index()
+
+    def extract_image_feature(self, path):
+        """Extract CLIP image embedding."""
+        image = Image.open(path)
+        tensor = self.preprocess(image).unsqueeze(0).to(self.device)
+        with torch.no_grad():
+            return self.clip_model.encode_image(tensor).cpu().numpy()
+
+    def extract_text_feature(self, text):
+        """Extract CLIP text embedding."""
+        tokens = self.tokenizer([text]).to(self.device)
+        with torch.no_grad():
+            return self.clip_model.encode_text(tokens).cpu().numpy()
+
+    def load_or_build_index(self):
+        """Loads FAISS index or builds a new one from image features."""
+        # Check if the FAISS index and corresponding image paths already exist
+        if Path(self.faiss_index).exists() and Path(self.data_path_npy).exists():
+            self.LOGGER.info("Loading existing FAISS index...")
+            self.index = self.faiss.read_index(self.faiss_index)  # Load the FAISS index from disk
+            self.image_paths = np.load(self.data_path_npy)  # Load the saved image path list
+            return  # Exit the function as the index is successfully loaded
+
+        # If the index doesn't exist, start building it from scratch
+        self.LOGGER.info("Building FAISS index from images...")
+        vectors = []  # List to store feature vectors of images
+
+        # Iterate over all image files in the data directory
+        for file in self.data_dir.iterdir():
+            # Skip files that are not valid image formats
+            if file.suffix.lower().lstrip(".") not in IMG_FORMATS:
+                continue
+            try:
+                # Extract feature vector for the image and add to the list
+                vectors.append(self.extract_image_feature(file))
+                self.image_paths.append(file.name)  # Store the corresponding image name
+            except Exception as e:
+                self.LOGGER.warning(f"Skipping {file.name}: {e}")
+
+        # If no vectors were successfully created, raise an error
+        if not vectors:
+            raise RuntimeError("No image embeddings could be generated.")
+
+        vectors = np.vstack(vectors).astype("float32")  # Stack all vectors into a NumPy array and convert to float32
+        self.faiss.normalize_L2(vectors)  # Normalize vectors to unit length for cosine similarity
+
+        self.index = self.faiss.IndexFlatIP(vectors.shape[1])  # Create a new FAISS index using inner product
+        self.index.add(vectors)  # Add the normalized vectors to the FAISS index
+        self.faiss.write_index(self.index, self.faiss_index)  # Save the newly built FAISS index to disk
+        np.save(self.data_path_npy, np.array(self.image_paths))  # Save the list of image paths to disk
+
+        self.LOGGER.info(f"Indexed {len(self.image_paths)} images.")
+
+    def search(self, query, k=30, similarity_thresh=0.1):
+        """Returns top-k semantically similar images to the given query."""
+        text_feat = self.extract_text_feature(query).astype("float32")
+        self.faiss.normalize_L2(text_feat)
+
+        D, index = self.index.search(text_feat, k)
+        results = [
+            (self.image_paths[i], float(D[0][idx])) for idx, i in enumerate(index[0]) if D[0][idx] >= similarity_thresh
+        ]
+        results.sort(key=lambda x: x[1], reverse=True)
+
+        self.LOGGER.info("\nRanked Results:")
+        for name, score in results:
+            self.LOGGER.info(f"  - {name} | Similarity: {score:.4f}")
+
+        return [r[0] for r in results]
+
+    def __call__(self, query):
+        """Direct call for search function."""
+        return self.search(query)
+
+
+class SearchApp:
+    """
+    A Flask-based web interface powers the semantic image search experience, enabling users to input natural language
+    queries and instantly view the most relevant images retrieved from the indexed database—all through a clean,
+    responsive, and easily customizable frontend.
+
+    Args:
+        data (str): Path to images to index and search.
+        device (str): Device to run inference on (e.g. 'cpu', 'cuda').
+    """
+
+    def __init__(self, data="images", device=None):
+        """Initialization of the VisualAISearch class for performing semantic image search."""
+        check_requirements("flask")
+        from flask import Flask, render_template, request
+
+        self.render_template = render_template
+        self.request = request
+        self.searcher = VisualAISearch(data=data, device=device)
+        self.app = Flask(
+            __name__,
+            template_folder="templates",
+            static_folder=Path(data).resolve(),  # Absolute path to serve images
+            static_url_path="/images",  # URL prefix for images
+        )
+        self.app.add_url_rule("/", view_func=self.index, methods=["GET", "POST"])
+
+    def index(self):
+        """Function to process the user query and display output."""
+        results = []
+        if self.request.method == "POST":
+            query = self.request.form.get("query", "").strip()
+            results = self.searcher(query)
+        return self.render_template("similarity-search.html", results=results)
+
+    def run(self, debug=False):
+        """Runs the Flask web app."""
+        self.app.run(debug=debug)

{ultralytics-8.3.125 → ultralytics-8.3.127}/ultralytics/solutions/solutions.py

@@ -54,55 +54,56 @@ class BaseSolution:
             is_cli (bool): Enables CLI mode if set to True.
             **kwargs (Any): Additional configuration parameters that override defaults.
         """
-        check_requirements("shapely>=2.0.0")
-        from shapely.geometry import LineString, Point, Polygon
-        from shapely.prepared import prep
-
-        self.LineString = LineString
-        self.Polygon = Polygon
-        self.Point = Point
-        self.prep = prep
-        self.annotator = None  # Initialize annotator
-        self.tracks = None
-        self.track_data = None
-        self.boxes = []
-        self.clss = []
-        self.track_ids = []
-        self.track_line = None
-        self.masks = None
-        self.r_s = None
-
-        self.LOGGER = LOGGER  # Store logger object to be used in multiple solution classes
         self.CFG = vars(SolutionConfig().update(**kwargs))
-        self.LOGGER.info(f"Ultralytics Solutions: ✅ {self.CFG}")
-
-        self.region = self.CFG["region"]  # Store region data for other classes usage
-        self.line_width = self.CFG["line_width"]
-
-        # Load Model and store additional information (classes, show_conf, show_label)
-        if self.CFG["model"] is None:
-            self.CFG["model"] = "yolo11n.pt"
-        self.model = YOLO(self.CFG["model"])
-        self.names = self.model.names
-        self.classes = self.CFG["classes"]
-        self.show_conf = self.CFG["show_conf"]
-        self.show_labels = self.CFG["show_labels"]
-
-        self.track_add_args = {  # Tracker additional arguments for advance configuration
-            k: self.CFG[k] for k in ["iou", "conf", "device", "max_det", "half", "tracker", "device", "verbose"]
-        }  # verbose must be passed to track method; setting it False in YOLO still logs the track information.
-
-        if is_cli and self.CFG["source"] is None:
-            d_s = "solutions_ci_demo.mp4" if "-pose" not in self.CFG["model"] else "solution_ci_pose_demo.mp4"
-            self.LOGGER.warning(f"source not provided. using default source {ASSETS_URL}/{d_s}")
-            from ultralytics.utils.downloads import safe_download
-
-            safe_download(f"{ASSETS_URL}/{d_s}")  # download source from ultralytics assets
-            self.CFG["source"] = d_s  # set default source
-
-        # Initialize environment and region setup
-        self.env_check = check_imshow(warn=True)
-        self.track_history = defaultdict(list)
+        self.LOGGER = LOGGER  # Store logger object to be used in multiple solution classes
+
+        if self.__class__.__name__ != "VisualAISearch":
+            check_requirements("shapely>=2.0.0")
+            from shapely.geometry import LineString, Point, Polygon
+            from shapely.prepared import prep
+
+            self.LineString = LineString
+            self.Polygon = Polygon
+            self.Point = Point
+            self.prep = prep
+            self.annotator = None  # Initialize annotator
+            self.tracks = None
+            self.track_data = None
+            self.boxes = []
+            self.clss = []
+            self.track_ids = []
+            self.track_line = None
+            self.masks = None
+            self.r_s = None
+
+            self.LOGGER.info(f"Ultralytics Solutions: ✅ {self.CFG}")
+            self.region = self.CFG["region"]  # Store region data for other classes usage
+            self.line_width = self.CFG["line_width"]
+
+            # Load Model and store additional information (classes, show_conf, show_label)
+            if self.CFG["model"] is None:
+                self.CFG["model"] = "yolo11n.pt"
+            self.model = YOLO(self.CFG["model"])
+            self.names = self.model.names
+            self.classes = self.CFG["classes"]
+            self.show_conf = self.CFG["show_conf"]
+            self.show_labels = self.CFG["show_labels"]
+
+            self.track_add_args = {  # Tracker additional arguments for advance configuration
+                k: self.CFG[k] for k in ["iou", "conf", "device", "max_det", "half", "tracker", "device", "verbose"]
+            }  # verbose must be passed to track method; setting it False in YOLO still logs the track information.
+
+            if is_cli and self.CFG["source"] is None:
+                d_s = "solutions_ci_demo.mp4" if "-pose" not in self.CFG["model"] else "solution_ci_pose_demo.mp4"
+                self.LOGGER.warning(f"source not provided. using default source {ASSETS_URL}/{d_s}")
+                from ultralytics.utils.downloads import safe_download
+
+                safe_download(f"{ASSETS_URL}/{d_s}")  # download source from ultralytics assets
+                self.CFG["source"] = d_s  # set default source
+
+            # Initialize environment and region setup
+            self.env_check = check_imshow(warn=True)
+            self.track_history = defaultdict(list)
 
     def adjust_box_label(self, cls, conf, track_id=None):
         """

{ultralytics-8.3.125 → ultralytics-8.3.127}/ultralytics/utils/__init__.py

@@ -182,6 +182,10 @@ class TQDM(rich.tqdm if TQDM_RICH else tqdm.tqdm):
         kwargs.setdefault("bar_format", TQDM_BAR_FORMAT)  # override default value if passed
         super().__init__(*args, **kwargs)
 
+    def __iter__(self):
+        """Return self as iterator to satisfy Iterable interface."""
+        return super().__iter__()
+
 
 class SimpleClass:
     """