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

Créer et suivre des graphiques à partir d’expériences de machine learning.

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 fil du temps pendant l’entraînement. Pour en savoir plus sur le framework de graphiques personnalisés, voir le guide pas à pas des graphiques personnalisés.

​

Graphiques de base

Pour créer un graphique W&B :

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

Les graphiques de base suivants permettent de créer des visualisations simples de métriques et de résultats.

Ligne

Consignez un graphique en courbes personnalisé, une liste de points reliés et ordonnés sur des axes arbitraires.

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 utiliser ceci pour enregistrer des courbes dans n’importe quelles deux dimensions. Si vous tracez deux listes de valeurs l’une par rapport à l’autre, le nombre de valeurs dans chaque liste doit correspondre exactement. Par exemple, chaque point doit avoir un x et un y.

Pour plus d’informations, voir le rapport Création de graphiques en courbes personnalisés avec W&B.

Exécuter le code

Nuage de points

Journalisez un graphique de dispersion personnalisé sous la forme d’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 utiliser ceci pour enregistrer des points sur un nuage de points selon n’importe quelles deux dimensions. Si vous tracez deux listes de valeurs l’une par rapport à l’autre, le nombre de valeurs dans les listes doit correspondre exactement. Par exemple, chaque point doit avoir un x et un y.

Pour plus d’informations, voir Creating Custom Scatter Plots With W&B dans Reports.

Exécuter le code

Barres

Enregistrez nativement un graphique à barres personnalisé (une liste de valeurs associées à des libellés, affichées sous forme de barres) en quelques lignes :

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 enregistrer des graphiques à barres arbitraires. Le nombre d’étiquettes et de valeurs dans les listes doit correspondre exactement. Chaque point de données doit inclure les deux.

Pour plus d’informations, voir le rapport Graphiques à barres personnalisés.

Exécuter le code

Histogramme

Journalisez nativement un histogramme personnalisé (répartissez une liste de valeurs dans des bins selon leur nombre ou leur fréquence d’occurrence) en quelques lignes. Si vous avez une liste de scores de confiance de prédiction (scores), vous pouvez visualiser la distribution comme ceci :

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 utiliser ceci pour enregistrer des histogrammes arbitraires. Notez que data est une liste de listes, prévue pour représenter un tableau 2D de lignes et de colonnes.

Pour plus d’informations, voir le rapport Créer des histogrammes personnalisés avec W&B.

Exécuter le code

Multiligne

Tracez plusieurs lignes, ou plusieurs listes distinctes de paires de coordonnées x-y, sur les mêmes 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 être exactement le même. Vous pouvez fournir une liste de valeurs x correspondant à 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 Graphiques multilignes personnalisés.

​

Graphiques d’évaluation du modèle

Ces graphiques prédéfinis intègrent des méthodes wandb.plot() qui permettent de journaliser rapidement et facilement des graphiques directement depuis votre script, puis de voir exactement les informations recherchées dans l’interface utilisateur.

Courbes de précision-rappel

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

import wandb
with wandb.init() as run:
    # ground_truth est une liste de vraies étiquettes, predictions est 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 ces données chaque fois que votre code a accès à :

• aux scores prédits d’un modèle (predictions) sur un ensemble d’exemples.
• aux étiquettes de vérité de terrain correspondantes (ground_truth) pour ces exemples.
• (Facultatif) à une liste des étiquettes ou des noms de classe. Par exemple, labels=["cat", "dog", "bird"], si l’indice d’étiquette 0 correspond à cat, 1 à dog et 2 à bird.
• (Facultatif) à un sous-ensemble des étiquettes à visualiser dans le graphique, toujours au format liste.

Pour plus d’informations, voir le Reports Plot Precision Recall Curves With W&B.

Exécuter le code

Courbes ROC

Créez une courbe ROC en une seule ligne :

import wandb

with wandb.init() as run:
    # ground_truth est une liste de labels réels, predictions est 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 ceci dès que votre code a accès à :

• Les scores prédits d’un modèle (predictions) sur un ensemble d’exemples.
• Les étiquettes de référence correspondantes (ground_truth) pour ces exemples.
• (Facultatif) Une liste des étiquettes ou des noms de classe. Par exemple, labels=["cat", "dog", "bird"], si l’indice d’étiquette 0 correspond à cat, 1 à dog et 2 à bird.
• (Facultatif) Un sous-ensemble (toujours au format liste) de ces étiquettes à visualiser sur le graphique.

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

Exécuter le code

Matrice de confusion

Créez une matrice de confusion à plusieurs classes en une 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 ces éléments partout où votre code a accès à :

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

Pour plus d’informations, voir le rapport Matrice de confusion : utilisation et exemples.

Exécuter le code

​

Graphiques personnalisés interactifs

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

import wandb
# Créer un tableau avec les colonnes à tracer.
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 remplir le nouveau préréglage de graphique personnalisé.
# Pour utiliser votre propre préréglage 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é dans le journal.
    run.log({"my_custom_chart": my_custom_chart})

Exécutez le code

​

Graphiques Matplotlib et Plotly

Au lieu d’utiliser les graphiques personnalisés de W&B avec wandb.plot(), vous pouvez journaliser des graphiques créé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("quelques nombres intéressants")

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

Passez simplement un graphique matplotlib ou un objet figure à wandb.Run.log(). Par défaut, nous convertirons le graphique en graphique Plotly. Si vous préférez journaliser le graphique sous forme d’image, vous pouvez le passer à wandb.Image. Nous acceptons aussi directement les graphiques Plotly.

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 W&B Tables

W&B prend en charge la journalisation de graphiques interactifs Plotly et Bokeh au format HTML, ainsi que leur ajout à Tables.

​

Journaliser des figures Plotly dans Tables au format HTML

Vous pouvez journaliser des graphiques Plotly interactifs dans les Tables de W&B en les convertissant au format 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"])

    # Créer le chemin vers le graphique Plotly.
    path_to_plotly_html = "./plotly_figure.html"

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

    # Écrire le graphique Plotly en HTML.
    # Définir auto_play sur False empêche les graphiques Plotly animés
    # de se lancer automatiquement dans le tableau.
    fig.write_html(path_to_plotly_html, auto_play=False)

    # Ajouter le graphique Plotly en tant que fichier HTML dans le tableau.
    table.add_data(wandb.Html(path_to_plotly_html))

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

​

Journaliser des figures Bokeh dans Tables au format HTML

Vous pouvez journaliser des graphiques Bokeh interactifs dans W&B Tables 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})