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

ultralytics/utils/callbacks/mlflow.py

@@ -26,15 +26,15 @@ from ultralytics.utils import LOGGER, RUNS_DIR, SETTINGS, TESTS_RUNNING, colorst
 try:
     import os
 
-    assert not TESTS_RUNNING or 'test_mlflow' in os.environ.get('PYTEST_CURRENT_TEST', '')  # do not log pytest
-    assert SETTINGS['mlflow'] is True  # verify integration is enabled
+    assert not TESTS_RUNNING or "test_mlflow" in os.environ.get("PYTEST_CURRENT_TEST", "")  # do not log pytest
+    assert SETTINGS["mlflow"] is True  # verify integration is enabled
     import mlflow
 
-    assert hasattr(mlflow, '__version__')  # verify package is not directory
+    assert hasattr(mlflow, "__version__")  # verify package is not directory
     from pathlib import Path
 
-    PREFIX = colorstr('MLflow: ')
-    SANITIZE = lambda x: {k.replace('(', '').replace(')', ''): float(v) for k, v in x.items()}
+    PREFIX = colorstr("MLflow: ")
+    SANITIZE = lambda x: {k.replace("(", "").replace(")", ""): float(v) for k, v in x.items()}
 
 except (ImportError, AssertionError):
     mlflow = None
@@ -61,33 +61,33 @@ def on_pretrain_routine_end(trainer):
     """
     global mlflow
 
-    uri = os.environ.get('MLFLOW_TRACKING_URI') or str(RUNS_DIR / 'mlflow')
-    LOGGER.debug(f'{PREFIX} tracking uri: {uri}')
+    uri = os.environ.get("MLFLOW_TRACKING_URI") or str(RUNS_DIR / "mlflow")
+    LOGGER.debug(f"{PREFIX} tracking uri: {uri}")
     mlflow.set_tracking_uri(uri)
 
     # Set experiment and run names
-    experiment_name = os.environ.get('MLFLOW_EXPERIMENT_NAME') or trainer.args.project or '/Shared/YOLOv8'
-    run_name = os.environ.get('MLFLOW_RUN') or trainer.args.name
+    experiment_name = os.environ.get("MLFLOW_EXPERIMENT_NAME") or trainer.args.project or "/Shared/YOLOv8"
+    run_name = os.environ.get("MLFLOW_RUN") or trainer.args.name
     mlflow.set_experiment(experiment_name)
 
     mlflow.autolog()
     try:
         active_run = mlflow.active_run() or mlflow.start_run(run_name=run_name)
-        LOGGER.info(f'{PREFIX}logging run_id({active_run.info.run_id}) to {uri}')
+        LOGGER.info(f"{PREFIX}logging run_id({active_run.info.run_id}) to {uri}")
         if Path(uri).is_dir():
             LOGGER.info(f"{PREFIX}view at http://127.0.0.1:5000 with 'mlflow server --backend-store-uri {uri}'")
         LOGGER.info(f"{PREFIX}disable with 'yolo settings mlflow=False'")
         mlflow.log_params(dict(trainer.args))
     except Exception as e:
-        LOGGER.warning(f'{PREFIX}WARNING ⚠️ Failed to initialize: {e}\n'
-                       f'{PREFIX}WARNING ⚠️ Not tracking this run')
+        LOGGER.warning(f"{PREFIX}WARNING ⚠️ Failed to initialize: {e}\n" f"{PREFIX}WARNING ⚠️ Not tracking this run")
 
 
 def on_train_epoch_end(trainer):
     """Log training metrics at the end of each train epoch to MLflow."""
     if mlflow:
-        mlflow.log_metrics(metrics=SANITIZE(trainer.label_loss_items(trainer.tloss, prefix='train')),
-                           step=trainer.epoch)
+        mlflow.log_metrics(
+            metrics=SANITIZE(trainer.label_loss_items(trainer.tloss, prefix="train")), step=trainer.epoch
+        )
         mlflow.log_metrics(metrics=SANITIZE(trainer.lr), step=trainer.epoch)
 
 
@@ -101,16 +101,23 @@ def on_train_end(trainer):
     """Log model artifacts at the end of the training."""
     if mlflow:
         mlflow.log_artifact(str(trainer.best.parent))  # log save_dir/weights directory with best.pt and last.pt
-        for f in trainer.save_dir.glob('*'):  # log all other files in save_dir
-            if f.suffix in {'.png', '.jpg', '.csv', '.pt', '.yaml'}:
+        for f in trainer.save_dir.glob("*"):  # log all other files in save_dir
+            if f.suffix in {".png", ".jpg", ".csv", ".pt", ".yaml"}:
                 mlflow.log_artifact(str(f))
 
         mlflow.end_run()
-        LOGGER.info(f'{PREFIX}results logged to {mlflow.get_tracking_uri()}\n'
-                    f"{PREFIX}disable with 'yolo settings mlflow=False'")
-
-
-callbacks = {
-    'on_pretrain_routine_end': on_pretrain_routine_end,
-    'on_fit_epoch_end': on_fit_epoch_end,
-    'on_train_end': on_train_end} if mlflow else {}
+        LOGGER.info(
+            f"{PREFIX}results logged to {mlflow.get_tracking_uri()}\n"
+            f"{PREFIX}disable with 'yolo settings mlflow=False'"
+        )
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_end": on_pretrain_routine_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_train_end": on_train_end,
+    }
+    if mlflow
+    else {}
+)

ultralytics/utils/callbacks/neptune.py

@@ -4,11 +4,11 @@ from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
-    assert SETTINGS['neptune'] is True  # verify integration is enabled
+    assert SETTINGS["neptune"] is True  # verify integration is enabled
     import neptune
     from neptune.types import File
 
-    assert hasattr(neptune, '__version__')
+    assert hasattr(neptune, "__version__")
 
     run = None  # NeptuneAI experiment logger instance
 
@@ -23,11 +23,11 @@ def _log_scalars(scalars, step=0):
             run[k].append(value=v, step=step)
 
 
-def _log_images(imgs_dict, group=''):
+def _log_images(imgs_dict, group=""):
     """Log scalars to the NeptuneAI experiment logger."""
     if run:
         for k, v in imgs_dict.items():
-            run[f'{group}/{k}'].upload(File(v))
+            run[f"{group}/{k}"].upload(File(v))
 
 
 def _log_plot(title, plot_path):
@@ -43,34 +43,35 @@ def _log_plot(title, plot_path):
 
     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)
-    run[f'Plots/{title}'].upload(fig)
+    run[f"Plots/{title}"].upload(fig)
 
 
 def on_pretrain_routine_start(trainer):
     """Callback function called before the training routine starts."""
     try:
         global run
-        run = neptune.init_run(project=trainer.args.project or 'YOLOv8', name=trainer.args.name, tags=['YOLOv8'])
-        run['Configuration/Hyperparameters'] = {k: '' if v is None else v for k, v in vars(trainer.args).items()}
+        run = neptune.init_run(project=trainer.args.project or "YOLOv8", name=trainer.args.name, tags=["YOLOv8"])
+        run["Configuration/Hyperparameters"] = {k: "" if v is None else v for k, v in vars(trainer.args).items()}
     except Exception as e:
-        LOGGER.warning(f'WARNING ⚠️ NeptuneAI installed but not initialized correctly, not logging this run. {e}')
+        LOGGER.warning(f"WARNING ⚠️ NeptuneAI installed but not initialized correctly, not logging this run. {e}")
 
 
 def on_train_epoch_end(trainer):
     """Callback function called at end of each training epoch."""
-    _log_scalars(trainer.label_loss_items(trainer.tloss, prefix='train'), trainer.epoch + 1)
+    _log_scalars(trainer.label_loss_items(trainer.tloss, prefix="train"), trainer.epoch + 1)
     _log_scalars(trainer.lr, trainer.epoch + 1)
     if trainer.epoch == 1:
-        _log_images({f.stem: str(f) for f in trainer.save_dir.glob('train_batch*.jpg')}, 'Mosaic')
+        _log_images({f.stem: str(f) for f in trainer.save_dir.glob("train_batch*.jpg")}, "Mosaic")
 
 
 def on_fit_epoch_end(trainer):
     """Callback function called at end of each fit (train+val) epoch."""
     if run and trainer.epoch == 0:
         from ultralytics.utils.torch_utils import model_info_for_loggers
-        run['Configuration/Model'] = model_info_for_loggers(trainer)
+
+        run["Configuration/Model"] = model_info_for_loggers(trainer)
     _log_scalars(trainer.metrics, trainer.epoch + 1)
 
 
@@ -78,7 +79,7 @@ def on_val_end(validator):
     """Callback function called at end of each validation."""
     if run:
         # Log val_labels and val_pred
-        _log_images({f.stem: str(f) for f in validator.save_dir.glob('val*.jpg')}, 'Validation')
+        _log_images({f.stem: str(f) for f in validator.save_dir.glob("val*.jpg")}, "Validation")
 
 
 def on_train_end(trainer):
@@ -86,19 +87,28 @@ def on_train_end(trainer):
     if run:
         # 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)
         # Log the final model
-        run[f'weights/{trainer.args.name or trainer.args.task}/{str(trainer.best.name)}'].upload(File(str(
-            trainer.best)))
-
-
-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 neptune else {}
+        run[f"weights/{trainer.args.name or trainer.args.task}/{str(trainer.best.name)}"].upload(
+            File(str(trainer.best))
+        )
+
+
+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 neptune
+    else {}
+)

ultralytics/utils/callbacks/raytune.py

@@ -3,7 +3,7 @@
 from ultralytics.utils import SETTINGS
 
 try:
-    assert SETTINGS['raytune'] is True  # verify integration is enabled
+    assert SETTINGS["raytune"] is True  # verify integration is enabled
     import ray
     from ray import tune
     from ray.air import session
@@ -16,9 +16,14 @@ def on_fit_epoch_end(trainer):
     """Sends training metrics to Ray Tune at end of each epoch."""
     if ray.tune.is_session_enabled():
         metrics = trainer.metrics
-        metrics['epoch'] = trainer.epoch
+        metrics["epoch"] = trainer.epoch
         session.report(metrics)
 
 
-callbacks = {
-    'on_fit_epoch_end': on_fit_epoch_end, } if tune else {}
+callbacks = (
+    {
+        "on_fit_epoch_end": on_fit_epoch_end,
+    }
+    if tune
+    else {}
+)

ultralytics/utils/callbacks/tensorboard.py

@@ -7,7 +7,7 @@ try:
     from torch.utils.tensorboard import SummaryWriter
 
     assert not TESTS_RUNNING  # do not log pytest
-    assert SETTINGS['tensorboard'] is True  # verify integration is enabled
+    assert SETTINGS["tensorboard"] is True  # verify integration is enabled
     WRITER = None  # TensorBoard SummaryWriter instance
 
 except (ImportError, AssertionError, TypeError):
@@ -34,10 +34,10 @@ def _log_tensorboard_graph(trainer):
         p = next(trainer.model.parameters())  # for device, type
         im = torch.zeros((1, 3, *imgsz), device=p.device, dtype=p.dtype)  # input image (must be zeros, not empty)
         with warnings.catch_warnings():
-            warnings.simplefilter('ignore', category=UserWarning)  # suppress jit trace warning
+            warnings.simplefilter("ignore", category=UserWarning)  # suppress jit trace warning
             WRITER.add_graph(torch.jit.trace(de_parallel(trainer.model), im, strict=False), [])
     except Exception as e:
-        LOGGER.warning(f'WARNING ⚠️ TensorBoard graph visualization failure {e}')
+        LOGGER.warning(f"WARNING ⚠️ TensorBoard graph visualization failure {e}")
 
 
 def on_pretrain_routine_start(trainer):
@@ -46,10 +46,10 @@ def on_pretrain_routine_start(trainer):
         try:
             global WRITER
             WRITER = SummaryWriter(str(trainer.save_dir))
-            prefix = colorstr('TensorBoard: ')
+            prefix = colorstr("TensorBoard: ")
             LOGGER.info(f"{prefix}Start with 'tensorboard --logdir {trainer.save_dir}', view at http://localhost:6006/")
         except Exception as e:
-            LOGGER.warning(f'WARNING ⚠️ TensorBoard not initialized correctly, not logging this run. {e}')
+            LOGGER.warning(f"WARNING ⚠️ TensorBoard not initialized correctly, not logging this run. {e}")
 
 
 def on_train_start(trainer):
@@ -60,7 +60,7 @@ def on_train_start(trainer):
 
 def on_train_epoch_end(trainer):
     """Logs scalar statistics at the end of a training epoch."""
-    _log_scalars(trainer.label_loss_items(trainer.tloss, prefix='train'), trainer.epoch + 1)
+    _log_scalars(trainer.label_loss_items(trainer.tloss, prefix="train"), trainer.epoch + 1)
     _log_scalars(trainer.lr, trainer.epoch + 1)
 
 
@@ -69,8 +69,13 @@ def on_fit_epoch_end(trainer):
     _log_scalars(trainer.metrics, trainer.epoch + 1)
 
 
-callbacks = {
-    'on_pretrain_routine_start': on_pretrain_routine_start,
-    'on_train_start': on_train_start,
-    'on_fit_epoch_end': on_fit_epoch_end,
-    'on_train_epoch_end': on_train_epoch_end} if SummaryWriter else {}
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_train_start": on_train_start,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_train_epoch_end": on_train_epoch_end,
+    }
+    if SummaryWriter
+    else {}
+)

ultralytics/utils/callbacks/wb.py

@@ -5,10 +5,10 @@ from ultralytics.utils.torch_utils import model_info_for_loggers
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
-    assert SETTINGS['wandb'] is True  # verify integration is enabled
+    assert SETTINGS["wandb"] is True  # verify integration is enabled
     import wandb as wb
 
-    assert hasattr(wb, '__version__')  # verify package is not directory
+    assert hasattr(wb, "__version__")  # verify package is not directory
 
     import numpy as np
     import pandas as pd
@@ -19,7 +19,7 @@ except (ImportError, AssertionError):
     wb = None
 
 
-def _custom_table(x, y, classes, title='Precision Recall Curve', x_title='Recall', y_title='Precision'):
+def _custom_table(x, y, classes, title="Precision Recall Curve", x_title="Recall", y_title="Precision"):
     """
     Create and log a custom metric visualization to wandb.plot.pr_curve.
 
@@ -37,24 +37,25 @@ 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)
-    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('wandb/area-under-curve/v0',
-                         wb.Table(dataframe=df),
-                         fields=fields,
-                         string_fields=string_fields)
-
-
-def _plot_curve(x,
-                y,
-                names=None,
-                id='precision-recall',
-                title='Precision Recall Curve',
-                x_title='Recall',
-                y_title='Precision',
-                num_x=100,
-                only_mean=False):
+    df = pd.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(
+        "wandb/area-under-curve/v0", wb.Table(dataframe=df), fields=fields, string_fields=string_fields
+    )
+
+
+def _plot_curve(
+    x,
+    y,
+    names=None,
+    id="precision-recall",
+    title="Precision Recall Curve",
+    x_title="Recall",
+    y_title="Precision",
+    num_x=100,
+    only_mean=False,
+):
     """
     Log a metric curve visualization.
 
@@ -88,7 +89,7 @@ def _plot_curve(x,
         table = wb.Table(data=list(zip(x_log, y_log)), columns=[x_title, y_title])
         wb.run.log({title: wb.plot.line(table, x_title, y_title, title=title)})
     else:
-        classes = ['mean'] * len(x_log)
+        classes = ["mean"] * len(x_log)
         for i, yi in enumerate(y):
             x_log.extend(x_new)  # add new x
             y_log.extend(np.interp(x_new, x, yi))  # interpolate y to new x
@@ -99,7 +100,7 @@ def _plot_curve(x,
 def _log_plots(plots, step):
     """Logs plots from the input dictionary if they haven't been logged already at the specified step."""
     for name, params in plots.items():
-        timestamp = params['timestamp']
+        timestamp = params["timestamp"]
         if _processed_plots.get(name) != timestamp:
             wb.run.log({name.stem: wb.Image(str(name))}, step=step)
             _processed_plots[name] = timestamp
@@ -107,7 +108,7 @@ def _log_plots(plots, step):
 
 def on_pretrain_routine_start(trainer):
     """Initiate and start project if module is present."""
-    wb.run or wb.init(project=trainer.args.project or 'YOLOv8', name=trainer.args.name, config=vars(trainer.args))
+    wb.run or wb.init(project=trainer.args.project or "YOLOv8", name=trainer.args.name, config=vars(trainer.args))
 
 
 def on_fit_epoch_end(trainer):
@@ -121,7 +122,7 @@ def on_fit_epoch_end(trainer):
 
 def on_train_epoch_end(trainer):
     """Log metrics and save images at the end of each training epoch."""
-    wb.run.log(trainer.label_loss_items(trainer.tloss, prefix='train'), step=trainer.epoch + 1)
+    wb.run.log(trainer.label_loss_items(trainer.tloss, prefix="train"), step=trainer.epoch + 1)
     wb.run.log(trainer.lr, step=trainer.epoch + 1)
     if trainer.epoch == 1:
         _log_plots(trainer.plots, step=trainer.epoch + 1)
@@ -131,17 +132,17 @@ def on_train_end(trainer):
     """Save the best model as an artifact at end of training."""
     _log_plots(trainer.validator.plots, step=trainer.epoch + 1)
     _log_plots(trainer.plots, step=trainer.epoch + 1)
-    art = wb.Artifact(type='model', name=f'run_{wb.run.id}_model')
+    art = wb.Artifact(type="model", name=f"run_{wb.run.id}_model")
     if trainer.best.exists():
         art.add_file(trainer.best)
-        wb.run.log_artifact(art, aliases=['best'])
+        wb.run.log_artifact(art, aliases=["best"])
     for curve_name, curve_values in zip(trainer.validator.metrics.curves, trainer.validator.metrics.curves_results):
         x, y, x_title, y_title = curve_values
         _plot_curve(
             x,
             y,
             names=list(trainer.validator.metrics.names.values()),
-            id=f'curves/{curve_name}',
+            id=f"curves/{curve_name}",
             title=curve_name,
             x_title=x_title,
             y_title=y_title,
@@ -149,8 +150,13 @@ def on_train_end(trainer):
     wb.run.finish()  # required or run continues on dashboard
 
 
-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_train_end': on_train_end} if wb 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_train_end": on_train_end,
+    }
+    if wb
+    else {}
+)