ultralytics 8.1.1__py3-none-any.whl → 8.1.3__py3-none-any.whl

ultralytics/models/sam/model.py

@@ -18,7 +18,6 @@ from pathlib import Path
 
 from ultralytics.engine.model import Model
 from ultralytics.utils.torch_utils import model_info
-
 from .build import build_sam
 from .predict import Predictor
 

ultralytics/models/sam/modules/encoders.py

@@ -198,12 +198,7 @@ class PromptEncoder(nn.Module):
         """
         return self.pe_layer(self.image_embedding_size).unsqueeze(0)
 
-    def _embed_points(
-        self,
-        points: torch.Tensor,
-        labels: torch.Tensor,
-        pad: bool,
-    ) -> torch.Tensor:
+    def _embed_points(self, points: torch.Tensor, labels: torch.Tensor, pad: bool) -> torch.Tensor:
         """Embeds point prompts."""
         points = points + 0.5  # Shift to center of pixel
         if pad:

ultralytics/models/sam/predict.py

@@ -18,7 +18,6 @@ from ultralytics.engine.predictor import BasePredictor
 from ultralytics.engine.results import Results
 from ultralytics.utils import DEFAULT_CFG, ops
 from ultralytics.utils.torch_utils import select_device
-
 from .amg import (
     batch_iterator,
     batched_mask_to_box,

ultralytics/models/utils/loss.py

@@ -6,7 +6,6 @@ import torch.nn.functional as F
 
 from ultralytics.utils.loss import FocalLoss, VarifocalLoss
 from ultralytics.utils.metrics import bbox_iou
-
 from .ops import HungarianMatcher
 
 

ultralytics/models/yolo/detect/val.py

@@ -104,8 +104,7 @@ class DetectionValidator(BaseValidator):
         if len(cls):
             bbox = ops.xywh2xyxy(bbox) * torch.tensor(imgsz, device=self.device)[[1, 0, 1, 0]]  # target boxes
             ops.scale_boxes(imgsz, bbox, ori_shape, ratio_pad=ratio_pad)  # native-space labels
-        prepared_batch = dict(cls=cls, bbox=bbox, ori_shape=ori_shape, imgsz=imgsz, ratio_pad=ratio_pad)
-        return prepared_batch
+        return dict(cls=cls, bbox=bbox, ori_shape=ori_shape, imgsz=imgsz, ratio_pad=ratio_pad)
 
     def _prepare_pred(self, pred, pbatch):
         """Prepares a batch of images and annotations for validation."""

ultralytics/models/yolo/obb/val.py

@@ -18,7 +18,7 @@ class OBBValidator(DetectionValidator):
         ```python
         from ultralytics.models.yolo.obb import OBBValidator
 
-        args = dict(model='yolov8n-obb.pt', data='coco8-seg.yaml')
+        args = dict(model='yolov8n-obb.pt', data='dota8.yaml')
         validator = OBBValidator(args=args)
         validator(model=args['model'])
         ```
@@ -77,8 +77,7 @@ class OBBValidator(DetectionValidator):
         if len(cls):
             bbox[..., :4].mul_(torch.tensor(imgsz, device=self.device)[[1, 0, 1, 0]])  # target boxes
             ops.scale_boxes(imgsz, bbox, ori_shape, ratio_pad=ratio_pad, xywh=True)  # native-space labels
-        prepared_batch = dict(cls=cls, bbox=bbox, ori_shape=ori_shape, imgsz=imgsz, ratio_pad=ratio_pad)
-        return prepared_batch
+        return dict(cls=cls, bbox=bbox, ori_shape=ori_shape, imgsz=imgsz, ratio_pad=ratio_pad)
 
     def _prepare_pred(self, pred, pbatch):
         """Prepares and returns a batch for OBB validation with scaled and padded bounding boxes."""
@@ -118,11 +117,10 @@ class OBBValidator(DetectionValidator):
 
     def save_one_txt(self, predn, save_conf, shape, file):
         """Save YOLO detections to a txt file in normalized coordinates in a specific format."""
-        gn = torch.tensor(shape)[[1, 0, 1, 0]]  # normalization gain whwh
-        for *xyxy, conf, cls, angle in predn.tolist():
-            xywha = torch.tensor([*xyxy, angle]).view(1, 5)
-            xywha[:, :4] /= gn
-            xyxyxyxy = ops.xywhr2xyxyxyxy(xywha).view(-1).tolist()  # normalized xywh
+        gn = torch.tensor(shape)[[1, 0]]  # normalization gain whwh
+        for *xywh, conf, cls, angle in predn.tolist():
+            xywha = torch.tensor([*xywh, angle]).view(1, 5)
+            xyxyxyxy = (ops.xywhr2xyxyxyxy(xywha) / gn).view(-1).tolist()  # normalized xywh
             line = (cls, *xyxyxyxy, conf) if save_conf else (cls, *xyxyxyxy)  # label format
             with open(file, "a") as f:
                 f.write(("%g " * len(line)).rstrip() % line + "\n")
@@ -139,32 +137,21 @@ class OBBValidator(DetectionValidator):
             pred_txt.mkdir(parents=True, exist_ok=True)
             data = json.load(open(pred_json))
             # Save split results
-            LOGGER.info(f"Saving predictions with DOTA format to {str(pred_txt)}...")
+            LOGGER.info(f"Saving predictions with DOTA format to {pred_txt}...")
             for d in data:
                 image_id = d["image_id"]
                 score = d["score"]
                 classname = self.names[d["category_id"]].replace(" ", "-")
+                p = d["poly"]
 
-                lines = "{} {} {} {} {} {} {} {} {} {}\n".format(
-                    image_id,
-                    score,
-                    d["poly"][0],
-                    d["poly"][1],
-                    d["poly"][2],
-                    d["poly"][3],
-                    d["poly"][4],
-                    d["poly"][5],
-                    d["poly"][6],
-                    d["poly"][7],
-                )
-                with open(str(pred_txt / f"Task1_{classname}") + ".txt", "a") as f:
-                    f.writelines(lines)
+                with open(f'{pred_txt / f"Task1_{classname}"}.txt', "a") as f:
+                    f.writelines(f"{image_id} {score} {p[0]} {p[1]} {p[2]} {p[3]} {p[4]} {p[5]} {p[6]} {p[7]}\n")
             # Save merged results, this could result slightly lower map than using official merging script,
             # because of the probiou calculation.
             pred_merged_txt = self.save_dir / "predictions_merged_txt"  # predictions
             pred_merged_txt.mkdir(parents=True, exist_ok=True)
             merged_results = defaultdict(list)
-            LOGGER.info(f"Saving merged predictions with DOTA format to {str(pred_merged_txt)}...")
+            LOGGER.info(f"Saving merged predictions with DOTA format to {pred_merged_txt}...")
             for d in data:
                 image_id = d["image_id"].split("__")[0]
                 pattern = re.compile(r"\d+___\d+")
@@ -188,22 +175,10 @@ class OBBValidator(DetectionValidator):
                 b = ops.xywhr2xyxyxyxy(bbox[:, :5]).view(-1, 8)
                 for x in torch.cat([b, bbox[:, 5:7]], dim=-1).tolist():
                     classname = self.names[int(x[-1])].replace(" ", "-")
-                    poly = [round(i, 3) for i in x[:-2]]
+                    p = [round(i, 3) for i in x[:-2]]  # poly
                     score = round(x[-2], 3)
 
-                    lines = "{} {} {} {} {} {} {} {} {} {}\n".format(
-                        image_id,
-                        score,
-                        poly[0],
-                        poly[1],
-                        poly[2],
-                        poly[3],
-                        poly[4],
-                        poly[5],
-                        poly[6],
-                        poly[7],
-                    )
-                    with open(str(pred_merged_txt / f"Task1_{classname}") + ".txt", "a") as f:
-                        f.writelines(lines)
+                    with open(f'{pred_merged_txt / f"Task1_{classname}"}.txt', "a") as f:
+                        f.writelines(f"{image_id} {score} {p[0]} {p[1]} {p[2]} {p[3]} {p[4]} {p[5]} {p[6]} {p[7]}\n")
 
         return stats

ultralytics/nn/modules/head.py

@@ -8,11 +8,10 @@ import torch.nn as nn
 from torch.nn.init import constant_, xavier_uniform_
 
 from ultralytics.utils.tal import TORCH_1_10, dist2bbox, dist2rbox, make_anchors
-
 from .block import DFL, Proto
 from .conv import Conv
 from .transformer import MLP, DeformableTransformerDecoder, DeformableTransformerDecoderLayer
-from .utils import bias_init_with_prob, linear_init_
+from .utils import bias_init_with_prob, linear_init
 
 __all__ = "Detect", "Segment", "Pose", "Classify", "OBB", "RTDETRDecoder"
 
@@ -418,18 +417,18 @@ class RTDETRDecoder(nn.Module):
         """Initializes or resets the parameters of the model's various components with predefined weights and biases."""
         # Class and bbox head init
         bias_cls = bias_init_with_prob(0.01) / 80 * self.nc
-        # NOTE: the weight initialization in `linear_init_` would cause NaN when training with custom datasets.
-        # linear_init_(self.enc_score_head)
+        # NOTE: the weight initialization in `linear_init` would cause NaN when training with custom datasets.
+        # linear_init(self.enc_score_head)
         constant_(self.enc_score_head.bias, bias_cls)
         constant_(self.enc_bbox_head.layers[-1].weight, 0.0)
         constant_(self.enc_bbox_head.layers[-1].bias, 0.0)
         for cls_, reg_ in zip(self.dec_score_head, self.dec_bbox_head):
-            # linear_init_(cls_)
+            # linear_init(cls_)
             constant_(cls_.bias, bias_cls)
             constant_(reg_.layers[-1].weight, 0.0)
             constant_(reg_.layers[-1].bias, 0.0)
 
-        linear_init_(self.enc_output[0])
+        linear_init(self.enc_output[0])
         xavier_uniform_(self.enc_output[0].weight)
         if self.learnt_init_query:
             xavier_uniform_(self.tgt_embed.weight)

ultralytics/nn/modules/utils.py

@@ -23,7 +23,7 @@ def bias_init_with_prob(prior_prob=0.01):
     return float(-np.log((1 - prior_prob) / prior_prob))  # return bias_init
 
 
-def linear_init_(module):
+def linear_init(module):
     """Initialize the weights and biases of a linear module."""
     bound = 1 / math.sqrt(module.weight.shape[0])
     uniform_(module.weight, -bound, bound)

ultralytics/nn/tasks.py

@@ -339,7 +339,7 @@ class DetectionModel(BaseModel):
 
 
 class OBBModel(DetectionModel):
-    """"YOLOv8 Oriented Bounding Box (OBB) model."""
+    """YOLOv8 Oriented Bounding Box (OBB) model."""
 
     def __init__(self, cfg="yolov8n-obb.yaml", ch=3, nc=None, verbose=True):
         """Initialize YOLOv8 OBB model with given config and parameters."""

ultralytics/solutions/ai_gym.py

@@ -78,8 +78,16 @@ class AIGym:
         self.keypoints = results[0].keypoints.data
         self.annotator = Annotator(im0, line_width=2)
 
+        num_keypoints = len(results[0])
+
+        # Resize self.angle, self.count, and self.stage if the number of keypoints has changed
+        if len(self.angle) != num_keypoints:
+            self.angle = [0] * num_keypoints
+            self.count = [0] * num_keypoints
+            self.stage = ["-" for _ in range(num_keypoints)]
+
         for ind, k in enumerate(reversed(self.keypoints)):
-            if self.pose_type == "pushup" or self.pose_type == "pullup":
+            if self.pose_type in ["pushup", "pullup"]:
                 self.angle[ind] = self.annotator.estimate_pose_angle(
                     k[int(self.kpts_to_check[0])].cpu(),
                     k[int(self.kpts_to_check[1])].cpu(),

ultralytics/solutions/distance_calculation.py

@@ -86,10 +86,9 @@ class DistanceCalculation:
             self.left_mouse_count += 1
             if self.left_mouse_count <= 2:
                 for box, track_id in zip(self.boxes, self.trk_ids):
-                    if box[0] < x < box[2] and box[1] < y < box[3]:
-                        if track_id not in self.selected_boxes:
-                            self.selected_boxes[track_id] = []
-                            self.selected_boxes[track_id] = box
+                    if box[0] < x < box[2] and box[1] < y < box[3] and track_id not in self.selected_boxes:
+                        self.selected_boxes[track_id] = []
+                        self.selected_boxes[track_id] = box
 
         if event == cv2.EVENT_RBUTTONDOWN:
             self.selected_boxes = {}
@@ -149,10 +148,7 @@ class DistanceCalculation:
         if tracks[0].boxes.id is None:
             if self.view_img:
                 self.display_frames()
-                return
-            else:
-                return
-
+            return
         self.extract_tracks(tracks)
 
         self.annotator = Annotator(self.im0, line_width=2)

ultralytics/solutions/heatmap.py

@@ -169,10 +169,7 @@ class Heatmap:
         if tracks[0].boxes.id is None:
             if self.view_img and self.env_check:
                 self.display_frames()
-                return
-            else:
-                return
-
+            return
         self.heatmap *= self.decay_factor  # decay factor
         self.extract_results(tracks)
         self.annotator = Annotator(self.im0, self.count_txt_thickness, None)
@@ -207,23 +204,21 @@ class Heatmap:
 
                 # Count objects
                 if len(self.count_reg_pts) == 4:
-                    if self.counting_region.contains(Point(track_line[-1])):
-                        if track_id not in self.counting_list:
-                            self.counting_list.append(track_id)
-                            if box[0] < self.counting_region.centroid.x:
-                                self.out_counts += 1
-                            else:
-                                self.in_counts += 1
+                    if self.counting_region.contains(Point(track_line[-1])) and track_id not in self.counting_list:
+                        self.counting_list.append(track_id)
+                        if box[0] < self.counting_region.centroid.x:
+                            self.out_counts += 1
+                        else:
+                            self.in_counts += 1
 
                 elif len(self.count_reg_pts) == 2:
                     distance = Point(track_line[-1]).distance(self.counting_region)
-                    if distance < self.line_dist_thresh:
-                        if track_id not in self.counting_list:
-                            self.counting_list.append(track_id)
-                            if box[0] < self.counting_region.centroid.x:
-                                self.out_counts += 1
-                            else:
-                                self.in_counts += 1
+                    if distance < self.line_dist_thresh and track_id not in self.counting_list:
+                        self.counting_list.append(track_id)
+                        if box[0] < self.counting_region.centroid.x:
+                            self.out_counts += 1
+                        else:
+                            self.in_counts += 1
         else:
             for box, cls in zip(self.boxes, self.clss):
                 if self.shape == "circle":
@@ -244,8 +239,8 @@ class Heatmap:
         heatmap_normalized = cv2.normalize(self.heatmap, None, 0, 255, cv2.NORM_MINMAX)
         heatmap_colored = cv2.applyColorMap(heatmap_normalized.astype(np.uint8), self.colormap)
 
-        incount_label = "In Count : " + f"{self.in_counts}"
-        outcount_label = "OutCount : " + f"{self.out_counts}"
+        incount_label = f"In Count : {self.in_counts}"
+        outcount_label = f"OutCount : {self.out_counts}"
 
         # Display counts based on user choice
         counts_label = None
@@ -256,7 +251,7 @@ class Heatmap:
         elif not self.view_out_counts:
             counts_label = incount_label
         else:
-            counts_label = incount_label + " " + outcount_label
+            counts_label = f"{incount_label} {outcount_label}"
 
         if self.count_reg_pts is not None and counts_label is not None:
             self.annotator.count_labels(

ultralytics/solutions/object_counter.py

@@ -139,11 +139,14 @@ class ObjectCounter:
         # global is_drawing, selected_point
         if event == cv2.EVENT_LBUTTONDOWN:
             for i, point in enumerate(self.reg_pts):
-                if isinstance(point, (tuple, list)) and len(point) >= 2:
-                    if abs(x - point[0]) < 10 and abs(y - point[1]) < 10:
-                        self.selected_point = i
-                        self.is_drawing = True
-                        break
+                if (
+                    isinstance(point, (tuple, list))
+                    and len(point) >= 2
+                    and (abs(x - point[0]) < 10 and abs(y - point[1]) < 10)
+                ):
+                    self.selected_point = i
+                    self.is_drawing = True
+                    break
 
         elif event == cv2.EVENT_MOUSEMOVE:
             if self.is_drawing and self.selected_point is not None:
@@ -166,9 +169,8 @@ class ObjectCounter:
 
         # Extract tracks
         for box, track_id, cls in zip(boxes, track_ids, clss):
-            self.annotator.box_label(
-                box, label=str(track_id) + ":" + self.names[cls], color=colors(int(cls), True)
-            )  # Draw bounding box
+            # Draw bounding box
+            self.annotator.box_label(box, label=f"{track_id}:{self.names[cls]}", color=colors(int(cls), True))
 
             # Draw Tracks
             track_line = self.track_history[track_id]
@@ -186,28 +188,29 @@ class ObjectCounter:
 
             # Count objects
             if len(self.reg_pts) == 4:
-                if prev_position is not None:
-                    if self.counting_region.contains(Point(track_line[-1])):
-                        if track_id not in self.counting_list:
-                            self.counting_list.append(track_id)
-                            if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
-                                self.in_counts += 1
-                            else:
-                                self.out_counts += 1
+                if (
+                    prev_position is not None
+                    and self.counting_region.contains(Point(track_line[-1]))
+                    and track_id not in self.counting_list
+                ):
+                    self.counting_list.append(track_id)
+                    if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
+                        self.in_counts += 1
+                    else:
+                        self.out_counts += 1
 
             elif len(self.reg_pts) == 2:
                 if prev_position is not None:
                     distance = Point(track_line[-1]).distance(self.counting_region)
-                    if distance < self.line_dist_thresh:
-                        if track_id not in self.counting_list:
-                            self.counting_list.append(track_id)
-                            if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
-                                self.in_counts += 1
-                            else:
-                                self.out_counts += 1
+                    if distance < self.line_dist_thresh and track_id not in self.counting_list:
+                        self.counting_list.append(track_id)
+                        if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
+                            self.in_counts += 1
+                        else:
+                            self.out_counts += 1
 
-        incount_label = "In Count : " + f"{self.in_counts}"
-        outcount_label = "OutCount : " + f"{self.out_counts}"
+        incount_label = f"In Count : {self.in_counts}"
+        outcount_label = f"OutCount : {self.out_counts}"
 
         # Display counts based on user choice
         counts_label = None
@@ -218,7 +221,7 @@ class ObjectCounter:
         elif not self.view_out_counts:
             counts_label = incount_label
         else:
-            counts_label = incount_label + " " + outcount_label
+            counts_label = f"{incount_label} {outcount_label}"
 
         if counts_label is not None:
             self.annotator.count_labels(
@@ -254,9 +257,7 @@ class ObjectCounter:
         if tracks[0].boxes.id is None:
             if self.view_img:
                 self.display_frames()
-                return
-            else:
-                return
+            return
         self.extract_and_process_tracks(tracks)
 
         if self.view_img:

ultralytics/solutions/speed_estimation.py

@@ -114,9 +114,7 @@ class SpeedEstimator:
             cls (str): object class name
             track (list): tracking history for tracks path drawing
         """
-        speed_label = (
-            str(int(self.dist_data[track_id])) + "km/ph" if track_id in self.dist_data else self.names[int(cls)]
-        )
+        speed_label = f"{int(self.dist_data[track_id])}km/ph" if track_id in self.dist_data else self.names[int(cls)]
         bbox_color = colors(int(track_id)) if track_id in self.dist_data else (255, 0, 255)
 
         self.annotator.box_label(box, speed_label, bbox_color)
@@ -132,28 +130,28 @@ class SpeedEstimator:
             track (list): tracking history for tracks path drawing
         """
 
-        if self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
-            if self.reg_pts[1][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[1][1] + self.spdl_dist_thresh:
-                direction = "known"
+        if not self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
+            return
+        if self.reg_pts[1][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[1][1] + self.spdl_dist_thresh:
+            direction = "known"
 
-            elif self.reg_pts[0][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[0][1] + self.spdl_dist_thresh:
-                direction = "known"
+        elif self.reg_pts[0][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[0][1] + self.spdl_dist_thresh:
+            direction = "known"
 
-            else:
-                direction = "unknown"
+        else:
+            direction = "unknown"
 
-            if self.trk_previous_times[trk_id] != 0 and direction != "unknown":
-                if trk_id not in self.trk_idslist:
-                    self.trk_idslist.append(trk_id)
+        if self.trk_previous_times[trk_id] != 0 and direction != "unknown" and trk_id not in self.trk_idslist:
+            self.trk_idslist.append(trk_id)
 
-                    time_difference = time() - self.trk_previous_times[trk_id]
-                    if time_difference > 0:
-                        dist_difference = np.abs(track[-1][1] - self.trk_previous_points[trk_id][1])
-                        speed = dist_difference / time_difference
-                        self.dist_data[trk_id] = speed
+            time_difference = time() - self.trk_previous_times[trk_id]
+            if time_difference > 0:
+                dist_difference = np.abs(track[-1][1] - self.trk_previous_points[trk_id][1])
+                speed = dist_difference / time_difference
+                self.dist_data[trk_id] = speed
 
-            self.trk_previous_times[trk_id] = time()
-            self.trk_previous_points[trk_id] = track[-1]
+        self.trk_previous_times[trk_id] = time()
+        self.trk_previous_points[trk_id] = track[-1]
 
     def estimate_speed(self, im0, tracks):
         """
@@ -166,10 +164,7 @@ class SpeedEstimator:
         if tracks[0].boxes.id is None:
             if self.view_img and self.env_check:
                 self.display_frames()
-                return
-            else:
-                return
-
+            return
         self.extract_tracks(tracks)
 
         self.annotator = Annotator(self.im0, line_width=2)

ultralytics/trackers/track.py

@@ -7,7 +7,6 @@ import torch
 
 from ultralytics.utils import IterableSimpleNamespace, yaml_load
 from ultralytics.utils.checks import check_yaml
-
 from .bot_sort import BOTSORT
 from .byte_tracker import BYTETracker
 

ultralytics/trackers/utils/gmc.py

@@ -67,7 +67,7 @@ class GMC:
                 maxCorners=1000, qualityLevel=0.01, minDistance=1, blockSize=3, useHarrisDetector=False, k=0.04
             )
 
-        elif self.method in ["none", "None", None]:
+        elif self.method in {"none", "None", None}:
             self.method = None
         else:
             raise ValueError(f"Error: Unknown GMC method:{method}")

ultralytics/trackers/utils/matching.py

@@ -70,9 +70,7 @@ def iou_distance(atracks: list, btracks: list) -> np.ndarray:
         (np.ndarray): Cost matrix computed based on IoU.
     """
 
-    if (len(atracks) > 0 and isinstance(atracks[0], np.ndarray)) or (
-        len(btracks) > 0 and isinstance(btracks[0], np.ndarray)
-    ):
+    if atracks and isinstance(atracks[0], np.ndarray) or btracks and isinstance(btracks[0], np.ndarray):
         atlbrs = atracks
         btlbrs = btracks
     else:

ultralytics/utils/benchmarks.py

@@ -26,7 +26,6 @@ ncnn                    | `ncnn`                    | yolov8n_ncnn_model/
 
 import glob
 import platform
-import sys
 import time
 from pathlib import Path
 
@@ -85,12 +84,8 @@ def benchmark(
         emoji, filename = "❌", None  # export defaults
         try:
             assert i != 9 or LINUX, "Edge TPU export only supported on Linux"
-            if i == 5:
-                assert MACOS or LINUX, "CoreML export only supported on macOS and Linux"
-            elif i == 10:
-                assert MACOS or LINUX, "TF.js export only supported on macOS and Linux"
-            # elif i == 11:
-            #     assert sys.version_info < (3, 11), "PaddlePaddle export only supported on Python<=3.10"
+            if i in {5, 10}:  # CoreML and TF.js
+                assert MACOS or LINUX, "export only supported on macOS and Linux"
             if "cpu" in device.type:
                 assert cpu, "inference not supported on CPU"
             if "cuda" in device.type:

ultralytics/utils/callbacks/base.py

@@ -4,6 +4,7 @@
 from collections import defaultdict
 from copy import deepcopy
 
+
 # Trainer callbacks ----------------------------------------------------------------------------------------------------
 
 

ultralytics/utils/callbacks/comet.py

@@ -105,12 +105,7 @@ def _fetch_trainer_metadata(trainer):
     save_interval = curr_epoch % save_period == 0
     save_assets = save and save_period > 0 and save_interval and not final_epoch
 
-    return dict(
-        curr_epoch=curr_epoch,
-        curr_step=curr_step,
-        save_assets=save_assets,
-        final_epoch=final_epoch,
-    )
+    return dict(curr_epoch=curr_epoch, curr_step=curr_step, save_assets=save_assets, final_epoch=final_epoch)
 
 
 def _scale_bounding_box_to_original_image_shape(box, resized_image_shape, original_image_shape, ratio_pad):
@@ -218,11 +213,7 @@ def _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch):
     conf_mat = trainer.validator.confusion_matrix.matrix
     names = list(trainer.data["names"].values()) + ["background"]
     experiment.log_confusion_matrix(
-        matrix=conf_mat,
-        labels=names,
-        max_categories=len(names),
-        epoch=curr_epoch,
-        step=curr_step,
+        matrix=conf_mat, labels=names, max_categories=len(names), epoch=curr_epoch, step=curr_step
     )
 
 
@@ -294,12 +285,7 @@ def _log_plots(experiment, trainer):
 def _log_model(experiment, trainer):
     """Log the best-trained model to Comet.ml."""
     model_name = _get_comet_model_name()
-    experiment.log_model(
-        model_name,
-        file_or_folder=str(trainer.best),
-        file_name="best.pt",
-        overwrite=True,
-    )
+    experiment.log_model(model_name, file_or_folder=str(trainer.best), file_name="best.pt", overwrite=True)
 
 
 def on_pretrain_routine_start(trainer):
@@ -320,11 +306,7 @@ def on_train_epoch_end(trainer):
     curr_epoch = metadata["curr_epoch"]
     curr_step = metadata["curr_step"]
 
-    experiment.log_metrics(
-        trainer.label_loss_items(trainer.tloss, prefix="train"),
-        step=curr_step,
-        epoch=curr_epoch,
-    )
+    experiment.log_metrics(trainer.label_loss_items(trainer.tloss, prefix="train"), step=curr_step, epoch=curr_epoch)
 
     if curr_epoch == 1:
         _log_images(experiment, trainer.save_dir.glob("train_batch*.jpg"), curr_step)

ultralytics/utils/callbacks/hub.py

@@ -3,9 +3,7 @@
 import json
 from time import time
 
-from hub_sdk.config import HUB_WEB_ROOT
-
-from ultralytics.hub.utils import PREFIX, events
+from ultralytics.hub.utils import HUB_WEB_ROOT, PREFIX, events
 from ultralytics.utils import LOGGER, SETTINGS
 
 

ultralytics/utils/callbacks/neptune.py

@@ -96,9 +96,7 @@ def on_train_end(trainer):
         for f in files:
             _log_plot(title=f.stem, plot_path=f)
         # Log the final model
-        run[f"weights/{trainer.args.name or trainer.args.task}/{str(trainer.best.name)}"].upload(
-            File(str(trainer.best))
-        )
+        run[f"weights/{trainer.args.name or trainer.args.task}/{trainer.best.name}"].upload(File(str(trainer.best)))
 
 
 callbacks = (

ultralytics/utils/callbacks/tensorboard.py

@@ -10,8 +10,9 @@ try:
     assert SETTINGS["tensorboard"] is True  # verify integration is enabled
     WRITER = None  # TensorBoard SummaryWriter instance
 
-except (ImportError, AssertionError, TypeError):
+except (ImportError, AssertionError, TypeError, AttributeError):
     # TypeError for handling 'Descriptors cannot not be created directly.' protobuf errors in Windows
+    # AttributeError: module 'tensorflow' has no attribute 'io' if 'tensorflow' not installed
     SummaryWriter = None