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

ultralytics/utils/callbacks/comet.py

@@ -4,20 +4,20 @@ from ultralytics.utils import LOGGER, RANK, SETTINGS, TESTS_RUNNING, ops
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
-    assert SETTINGS['comet'] is True  # verify integration is enabled
+    assert SETTINGS["comet"] is True  # verify integration is enabled
     import comet_ml
 
-    assert hasattr(comet_ml, '__version__')  # verify package is not directory
+    assert hasattr(comet_ml, "__version__")  # verify package is not directory
 
     import os
     from pathlib import Path
 
     # Ensures certain logging functions only run for supported tasks
-    COMET_SUPPORTED_TASKS = ['detect']
+    COMET_SUPPORTED_TASKS = ["detect"]
 
     # Names of plots created by YOLOv8 that are logged to Comet
-    EVALUATION_PLOT_NAMES = 'F1_curve', 'P_curve', 'R_curve', 'PR_curve', 'confusion_matrix'
-    LABEL_PLOT_NAMES = 'labels', 'labels_correlogram'
+    EVALUATION_PLOT_NAMES = "F1_curve", "P_curve", "R_curve", "PR_curve", "confusion_matrix"
+    LABEL_PLOT_NAMES = "labels", "labels_correlogram"
 
     _comet_image_prediction_count = 0
 
@@ -27,43 +27,43 @@ except (ImportError, AssertionError):
 
 def _get_comet_mode():
     """Returns the mode of comet set in the environment variables, defaults to 'online' if not set."""
-    return os.getenv('COMET_MODE', 'online')
+    return os.getenv("COMET_MODE", "online")
 
 
 def _get_comet_model_name():
     """Returns the model name for Comet from the environment variable 'COMET_MODEL_NAME' or defaults to 'YOLOv8'."""
-    return os.getenv('COMET_MODEL_NAME', 'YOLOv8')
+    return os.getenv("COMET_MODEL_NAME", "YOLOv8")
 
 
 def _get_eval_batch_logging_interval():
     """Get the evaluation batch logging interval from environment variable or use default value 1."""
-    return int(os.getenv('COMET_EVAL_BATCH_LOGGING_INTERVAL', 1))
+    return int(os.getenv("COMET_EVAL_BATCH_LOGGING_INTERVAL", 1))
 
 
 def _get_max_image_predictions_to_log():
     """Get the maximum number of image predictions to log from the environment variables."""
-    return int(os.getenv('COMET_MAX_IMAGE_PREDICTIONS', 100))
+    return int(os.getenv("COMET_MAX_IMAGE_PREDICTIONS", 100))
 
 
 def _scale_confidence_score(score):
     """Scales the given confidence score by a factor specified in an environment variable."""
-    scale = float(os.getenv('COMET_MAX_CONFIDENCE_SCORE', 100.0))
+    scale = float(os.getenv("COMET_MAX_CONFIDENCE_SCORE", 100.0))
     return score * scale
 
 
 def _should_log_confusion_matrix():
     """Determines if the confusion matrix should be logged based on the environment variable settings."""
-    return os.getenv('COMET_EVAL_LOG_CONFUSION_MATRIX', 'false').lower() == 'true'
+    return os.getenv("COMET_EVAL_LOG_CONFUSION_MATRIX", "false").lower() == "true"
 
 
 def _should_log_image_predictions():
     """Determines whether to log image predictions based on a specified environment variable."""
-    return os.getenv('COMET_EVAL_LOG_IMAGE_PREDICTIONS', 'true').lower() == 'true'
+    return os.getenv("COMET_EVAL_LOG_IMAGE_PREDICTIONS", "true").lower() == "true"
 
 
 def _get_experiment_type(mode, project_name):
     """Return an experiment based on mode and project name."""
-    if mode == 'offline':
+    if mode == "offline":
         return comet_ml.OfflineExperiment(project_name=project_name)
 
     return comet_ml.Experiment(project_name=project_name)
@@ -75,18 +75,21 @@ def _create_experiment(args):
         return
     try:
         comet_mode = _get_comet_mode()
-        _project_name = os.getenv('COMET_PROJECT_NAME', args.project)
+        _project_name = os.getenv("COMET_PROJECT_NAME", args.project)
         experiment = _get_experiment_type(comet_mode, _project_name)
         experiment.log_parameters(vars(args))
-        experiment.log_others({
-            'eval_batch_logging_interval': _get_eval_batch_logging_interval(),
-            'log_confusion_matrix_on_eval': _should_log_confusion_matrix(),
-            'log_image_predictions': _should_log_image_predictions(),
-            'max_image_predictions': _get_max_image_predictions_to_log(), })
-        experiment.log_other('Created from', 'yolov8')
+        experiment.log_others(
+            {
+                "eval_batch_logging_interval": _get_eval_batch_logging_interval(),
+                "log_confusion_matrix_on_eval": _should_log_confusion_matrix(),
+                "log_image_predictions": _should_log_image_predictions(),
+                "max_image_predictions": _get_max_image_predictions_to_log(),
+            }
+        )
+        experiment.log_other("Created from", "yolov8")
 
     except Exception as e:
-        LOGGER.warning(f'WARNING ⚠️ Comet installed but not initialized correctly, not logging this run. {e}')
+        LOGGER.warning(f"WARNING ⚠️ Comet installed but not initialized correctly, not logging this run. {e}")
 
 
 def _fetch_trainer_metadata(trainer):
@@ -134,29 +137,32 @@ def _scale_bounding_box_to_original_image_shape(box, resized_image_shape, origin
 
 def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, class_name_map=None):
     """Format ground truth annotations for detection."""
-    indices = batch['batch_idx'] == img_idx
-    bboxes = batch['bboxes'][indices]
+    indices = batch["batch_idx"] == img_idx
+    bboxes = batch["bboxes"][indices]
     if len(bboxes) == 0:
-        LOGGER.debug(f'COMET WARNING: Image: {image_path} has no bounding boxes labels')
+        LOGGER.debug(f"COMET WARNING: Image: {image_path} has no bounding boxes labels")
         return None
 
-    cls_labels = batch['cls'][indices].squeeze(1).tolist()
+    cls_labels = batch["cls"][indices].squeeze(1).tolist()
     if class_name_map:
         cls_labels = [str(class_name_map[label]) for label in cls_labels]
 
-    original_image_shape = batch['ori_shape'][img_idx]
-    resized_image_shape = batch['resized_shape'][img_idx]
-    ratio_pad = batch['ratio_pad'][img_idx]
+    original_image_shape = batch["ori_shape"][img_idx]
+    resized_image_shape = batch["resized_shape"][img_idx]
+    ratio_pad = batch["ratio_pad"][img_idx]
 
     data = []
     for box, label in zip(bboxes, cls_labels):
         box = _scale_bounding_box_to_original_image_shape(box, resized_image_shape, original_image_shape, ratio_pad)
-        data.append({
-            'boxes': [box],
-            'label': f'gt_{label}',
-            'score': _scale_confidence_score(1.0), })
+        data.append(
+            {
+                "boxes": [box],
+                "label": f"gt_{label}",
+                "score": _scale_confidence_score(1.0),
+            }
+        )
 
-    return {'name': 'ground_truth', 'data': data}
+    return {"name": "ground_truth", "data": data}
 
 
 def _format_prediction_annotations_for_detection(image_path, metadata, class_label_map=None):
@@ -166,31 +172,34 @@ def _format_prediction_annotations_for_detection(image_path, metadata, class_lab
 
     predictions = metadata.get(image_id)
     if not predictions:
-        LOGGER.debug(f'COMET WARNING: Image: {image_path} has no bounding boxes predictions')
+        LOGGER.debug(f"COMET WARNING: Image: {image_path} has no bounding boxes predictions")
         return None
 
     data = []
     for prediction in predictions:
-        boxes = prediction['bbox']
-        score = _scale_confidence_score(prediction['score'])
-        cls_label = prediction['category_id']
+        boxes = prediction["bbox"]
+        score = _scale_confidence_score(prediction["score"])
+        cls_label = prediction["category_id"]
         if class_label_map:
             cls_label = str(class_label_map[cls_label])
 
-        data.append({'boxes': [boxes], 'label': cls_label, 'score': score})
+        data.append({"boxes": [boxes], "label": cls_label, "score": score})
 
-    return {'name': 'prediction', 'data': data}
+    return {"name": "prediction", "data": data}
 
 
 def _fetch_annotations(img_idx, image_path, batch, prediction_metadata_map, class_label_map):
     """Join the ground truth and prediction annotations if they exist."""
-    ground_truth_annotations = _format_ground_truth_annotations_for_detection(img_idx, image_path, batch,
-                                                                              class_label_map)
-    prediction_annotations = _format_prediction_annotations_for_detection(image_path, prediction_metadata_map,
-                                                                          class_label_map)
+    ground_truth_annotations = _format_ground_truth_annotations_for_detection(
+        img_idx, image_path, batch, class_label_map
+    )
+    prediction_annotations = _format_prediction_annotations_for_detection(
+        image_path, prediction_metadata_map, class_label_map
+    )
 
     annotations = [
-        annotation for annotation in [ground_truth_annotations, prediction_annotations] if annotation is not None]
+        annotation for annotation in [ground_truth_annotations, prediction_annotations] if annotation is not None
+    ]
     return [annotations] if annotations else None
 
 
@@ -198,8 +207,8 @@ def _create_prediction_metadata_map(model_predictions):
     """Create metadata map for model predictions by groupings them based on image ID."""
     pred_metadata_map = {}
     for prediction in model_predictions:
-        pred_metadata_map.setdefault(prediction['image_id'], [])
-        pred_metadata_map[prediction['image_id']].append(prediction)
+        pred_metadata_map.setdefault(prediction["image_id"], [])
+        pred_metadata_map[prediction["image_id"]].append(prediction)
 
     return pred_metadata_map
 
@@ -207,7 +216,7 @@ def _create_prediction_metadata_map(model_predictions):
 def _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch):
     """Log the confusion matrix to Comet experiment."""
     conf_mat = trainer.validator.confusion_matrix.matrix
-    names = list(trainer.data['names'].values()) + ['background']
+    names = list(trainer.data["names"].values()) + ["background"]
     experiment.log_confusion_matrix(
         matrix=conf_mat,
         labels=names,
@@ -251,7 +260,7 @@ def _log_image_predictions(experiment, validator, curr_step):
         if (batch_idx + 1) % batch_logging_interval != 0:
             continue
 
-        image_paths = batch['im_file']
+        image_paths = batch["im_file"]
         for img_idx, image_path in enumerate(image_paths):
             if _comet_image_prediction_count >= max_image_predictions:
                 return
@@ -275,10 +284,10 @@ def _log_image_predictions(experiment, validator, curr_step):
 
 def _log_plots(experiment, trainer):
     """Logs evaluation plots and label plots for the experiment."""
-    plot_filenames = [trainer.save_dir / f'{plots}.png' for plots in EVALUATION_PLOT_NAMES]
+    plot_filenames = [trainer.save_dir / f"{plots}.png" for plots in EVALUATION_PLOT_NAMES]
     _log_images(experiment, plot_filenames, None)
 
-    label_plot_filenames = [trainer.save_dir / f'{labels}.jpg' for labels in LABEL_PLOT_NAMES]
+    label_plot_filenames = [trainer.save_dir / f"{labels}.jpg" for labels in LABEL_PLOT_NAMES]
     _log_images(experiment, label_plot_filenames, None)
 
 
@@ -288,7 +297,7 @@ def _log_model(experiment, trainer):
     experiment.log_model(
         model_name,
         file_or_folder=str(trainer.best),
-        file_name='best.pt',
+        file_name="best.pt",
         overwrite=True,
     )
 
@@ -296,7 +305,7 @@ def _log_model(experiment, trainer):
 def on_pretrain_routine_start(trainer):
     """Creates or resumes a CometML experiment at the start of a YOLO pre-training routine."""
     experiment = comet_ml.get_global_experiment()
-    is_alive = getattr(experiment, 'alive', False)
+    is_alive = getattr(experiment, "alive", False)
     if not experiment or not is_alive:
         _create_experiment(trainer.args)
 
@@ -308,17 +317,17 @@ def on_train_epoch_end(trainer):
         return
 
     metadata = _fetch_trainer_metadata(trainer)
-    curr_epoch = metadata['curr_epoch']
-    curr_step = metadata['curr_step']
+    curr_epoch = metadata["curr_epoch"]
+    curr_step = metadata["curr_step"]
 
     experiment.log_metrics(
-        trainer.label_loss_items(trainer.tloss, prefix='train'),
+        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)
+        _log_images(experiment, trainer.save_dir.glob("train_batch*.jpg"), curr_step)
 
 
 def on_fit_epoch_end(trainer):
@@ -328,14 +337,15 @@ def on_fit_epoch_end(trainer):
         return
 
     metadata = _fetch_trainer_metadata(trainer)
-    curr_epoch = metadata['curr_epoch']
-    curr_step = metadata['curr_step']
-    save_assets = metadata['save_assets']
+    curr_epoch = metadata["curr_epoch"]
+    curr_step = metadata["curr_step"]
+    save_assets = metadata["save_assets"]
 
     experiment.log_metrics(trainer.metrics, step=curr_step, epoch=curr_epoch)
     experiment.log_metrics(trainer.lr, step=curr_step, epoch=curr_epoch)
     if curr_epoch == 1:
         from ultralytics.utils.torch_utils import model_info_for_loggers
+
         experiment.log_metrics(model_info_for_loggers(trainer), step=curr_step, epoch=curr_epoch)
 
     if not save_assets:
@@ -355,8 +365,8 @@ def on_train_end(trainer):
         return
 
     metadata = _fetch_trainer_metadata(trainer)
-    curr_epoch = metadata['curr_epoch']
-    curr_step = metadata['curr_step']
+    curr_epoch = metadata["curr_epoch"]
+    curr_step = metadata["curr_step"]
     plots = trainer.args.plots
 
     _log_model(experiment, trainer)
@@ -371,8 +381,13 @@ def on_train_end(trainer):
     _comet_image_prediction_count = 0
 
 
-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 comet_ml 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 comet_ml
+    else {}
+)

ultralytics/utils/callbacks/dvc.py

@@ -4,9 +4,10 @@ from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING, checks
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
-    assert SETTINGS['dvc'] is True  # verify integration is enabled
+    assert SETTINGS["dvc"] is True  # verify integration is enabled
     import dvclive
-    assert checks.check_version('dvclive', '2.11.0', verbose=True)
+
+    assert checks.check_version("dvclive", "2.11.0", verbose=True)
 
     import os
     import re
@@ -24,24 +25,24 @@ except (ImportError, AssertionError, TypeError):
     dvclive = None
 
 
-def _log_images(path, prefix=''):
+def _log_images(path, prefix=""):
     """Logs images at specified path with an optional prefix using DVCLive."""
     if live:
         name = path.name
 
         # Group images by batch to enable sliders in UI
-        if m := re.search(r'_batch(\d+)', name):
+        if m := re.search(r"_batch(\d+)", name):
             ni = m[1]
-            new_stem = re.sub(r'_batch(\d+)', '_batch', path.stem)
+            new_stem = re.sub(r"_batch(\d+)", "_batch", path.stem)
             name = (Path(new_stem) / ni).with_suffix(path.suffix)
 
         live.log_image(os.path.join(prefix, name), path)
 
 
-def _log_plots(plots, prefix=''):
+def _log_plots(plots, prefix=""):
     """Logs plot images for training progress if they have not been previously processed."""
     for name, params in plots.items():
-        timestamp = params['timestamp']
+        timestamp = params["timestamp"]
         if _processed_plots.get(name) != timestamp:
             _log_images(name, prefix)
             _processed_plots[name] = timestamp
@@ -53,15 +54,15 @@ def _log_confusion_matrix(validator):
     preds = []
     matrix = validator.confusion_matrix.matrix
     names = list(validator.names.values())
-    if validator.confusion_matrix.task == 'detect':
-        names += ['background']
+    if validator.confusion_matrix.task == "detect":
+        names += ["background"]
 
     for ti, pred in enumerate(matrix.T.astype(int)):
         for pi, num in enumerate(pred):
             targets.extend([names[ti]] * num)
             preds.extend([names[pi]] * num)
 
-    live.log_sklearn_plot('confusion_matrix', targets, preds, name='cf.json', normalized=True)
+    live.log_sklearn_plot("confusion_matrix", targets, preds, name="cf.json", normalized=True)
 
 
 def on_pretrain_routine_start(trainer):
@@ -71,12 +72,12 @@ def on_pretrain_routine_start(trainer):
         live = dvclive.Live(save_dvc_exp=True, cache_images=True)
         LOGGER.info("DVCLive is detected and auto logging is enabled (run 'yolo settings dvc=False' to disable).")
     except Exception as e:
-        LOGGER.warning(f'WARNING ⚠️ DVCLive installed but not initialized correctly, not logging this run. {e}')
+        LOGGER.warning(f"WARNING ⚠️ DVCLive installed but not initialized correctly, not logging this run. {e}")
 
 
 def on_pretrain_routine_end(trainer):
     """Logs plots related to the training process at the end of the pretraining routine."""
-    _log_plots(trainer.plots, 'train')
+    _log_plots(trainer.plots, "train")
 
 
 def on_train_start(trainer):
@@ -95,17 +96,18 @@ def on_fit_epoch_end(trainer):
     """Logs training metrics and model info, and advances to next step on the end of each fit epoch."""
     global _training_epoch
     if live and _training_epoch:
-        all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix='train'), **trainer.metrics, **trainer.lr}
+        all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics, **trainer.lr}
         for metric, value in all_metrics.items():
             live.log_metric(metric, value)
 
         if trainer.epoch == 0:
             from ultralytics.utils.torch_utils import model_info_for_loggers
+
             for metric, value in model_info_for_loggers(trainer).items():
                 live.log_metric(metric, value, plot=False)
 
-        _log_plots(trainer.plots, 'train')
-        _log_plots(trainer.validator.plots, 'val')
+        _log_plots(trainer.plots, "train")
+        _log_plots(trainer.validator.plots, "val")
 
         live.next_step()
         _training_epoch = False
@@ -115,24 +117,29 @@ def on_train_end(trainer):
     """Logs the best metrics, plots, and confusion matrix at the end of training if DVCLive is active."""
     if live:
         # At the end log the best metrics. It runs validator on the best model internally.
-        all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix='train'), **trainer.metrics, **trainer.lr}
+        all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics, **trainer.lr}
         for metric, value in all_metrics.items():
             live.log_metric(metric, value, plot=False)
 
-        _log_plots(trainer.plots, 'val')
-        _log_plots(trainer.validator.plots, 'val')
+        _log_plots(trainer.plots, "val")
+        _log_plots(trainer.validator.plots, "val")
         _log_confusion_matrix(trainer.validator)
 
         if trainer.best.exists():
-            live.log_artifact(trainer.best, copy=True, type='model')
+            live.log_artifact(trainer.best, copy=True, type="model")
 
         live.end()
 
 
-callbacks = {
-    '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_fit_epoch_end': on_fit_epoch_end,
-    'on_train_end': on_train_end} if dvclive else {}
+callbacks = (
+    {
+        "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_fit_epoch_end": on_fit_epoch_end,
+        "on_train_end": on_train_end,
+    }
+    if dvclive
+    else {}
+)

ultralytics/utils/callbacks/hub.py

@@ -3,57 +3,70 @@
 import json
 from time import time
 
-from ultralytics.hub.utils import HUB_WEB_ROOT, PREFIX, events
+from hub_sdk.config import HUB_WEB_ROOT
+
+from ultralytics.hub.utils import PREFIX, events
 from ultralytics.utils import LOGGER, SETTINGS
 
 
 def on_pretrain_routine_end(trainer):
     """Logs info before starting timer for upload rate limit."""
-    session = getattr(trainer, 'hub_session', None)
+    session = getattr(trainer, "hub_session", None)
     if session:
         # Start timer for upload rate limit
-        LOGGER.info(f'{PREFIX}View model at {HUB_WEB_ROOT}/models/{session.model_id} 🚀')
-        session.timers = {'metrics': time(), 'ckpt': time()}  # start timer on session.rate_limit
+        session.timers = {
+            "metrics": time(),
+            "ckpt": time(),
+        }  # start timer on session.rate_limit
 
 
 def on_fit_epoch_end(trainer):
     """Uploads training progress metrics at the end of each epoch."""
-    session = getattr(trainer, 'hub_session', None)
+    session = getattr(trainer, "hub_session", None)
     if session:
         # Upload metrics after val end
-        all_plots = {**trainer.label_loss_items(trainer.tloss, prefix='train'), **trainer.metrics}
+        all_plots = {
+            **trainer.label_loss_items(trainer.tloss, prefix="train"),
+            **trainer.metrics,
+        }
         if trainer.epoch == 0:
             from ultralytics.utils.torch_utils import model_info_for_loggers
+
             all_plots = {**all_plots, **model_info_for_loggers(trainer)}
+
         session.metrics_queue[trainer.epoch] = json.dumps(all_plots)
-        if time() - session.timers['metrics'] > session.rate_limits['metrics']:
+        if time() - session.timers["metrics"] > session.rate_limits["metrics"]:
             session.upload_metrics()
-            session.timers['metrics'] = time()  # reset timer
+            session.timers["metrics"] = time()  # reset timer
             session.metrics_queue = {}  # reset queue
 
 
 def on_model_save(trainer):
     """Saves checkpoints to Ultralytics HUB with rate limiting."""
-    session = getattr(trainer, 'hub_session', None)
+    session = getattr(trainer, "hub_session", None)
     if session:
         # Upload checkpoints with rate limiting
         is_best = trainer.best_fitness == trainer.fitness
-        if time() - session.timers['ckpt'] > session.rate_limits['ckpt']:
-            LOGGER.info(f'{PREFIX}Uploading checkpoint {HUB_WEB_ROOT}/models/{session.model_id}')
+        if time() - session.timers["ckpt"] > session.rate_limits["ckpt"]:
+            LOGGER.info(f"{PREFIX}Uploading checkpoint {HUB_WEB_ROOT}/models/{session.model_file}")
             session.upload_model(trainer.epoch, trainer.last, is_best)
-            session.timers['ckpt'] = time()  # reset timer
+            session.timers["ckpt"] = time()  # reset timer
 
 
 def on_train_end(trainer):
     """Upload final model and metrics to Ultralytics HUB at the end of training."""
-    session = getattr(trainer, 'hub_session', None)
+    session = getattr(trainer, "hub_session", None)
     if session:
         # Upload final model and metrics with exponential standoff
-        LOGGER.info(f'{PREFIX}Syncing final model...')
-        session.upload_model(trainer.epoch, trainer.best, map=trainer.metrics.get('metrics/mAP50-95(B)', 0), final=True)
+        LOGGER.info(f"{PREFIX}Syncing final model...")
+        session.upload_model(
+            trainer.epoch,
+            trainer.best,
+            map=trainer.metrics.get("metrics/mAP50-95(B)", 0),
+            final=True,
+        )
         session.alive = False  # stop heartbeats
-        LOGGER.info(f'{PREFIX}Done ✅\n'
-                    f'{PREFIX}View model at {HUB_WEB_ROOT}/models/{session.model_id} 🚀')
+        LOGGER.info(f"{PREFIX}Done ✅\n" f"{PREFIX}View model at {session.model_url} 🚀")
 
 
 def on_train_start(trainer):
@@ -76,12 +89,17 @@ def on_export_start(exporter):
     events(exporter.args)
 
 
-callbacks = {
-    'on_pretrain_routine_end': on_pretrain_routine_end,
-    'on_fit_epoch_end': on_fit_epoch_end,
-    'on_model_save': on_model_save,
-    'on_train_end': on_train_end,
-    'on_train_start': on_train_start,
-    'on_val_start': on_val_start,
-    'on_predict_start': on_predict_start,
-    'on_export_start': on_export_start} if SETTINGS['hub'] is True else {}  # verify enabled
+callbacks = (
+    {
+        "on_pretrain_routine_end": on_pretrain_routine_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_model_save": on_model_save,
+        "on_train_end": on_train_end,
+        "on_train_start": on_train_start,
+        "on_val_start": on_val_start,
+        "on_predict_start": on_predict_start,
+        "on_export_start": on_export_start,
+    }
+    if SETTINGS["hub"] is True
+    else {}
+)  # verify enabled