ultralytics 8.1.41__py3-none-any.whl → 8.1.43__py3-none-any.whl

ultralytics/engine/trainer.py

@@ -331,6 +331,10 @@ class BaseTrainer:
         while True:
             self.epoch = epoch
             self.run_callbacks("on_train_epoch_start")
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")  # suppress 'Detected lr_scheduler.step() before optimizer.step()'
+                self.scheduler.step()
+
             self.model.train()
             if RANK != -1:
                 self.train_loader.sampler.set_epoch(epoch)
@@ -426,15 +430,12 @@ class BaseTrainer:
             t = time.time()
             self.epoch_time = t - self.epoch_time_start
             self.epoch_time_start = t
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore")  # suppress 'Detected lr_scheduler.step() before optimizer.step()'
-                if self.args.time:
-                    mean_epoch_time = (t - self.train_time_start) / (epoch - self.start_epoch + 1)
-                    self.epochs = self.args.epochs = math.ceil(self.args.time * 3600 / mean_epoch_time)
-                    self._setup_scheduler()
-                    self.scheduler.last_epoch = self.epoch  # do not move
-                    self.stop |= epoch >= self.epochs  # stop if exceeded epochs
-                self.scheduler.step()
+            if self.args.time:
+                mean_epoch_time = (t - self.train_time_start) / (epoch - self.start_epoch + 1)
+                self.epochs = self.args.epochs = math.ceil(self.args.time * 3600 / mean_epoch_time)
+                self._setup_scheduler()
+                self.scheduler.last_epoch = self.epoch  # do not move
+                self.stop |= epoch >= self.epochs  # stop if exceeded epochs
             self.run_callbacks("on_fit_epoch_end")
             torch.cuda.empty_cache()  # clear GPU memory at end of epoch, may help reduce CUDA out of memory errors
 
@@ -463,7 +464,7 @@ class BaseTrainer:
     def save_model(self):
         """Save model training checkpoints with additional metadata."""
         import io
-        import pandas as pd  # scope for faster startup
+        import pandas as pd  # scope for faster 'import ultralytics'
 
         # Serialize ckpt to a byte buffer once (faster than repeated torch.save() calls)
         buffer = io.BytesIO()

ultralytics/models/fastsam/prompt.py

@@ -4,7 +4,6 @@ import os
 from pathlib import Path
 
 import cv2
-import matplotlib.pyplot as plt
 import numpy as np
 import torch
 from PIL import Image
@@ -118,6 +117,8 @@ class FastSAMPrompt:
             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)
@@ -202,6 +203,8 @@ class FastSAMPrompt:
             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))

ultralytics/models/sam/predict.py

@@ -11,7 +11,6 @@ segmentation tasks.
 import numpy as np
 import torch
 import torch.nn.functional as F
-import torchvision
 
 from ultralytics.data.augment import LetterBox
 from ultralytics.engine.predictor import BasePredictor
@@ -246,6 +245,8 @@ class Predictor(BasePredictor):
         Returns:
             (tuple): A tuple containing segmented masks, confidence scores, and bounding boxes.
         """
+        import torchvision  # scope for faster 'import ultralytics'
+
         self.segment_all = True
         ih, iw = im.shape[2:]
         crop_regions, layer_idxs = generate_crop_boxes((ih, iw), crop_n_layers, crop_overlap_ratio)
@@ -449,6 +450,8 @@ class Predictor(BasePredictor):
                 - new_masks (torch.Tensor): The processed masks with small regions removed. Shape is (N, H, W).
                 - keep (List[int]): The indices of the remaining masks post-NMS, which can be used to filter the boxes.
         """
+        import torchvision  # scope for faster 'import ultralytics'
+
         if len(masks) == 0:
             return masks
 

ultralytics/models/yolo/classify/train.py

@@ -1,7 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import torch
-import torchvision
 
 from ultralytics.data import ClassificationDataset, build_dataloader
 from ultralytics.engine.trainer import BaseTrainer
@@ -59,6 +58,8 @@ class ClassificationTrainer(BaseTrainer):
 
     def setup_model(self):
         """Load, create or download model for any task."""
+        import torchvision  # scope for faster 'import ultralytics'
+
         if isinstance(self.model, torch.nn.Module):  # if model is loaded beforehand. No setup needed
             return
 

ultralytics/solutions/heatmap.py

@@ -30,6 +30,7 @@ class Heatmap:
         self.imw = None
         self.imh = None
         self.im0 = None
+        self.tf = 2
         self.view_in_counts = True
         self.view_out_counts = True
 
@@ -56,11 +57,9 @@ class Heatmap:
         self.out_counts = 0
         self.count_ids = []
         self.class_wise_count = {}
-        self.count_txt_thickness = 0
-        self.count_txt_color = (255, 255, 255)
-        self.line_color = (255, 255, 255)
+        self.count_txt_color = (0, 0, 0)
+        self.count_bg_color = (255, 255, 255)
         self.cls_txtdisplay_gap = 50
-        self.fontsize = 0.6
 
         # Decay factor
         self.decay_factor = 0.99
@@ -79,16 +78,14 @@ class Heatmap:
         view_in_counts=True,
         view_out_counts=True,
         count_reg_pts=None,
-        count_txt_thickness=2,
-        count_txt_color=(255, 255, 255),
-        fontsize=0.8,
-        line_color=(255, 255, 255),
+        count_txt_color=(0, 0, 0),
+        count_bg_color=(255, 255, 255),
         count_reg_color=(255, 0, 255),
         region_thickness=5,
         line_dist_thresh=15,
+        line_thickness=2,
         decay_factor=0.99,
         shape="circle",
-        cls_txtdisplay_gap=50,
     ):
         """
         Configures the heatmap colormap, width, height and display parameters.
@@ -98,22 +95,21 @@ class Heatmap:
             imw (int): The width of the frame.
             imh (int): The height of the frame.
             classes_names (dict): Classes names
+            line_thickness (int): Line thickness for bounding boxes.
             heatmap_alpha (float): alpha value for heatmap display
             view_img (bool): Flag indicating frame display
             view_in_counts (bool): Flag to control whether to display the incounts on video stream.
             view_out_counts (bool): Flag to control whether to display the outcounts on video stream.
             count_reg_pts (list): Object counting region points
-            count_txt_thickness (int): Text thickness for object counting display
             count_txt_color (RGB color): count text color value
-            fontsize (float): Text display font size
-            line_color (RGB color): count highlighter line color
+            count_bg_color (RGB color): count highlighter line color
             count_reg_color (RGB color): Color of object counting region
             region_thickness (int): Object counting Region thickness
             line_dist_thresh (int): Euclidean Distance threshold for line counter
             decay_factor (float): value for removing heatmap area after object passed
             shape (str): Heatmap shape, rect or circle shape supported
-            cls_txtdisplay_gap (int): Display gap between each class count
         """
+        self.tf = line_thickness
         self.names = classes_names
         self.imw = imw
         self.imh = imh
@@ -141,16 +137,13 @@ class Heatmap:
         # Heatmap new frame
         self.heatmap = np.zeros((int(self.imh), int(self.imw)), dtype=np.float32)
 
-        self.count_txt_thickness = count_txt_thickness
         self.count_txt_color = count_txt_color
-        self.fontsize = fontsize
-        self.line_color = line_color
+        self.count_bg_color = count_bg_color
         self.region_color = count_reg_color
         self.region_thickness = region_thickness
         self.decay_factor = decay_factor
         self.line_dist_thresh = line_dist_thresh
         self.shape = shape
-        self.cls_txtdisplay_gap = cls_txtdisplay_gap
 
         # shape of heatmap, if not selected
         if self.shape not in {"circle", "rect"}:
@@ -185,7 +178,7 @@ class Heatmap:
             return im0
         self.heatmap *= self.decay_factor  # decay factor
         self.extract_results(tracks)
-        self.annotator = Annotator(self.im0, self.count_txt_thickness, None)
+        self.annotator = Annotator(self.im0, self.tf, None)
 
         if self.count_reg_pts is not None:
             # Draw counting region
@@ -239,11 +232,8 @@ class Heatmap:
 
                 # Count objects using line
                 elif len(self.count_reg_pts) == 2:
-                    is_inside = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0
-
-                    if prev_position is not None and is_inside and track_id not in self.count_ids:
+                    if prev_position is not None and track_id not in self.count_ids:
                         distance = Point(track_line[-1]).distance(self.counting_region)
-
                         if distance < self.line_dist_thresh and track_id not in self.count_ids:
                             self.count_ids.append(track_id)
 
@@ -293,11 +283,8 @@ class Heatmap:
         if self.count_reg_pts is not None and label is not None:
             self.annotator.display_counts(
                 counts=label,
-                tf=self.count_txt_thickness,
-                fontScale=self.fontsize,
-                txt_color=self.count_txt_color,
-                line_color=self.line_color,
-                classwise_txtgap=self.cls_txtdisplay_gap,
+                count_txt_color=self.count_txt_color,
+                count_bg_color=self.count_bg_color,
             )
 
         self.im0 = cv2.addWeighted(self.im0, 1 - self.heatmap_alpha, heatmap_colored, self.heatmap_alpha, 0)

ultralytics/solutions/object_counter.py

@@ -1,7 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 from collections import defaultdict
-
 import cv2
 
 from ultralytics.utils.checks import check_imshow, check_requirements
@@ -47,7 +46,7 @@ class ObjectCounter:
         self.class_wise_count = {}
         self.count_txt_thickness = 0
         self.count_txt_color = (255, 255, 255)
-        self.line_color = (255, 255, 255)
+        self.count_bg_color = (255, 255, 255)
         self.cls_txtdisplay_gap = 50
         self.fontsize = 0.6
 
@@ -65,16 +64,14 @@ class ObjectCounter:
         classes_names,
         reg_pts,
         count_reg_color=(255, 0, 255),
+        count_txt_color=(0, 0, 0),
+        count_bg_color=(255, 255, 255),
         line_thickness=2,
         track_thickness=2,
         view_img=False,
         view_in_counts=True,
         view_out_counts=True,
         draw_tracks=False,
-        count_txt_thickness=3,
-        count_txt_color=(255, 255, 255),
-        fontsize=0.8,
-        line_color=(255, 255, 255),
         track_color=None,
         region_thickness=5,
         line_dist_thresh=15,
@@ -92,10 +89,8 @@ class ObjectCounter:
             classes_names (dict): Classes names
             track_thickness (int): Track thickness
             draw_tracks (Bool): draw tracks
-            count_txt_thickness (int): Text thickness for object counting display
             count_txt_color (RGB color): count text color value
-            fontsize (float): Text display font size
-            line_color (RGB color): count highlighter line color
+            count_bg_color (RGB color): count highlighter line color
             count_reg_color (RGB color): Color of object counting region
             track_color (RGB color): color for tracks
             region_thickness (int): Object counting Region thickness
@@ -125,10 +120,8 @@ class ObjectCounter:
 
         self.names = classes_names
         self.track_color = track_color
-        self.count_txt_thickness = count_txt_thickness
         self.count_txt_color = count_txt_color
-        self.fontsize = fontsize
-        self.line_color = line_color
+        self.count_bg_color = count_bg_color
         self.region_color = count_reg_color
         self.region_thickness = region_thickness
         self.line_dist_thresh = line_dist_thresh
@@ -172,6 +165,9 @@ class ObjectCounter:
         # Annotator Init and region drawing
         self.annotator = Annotator(self.im0, self.tf, self.names)
 
+        # Draw region or line
+        self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)
+
         if tracks[0].boxes.id is not None:
             boxes = tracks[0].boxes.xyxy.cpu()
             clss = tracks[0].boxes.cls.cpu().tolist()
@@ -220,17 +216,14 @@ class ObjectCounter:
 
                 # Count objects using line
                 elif len(self.reg_pts) == 2:
-                    is_inside = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0
-
-                    if prev_position is not None and is_inside and track_id not in self.count_ids:
+                    if prev_position is not None and track_id not in self.count_ids:
                         distance = Point(track_line[-1]).distance(self.counting_region)
-
                         if distance < self.line_dist_thresh and track_id not in self.count_ids:
                             self.count_ids.append(track_id)
 
                             if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
                                 self.in_counts += 1
-                                self.class_wise_count[self.names[cls]]["in"] += 1
+                                self.class_wise_count[self.names[cls]]["in"] += 2
                             else:
                                 self.out_counts += 1
                                 self.class_wise_count[self.names[cls]]["out"] += 1
@@ -254,17 +247,13 @@ class ObjectCounter:
         if label is not None:
             self.annotator.display_counts(
                 counts=label,
-                tf=self.count_txt_thickness,
-                fontScale=self.fontsize,
-                txt_color=self.count_txt_color,
-                line_color=self.line_color,
-                classwise_txtgap=self.cls_txtdisplay_gap,
+                count_txt_color=self.count_txt_color,
+                count_bg_color=self.count_bg_color,
             )
 
     def display_frames(self):
         """Display frame."""
         if self.env_check:
-            self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)
             cv2.namedWindow(self.window_name)
             if len(self.reg_pts) == 4:  # only add mouse event If user drawn region
                 cv2.setMouseCallback(self.window_name, self.mouse_event_for_region, {"region_points": self.reg_pts})

ultralytics/solutions/queue_management.py

@@ -0,0 +1,187 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from collections import defaultdict
+
+import cv2
+
+from ultralytics.utils.checks import check_imshow, check_requirements
+from ultralytics.utils.plotting import Annotator, colors
+
+check_requirements("shapely>=2.0.0")
+
+from shapely.geometry import Point, Polygon
+
+
+class QueueManager:
+    """A class to manage the queue management in real-time video stream based on their tracks."""
+
+    def __init__(self):
+        """Initializes the queue manager with default values for various tracking and counting parameters."""
+
+        # Mouse events
+        self.is_drawing = False
+        self.selected_point = None
+
+        # Region & Line Information
+        self.reg_pts = [(20, 60), (20, 680), (1120, 680), (1120, 60)]
+        self.counting_region = None
+        self.region_color = (255, 0, 255)
+        self.region_thickness = 5
+
+        # Image and annotation Information
+        self.im0 = None
+        self.tf = None
+        self.view_img = False
+        self.view_queue_counts = True
+        self.fontsize = 0.6
+
+        self.names = None  # Classes names
+        self.annotator = None  # Annotator
+        self.window_name = "Ultralytics YOLOv8 Queue Manager"
+
+        # Object counting Information
+        self.counts = 0
+        self.count_txt_color = (255, 255, 255)
+
+        # Tracks info
+        self.track_history = defaultdict(list)
+        self.track_thickness = 2
+        self.draw_tracks = False
+        self.track_color = None
+
+        # Check if environment support imshow
+        self.env_check = check_imshow(warn=True)
+
+    def set_args(
+        self,
+        classes_names,
+        reg_pts,
+        line_thickness=2,
+        track_thickness=2,
+        view_img=False,
+        region_color=(255, 0, 255),
+        view_queue_counts=True,
+        draw_tracks=False,
+        count_txt_color=(255, 255, 255),
+        track_color=None,
+        region_thickness=5,
+        fontsize=0.7,
+    ):
+        """
+        Configures the Counter's image, bounding box line thickness, and counting region points.
+
+        Args:
+            line_thickness (int): Line thickness for bounding boxes.
+            view_img (bool): Flag to control whether to display the video stream.
+            view_queue_counts (bool): Flag to control whether to display the counts on video stream.
+            reg_pts (list): Initial list of points defining the counting region.
+            classes_names (dict): Classes names
+            region_color (RGB color): Color of queue region
+            track_thickness (int): Track thickness
+            draw_tracks (Bool): draw tracks
+            count_txt_color (RGB color): count text color value
+            track_color (RGB color): color for tracks
+            region_thickness (int): Object counting Region thickness
+            fontsize (float): Text display font size
+        """
+        self.tf = line_thickness
+        self.view_img = view_img
+        self.view_queue_counts = view_queue_counts
+        self.track_thickness = track_thickness
+        self.draw_tracks = draw_tracks
+        self.region_color = region_color
+
+        if len(reg_pts) >= 3:
+            print("Queue region initiated...")
+            self.reg_pts = reg_pts
+            self.counting_region = Polygon(self.reg_pts)
+        else:
+            print("Invalid region points provided...")
+            print("Using default region now....")
+            self.counting_region = Polygon(self.reg_pts)
+
+        self.names = classes_names
+        self.track_color = track_color
+        self.count_txt_color = count_txt_color
+        self.region_thickness = region_thickness
+        self.fontsize = fontsize
+
+    def extract_and_process_tracks(self, tracks):
+        """Extracts and processes tracks for queue management in a video stream."""
+
+        # Annotator Init and queue region drawing
+        self.annotator = Annotator(self.im0, self.tf, self.names)
+
+        if tracks[0].boxes.id is not None:
+            boxes = tracks[0].boxes.xyxy.cpu()
+            clss = tracks[0].boxes.cls.cpu().tolist()
+            track_ids = tracks[0].boxes.id.int().cpu().tolist()
+
+            # Extract tracks
+            for box, track_id, cls in zip(boxes, track_ids, clss):
+                # Draw bounding box
+                self.annotator.box_label(box, label=f"{self.names[cls]}#{track_id}", color=colors(int(track_id), True))
+
+                # Draw Tracks
+                track_line = self.track_history[track_id]
+                track_line.append((float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2)))
+                if len(track_line) > 30:
+                    track_line.pop(0)
+
+                # Draw track trails
+                if self.draw_tracks:
+                    self.annotator.draw_centroid_and_tracks(
+                        track_line,
+                        color=self.track_color if self.track_color else colors(int(track_id), True),
+                        track_thickness=self.track_thickness,
+                    )
+
+                prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
+
+                if len(self.reg_pts) >= 3:
+                    is_inside = self.counting_region.contains(Point(track_line[-1]))
+                    if prev_position is not None and is_inside:
+                        self.counts += 1
+
+        label = "Queue Counts : " + str(self.counts)
+
+        if label is not None:
+            self.annotator.queue_counts_display(
+                label,
+                points=self.reg_pts,
+                region_color=self.region_color,
+                txt_color=self.count_txt_color,
+                fontsize=self.fontsize,
+            )
+
+        self.counts = 0
+        self.display_frames()
+
+    def display_frames(self):
+        """Display frame."""
+        if self.env_check:
+            self.annotator.draw_region(reg_pts=self.reg_pts, thickness=self.region_thickness, color=self.region_color)
+            cv2.namedWindow(self.window_name)
+            cv2.imshow(self.window_name, self.im0)
+            # Break Window
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                return
+
+    def process_queue(self, im0, tracks):
+        """
+        Main function to start the queue management process.
+
+        Args:
+            im0 (ndarray): Current frame from the video stream.
+            tracks (list): List of tracks obtained from the object tracking process.
+        """
+        self.im0 = im0  # store image
+        self.extract_and_process_tracks(tracks)  # draw region even if no objects
+
+        if self.view_img:
+            self.display_frames()
+        return self.im0
+
+
+if __name__ == "__main__":
+    QueueManager()

ultralytics/utils/__init__.py

@@ -1,6 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import contextlib
+import importlib.metadata
 import inspect
 import logging.config
 import os
@@ -42,6 +43,8 @@ TQDM_BAR_FORMAT = "{l_bar}{bar:10}{r_bar}" if VERBOSE else None  # tqdm bar form
 LOGGING_NAME = "ultralytics"
 MACOS, LINUX, WINDOWS = (platform.system() == x for x in ["Darwin", "Linux", "Windows"])  # environment booleans
 ARM64 = platform.machine() in {"arm64", "aarch64"}  # ARM64 booleans
+PYTHON_VERSION = platform.python_version()
+TORCHVISION_VERSION = importlib.metadata.version("torchvision")  # faster than importing torchvision
 HELP_MSG = """
     Usage examples for running YOLOv8:
 
@@ -230,37 +233,42 @@ def plt_settings(rcparams=None, backend="Agg"):
     return decorator
 
 
-def set_logging(name=LOGGING_NAME, verbose=True):
-    """Sets up logging for the given name with UTF-8 encoding support."""
+def set_logging(name="LOGGING_NAME", verbose=True):
+    """Sets up logging for the given name with UTF-8 encoding support, ensuring compatibility across different
+    environments.
+    """
     level = logging.INFO if verbose and RANK in {-1, 0} else logging.ERROR  # rank in world for Multi-GPU trainings
 
-    # Configure the console (stdout) encoding to UTF-8
+    # Configure the console (stdout) encoding to UTF-8, with checks for compatibility
     formatter = logging.Formatter("%(message)s")  # Default formatter
-    if WINDOWS and sys.stdout.encoding != "utf-8":
+    if WINDOWS and hasattr(sys.stdout, "encoding") and sys.stdout.encoding != "utf-8":
+
+        class CustomFormatter(logging.Formatter):
+            def format(self, record):
+                """Sets up logging with UTF-8 encoding and configurable verbosity."""
+                return emojis(super().format(record))
+
         try:
+            # Attempt to reconfigure stdout to use UTF-8 encoding if possible
             if hasattr(sys.stdout, "reconfigure"):
                 sys.stdout.reconfigure(encoding="utf-8")
+            # For environments where reconfigure is not available, wrap stdout in a TextIOWrapper
             elif hasattr(sys.stdout, "buffer"):
                 import io
 
                 sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
             else:
-                sys.stdout.encoding = "utf-8"
+                formatter = CustomFormatter("%(message)s")
         except Exception as e:
             print(f"Creating custom formatter for non UTF-8 environments due to {e}")
+            formatter = CustomFormatter("%(message)s")
 
-            class CustomFormatter(logging.Formatter):
-                def format(self, record):
-                    """Sets up logging with UTF-8 encoding and configurable verbosity."""
-                    return emojis(super().format(record))
-
-            formatter = CustomFormatter("%(message)s")  # Use CustomFormatter to eliminate UTF-8 output as last recourse
-
-    # Create and configure the StreamHandler
+    # Create and configure the StreamHandler with the appropriate formatter and level
     stream_handler = logging.StreamHandler(sys.stdout)
     stream_handler.setFormatter(formatter)
     stream_handler.setLevel(level)
 
+    # Set up the logger
     logger = logging.getLogger(name)
     logger.setLevel(level)
     logger.addHandler(stream_handler)
@@ -471,7 +479,7 @@ def is_online() -> bool:
 
     for host in "1.1.1.1", "8.8.8.8", "223.5.5.5":  # Cloudflare, Google, AliDNS:
         try:
-            test_connection = socket.create_connection(address=(host, 53), timeout=2)
+            test_connection = socket.create_connection(address=(host, 80), timeout=2)
         except (socket.timeout, socket.gaierror, OSError):
             continue
         else:

ultralytics/utils/benchmarks.py

@@ -69,8 +69,7 @@ def benchmark(
         benchmark(model='yolov8n.pt', imgsz=640)
         ```
     """
-
-    import pandas as pd
+    import pandas as pd  # scope for faster 'import ultralytics'
 
     pd.options.display.max_columns = 10
     pd.options.display.width = 120

ultralytics/utils/callbacks/clearml.py

@@ -7,8 +7,6 @@ try:
     assert SETTINGS["clearml"] is True  # verify integration is enabled
     import clearml
     from clearml import Task
-    from clearml.binding.frameworks.pytorch_bind import PatchPyTorchModelIO
-    from clearml.binding.matplotlib_bind import PatchedMatplotlib
 
     assert hasattr(clearml, "__version__")  # verify package is not directory
 
@@ -61,8 +59,11 @@ def on_pretrain_routine_start(trainer):
     """Runs at start of pretraining routine; initializes and connects/ logs task to ClearML."""
     try:
         if task := Task.current_task():
-            # Make sure the automatic pytorch and matplotlib bindings are disabled!
+            # WARNING: make sure the automatic pytorch and matplotlib bindings are disabled!
             # We are logging these plots and model files manually in the integration
+            from clearml.binding.frameworks.pytorch_bind import PatchPyTorchModelIO
+            from clearml.binding.matplotlib_bind import PatchedMatplotlib
+
             PatchPyTorchModelIO.update_current_task(None)
             PatchedMatplotlib.update_current_task(None)
         else:

ultralytics/utils/callbacks/wb.py

@@ -9,10 +9,6 @@ try:
     import wandb as wb
 
     assert hasattr(wb, "__version__")  # verify package is not directory
-
-    import numpy as np
-    import pandas as pd
-
     _processed_plots = {}
 
 except (ImportError, AssertionError):
@@ -38,7 +34,9 @@ def _custom_table(x, y, classes, title="Precision Recall Curve", x_title="Recall
     Returns:
         (wandb.Object): A wandb object suitable for logging, showcasing the crafted metric visualization.
     """
-    df = pd.DataFrame({"class": classes, "y": y, "x": x}).round(3)
+    import pandas  # scope for faster 'import ultralytics'
+
+    df = pandas.DataFrame({"class": classes, "y": y, "x": x}).round(3)
     fields = {"x": "x", "y": "y", "class": "class"}
     string_fields = {"title": title, "x-axis-title": x_title, "y-axis-title": y_title}
     return wb.plot_table(
@@ -77,6 +75,8 @@ def _plot_curve(
     Note:
         The function leverages the '_custom_table' function to generate the actual visualization.
     """
+    import numpy as np
+
     # Create new x
     if names is None:
         names = []