Créer et suivre des graphiques à partir d’expériences

Dans W&B Models, les méthodes de wandb.plot vous permettent de suivre des graphiques avec wandb.Run.log(), y compris des graphiques qui évoluent au cours de l’entraînement. Pour en savoir plus sur le framework de graphiques personnalisés, consultez le guide pas à pas des graphiques personnalisés.

Graphiques de base

Pour créer un graphique W&B :

Créez un objet wandb.Table et ajoutez-y les données que vous souhaitez visualiser.
Générez un graphique à l’aide de l’une des fonctions utilitaires intégrées de W&B
Journalisez le graphique avec wandb.Run.log().

Les graphiques de base suivants permettent de visualiser simplement des métriques et des résultats.

Ligne
Nuage de points
Barres
Histogramme
Multiligne

Journalisez un graphique en courbes personnalisé, c’est-à-dire une liste de points ordonnés et reliés entre eux, sur des axes quelconques.

import wandb

with wandb.init() as run:
    data = [[x, y] for (x, y) in zip(x_values, y_values)]
    table = wandb.Table(data=data, columns=["x", "y"])
    run.log(
        {
            "my_custom_plot_id": wandb.plot.line(
                table, "x", "y", title="Custom Y versus X line plot"
            )
        }
    )

Vous pouvez l’utiliser pour journaliser des courbes selon deux dimensions quelconques. Si vous tracez deux listes de valeurs l’une en fonction de l’autre, les deux listes doivent contenir exactement le même nombre de valeurs. Par exemple, chaque point doit avoir une valeur x et une valeur y.

Pour plus d’informations, voir le rapport Creating Custom Line Plots With W&B.Exécuter le code

Journalisez un nuage de points personnalisé, c’est-à-dire une liste de points (x, y) sur deux axes arbitraires x et y.

import wandb

with wandb.init() as run:
    data = [[x, y] for (x, y) in zip(class_x_scores, class_y_scores)]
    table = wandb.Table(data=data, columns=["class_x", "class_y"])
    run.log({"my_custom_id": wandb.plot.scatter(table, "class_x", "class_y")})

Vous pouvez l’utiliser pour journaliser un nuage de points sur deux dimensions quelconques. Si vous représentez deux listes de valeurs l’une en fonction de l’autre, les deux listes doivent contenir exactement le même nombre de valeurs. Par exemple, chaque point doit avoir une coordonnée x et une coordonnée y.

Pour plus d’informations, voir le rapport Creating Custom Scatter Plots With W&B.Exécuter le code

Journalisez nativement, en quelques lignes, un graphique à barres personnalisé (une liste de valeurs étiquetées affichées sous forme de barres) :

import wandb

with wandb.init() as run:
    data = [[label, val] for (label, val) in zip(labels, values)]
    table = wandb.Table(data=data, columns=["label", "value"])
    run.log(
        {
            "my_bar_chart_id": wandb.plot.bar(
                table, "label", "value", title="Custom bar chart"
            )
        }
    )

Vous pouvez l’utiliser pour journaliser n’importe quel graphique à barres. Les listes doivent contenir exactement le même nombre d’étiquettes et de valeurs : chaque point de données doit avoir les deux.

Pour plus d’informations, voir le rapport Custom Bar Charts.Exécuter le code

Journalisez nativement un histogramme personnalisé (qui répartit une liste de valeurs en intervalles selon leur nombre ou leur fréquence d’occurrence) en quelques lignes seulement. Si vous disposez d’une liste de scores de confiance de prédiction (scores), vous pouvez visualiser leur distribution ainsi :

import wandb

with wandb.init() as run:
    data = [[s] for s in scores]
    table = wandb.Table(data=data, columns=["scores"])
    run.log({"my_histogram": wandb.plot.histogram(table, "scores", title="Histogram")})

Vous pouvez l’utiliser pour journaliser des histogrammes quelconques. Notez que data est une liste de listes, conçue pour représenter un tableau 2D de lignes et de colonnes.

Pour plus d’informations, voir le rapport Creating Custom Histograms With W&B.Exécuter le code

Tracez plusieurs lignes, ou plusieurs listes distinctes de paires de coordonnées x-y, sur un même système d’axes x-y :

import wandb

with wandb.init() as run:
    run.log(
        {
            "my_custom_id": wandb.plot.line_series(
                xs=[0, 1, 2, 3, 4],
                ys=[[10, 20, 30, 40, 50], [0.5, 11, 72, 3, 41]],
                keys=["metric Y", "metric Z"],
                title="Two Random Metrics",
                xname="x units",
            )
        }
    )

Notez que le nombre de points x et y doit correspondre exactement. Vous pouvez fournir une seule liste de valeurs x pour plusieurs listes de valeurs y, ou une liste distincte de valeurs x pour chaque liste de valeurs y.

Pour plus d’informations, voir le rapport Custom Multi-Line Plots.

Graphiques d’évaluation de modèles

Ces graphiques prédéfinis intègrent des méthodes wandb.plot() qui vous permettent de journaliser rapidement des graphiques directement depuis votre script et de retrouver précisément les informations qui vous intéressent dans l’interface utilisateur.

Courbes précision-rappel
Courbes ROC
Matrice de confusion

Créez une courbe précision-rappel en une seule ligne :

import wandb
with wandb.init() as run:
    # ground_truth est une liste d’étiquettes réelles et predictions, une liste de scores prédits.
    # Par exemple, ground_truth = [0, 1, 1, 0], predictions = [0.1, 0.4, 0.35, 0.8]
    ground_truth = [0, 1, 1, 0]
    predictions = [0.1, 0.4, 0.35, 0.8]
    run.log({"pr": wandb.plot.pr_curve(ground_truth, predictions)})

Vous pouvez journaliser ce graphique dès que votre code a accès aux éléments suivants :

Les scores prédits par un modèle (predictions) sur un ensemble d’exemples.
Les étiquettes de vérité terrain correspondantes (ground_truth) pour ces exemples.
(Facultatif) Une liste des étiquettes ou des noms de classes. Par exemple, labels=["cat", "dog", "bird"], si l’index d’étiquette 0 correspond à chat, 1 à chien et 2 à oiseau.
(Facultatif) Un sous-ensemble (toujours sous forme de liste) des étiquettes à visualiser dans le graphique.

Pour plus d’informations, voir le rapport Plot Precision Recall Curves With W&B.Exécuter le code

Créez une courbe ROC en une seule ligne :

import wandb

with wandb.init() as run:
    # ground_truth est une liste d’étiquettes réelles et predictions une liste de scores prédits.
    # Par exemple, ground_truth = [0, 1, 1, 0], predictions = [0.1, 0.4, 0.35, 0.8]
    ground_truth = [0, 1, 1, 0]
    predictions = [0.1, 0.4, 0.35, 0.8]
    run.log({"roc": wandb.plot.roc_curve(ground_truth, predictions)})

Vous pouvez journaliser ce graphique dès que votre code a accès aux éléments suivants :

Les scores prédits par un modèle (predictions) sur un ensemble d’exemples.
Les étiquettes de vérité terrain correspondantes (ground_truth) pour ces exemples.
(Facultatif) Une liste des étiquettes ou des noms de classes. Par exemple, labels=["cat", "dog", "bird"], si l’index d’étiquette 0 correspond à « chat », 1 à « chien » et 2 à « oiseau ».
(Facultatif) Un sous-ensemble (toujours sous forme de liste) de ces étiquettes à afficher sur le graphique.

Pour plus d’informations, voir le rapport Plot ROC Curves With W&B.Exécuter le code

Créez une matrice de confusion multiclasse en une seule ligne :

import wandb

cm = wandb.plot.confusion_matrix(
    y_true=ground_truth, preds=predictions, class_names=class_names
)

with wandb.init() as run:
    run.log({"conf_mat": cm})

Vous pouvez journaliser ce graphique à tout endroit où votre code a accès aux éléments suivants :

Les étiquettes prédites par un modèle sur un ensemble d’exemples (preds) ou les scores de probabilité normalisés (probs). Les probabilités doivent avoir la forme (nombre d’exemples, nombre de classes). Vous pouvez fournir soit des probabilités, soit des prédictions, mais pas les deux.
Les étiquettes de vérité terrain correspondant à ces exemples (y_true).
La liste complète des étiquettes ou des noms de classes, sous forme de chaînes de caractères, dans class_names. Par exemple, class_names=["cat", "dog", "bird"] si l’index 0 correspond à cat, 1 à dog et 2 à bird.

Pour plus d’informations, voir le rapport Confusion Matrix: Usage and Examples.Exécuter le code

Graphiques personnalisés interactifs

Pour une personnalisation complète, ajustez un preset de graphique personnalisé intégré ou créez-en un nouveau, puis enregistrez le graphique. Utilisez l’ID du graphique pour journaliser des données dans ce preset personnalisé directement depuis votre script.

import wandb
# Créer un tableau contenant les colonnes à représenter.
table = wandb.Table(data=data, columns=["step", "height"])

# Associer les colonnes du tableau aux champs du graphique.
fields = {"x": "step", "value": "height"}

# Utiliser le tableau pour alimenter le nouveau preset de graphique personnalisé.
# Pour utiliser votre propre preset de graphique enregistré, modifiez vega_spec_name.
# Pour modifier le titre, modifiez string_fields.
my_custom_chart = wandb.plot_table(
    vega_spec_name="carey/new_chart",
    data_table=table,
    fields=fields,
    string_fields={"title": "Height Histogram"},
)

with wandb.init() as run:
    # Journaliser le graphique personnalisé.
    run.log({"my_custom_chart": my_custom_chart})

Exécuter le code

Graphiques Matplotlib et Plotly

Plutôt que d’utiliser les graphiques personnalisés de W&B avec wandb.plot(), vous pouvez journaliser des graphiques générés avec matplotlib et Plotly.

import wandb
import matplotlib.pyplot as plt

with wandb.init() as run:
    # Créer un graphique matplotlib simple.
    plt.figure()
    plt.plot([1, 2, 3, 4])
    plt.ylabel("some interesting numbers")

    # Journaliser le graphique dans W&B.
    run.log({"chart": plt})

Passez un graphique matplotlib ou un objet figure à wandb.Run.log(). Par défaut, nous convertissons le graphique en graphique Plotly. Si vous préférez journaliser le graphique sous forme d’image, passez-le à wandb.Image. Les graphiques Plotly sont également acceptés directement.

Si vous obtenez une erreur du type « You attempted to log an empty plot », stockez la figure séparément du graphique avec fig = plt.figure(), puis journalisez fig dans votre appel à wandb.Run.log().

Journaliser du HTML personnalisé dans des tableaux W&B

W&B permet de journaliser des graphiques interactifs Plotly et Bokeh au format HTML, puis de les ajouter à des Tables.

Journaliser des figures Plotly dans des Tables au format HTML

Vous pouvez journaliser des graphiques Plotly interactifs dans des tableaux W&B en les convertissant en HTML.

import wandb
import plotly.express as px

# Initialiser un nouveau run.
with wandb.init(project="log-plotly-fig-tables", name="plotly_html") as run:

    # Créer un tableau.
    table = wandb.Table(columns=["plotly_figure"])

    # Définir le chemin de la figure Plotly.
    path_to_plotly_html = "./plotly_figure.html"

    # Exemple de figure Plotly.
    fig = px.scatter(x=[0, 1, 2, 3, 4], y=[0, 1, 4, 9, 16])

    # Exporter la figure Plotly au format HTML.
    # Définir auto_play sur False empêche la lecture automatique
    # des graphiques Plotly animés dans le tableau.
    fig.write_html(path_to_plotly_html, auto_play=False)

    # Ajouter la figure Plotly au tableau sous forme de fichier HTML.
    table.add_data(wandb.Html(path_to_plotly_html))

    # Journaliser le tableau.
    run.log({"test_table": table})

Journaliser des figures Bokeh dans des Tables au format HTML

Vous pouvez journaliser des graphiques Bokeh interactifs dans des tableaux W&B en les convertissant au format HTML.

from scipy.signal import spectrogram
import holoviews as hv
import panel as pn
from scipy.io import wavfile
import numpy as np
from bokeh.resources import INLINE

hv.extension("bokeh", logo=False)
import wandb


def save_audio_with_bokeh_plot_to_html(audio_path, html_file_name):
    sr, wav_data = wavfile.read(audio_path)
    duration = len(wav_data) / sr
    f, t, sxx = spectrogram(wav_data, sr)
    spec_gram = hv.Image((t, f, np.log10(sxx)), ["Time (s)", "Frequency (hz)"]).opts(
        width=500, height=150, labelled=[]
    )
    audio = pn.pane.Audio(wav_data, sample_rate=sr, name="Audio", throttle=500)
    slider = pn.widgets.FloatSlider(end=duration, visible=False)
    line = hv.VLine(0).opts(color="white")
    slider.jslink(audio, value="time", bidirectional=True)
    slider.jslink(line, value="glyph.location")
    combined = pn.Row(audio, spec_gram * line, slider).save(html_file_name)


html_file_name = "audio_with_plot.html"
audio_path = "hello.wav"
save_audio_with_bokeh_plot_to_html(audio_path, html_file_name)

wandb_html = wandb.Html(html_file_name)

with wandb.init(project="audio_test") as run:
    my_table = wandb.Table(columns=["audio_with_plot"], data=[[wandb_html]])
    run.log({"audio_table": my_table})

​Graphiques de base

​Graphiques d’évaluation de modèles

​Graphiques personnalisés interactifs

​Graphiques Matplotlib et Plotly

​Journaliser du HTML personnalisé dans des tableaux W&B

​Journaliser des figures Plotly dans des Tables au format HTML

​Journaliser des figures Bokeh dans des Tables au format HTML

Graphiques de base

Graphiques d’évaluation de modèles

Graphiques personnalisés interactifs

Graphiques Matplotlib et Plotly

Journaliser du HTML personnalisé dans des tableaux W&B

Journaliser des figures Plotly dans des Tables au format HTML

Journaliser des figures Bokeh dans des Tables au format HTML