> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
> Créer et suivre des graphiques à partir d'expériences de machine learning.
# 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 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](/fr/models/app/features/custom-charts/walkthrough/).
### 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](/fr/models/ref/python/custom-charts) 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.
Consignez un graphique en courbes personnalisé, une liste de points reliés et ordonnés sur des axes arbitraires.
```python theme={null}
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](https://wandb.ai/wandb/plots/reports/Custom-Line-Plots--VmlldzoyNjk5NTA).
[Exécuter le code](https://tiny.cc/custom-charts)
Journalisez un graphique de dispersion personnalisé sous la forme d’une liste de points (x, y) sur deux axes arbitraires x et y.
```python theme={null}
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](https://wandb.ai/wandb/plots/reports/Custom-Scatter-Plots--VmlldzoyNjk5NDQ) dans Reports.
[Exécuter le code](https://tiny.cc/custom-charts)
Enregistrez nativement un graphique à barres personnalisé (une liste de valeurs associées à des libellés, affichées sous forme de barres) en quelques lignes :
```python theme={null}
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](https://wandb.ai/wandb/plots/reports/Custom-Bar-Charts--VmlldzoyNzExNzk).
[Exécuter le code](https://tiny.cc/custom-charts)
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 :
```python theme={null}
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](https://wandb.ai/wandb/plots/reports/Custom-Histograms--VmlldzoyNzE0NzM).
[Exécuter le code](https://tiny.cc/custom-charts)
Tracez plusieurs lignes, ou plusieurs listes distinctes de paires de coordonnées x-y, sur les mêmes axes x-y :
```python theme={null}
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](https://wandb.ai/wandb/plots/reports/Custom-Multi-Line-Plots--VmlldzozOTMwMjU).
### Graphiques d’évaluation du modèle
Ces graphiques prédéfinis intègrent des méthodes `wandb.plot()` qui permettent de journaliser rapidement des graphiques directement depuis votre script, puis de voir exactement les informations recherchées dans l’interface utilisateur.
Créez une [courbe de précision-rappel](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve) en une ligne :
```python theme={null}
import wandb
with wandb.init() as run:
# ground_truth est une liste d'étiquettes réelles, 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](https://wandb.ai/wandb/plots/reports/Plot-Precision-Recall-Curves--VmlldzoyNjk1ODY).
[Exécuter le code](https://colab.research.google.com/drive/1mS8ogA3LcZWOXchfJoMrboW3opY1A8BY?usp=sharing)
Créez une [courbe ROC](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html#sklearn.metrics.roc_curve) en une seule ligne :
```python theme={null}
import wandb
with wandb.init() as run:
# ground_truth est une liste d'étiquettes réelles, 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](https://wandb.ai/wandb/plots/reports/Plot-ROC-Curves--VmlldzoyNjk3MDE).
[Exécuter le code](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/wandb-log/Plot_ROC_Curves_with_W%26B.ipynb)
Créez une [matrice de confusion](https://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html) à plusieurs classes en une ligne :
```python theme={null}
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](https://wandb.ai/wandb/plots/reports/Confusion-Matrix--VmlldzozMDg1NTM).
[Exécuter le code](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/wandb-log/Log_a_Confusion_Matrix_with_W%26B.ipynb)
### Graphiques personnalisés interactifs
Pour une personnalisation complète, modifiez un [préréglage de graphique personnalisé](/fr/models/app/features/custom-charts/walkthrough/) 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.
```python theme={null}
import wandb
# Créer un tableau avec 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 remplir le nouveau préréglage de graphique personnalisé.
# Pour utiliser votre propre préréglage 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écutez le code](https://tiny.cc/custom-charts)
### Graphiques Matplotlib et Plotly
Au lieu d'utiliser les [graphiques personnalisés](/fr/models/app/features/custom-charts/walkthrough/) de W\&B avec `wandb.plot()`, vous pouvez journaliser des graphiques créés avec [matplotlib](https://matplotlib.org/) et [Plotly](https://plotly.com/).
```python theme={null}
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 simplement un graphique `matplotlib` ou un objet figure à `wandb.Run.log()`. Par défaut, nous convertirons le graphique en graphique [Plotly](https://plot.ly/). 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 W\&B Tables au format HTML
Vous pouvez journaliser des graphiques Plotly interactifs dans W\&B Tables en les convertissant au format HTML.
```python theme={null}
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 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])
# Écrire la figure 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 la figure 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.
```python theme={null}
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})
```