Vai al contenuto

Riferimento per ultralytics/utils/callbacks/clearml.py

Nota

Questo file è disponibile all'indirizzo https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/utils/callbacks/ clearml.py. Se riscontri un problema, contribuisci a risolverlo inviando una Pull Request 🛠️. Grazie 🙏!



ultralytics.utils.callbacks.clearml._log_debug_samples(files, title='Debug Samples')

File di log (immagini) come esempi di debug nel task ClearML .

Parametri:

Nome Tipo Descrizione Predefinito
files list

Un elenco di percorsi di file in formato PosixPath.

richiesto
title str

Un titolo che raggruppa le immagini con gli stessi valori.

'Debug Samples'
Codice sorgente in ultralytics/utils/callbacks/clearml.py
def _log_debug_samples(files, title="Debug Samples") -> None:
    """
    Log files (images) as debug samples in the ClearML task.

    Args:
        files (list): A list of file paths in PosixPath format.
        title (str): A title that groups together images with the same values.
    """
    import re

    if task := Task.current_task():
        for f in files:
            if f.exists():
                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
                )



ultralytics.utils.callbacks.clearml._log_plot(title, plot_path)

Registra un'immagine come un plot nella sezione plot di ClearML.

Parametri:

Nome Tipo Descrizione Predefinito
title str

Il titolo della trama.

richiesto
plot_path str

Il percorso del file immagine salvato.

richiesto
Codice sorgente in ultralytics/utils/callbacks/clearml.py
def _log_plot(title, plot_path) -> None:
    """
    Log an image as a plot in the plot section of ClearML.

    Args:
        title (str): The title of the plot.
        plot_path (str): The path to the saved image file.
    """
    import matplotlib.image as mpimg
    import matplotlib.pyplot as plt

    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.imshow(img)

    Task.current_task().get_logger().report_matplotlib_figure(
        title=title, series="", figure=fig, report_interactive=False
    )



ultralytics.utils.callbacks.clearml.on_pretrain_routine_start(trainer)

Viene eseguito all'inizio della routine di pre-training; inizializza e connette/registra l'attività a ClearML.

Codice sorgente in ultralytics/utils/callbacks/clearml.py
def on_pretrain_routine_start(trainer):
    """Runs at start of pretraining routine; initializes and connects/ logs task to ClearML."""
    try:
        if task := Task.current_task():
            # Make sure the automatic pytorch and matplotlib bindings are disabled!
            # We are logging these plots and model files manually in the integration
            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")
    except Exception as e:
        LOGGER.warning(f"WARNING ⚠️ ClearML installed but not initialized correctly, not logging this run. {e}")



ultralytics.utils.callbacks.clearml.on_train_epoch_end(trainer)

Registra i campioni di debug per il primo periodo di addestramento di YOLO e riporta i progressi dell'addestramento in corso.

Codice sorgente in ultralytics/utils/callbacks/clearml.py
def on_train_epoch_end(trainer):
    """Logs debug samples for the first epoch of YOLO training and report current training progress."""
    if task := Task.current_task():
        # Log debug samples
        if trainer.epoch == 1:
            _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.lr.items():
            task.get_logger().report_scalar("lr", k, v, iteration=trainer.epoch)



ultralytics.utils.callbacks.clearml.on_fit_epoch_end(trainer)

Riporta le informazioni sul modello al logger alla fine di un'epoca.

Codice sorgente in ultralytics/utils/callbacks/clearml.py
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
        )
        for k, v in trainer.metrics.items():
            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)



ultralytics.utils.callbacks.clearml.on_val_end(validator)

Registra i risultati della convalida, comprese le etichette e le previsioni.

Codice sorgente in ultralytics/utils/callbacks/clearml.py
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")



ultralytics.utils.callbacks.clearml.on_train_end(trainer)

Registra il modello finale e il suo nome al termine della formazione.

Codice sorgente in ultralytics/utils/callbacks/clearml.py
def on_train_end(trainer):
    """Logs final model and its name on training completion."""
    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")),
        ]
        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)
        # Report final metrics
        for k, v in trainer.validator.metrics.results_dict.items():
            task.get_logger().report_single_value(k, v)
        # Log the final model
        task.update_output_model(model_path=str(trainer.best), model_name=trainer.args.name, auto_delete_file=False)





Creato 2023-11-12, Aggiornato 2023-11-25
Autori: glenn-jocher (3), Laughing-q (1)