सामग्री पर जाएं

के लिए संदर्भ ultralytics/utils/callbacks/wb.py

नोट

यह फ़ाइल यहाँ उपलब्ध है https://github.com/ultralytics/ultralytics/बूँद/मुख्य/ultralytics/utils/callbacks/wb.py का उपयोग करें। यदि आप कोई समस्या देखते हैं तो कृपया पुल अनुरोध का योगदान करके इसे ठीक करने में मदद करें 🛠️। 🙏 धन्यवाद !



ultralytics.utils.callbacks.wb._custom_table(x, y, classes, title='Precision Recall Curve', x_title='Recall', y_title='Precision')

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 different classes.

पैरामीटर:

नाम प्रकार या क़िस्‍म चूक
x List

x-अक्ष के लिए मान; लंबाई एन होने की उम्मीद है।

आवश्यक
y List

y-अक्ष के लिए संगत मान; लंबाई एन होने की भी उम्मीद है।

आवश्यक
classes List

प्रत्येक बिंदु के वर्ग की पहचान करने वाले लेबल; लंबाई एन।

आवश्यक
title str

साजिश के लिए शीर्षक; 'प्रेसिजन रिकॉल कर्व' के लिए डिफ़ॉल्ट।

'Precision Recall Curve'
x_title str

x-अक्ष के लिए लेबल; 'रिकॉल' के लिए डिफ़ॉल्ट।

'Recall'
y_title str

y-अक्ष के लिए लेबल; डिफ़ॉल्ट रूप से 'प्रेसिजन' पर सेट होता है.

'Precision'

देता:

प्रकार या क़िस्‍म
Object

लॉगिंग के लिए उपयुक्त एक वैंडब ऑब्जेक्ट, तैयार किए गए मीट्रिक विज़ुअलाइज़ेशन को प्रदर्शित करता है।

में स्रोत कोड ultralytics/utils/callbacks/wb.py
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.

    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
    different classes.

    Args:
        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, optional): Title for the plot; defaults to 'Precision Recall Curve'.
        x_title (str, optional): Label for the x-axis; defaults to 'Recall'.
        y_title (str, optional): Label for the y-axis; defaults to 'Precision'.

    Returns:
        (wandb.Object): A wandb object suitable for logging, showcasing the crafted metric visualization.
    """
    import pandas  # scope for faster 'import ultralytics'

    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
    )



ultralytics.utils.callbacks.wb._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)

मीट्रिक वक्र दृश्यावलोकन लॉग करें.

यह फ़ंक्शन इनपुट डेटा के आधार पर एक मीट्रिक वक्र उत्पन्न करता है और विज़ुअलाइज़ेशन को wandb में लॉग करता है। वक्र 'only_mean' ध्वज के आधार पर एकत्रित डेटा (माध्य) या व्यक्तिगत वर्ग डेटा का प्रतिनिधित्व कर सकता है।

पैरामीटर:

नाम प्रकार या क़िस्‍म चूक
x ndarray

लंबाई N के साथ x-अक्ष के लिए डेटा बिंदु।

आवश्यक
y ndarray

आकार CxN के साथ y-अक्ष के लिए संगत डेटा बिंदु, जहां C वर्गों की संख्या है।

आवश्यक
names list

y-अक्ष डेटा के अनुरूप वर्गों के नाम; लंबाई C. डिफ़ॉल्ट से [].

None
id str

wandb में लॉग किए गए डेटा के लिए युनीक आइडेंटिफ़ायर. 'सटीक-याद' के लिए डिफ़ॉल्ट।

'precision-recall'
title str

विज़ुअलाइज़ेशन प्लॉट के लिए शीर्षक. 'प्रेसिजन रिकॉल कर्व' के लिए डिफ़ॉल्ट।

'Precision Recall Curve'
x_title str

x-अक्ष के लिए लेबल। 'रिकॉल' के लिए डिफ़ॉल्ट।

'Recall'
y_title str

y-अक्ष के लिए लेबल। डिफ़ॉल्ट रूप से 'सटीक' पर सेट होता है.

'Precision'
num_x int

विज़ुअलाइज़ेशन के लिए इंटरपोलेटेड डेटा बिंदुओं की संख्या। 100 के लिए डिफ़ॉल्ट।

100
only_mean bool

ध्वज इंगित करने के लिए यदि केवल माध्य वक्र को प्लॉट किया जाना चाहिए। सही करने के लिए डिफ़ॉल्ट।

False
नोट

फ़ंक्शन वास्तविक विज़ुअलाइज़ेशन उत्पन्न करने के लिए '_custom_table' फ़ंक्शन का लाभ उठाता है।

में स्रोत कोड ultralytics/utils/callbacks/wb.py
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.

    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 CxN, where C is the number of classes.
        names (list, optional): Names of the classes corresponding to the y-axis data; length C. Defaults to [].
        id (str, optional): Unique identifier for the logged data in wandb. Defaults to 'precision-recall'.
        title (str, optional): Title for the visualization plot. Defaults to 'Precision Recall Curve'.
        x_title (str, optional): Label for the x-axis. Defaults to 'Recall'.
        y_title (str, optional): Label for the y-axis. Defaults to 'Precision'.
        num_x (int, optional): Number of interpolated data points for visualization. Defaults to 100.
        only_mean (bool, optional): Flag to indicate if only the mean curve should be plotted. Defaults to True.

    Note:
        The function leverages the '_custom_table' function to generate the actual visualization.
    """
    import numpy as np

    # Create new x
    if names is None:
        names = []
    x_new = np.linspace(x[0], x[-1], num_x).round(5)

    # Create arrays for logging
    x_log = x_new.tolist()
    y_log = np.interp(x_new, x, np.mean(y, axis=0)).round(3).tolist()

    if only_mean:
        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)
        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
            classes.extend([names[i]] * len(x_new))  # add class names
        wb.log({id: _custom_table(x_log, y_log, classes, title, x_title, y_title)}, commit=False)



ultralytics.utils.callbacks.wb._log_plots(plots, step)

इनपुट शब्दकोश से लॉग प्लॉट यदि वे पहले से ही निर्दिष्ट चरण पर लॉग नहीं किए गए हैं।

में स्रोत कोड ultralytics/utils/callbacks/wb.py
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.copy().items():  # shallow copy to prevent plots dict changing during iteration
        timestamp = params["timestamp"]
        if _processed_plots.get(name) != timestamp:
            wb.run.log({name.stem: wb.Image(str(name))}, step=step)
            _processed_plots[name] = timestamp



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

मॉड्यूल मौजूद होने पर प्रोजेक्ट शुरू करें और शुरू करें।

में स्रोत कोड ultralytics/utils/callbacks/wb.py
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))



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

एक युग के अंत में प्रशिक्षण मैट्रिक्स और मॉडल जानकारी लॉग करता है।

में स्रोत कोड ultralytics/utils/callbacks/wb.py
def on_fit_epoch_end(trainer):
    """Logs 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)



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

मेट्रिक्स लॉग करें और प्रत्येक प्रशिक्षण युग के अंत में छवियों को सहेजें।

में स्रोत कोड ultralytics/utils/callbacks/wb.py
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.lr, step=trainer.epoch + 1)
    if trainer.epoch == 1:
        _log_plots(trainer.plots, step=trainer.epoch + 1)



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

प्रशिक्षण के अंत में एक आर्टिफैक्ट के रूप में सर्वश्रेष्ठ मॉडल को बचाएं।

में स्रोत कोड ultralytics/utils/callbacks/wb.py
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")
    if trainer.best.exists():
        art.add_file(trainer.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}",
            title=curve_name,
            x_title=x_title,
            y_title=y_title,
        )
    wb.run.finish()  # required or run continues on dashboard





Created 2023-11-12, Updated 2024-06-02
Authors: glenn-jocher (5), Burhan-Q (1), Laughing-q (1)