ultralytics 8.0.237__py3-none-any.whl → 8.0.239__py3-none-any.whl

ultralytics/utils/autobatch.py

@@ -42,14 +42,14 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
     """
 
     # Check device
-    prefix = colorstr('AutoBatch: ')
-    LOGGER.info(f'{prefix}Computing optimal batch size for imgsz={imgsz}')
+    prefix = colorstr("AutoBatch: ")
+    LOGGER.info(f"{prefix}Computing optimal batch size for imgsz={imgsz}")
     device = next(model.parameters()).device  # get model device
-    if device.type == 'cpu':
-        LOGGER.info(f'{prefix}CUDA not detected, using default CPU batch-size {batch_size}')
+    if device.type == "cpu":
+        LOGGER.info(f"{prefix}CUDA not detected, using default CPU batch-size {batch_size}")
         return batch_size
     if torch.backends.cudnn.benchmark:
-        LOGGER.info(f'{prefix} ⚠️ Requires torch.backends.cudnn.benchmark=False, using default batch-size {batch_size}')
+        LOGGER.info(f"{prefix} ⚠️ Requires torch.backends.cudnn.benchmark=False, using default batch-size {batch_size}")
         return batch_size
 
     # Inspect CUDA memory
@@ -60,7 +60,7 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
     r = torch.cuda.memory_reserved(device) / gb  # GiB reserved
     a = torch.cuda.memory_allocated(device) / gb  # GiB allocated
     f = t - (r + a)  # GiB free
-    LOGGER.info(f'{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free')
+    LOGGER.info(f"{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free")
 
     # Profile batch sizes
     batch_sizes = [1, 2, 4, 8, 16]
@@ -70,7 +70,7 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
 
         # Fit a solution
         y = [x[2] for x in results if x]  # memory [2]
-        p = np.polyfit(batch_sizes[:len(y)], y, deg=1)  # first degree polynomial fit
+        p = np.polyfit(batch_sizes[: len(y)], y, deg=1)  # first degree polynomial fit
         b = int((f * fraction - p[1]) / p[0])  # y intercept (optimal batch size)
         if None in results:  # some sizes failed
             i = results.index(None)  # first fail index
@@ -78,11 +78,11 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
                 b = batch_sizes[max(i - 1, 0)]  # select prior safe point
         if b < 1 or b > 1024:  # b outside of safe range
             b = batch_size
-            LOGGER.info(f'{prefix}WARNING ⚠️ CUDA anomaly detected, using default batch-size {batch_size}.')
+            LOGGER.info(f"{prefix}WARNING ⚠️ CUDA anomaly detected, using default batch-size {batch_size}.")
 
         fraction = (np.polyval(p, b) + r + a) / t  # actual fraction predicted
-        LOGGER.info(f'{prefix}Using batch-size {b} for {d} {t * fraction:.2f}G/{t:.2f}G ({fraction * 100:.0f}%) ✅')
+        LOGGER.info(f"{prefix}Using batch-size {b} for {d} {t * fraction:.2f}G/{t:.2f}G ({fraction * 100:.0f}%) ✅")
         return b
     except Exception as e:
-        LOGGER.warning(f'{prefix}WARNING ⚠️ error detected: {e},  using default batch-size {batch_size}.')
+        LOGGER.warning(f"{prefix}WARNING ⚠️ error detected: {e},  using default batch-size {batch_size}.")
         return batch_size

ultralytics/utils/benchmarks.py

@@ -42,13 +42,9 @@ from ultralytics.utils.files import file_size
 from ultralytics.utils.torch_utils import select_device
 
 
-def benchmark(model=WEIGHTS_DIR / 'yolov8n.pt',
-              data=None,
-              imgsz=160,
-              half=False,
-              int8=False,
-              device='cpu',
-              verbose=False):
+def benchmark(
+    model=WEIGHTS_DIR / "yolov8n.pt", data=None, imgsz=160, half=False, int8=False, device="cpu", verbose=False
+):
     """
     Benchmark a YOLO model across different formats for speed and accuracy.
 
@@ -76,6 +72,7 @@ def benchmark(model=WEIGHTS_DIR / 'yolov8n.pt',
     """
 
     import pandas as pd
+
     pd.options.display.max_columns = 10
     pd.options.display.width = 120
     device = select_device(device, verbose=False)
@@ -85,67 +82,62 @@ def benchmark(model=WEIGHTS_DIR / 'yolov8n.pt',
     y = []
     t0 = time.time()
     for i, (name, format, suffix, cpu, gpu) in export_formats().iterrows():  # index, (name, format, suffix, CPU, GPU)
-        emoji, filename = '❌', None  # export defaults
+        emoji, filename = "❌", None  # export defaults
         try:
-            assert i != 9 or LINUX, 'Edge TPU export only supported on Linux'
+            assert i != 9 or LINUX, "Edge TPU export only supported on Linux"
             if i == 10:
-                assert MACOS or LINUX, 'TF.js export only supported on macOS and Linux'
+                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 'cpu' in device.type:
-                assert cpu, 'inference not supported on CPU'
-            if 'cuda' in device.type:
-                assert gpu, 'inference not supported on GPU'
+                assert sys.version_info < (3, 11), "PaddlePaddle export only supported on Python<=3.10"
+            if "cpu" in device.type:
+                assert cpu, "inference not supported on CPU"
+            if "cuda" in device.type:
+                assert gpu, "inference not supported on GPU"
 
             # Export
-            if format == '-':
+            if format == "-":
                 filename = model.ckpt_path or model.cfg
                 exported_model = model  # PyTorch format
             else:
                 filename = model.export(imgsz=imgsz, format=format, half=half, int8=int8, device=device, verbose=False)
                 exported_model = YOLO(filename, task=model.task)
-                assert suffix in str(filename), 'export failed'
-            emoji = '❎'  # indicates export succeeded
+                assert suffix in str(filename), "export failed"
+            emoji = "❎"  # indicates export succeeded
 
             # Predict
-            assert model.task != 'pose' or i != 7, 'GraphDef Pose inference is not supported'
-            assert i not in (9, 10), 'inference not supported'  # Edge TPU and TF.js are unsupported
-            assert i != 5 or platform.system() == 'Darwin', 'inference only supported on macOS>=10.13'  # CoreML
-            exported_model.predict(ASSETS / 'bus.jpg', imgsz=imgsz, device=device, half=half)
+            assert model.task != "pose" or i != 7, "GraphDef Pose inference is not supported"
+            assert i not in (9, 10), "inference not supported"  # Edge TPU and TF.js are unsupported
+            assert i != 5 or platform.system() == "Darwin", "inference only supported on macOS>=10.13"  # CoreML
+            exported_model.predict(ASSETS / "bus.jpg", imgsz=imgsz, device=device, half=half)
 
             # Validate
             data = data or TASK2DATA[model.task]  # task to dataset, i.e. coco8.yaml for task=detect
             key = TASK2METRIC[model.task]  # task to metric, i.e. metrics/mAP50-95(B) for task=detect
-            results = exported_model.val(data=data,
-                                         batch=1,
-                                         imgsz=imgsz,
-                                         plots=False,
-                                         device=device,
-                                         half=half,
-                                         int8=int8,
-                                         verbose=False)
-            metric, speed = results.results_dict[key], results.speed['inference']
-            y.append([name, '✅', round(file_size(filename), 1), round(metric, 4), round(speed, 2)])
+            results = exported_model.val(
+                data=data, batch=1, imgsz=imgsz, plots=False, device=device, half=half, int8=int8, verbose=False
+            )
+            metric, speed = results.results_dict[key], results.speed["inference"]
+            y.append([name, "✅", round(file_size(filename), 1), round(metric, 4), round(speed, 2)])
         except Exception as e:
             if verbose:
-                assert type(e) is AssertionError, f'Benchmark failure for {name}: {e}'
-            LOGGER.warning(f'ERROR ❌️ Benchmark failure for {name}: {e}')
+                assert type(e) is AssertionError, f"Benchmark failure for {name}: {e}"
+            LOGGER.warning(f"ERROR ❌️ Benchmark failure for {name}: {e}")
             y.append([name, emoji, round(file_size(filename), 1), None, None])  # mAP, t_inference
 
     # Print results
     check_yolo(device=device)  # print system info
-    df = pd.DataFrame(y, columns=['Format', 'Status❔', 'Size (MB)', key, 'Inference time (ms/im)'])
+    df = pd.DataFrame(y, columns=["Format", "Status❔", "Size (MB)", key, "Inference time (ms/im)"])
 
     name = Path(model.ckpt_path).name
-    s = f'\nBenchmarks complete for {name} on {data} at imgsz={imgsz} ({time.time() - t0:.2f}s)\n{df}\n'
+    s = f"\nBenchmarks complete for {name} on {data} at imgsz={imgsz} ({time.time() - t0:.2f}s)\n{df}\n"
     LOGGER.info(s)
-    with open('benchmarks.log', 'a', errors='ignore', encoding='utf-8') as f:
+    with open("benchmarks.log", "a", errors="ignore", encoding="utf-8") as f:
         f.write(s)
 
     if verbose and isinstance(verbose, float):
         metrics = df[key].array  # values to compare to floor
         floor = verbose  # minimum metric floor to pass, i.e. = 0.29 mAP for YOLOv5n
-        assert all(x > floor for x in metrics if pd.notna(x)), f'Benchmark failure: metric(s) < floor {floor}'
+        assert all(x > floor for x in metrics if pd.notna(x)), f"Benchmark failure: metric(s) < floor {floor}"
 
     return df
 
@@ -175,15 +167,17 @@ class ProfileModels:
         ```
     """
 
-    def __init__(self,
-                 paths: list,
-                 num_timed_runs=100,
-                 num_warmup_runs=10,
-                 min_time=60,
-                 imgsz=640,
-                 half=True,
-                 trt=True,
-                 device=None):
+    def __init__(
+        self,
+        paths: list,
+        num_timed_runs=100,
+        num_warmup_runs=10,
+        min_time=60,
+        imgsz=640,
+        half=True,
+        trt=True,
+        device=None,
+    ):
         """
         Initialize the ProfileModels class for profiling models.
 
@@ -204,37 +198,32 @@ class ProfileModels:
         self.imgsz = imgsz
         self.half = half
         self.trt = trt  # run TensorRT profiling
-        self.device = device or torch.device(0 if torch.cuda.is_available() else 'cpu')
+        self.device = device or torch.device(0 if torch.cuda.is_available() else "cpu")
 
     def profile(self):
         """Logs the benchmarking results of a model, checks metrics against floor and returns the results."""
         files = self.get_files()
 
         if not files:
-            print('No matching *.pt or *.onnx files found.')
+            print("No matching *.pt or *.onnx files found.")
             return
 
         table_rows = []
         output = []
         for file in files:
-            engine_file = file.with_suffix('.engine')
-            if file.suffix in ('.pt', '.yaml', '.yml'):
+            engine_file = file.with_suffix(".engine")
+            if file.suffix in (".pt", ".yaml", ".yml"):
                 model = YOLO(str(file))
                 model.fuse()  # to report correct params and GFLOPs in model.info()
                 model_info = model.info()
-                if self.trt and self.device.type != 'cpu' and not engine_file.is_file():
-                    engine_file = model.export(format='engine',
-                                               half=self.half,
-                                               imgsz=self.imgsz,
-                                               device=self.device,
-                                               verbose=False)
-                onnx_file = model.export(format='onnx',
-                                         half=self.half,
-                                         imgsz=self.imgsz,
-                                         simplify=True,
-                                         device=self.device,
-                                         verbose=False)
-            elif file.suffix == '.onnx':
+                if self.trt and self.device.type != "cpu" and not engine_file.is_file():
+                    engine_file = model.export(
+                        format="engine", half=self.half, imgsz=self.imgsz, device=self.device, verbose=False
+                    )
+                onnx_file = model.export(
+                    format="onnx", half=self.half, imgsz=self.imgsz, simplify=True, device=self.device, verbose=False
+                )
+            elif file.suffix == ".onnx":
                 model_info = self.get_onnx_model_info(file)
                 onnx_file = file
             else:
@@ -254,14 +243,14 @@ class ProfileModels:
         for path in self.paths:
             path = Path(path)
             if path.is_dir():
-                extensions = ['*.pt', '*.onnx', '*.yaml']
+                extensions = ["*.pt", "*.onnx", "*.yaml"]
                 files.extend([file for ext in extensions for file in glob.glob(str(path / ext))])
-            elif path.suffix in {'.pt', '.yaml', '.yml'}:  # add non-existing
+            elif path.suffix in {".pt", ".yaml", ".yml"}:  # add non-existing
                 files.append(str(path))
             else:
                 files.extend(glob.glob(str(path)))
 
-        print(f'Profiling: {sorted(files)}')
+        print(f"Profiling: {sorted(files)}")
         return [Path(file) for file in sorted(files)]
 
     def get_onnx_model_info(self, onnx_file: str):
@@ -306,7 +295,7 @@ class ProfileModels:
         run_times = []
         for _ in TQDM(range(num_runs), desc=engine_file):
             results = model(input_data, imgsz=self.imgsz, verbose=False)
-            run_times.append(results[0].speed['inference'])  # Convert to milliseconds
+            run_times.append(results[0].speed["inference"])  # Convert to milliseconds
 
         run_times = self.iterative_sigma_clipping(np.array(run_times), sigma=2, max_iters=3)  # sigma clipping
         return np.mean(run_times), np.std(run_times)
@@ -315,31 +304,31 @@ class ProfileModels:
         """Profiles an ONNX model by executing it multiple times and returns the mean and standard deviation of run
         times.
         """
-        check_requirements('onnxruntime')
+        check_requirements("onnxruntime")
         import onnxruntime as ort
 
         # Session with either 'TensorrtExecutionProvider', 'CUDAExecutionProvider', 'CPUExecutionProvider'
         sess_options = ort.SessionOptions()
         sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
         sess_options.intra_op_num_threads = 8  # Limit the number of threads
-        sess = ort.InferenceSession(onnx_file, sess_options, providers=['CPUExecutionProvider'])
+        sess = ort.InferenceSession(onnx_file, sess_options, providers=["CPUExecutionProvider"])
 
         input_tensor = sess.get_inputs()[0]
         input_type = input_tensor.type
 
         # Mapping ONNX datatype to numpy datatype
-        if 'float16' in input_type:
+        if "float16" in input_type:
             input_dtype = np.float16
-        elif 'float' in input_type:
+        elif "float" in input_type:
             input_dtype = np.float32
-        elif 'double' in input_type:
+        elif "double" in input_type:
             input_dtype = np.float64
-        elif 'int64' in input_type:
+        elif "int64" in input_type:
             input_dtype = np.int64
-        elif 'int32' in input_type:
+        elif "int32" in input_type:
             input_dtype = np.int32
         else:
-            raise ValueError(f'Unsupported ONNX datatype {input_type}')
+            raise ValueError(f"Unsupported ONNX datatype {input_type}")
 
         input_data = np.random.rand(*input_tensor.shape).astype(input_dtype)
         input_name = input_tensor.name
@@ -369,25 +358,26 @@ class ProfileModels:
     def generate_table_row(self, model_name, t_onnx, t_engine, model_info):
         """Generates a formatted string for a table row that includes model performance and metric details."""
         layers, params, gradients, flops = model_info
-        return f'| {model_name:18s} | {self.imgsz} | - | {t_onnx[0]:.2f} ± {t_onnx[1]:.2f} ms | {t_engine[0]:.2f} ± {t_engine[1]:.2f} ms | {params / 1e6:.1f} | {flops:.1f} |'
+        return f"| {model_name:18s} | {self.imgsz} | - | {t_onnx[0]:.2f} ± {t_onnx[1]:.2f} ms | {t_engine[0]:.2f} ± {t_engine[1]:.2f} ms | {params / 1e6:.1f} | {flops:.1f} |"
 
     def generate_results_dict(self, model_name, t_onnx, t_engine, model_info):
         """Generates a dictionary of model details including name, parameters, GFLOPS and speed metrics."""
         layers, params, gradients, flops = model_info
         return {
-            'model/name': model_name,
-            'model/parameters': params,
-            'model/GFLOPs': round(flops, 3),
-            'model/speed_ONNX(ms)': round(t_onnx[0], 3),
-            'model/speed_TensorRT(ms)': round(t_engine[0], 3)}
+            "model/name": model_name,
+            "model/parameters": params,
+            "model/GFLOPs": round(flops, 3),
+            "model/speed_ONNX(ms)": round(t_onnx[0], 3),
+            "model/speed_TensorRT(ms)": round(t_engine[0], 3),
+        }
 
     def print_table(self, table_rows):
         """Formats and prints a comparison table for different models with given statistics and performance data."""
-        gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'GPU'
-        header = f'| Model | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>{gpu} TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |'
-        separator = '|-------------|---------------------|--------------------|------------------------------|-----------------------------------|------------------|-----------------|'
+        gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "GPU"
+        header = f"| Model | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>{gpu} TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |"
+        separator = "|-------------|---------------------|--------------------|------------------------------|-----------------------------------|------------------|-----------------|"
 
-        print(f'\n\n{header}')
+        print(f"\n\n{header}")
         print(separator)
         for row in table_rows:
             print(row)

ultralytics/utils/callbacks/__init__.py

@@ -2,4 +2,4 @@
 
 from .base import add_integration_callbacks, default_callbacks, get_default_callbacks
 
-__all__ = 'add_integration_callbacks', 'default_callbacks', 'get_default_callbacks'
+__all__ = "add_integration_callbacks", "default_callbacks", "get_default_callbacks"

ultralytics/utils/callbacks/base.py

@@ -143,37 +143,35 @@ def on_export_end(exporter):
 
 default_callbacks = {
     # Run in trainer
-    'on_pretrain_routine_start': [on_pretrain_routine_start],
-    'on_pretrain_routine_end': [on_pretrain_routine_end],
-    'on_train_start': [on_train_start],
-    'on_train_epoch_start': [on_train_epoch_start],
-    'on_train_batch_start': [on_train_batch_start],
-    'optimizer_step': [optimizer_step],
-    'on_before_zero_grad': [on_before_zero_grad],
-    'on_train_batch_end': [on_train_batch_end],
-    'on_train_epoch_end': [on_train_epoch_end],
-    'on_fit_epoch_end': [on_fit_epoch_end],  # fit = train + val
-    'on_model_save': [on_model_save],
-    'on_train_end': [on_train_end],
-    'on_params_update': [on_params_update],
-    'teardown': [teardown],
-
+    "on_pretrain_routine_start": [on_pretrain_routine_start],
+    "on_pretrain_routine_end": [on_pretrain_routine_end],
+    "on_train_start": [on_train_start],
+    "on_train_epoch_start": [on_train_epoch_start],
+    "on_train_batch_start": [on_train_batch_start],
+    "optimizer_step": [optimizer_step],
+    "on_before_zero_grad": [on_before_zero_grad],
+    "on_train_batch_end": [on_train_batch_end],
+    "on_train_epoch_end": [on_train_epoch_end],
+    "on_fit_epoch_end": [on_fit_epoch_end],  # fit = train + val
+    "on_model_save": [on_model_save],
+    "on_train_end": [on_train_end],
+    "on_params_update": [on_params_update],
+    "teardown": [teardown],
     # Run in validator
-    'on_val_start': [on_val_start],
-    'on_val_batch_start': [on_val_batch_start],
-    'on_val_batch_end': [on_val_batch_end],
-    'on_val_end': [on_val_end],
-
+    "on_val_start": [on_val_start],
+    "on_val_batch_start": [on_val_batch_start],
+    "on_val_batch_end": [on_val_batch_end],
+    "on_val_end": [on_val_end],
     # Run in predictor
-    'on_predict_start': [on_predict_start],
-    'on_predict_batch_start': [on_predict_batch_start],
-    'on_predict_postprocess_end': [on_predict_postprocess_end],
-    'on_predict_batch_end': [on_predict_batch_end],
-    'on_predict_end': [on_predict_end],
-
+    "on_predict_start": [on_predict_start],
+    "on_predict_batch_start": [on_predict_batch_start],
+    "on_predict_postprocess_end": [on_predict_postprocess_end],
+    "on_predict_batch_end": [on_predict_batch_end],
+    "on_predict_end": [on_predict_end],
     # Run in exporter
-    'on_export_start': [on_export_start],
-    'on_export_end': [on_export_end]}
+    "on_export_start": [on_export_start],
+    "on_export_end": [on_export_end],
+}
 
 
 def get_default_callbacks():
@@ -197,10 +195,11 @@ def add_integration_callbacks(instance):
 
     # Load HUB callbacks
     from .hub import callbacks as hub_cb
+
     callbacks_list = [hub_cb]
 
     # Load training callbacks
-    if 'Trainer' in instance.__class__.__name__:
+    if "Trainer" in instance.__class__.__name__:
         from .clearml import callbacks as clear_cb
         from .comet import callbacks as comet_cb
         from .dvc import callbacks as dvc_cb
@@ -209,6 +208,7 @@ def add_integration_callbacks(instance):
         from .raytune import callbacks as tune_cb
         from .tensorboard import callbacks as tb_cb
         from .wb import callbacks as wb_cb
+
         callbacks_list.extend([clear_cb, comet_cb, dvc_cb, mlflow_cb, neptune_cb, tune_cb, tb_cb, wb_cb])
 
     # Add the callbacks to the callbacks dictionary

ultralytics/utils/callbacks/clearml.py

@@ -4,19 +4,19 @@ from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
-    assert SETTINGS['clearml'] is True  # verify integration is enabled
+    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
+    assert hasattr(clearml, "__version__")  # verify package is not directory
 
 except (ImportError, AssertionError):
     clearml = None
 
 
-def _log_debug_samples(files, title='Debug Samples') -> None:
+def _log_debug_samples(files, title="Debug Samples") -> None:
     """
     Log files (images) as debug samples in the ClearML task.
 
@@ -29,12 +29,11 @@ def _log_debug_samples(files, title='Debug Samples') -> None:
     if task := Task.current_task():
         for f in files:
             if f.exists():
-                it = re.search(r'_batch(\d+)', f.name)
+                it = re.search(r"_batch(\d+)", f.name)
                 iteration = int(it.groups()[0]) if it else 0
-                task.get_logger().report_image(title=title,
-                                               series=f.name.replace(it.group(), ''),
-                                               local_path=str(f),
-                                               iteration=iteration)
+                task.get_logger().report_image(
+                    title=title, series=f.name.replace(it.group(), ""), local_path=str(f), iteration=iteration
+                )
 
 
 def _log_plot(title, plot_path) -> None:
@@ -50,13 +49,12 @@ def _log_plot(title, plot_path) -> None:
 
     img = mpimg.imread(plot_path)
     fig = plt.figure()
-    ax = fig.add_axes([0, 0, 1, 1], frameon=False, aspect='auto', xticks=[], yticks=[])  # no ticks
+    ax = fig.add_axes([0, 0, 1, 1], frameon=False, aspect="auto", xticks=[], yticks=[])  # no ticks
     ax.imshow(img)
 
-    Task.current_task().get_logger().report_matplotlib_figure(title=title,
-                                                              series='',
-                                                              figure=fig,
-                                                              report_interactive=False)
+    Task.current_task().get_logger().report_matplotlib_figure(
+        title=title, series="", figure=fig, report_interactive=False
+    )
 
 
 def on_pretrain_routine_start(trainer):
@@ -68,19 +66,21 @@ def on_pretrain_routine_start(trainer):
             PatchPyTorchModelIO.update_current_task(None)
             PatchedMatplotlib.update_current_task(None)
         else:
-            task = Task.init(project_name=trainer.args.project or 'YOLOv8',
-                             task_name=trainer.args.name,
-                             tags=['YOLOv8'],
-                             output_uri=True,
-                             reuse_last_task_id=False,
-                             auto_connect_frameworks={
-                                 'pytorch': False,
-                                 'matplotlib': False})
-            LOGGER.warning('ClearML Initialized a new task. If you want to run remotely, '
-                           'please add clearml-init and connect your arguments before initializing YOLO.')
-        task.connect(vars(trainer.args), name='General')
+            task = Task.init(
+                project_name=trainer.args.project or "YOLOv8",
+                task_name=trainer.args.name,
+                tags=["YOLOv8"],
+                output_uri=True,
+                reuse_last_task_id=False,
+                auto_connect_frameworks={"pytorch": False, "matplotlib": False},
+            )
+            LOGGER.warning(
+                "ClearML Initialized a new task. If you want to run remotely, "
+                "please add clearml-init and connect your arguments before initializing YOLO."
+            )
+        task.connect(vars(trainer.args), name="General")
     except Exception as e:
-        LOGGER.warning(f'WARNING ⚠️ ClearML installed but not initialized correctly, not logging this run. {e}')
+        LOGGER.warning(f"WARNING ⚠️ ClearML installed but not initialized correctly, not logging this run. {e}")
 
 
 def on_train_epoch_end(trainer):
@@ -88,26 +88,26 @@ def on_train_epoch_end(trainer):
     if task := Task.current_task():
         # Log debug samples
         if trainer.epoch == 1:
-            _log_debug_samples(sorted(trainer.save_dir.glob('train_batch*.jpg')), 'Mosaic')
+            _log_debug_samples(sorted(trainer.save_dir.glob("train_batch*.jpg")), "Mosaic")
         # Report the current training progress
-        for k, v in trainer.label_loss_items(trainer.tloss, prefix='train').items():
-            task.get_logger().report_scalar('train', k, v, iteration=trainer.epoch)
+        for k, v in trainer.label_loss_items(trainer.tloss, prefix="train").items():
+            task.get_logger().report_scalar("train", k, v, iteration=trainer.epoch)
         for k, v in trainer.lr.items():
-            task.get_logger().report_scalar('lr', k, v, iteration=trainer.epoch)
+            task.get_logger().report_scalar("lr", k, v, iteration=trainer.epoch)
 
 
 def on_fit_epoch_end(trainer):
     """Reports model information to logger at the end of an epoch."""
     if task := Task.current_task():
         # You should have access to the validation bboxes under jdict
-        task.get_logger().report_scalar(title='Epoch Time',
-                                        series='Epoch Time',
-                                        value=trainer.epoch_time,
-                                        iteration=trainer.epoch)
+        task.get_logger().report_scalar(
+            title="Epoch Time", series="Epoch Time", value=trainer.epoch_time, iteration=trainer.epoch
+        )
         for k, v in trainer.metrics.items():
-            task.get_logger().report_scalar('val', k, v, iteration=trainer.epoch)
+            task.get_logger().report_scalar("val", k, v, iteration=trainer.epoch)
         if trainer.epoch == 0:
             from ultralytics.utils.torch_utils import model_info_for_loggers
+
             for k, v in model_info_for_loggers(trainer).items():
                 task.get_logger().report_single_value(k, v)
 
@@ -116,7 +116,7 @@ def on_val_end(validator):
     """Logs validation results including labels and predictions."""
     if Task.current_task():
         # Log val_labels and val_pred
-        _log_debug_samples(sorted(validator.save_dir.glob('val*.jpg')), 'Validation')
+        _log_debug_samples(sorted(validator.save_dir.glob("val*.jpg")), "Validation")
 
 
 def on_train_end(trainer):
@@ -124,8 +124,11 @@ def on_train_end(trainer):
     if task := Task.current_task():
         # Log final results, CM matrix + PR plots
         files = [
-            'results.png', 'confusion_matrix.png', 'confusion_matrix_normalized.png',
-            *(f'{x}_curve.png' for x in ('F1', 'PR', 'P', 'R'))]
+            "results.png",
+            "confusion_matrix.png",
+            "confusion_matrix_normalized.png",
+            *(f"{x}_curve.png" for x in ("F1", "PR", "P", "R")),
+        ]
         files = [(trainer.save_dir / f) for f in files if (trainer.save_dir / f).exists()]  # filter
         for f in files:
             _log_plot(title=f.stem, plot_path=f)
@@ -136,9 +139,14 @@ def on_train_end(trainer):
         task.update_output_model(model_path=str(trainer.best), model_name=trainer.args.name, auto_delete_file=False)
 
 
-callbacks = {
-    'on_pretrain_routine_start': on_pretrain_routine_start,
-    'on_train_epoch_end': on_train_epoch_end,
-    'on_fit_epoch_end': on_fit_epoch_end,
-    'on_val_end': on_val_end,
-    'on_train_end': on_train_end} if clearml else {}
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_train_epoch_end": on_train_epoch_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_val_end": on_val_end,
+        "on_train_end": on_train_end,
+    }
+    if clearml
+    else {}
+)