> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
> Créez et suivez 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 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](/fr/products/wandb/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/products/wandb/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 visualiser simplement des métriques et des résultats.
Journalisez un graphique en courbes personnalisé, c’est-à-dire une liste de points ordonnés et reliés entre eux, sur des axes quelconques.
```python theme={"system"}
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](https://forge.coreweave.com/wandb/wandb/plots/reports/Custom-Line-Plots--VmlldzoyNjk5NTA).
[Exécuter le code](https://tiny.cc/custom-charts)
Journalisez un nuage de points personnalisé, c’est-à-dire une liste de points (x, y) sur deux axes arbitraires x et y.
```python theme={"system"}
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](https://forge.coreweave.com/wandb/wandb/plots/reports/Custom-Scatter-Plots--VmlldzoyNjk5NDQ).
[Exécuter le code](https://tiny.cc/custom-charts)
Journalisez nativement, en quelques lignes, un graphique à barres personnalisé (une liste de valeurs étiquetées affichées sous forme de barres) :
```python theme={"system"}
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](https://forge.coreweave.com/wandb/wandb/plots/reports/Custom-Bar-Charts--VmlldzoyNzExNzk).
[Exécuter le code](https://tiny.cc/custom-charts)
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 :
```python theme={"system"}
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](https://forge.coreweave.com/wandb/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 un même système d’axes x-y :
```python theme={"system"}
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](https://forge.coreweave.com/wandb/wandb/plots/reports/Custom-Multi-Line-Plots--VmlldzozOTMwMjU).
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.
Créez une [courbe précision-rappel](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve) en une seule ligne :
```python theme={"system"}
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](https://forge.coreweave.com/wandb/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={"system"}
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](https://forge.coreweave.com/wandb/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) multiclasse en une seule ligne :
```python theme={"system"}
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](https://forge.coreweave.com/wandb/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, ajustez un [preset de graphique personnalisé](/fr/products/wandb/app/features/custom-charts/walkthrough) 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.
```python theme={"system"}
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](https://tiny.cc/custom-charts)
Graphiques Matplotlib et Plotly
Plutôt que d’utiliser les [graphiques personnalisés](/fr/products/wandb/app/features/custom-charts/walkthrough) de W\&B avec `wandb.plot()`, vous pouvez journaliser des graphiques générés avec [matplotlib](https://matplotlib.org/) et [Plotly](https://plotly.com/).
```python theme={"system"}
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](https://plot.ly/). 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.
Vous pouvez journaliser des graphiques Plotly interactifs dans des tableaux W\&B en les convertissant en HTML.
```python theme={"system"}
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})
```
Vous pouvez journaliser des graphiques Bokeh interactifs dans des tableaux W\&B en les convertissant au format HTML.
```python theme={"system"}
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})
```
## Related topics
- [Exemples de code et notebooks](/fr/products/wandb/examples.md)