dgenerate-ultralytics-headless 8.3.137__py3-none-any.whl → 8.3.224__py3-none-any.whl

ultralytics/utils/callbacks/hub.py

@@ -3,8 +3,9 @@
 import json
 from time import time
 
-from ultralytics.hub import HUB_WEB_ROOT, PREFIX, HUBTrainingSession, events
+from ultralytics.hub import HUB_WEB_ROOT, PREFIX, HUBTrainingSession
 from ultralytics.utils import LOGGER, RANK, SETTINGS
+from ultralytics.utils.events import events
 
 
 def on_pretrain_routine_start(trainer):
@@ -73,22 +74,23 @@ def on_train_end(trainer):
 
 def on_train_start(trainer):
     """Run events on train start."""
-    events(trainer.args)
+    events(trainer.args, trainer.device)
 
 
 def on_val_start(validator):
     """Run events on validation start."""
-    events(validator.args)
+    if not validator.training:
+        events(validator.args, validator.device)
 
 
 def on_predict_start(predictor):
     """Run events on predict start."""
-    events(predictor.args)
+    events(predictor.args, predictor.device)
 
 
 def on_export_start(exporter):
     """Run events on export start."""
-    events(exporter.args)
+    events(exporter.args, exporter.device)
 
 
 callbacks = (
@@ -105,4 +107,4 @@ callbacks = (
     }
     if SETTINGS["hub"] is True
     else {}
-)  # verify hub is enabled before registering callbacks
+)

ultralytics/utils/callbacks/mlflow.py

@@ -45,24 +45,20 @@ def sanitize_dict(x: dict) -> dict:
 
 
 def on_pretrain_routine_end(trainer):
-    """
-    Log training parameters to MLflow at the end of the pretraining routine.
+    """Log training parameters to MLflow at the end of the pretraining routine.
 
     This function sets up MLflow logging based on environment variables and trainer arguments. It sets the tracking URI,
-    experiment name, and run name, then starts the MLflow run if not already active. It finally logs the parameters
-    from the trainer.
+    experiment name, and run name, then starts the MLflow run if not already active. It finally logs the parameters from
+    the trainer.
 
     Args:
         trainer (ultralytics.engine.trainer.BaseTrainer): The training object with arguments and parameters to log.
 
-    Global:
-        mlflow: The imported mlflow module to use for logging.
-
-    Environment Variables:
+    Notes:
         MLFLOW_TRACKING_URI: The URI for MLflow tracking. If not set, defaults to 'runs/mlflow'.
         MLFLOW_EXPERIMENT_NAME: The name of the MLflow experiment. If not set, defaults to trainer.args.project.
         MLFLOW_RUN: The name of the MLflow run. If not set, defaults to trainer.args.name.
-        MLFLOW_KEEP_RUN_ACTIVE: Boolean indicating whether to keep the MLflow run active after the end of training.
+        MLFLOW_KEEP_RUN_ACTIVE: Boolean indicating whether to keep the MLflow run active after training ends.
     """
     global mlflow
 
@@ -107,7 +103,7 @@ def on_fit_epoch_end(trainer):
 
 
 def on_train_end(trainer):
-    """Log model artifacts at the end of the training."""
+    """Log model artifacts at the end of training."""
     if not mlflow:
         return
     mlflow.log_artifact(str(trainer.best.parent))  # log save_dir/weights directory with best.pt and last.pt

ultralytics/utils/callbacks/neptune.py

@@ -18,12 +18,11 @@ except (ImportError, AssertionError):
 
 
 def _log_scalars(scalars: dict, step: int = 0) -> None:
-    """
-    Log scalars to the NeptuneAI experiment logger.
+    """Log scalars to the NeptuneAI experiment logger.
 
     Args:
         scalars (dict): Dictionary of scalar values to log to NeptuneAI.
-        step (int): The current step or iteration number for logging.
+        step (int, optional): The current step or iteration number for logging.
 
     Examples:
         >>> metrics = {"mAP": 0.85, "loss": 0.32}
@@ -35,11 +34,10 @@ def _log_scalars(scalars: dict, step: int = 0) -> None:
 
 
 def _log_images(imgs_dict: dict, group: str = "") -> None:
-    """
-    Log images to the NeptuneAI experiment logger.
+    """Log images to the NeptuneAI experiment logger.
 
-    This function logs image data to Neptune.ai when a valid Neptune run is active. Images are organized
-    under the specified group name.
+    This function logs image data to Neptune.ai when a valid Neptune run is active. Images are organized under the
+    specified group name.
 
     Args:
         imgs_dict (dict): Dictionary of images to log, with keys as image names and values as image data.
@@ -55,13 +53,7 @@ def _log_images(imgs_dict: dict, group: str = "") -> None:
 
 
 def _log_plot(title: str, plot_path: str) -> None:
-    """
-    Log plots to the NeptuneAI experiment logger.
-
-    Args:
-        title (str): Title of the plot.
-        plot_path (str): Path to the saved image file.
-    """
+    """Log plots to the NeptuneAI experiment logger."""
     import matplotlib.image as mpimg
     import matplotlib.pyplot as plt
 
@@ -73,7 +65,7 @@ def _log_plot(title: str, plot_path: str) -> None:
 
 
 def on_pretrain_routine_start(trainer) -> None:
-    """Callback function called before the training routine starts."""
+    """Initialize NeptuneAI run and log hyperparameters before training starts."""
     try:
         global run
         run = neptune.init_run(
@@ -87,7 +79,7 @@ def on_pretrain_routine_start(trainer) -> None:
 
 
 def on_train_epoch_end(trainer) -> None:
-    """Callback function called at end of each training epoch."""
+    """Log training metrics and learning rate at the end of each training epoch."""
     _log_scalars(trainer.label_loss_items(trainer.tloss, prefix="train"), trainer.epoch + 1)
     _log_scalars(trainer.lr, trainer.epoch + 1)
     if trainer.epoch == 1:
@@ -95,7 +87,7 @@ def on_train_epoch_end(trainer) -> None:
 
 
 def on_fit_epoch_end(trainer) -> None:
-    """Callback function called at end of each fit (train+val) epoch."""
+    """Log model info and validation metrics at the end of each fit epoch."""
     if run and trainer.epoch == 0:
         from ultralytics.utils.torch_utils import model_info_for_loggers
 
@@ -104,14 +96,14 @@ def on_fit_epoch_end(trainer) -> None:
 
 
 def on_val_end(validator) -> None:
-    """Callback function called at end of each validation."""
+    """Log validation images at the end of 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")
 
 
 def on_train_end(trainer) -> None:
-    """Callback function called at end of training."""
+    """Log final results, plots, and model weights at the end of training."""
     if run:
         # Log final results, CM matrix + PR plots
         files = [

ultralytics/utils/callbacks/platform.py

@@ -0,0 +1,73 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from ultralytics.utils import RANK, SETTINGS
+
+
+def on_pretrain_routine_start(trainer):
+    """Initialize and start console logging immediately at the very beginning."""
+    if RANK in {-1, 0}:
+        from ultralytics.utils.logger import DEFAULT_LOG_PATH, ConsoleLogger, SystemLogger
+
+        trainer.system_logger = SystemLogger()
+        trainer.console_logger = ConsoleLogger(DEFAULT_LOG_PATH)
+        trainer.console_logger.start_capture()
+
+
+def on_pretrain_routine_end(trainer):
+    """Handle pre-training routine completion event."""
+    pass
+
+
+def on_fit_epoch_end(trainer):
+    """Handle end of training epoch event and collect system metrics."""
+    if RANK in {-1, 0} and hasattr(trainer, "system_logger"):
+        system_metrics = trainer.system_logger.get_metrics()
+        print(system_metrics)  # for debug
+
+
+def on_model_save(trainer):
+    """Handle model checkpoint save event."""
+    pass
+
+
+def on_train_end(trainer):
+    """Stop console capture and finalize logs."""
+    if logger := getattr(trainer, "console_logger", None):
+        logger.stop_capture()
+
+
+def on_train_start(trainer):
+    """Handle training start event."""
+    pass
+
+
+def on_val_start(validator):
+    """Handle validation start event."""
+    pass
+
+
+def on_predict_start(predictor):
+    """Handle prediction start event."""
+    pass
+
+
+def on_export_start(exporter):
+    """Handle model export start event."""
+    pass
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "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.get("platform", False) is True  # disabled for debugging
+    else {}
+)

ultralytics/utils/callbacks/raytune.py

@@ -13,11 +13,10 @@ except (ImportError, AssertionError):
 
 
 def on_fit_epoch_end(trainer):
-    """
-    Reports training metrics to Ray Tune at epoch end when a Ray session is active.
+    """Report training metrics to Ray Tune at epoch end when a Ray session is active.
 
-    Captures metrics from the trainer object and sends them to Ray Tune with the current epoch number,
-    enabling hyperparameter tuning optimization. Only executes when within an active Ray Tune session.
+    Captures metrics from the trainer object and sends them to Ray Tune with the current epoch number, enabling
+    hyperparameter tuning optimization. Only executes when within an active Ray Tune session.
 
     Args:
         trainer (ultralytics.engine.trainer.BaseTrainer): The Ultralytics trainer object containing metrics and epochs.

ultralytics/utils/callbacks/tensorboard.py

@@ -22,8 +22,7 @@ except (ImportError, AssertionError, TypeError, AttributeError):
 
 
 def _log_scalars(scalars: dict, step: int = 0) -> None:
-    """
-    Log scalar values to TensorBoard.
+    """Log scalar values to TensorBoard.
 
     Args:
         scalars (dict): Dictionary of scalar values to log to TensorBoard. Keys are scalar names and values are the
@@ -31,7 +30,7 @@ def _log_scalars(scalars: dict, step: int = 0) -> None:
         step (int): Global step value to record with the scalar values. Used for x-axis in TensorBoard graphs.
 
     Examples:
-        >>> # Log training metrics
+        Log training metrics
         >>> metrics = {"loss": 0.5, "accuracy": 0.95}
         >>> _log_scalars(metrics, step=100)
     """
@@ -41,17 +40,15 @@ def _log_scalars(scalars: dict, step: int = 0) -> None:
 
 
 def _log_tensorboard_graph(trainer) -> None:
-    """
-    Log model graph to TensorBoard.
+    """Log model graph to TensorBoard.
 
     This function attempts to visualize the model architecture in TensorBoard by tracing the model with a dummy input
     tensor. It first tries a simple method suitable for YOLO models, and if that fails, falls back to a more complex
     approach for models like RTDETR that may require special handling.
 
     Args:
-        trainer (BaseTrainer): The trainer object containing the model to visualize. Must have attributes:
-            - model: PyTorch model to visualize
-            - args: Configuration arguments with 'imgsz' attribute
+        trainer (ultralytics.engine.trainer.BaseTrainer): The trainer object containing the model to visualize. Must
+            have attributes model and args with imgsz.
 
     Notes:
         This function requires TensorBoard integration to be enabled and the global WRITER to be initialized.
@@ -71,14 +68,14 @@ def _log_tensorboard_graph(trainer) -> None:
         # Try simple method first (YOLO)
         try:
             trainer.model.eval()  # place in .eval() mode to avoid BatchNorm statistics changes
-            WRITER.add_graph(torch.jit.trace(torch_utils.de_parallel(trainer.model), im, strict=False), [])
+            WRITER.add_graph(torch.jit.trace(torch_utils.unwrap_model(trainer.model), im, strict=False), [])
             LOGGER.info(f"{PREFIX}model graph visualization added ✅")
             return
 
         except Exception:
             # Fallback to TorchScript export steps (RTDETR)
             try:
-                model = deepcopy(torch_utils.de_parallel(trainer.model))
+                model = deepcopy(torch_utils.unwrap_model(trainer.model))
                 model.eval()
                 model = model.fuse(verbose=False)
                 for m in model.modules():
@@ -110,13 +107,13 @@ def on_train_start(trainer) -> None:
 
 
 def on_train_epoch_end(trainer) -> None:
-    """Logs scalar statistics at the end of a training epoch."""
+    """Log 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.lr, trainer.epoch + 1)
 
 
 def on_fit_epoch_end(trainer) -> None:
-    """Logs epoch metrics at end of training epoch."""
+    """Log epoch metrics at end of training epoch."""
     _log_scalars(trainer.metrics, trainer.epoch + 1)
 
 

ultralytics/utils/callbacks/wb.py

@@ -16,8 +16,7 @@ except (ImportError, AssertionError):
 
 
 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.
+    """Create and log a custom metric visualization to wandb.plot.pr_curve.
 
     This function crafts a custom metric visualization that mimics the behavior of the default wandb precision-recall
     curve while allowing for enhanced customization. The visual metric is useful for monitoring model performance across
@@ -27,20 +26,26 @@ def _custom_table(x, y, classes, title="Precision Recall Curve", x_title="Recall
         x (list): Values for the x-axis; expected to have length N.
         y (list): Corresponding values for the y-axis; also expected to have length N.
         classes (list): Labels identifying the class of each point; length N.
-        title (str): Title for the plot; defaults to 'Precision Recall Curve'.
-        x_title (str): Label for the x-axis; defaults to 'Recall'.
-        y_title (str): Label for the y-axis; defaults to 'Precision'.
+        title (str, optional): Title for the plot.
+        x_title (str, optional): Label for the x-axis.
+        y_title (str, optional): Label for the y-axis.
 
     Returns:
         (wandb.Object): A wandb object suitable for logging, showcasing the crafted metric visualization.
     """
-    import pandas  # scope for faster 'import ultralytics'
+    import polars as pl  # scope for faster 'import ultralytics'
+    import polars.selectors as cs
+
+    df = pl.DataFrame({"class": classes, "y": y, "x": x}).with_columns(cs.numeric().round(3))
+    data = df.select(["class", "y", "x"]).rows()
 
-    df = pandas.DataFrame({"class": classes, "y": y, "x": x}).round(3)
     fields = {"x": "x", "y": "y", "class": "class"}
     string_fields = {"title": title, "x-axis-title": x_title, "y-axis-title": y_title}
     return wb.plot_table(
-        "wandb/area-under-curve/v0", wb.Table(dataframe=df), fields=fields, string_fields=string_fields
+        "wandb/area-under-curve/v0",
+        wb.Table(data=data, columns=["class", "y", "x"]),
+        fields=fields,
+        string_fields=string_fields,
     )
 
 
@@ -55,22 +60,21 @@ def _plot_curve(
     num_x=100,
     only_mean=False,
 ):
-    """
-    Log a metric curve visualization.
+    """Log a metric curve visualization.
 
-    This function generates a metric curve based on input data and logs the visualization to wandb.
-    The curve can represent aggregated data (mean) or individual class data, depending on the 'only_mean' flag.
+    This function generates a metric curve based on input data and logs the visualization to wandb. The curve can
+    represent aggregated data (mean) or individual class data, depending on the 'only_mean' flag.
 
     Args:
         x (np.ndarray): Data points for the x-axis with length N.
         y (np.ndarray): Corresponding data points for the y-axis with shape (C, N), where C is the number of classes.
-        names (list): Names of the classes corresponding to the y-axis data; length C.
-        id (str): Unique identifier for the logged data in wandb.
-        title (str): Title for the visualization plot.
-        x_title (str): Label for the x-axis.
-        y_title (str): Label for the y-axis.
-        num_x (int): Number of interpolated data points for visualization.
-        only_mean (bool): Flag to indicate if only the mean curve should be plotted.
+        names (list, optional): Names of the classes corresponding to the y-axis data; length C.
+        id (str, optional): Unique identifier for the logged data in wandb.
+        title (str, optional): Title for the visualization plot.
+        x_title (str, optional): Label for the x-axis.
+        y_title (str, optional): Label for the y-axis.
+        num_x (int, optional): Number of interpolated data points for visualization.
+        only_mean (bool, optional): Flag to indicate if only the mean curve should be plotted.
 
     Notes:
         The function leverages the '_custom_table' function to generate the actual visualization.
@@ -99,21 +103,20 @@ def _plot_curve(
 
 
 def _log_plots(plots, step):
-    """
-    Log plots to WandB at a specific step if they haven't been logged already.
+    """Log plots to WandB at a specific step if they haven't been logged already.
 
-    This function checks each plot in the input dictionary against previously processed plots and logs
-    new or updated plots to WandB at the specified step.
+    This function checks each plot in the input dictionary against previously processed plots and logs new or updated
+    plots to WandB at the specified step.
 
     Args:
-        plots (dict): Dictionary of plots to log, where keys are plot names and values are dictionaries
-            containing plot metadata including timestamps.
+        plots (dict): Dictionary of plots to log, where keys are plot names and values are dictionaries containing plot
+            metadata including timestamps.
         step (int): The step/epoch at which to log the plots in the WandB run.
 
     Notes:
-        - The function uses a shallow copy of the plots dictionary to prevent modification during iteration
-        - Plots are identified by their stem name (filename without extension)
-        - Each plot is logged as a WandB Image object
+        The function uses a shallow copy of the plots dictionary to prevent modification during iteration.
+        Plots are identified by their stem name (filename without extension).
+        Each plot is logged as a WandB Image object.
     """
     for name, params in plots.copy().items():  # shallow copy to prevent plots dict changing during iteration
         timestamp = params["timestamp"]
@@ -123,7 +126,7 @@ def _log_plots(plots, step):
 
 
 def on_pretrain_routine_start(trainer):
-    """Initiate and start wandb project if module is present."""
+    """Initialize and start wandb project if module is present."""
     if not wb.run:
         wb.init(
             project=str(trainer.args.project).replace("/", "-") if trainer.args.project else "Ultralytics",
@@ -134,11 +137,11 @@ def on_pretrain_routine_start(trainer):
 
 def on_fit_epoch_end(trainer):
     """Log training metrics and model information at the end of an epoch."""
-    wb.run.log(trainer.metrics, step=trainer.epoch + 1)
     _log_plots(trainer.plots, step=trainer.epoch + 1)
     _log_plots(trainer.validator.plots, step=trainer.epoch + 1)
     if trainer.epoch == 0:
         wb.run.log(model_info_for_loggers(trainer), step=trainer.epoch + 1)
+    wb.run.log(trainer.metrics, step=trainer.epoch + 1, commit=True)  # commit forces sync
 
 
 def on_train_epoch_end(trainer):