> ## 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.
> Modifiez un rapport de manière interactive dans l’interface de l’application ou par programmation avec le SDK W&B.
# Modifier un rapport
L’API Report and Workspace de W\&B est en préversion publique.
Cette page explique comment modifier un rapport de manière interactive dans l’interface de l’application ou par programmation avec le SDK W\&B. Elle couvre l’ajout de graphiques, d’ensemble de runs, de blocs de code, de markdown, d’éléments HTML et de médias enrichis. Elle couvre également le filtrage et le regroupement des ensemble de runs, l’organisation de la mise en page du rapport et la visualisation de relations multidimensionnelles.
Le corps d’un rapport est constitué de *blocs*. Les blocs contiennent du texte, des images, des visualisations intégrées, des graphiques issus d’Experiments et de runs, ainsi que des grilles de panneaux.
Les *grilles de panneaux* sont un type spécifique de bloc qui contient des panneaux et des *ensemble de runs*. Les ensemble de runs constituent une collection de runs enregistrés dans un projet sur W\&B. Les panneaux sont des visualisations des données de run set.
Exécutez le [notebook Programmatic workspaces](https://colab.research.google.com/github/wandb/wandb-workspaces/blob/Update-wandb-workspaces-tuturial/Workspace_tutorial.ipynb) pour suivre un tutoriel complet sur la création d’une vue de Workspace enregistrée et personnalisée.
Pour modifier un rapport par programmation, vous devez avoir installé l’API Report and Workspace de W\&B (`wandb-workspaces`) ainsi que le SDK Python W\&B :
```bash theme={null}
pip install wandb wandb-workspaces
```
## Ajouter des graphiques
Les graphiques vous permettent de visualiser les données de run dans un rapport. Chaque grille de panneaux comporte un ensemble d’ensembles de runs et un ensemble de panneaux. Les ensembles de runs dans la grille de panneaux contrôlent les données affichées dans les panneaux de la grille. Créez une nouvelle grille de panneaux si vous souhaitez ajouter des graphiques qui récupèrent des données à partir d’un autre ensemble de runs.
Saisissez une barre oblique (`/`) dans le rapport pour afficher un menu déroulant. Sélectionnez **Add panel** pour ajouter un panneau. Vous pouvez ajouter n’importe quel panneau pris en charge par W\&B, y compris un graphique en courbes, un nuage de points ou un graphique en coordonnées parallèles.
Ajoutez des graphiques à un rapport par programmation avec le SDK. Passez une liste d’un ou plusieurs objets de type `plot` ou `chart` au paramètre `panels` de la classe d’API publique `PanelGrid`. Créez un objet `plot` ou `chart` avec la classe Python associée.
Les exemples suivants montrent comment créer un graphique en courbes et un nuage de points.
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(
project="report-editing",
title="Report title",
description="Report description.",
)
blocks = [
wr.PanelGrid(
panels=[
wr.LinePlot(x="time", y="velocity"),
wr.ScatterPlot(x="time", y="acceleration"),
]
)
]
report.blocks = blocks
report.save()
```
Pour plus d’informations sur les `plots` et `charts` disponibles que vous pouvez ajouter à un rapport par programmation, voir `wr.panels`.
## Ajouter des ensembles de runs
Ajoutez des ensembles de runs depuis des projets, de manière interactive dans l’interface de l’application ou avec le SDK W\&B.
Saisissez une barre oblique (`/`) dans le rapport pour afficher un menu déroulant. Dans ce menu, choisissez **Panel Grid**. W\&B importe automatiquement l’ensemble de runs du projet à partir duquel le rapport a été créé.
Si vous importez un panneau dans un rapport, le rapport hérite des noms des runs du projet. Dans le rapport, vous pouvez éventuellement [renommer un run](/fr/models/runs/#rename-a-run) pour donner davantage de contexte au lecteur. Le renommage s’applique uniquement au panneau concerné. Si vous clonez le panneau dans le même rapport, le panneau cloné reflète également le nouveau nom.
1. Dans le rapport, cliquez sur l’icône en forme de crayon pour ouvrir l’éditeur de rapport.
2. Dans l’ensemble de runs, recherchez le run à renommer. Survolez le nom du run et cliquez sur le menu **action ()**. Sélectionnez l’une des options suivantes, puis soumettez le formulaire.
* **Rename run for project** : renomme le run dans l’ensemble du projet. Pour générer un nouveau nom aléatoire, laissez le champ vide.
* **Rename run for panel grid** : renomme le run uniquement dans le rapport, tout en conservant le nom existant dans les autres contextes. Vous ne pouvez pas générer un nouveau nom aléatoire avec cette option.
3. Cliquez sur **Publish report**.
Ajoutez des ensembles de runs depuis des projets avec les classes `wr.Runset()` et `wr.PanelGrid`. Pour ajouter un ensemble de runs, suivez ces étapes :
1. Créez une instance de l’objet `wr.Runset()`. Indiquez le nom du projet qui contient les ensembles de runs pour le paramètre project, ainsi que l’entité propriétaire du projet pour le paramètre entity.
2. Créez une instance de l’objet `wr.PanelGrid()`. Transmettez une liste d’un ou plusieurs objets d’ensemble de runs au paramètre `runsets`.
3. Stockez une ou plusieurs instances de `wr.PanelGrid()` dans une liste.
4. Mettez à jour l’attribut blocks de l’instance du rapport avec la liste des instances de grille de panneaux.
Remplacez `[PROJECT-NAME]` par le nom de votre projet W\&B et `[ENTITY-NAME]` par le nom de votre entité W\&B dans l’exemple suivant :
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(
project="report-editing",
title="Report title",
description="Report description.",
)
panel_grids = wr.PanelGrid(
runsets=[wr.RunSet(project="[PROJECT-NAME]", entity="[ENTITY-NAME]")]
)
report.blocks = [panel_grids]
report.save()
```
Vous pouvez aussi ajouter des runsets et des panneaux en un seul appel au SDK :
```python theme={null}
import wandb
report = wr.Report(
project="report-editing",
title="Report title",
description="Report description.",
)
panel_grids = wr.PanelGrid(
panels=[
wr.LinePlot(
title="line title",
x="x",
y=["y"],
range_x=[0, 100],
range_y=[0, 100],
log_x=True,
log_y=True,
title_x="x axis title",
title_y="y axis title",
ignore_outliers=True,
groupby="hyperparam1",
groupby_aggfunc="mean",
groupby_rangefunc="minmax",
smoothing_factor=0.5,
smoothing_type="gaussian",
smoothing_show_original=True,
max_runs_to_show=10,
plot_type="stacked-area",
font_size="large",
legend_position="west",
),
wr.ScatterPlot(
title="scatter title",
x="y",
y="y",
# z='x',
range_x=[0, 0.0005],
range_y=[0, 0.0005],
# range_z=[0,1],
log_x=False,
log_y=False,
# log_z=True,
running_ymin=True,
running_ymean=True,
running_ymax=True,
font_size="small",
regression=True,
),
],
runsets=[wr.RunSet(project="[PROJECT-NAME]", entity="[ENTITY-NAME]")],
)
report.blocks = [panel_grids]
report.save()
```
## Figer un ensemble de runs
Un rapport met automatiquement à jour les ensembles de runs pour afficher les données les plus récentes du projet. Figez un ensemble de runs pour en conserver l’état dans un rapport à un moment précis, afin que les runs ultérieurs ne modifient pas ce que le rapport affiche.
Pour figer un ensemble de runs lors de l’affichage d’un rapport, cliquez sur l’icône en forme de flocon dans sa grille de panneaux, près du bouton **Filtre**.
## Regrouper un ensemble de runs par programmation
Regroupez les runs d'un ensemble de runs par programmation avec [l'API Workspace and Reports](/fr/models/ref/wandb_workspaces/reports). Le regroupement organise les runs associés dans des panneaux, ce qui facilite la comparaison des configurations et des résultats.
Vous pouvez regrouper les runs d'un ensemble de runs selon des valeurs de configuration, des métadonnées de run ou des métriques de synthèse. Le tableau suivant répertorie les méthodes de regroupement disponibles ainsi que les clés disponibles pour chacune d'elles :
| Méthode de regroupement | Description | Clés disponibles |
| ------------------------ | ----------------------------------------------------- | ---------------------------------------------------------------------- |
| Valeurs de configuration | Regrouper les runs selon des valeurs de configuration | Valeurs spécifiées dans le paramètre `config` de `wandb.init(config=)` |
| Métadonnées du run | Regrouper les runs selon les métadonnées du run | `State`, `Name`, `JobType` |
| Métriques de synthèse | Regrouper les runs selon les métriques de synthèse | Valeurs que vous journalisez dans un run avec `wandb.Run.log()` |
### Regrouper les runs par valeurs de configuration
Regroupez les runs par valeurs de configuration pour comparer des runs ayant des configurations similaires. Les valeurs de configuration sont des paramètres que vous spécifiez dans la configuration de votre run `(wandb.init(config=))`. Pour regrouper les runs par valeurs de configuration, utilisez la syntaxe `config.[KEY]`, où `[KEY]` est le nom de la valeur de configuration à utiliser pour le regroupement.
Par exemple, l’extrait de code suivant initialise d’abord un run avec une valeur de configuration pour `group`, puis regroupe des runs dans un rapport en fonction de la valeur de configuration `group`. Remplacez `[ENTITY]` et `[PROJECT]` par les noms de votre entité et de votre projet W\&B.
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
entity = "[ENTITY]"
project = "[PROJECT]"
for group in ["control", "experiment_a", "experiment_b"]:
for i in range(3):
with wandb.init(entity=entity, project=project, group=group, config={"group": group, "run": i}, name=f"{group}_run_{i}") as run:
# Simuler un entraînement
for step in range(100):
run.log({
"acc": 0.5 + (step / 100) * 0.3 + (i * 0.05),
"loss": 1.0 - (step / 100) * 0.5
})
```
Dans votre script Python ou notebook, vous pouvez ensuite regrouper les runs par valeur de `config.group` :
```python theme={null}
runset = wr.Runset(
project=project,
entity=entity,
groupby=["config.group"] # Regrouper par la valeur de configuration "group"
)
```
En reprenant l’exemple précédent, vous pouvez créer un rapport avec l’ensemble de runs regroupés :
```python theme={null}
report = wr.Report(
entity=entity,
project=project,
title="Grouped Runs Example",
)
report.blocks = [
wr.PanelGrid(
runsets=[runset],
)
]
report.save()
```
### Regrouper les runs par métadonnées de run
Regroupez les runs par métadonnées pour les organiser selon les propriétés intrinsèques du run plutôt que selon les valeurs enregistrées. Vous pouvez regrouper par le nom d’un run (`Name`), son état (`State`) ou son type de job (`JobType`).
En reprenant l’exemple précédent, vous pouvez regrouper vos runs par leur nom à l’aide de l’extrait de code suivant :
```python theme={null}
runset = wr.Runset(
project=project,
entity=entity,
groupby=["Name"] # Regrouper par noms de run
)
```
Le nom du run correspond au nom que vous indiquez dans le paramètre `wandb.init(name=)`. Si vous n’en indiquez pas, W\&B génère un nom aléatoire pour le run.
Vous pouvez trouver le nom du run dans la page **Aperçu** d’un run dans la W\&B App, ou par programmation avec `Api.runs().run.name`.
### Regrouper les runs par métriques de synthèse
Les exemples suivants montrent comment regrouper les runs par métriques de synthèse. Les métriques de synthèse sont les valeurs que vous consignez dans un run avec `wandb.Run.log()`. Après avoir consigné un run, vous pouvez retrouver les noms de vos métriques de synthèse dans la W\&B App, dans la section **Summary** de la page **Aperçu** d’un run.
La syntaxe pour regrouper les runs par métriques de synthèse est `summary.[KEY]`, où `[KEY]` est le nom de la métrique de synthèse selon laquelle vous souhaitez regrouper.
Par exemple, supposons que vous consigniez une métrique de synthèse appelée `acc`. Remplacez `[ENTITY]` et `[PROJECT]` par les noms de votre entité et de votre projet W\&B :
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
entity = "[ENTITY]"
project = "[PROJECT]"
for group in ["control", "experiment_a", "experiment_b"]:
for i in range(3):
with wandb.init(entity=entity, project=project, group=group, config={"group": group, "run": i}, name=f"{group}_run_{i}") as run:
# Simuler un entraînement
for step in range(100):
run.log({
"acc": 0.5 + (step / 100) * 0.3 + (i * 0.05),
"loss": 1.0 - (step / 100) * 0.5
})
```
Vous pouvez ensuite regrouper les runs en fonction de la métrique summary `summary.acc` :
```python theme={null}
runset = wr.Runset(
project=project,
entity=entity,
groupby=["summary.acc"] # Regrouper par valeurs de synthèse
)
```
## Filtrer un ensemble de runs par code
Filtrez des ensembles de runs par code et ajoutez-les à un rapport à l’aide de l’[API Workspace and Reports](/fr/models/ref/wandb_workspaces/reports). Le filtrage permet de restreindre un ensemble de runs aux runs spécifiques que vous souhaitez afficher, en fonction des valeurs de configuration, des métriques, des tags ou des propriétés de run.
La syntaxe générale d’une expression de filtre est :
```text theme={null}
Filter('[KEY]') operation [VALUE]
```
Dans cette expression, `[KEY]` est le nom du filtre, `operation` est un opérateur de comparaison (par exemple, `>`, `<`, `==`, `in`, `not in`, `or` et `and`), et `[VALUE]` est la valeur de comparaison. `Filter` est un espace réservé pour le type de filtre que vous souhaitez appliquer. Le tableau suivant répertorie les filtres disponibles et leur description :
| Filter | Description | Clés disponibles |
| ------------------------ | ---------------------------------------- | ------------------------------------------------------------------------------------ |
| `Config('[KEY]')` | Filtrer par les valeurs de configuration | Valeurs spécifiées dans le paramètre `config` de `wandb.init(config=)`. |
| `SummaryMetric('[KEY]')` | Filtrer par les métriques de synthèse | Valeurs que vous enregistrez dans un run avec `wandb.Run.log()`. |
| `Tags('[KEY]')` | Filtrer par les tags | Valeurs de tag que vous ajoutez à votre run (par programmation ou avec la W\&B App). |
| `Metric('[KEY]')` | Filtrer par les propriétés du run | `tags`, `state`, `displayName`, `jobType` |
Après avoir défini vos filtres, vous pouvez créer un rapport et passer les ensembles de runs filtrés à `wr.PanelGrid(runsets=)`. Voir les onglets **Report and Workspace API** sur cette page pour plus d’informations sur la façon d’ajouter différents éléments à un rapport par programmation.
Les exemples suivants montrent comment filtrer des ensembles de runs dans un rapport. Remplacez les valeurs entre crochets (par exemple, `[ENTITY]` et `[PROJECT]`) par vos propres valeurs.
### Filtres de configuration
Filtrez un ensemble de runs à l’aide d’une ou plusieurs valeurs de configuration. Les valeurs de configuration sont des paramètres que vous spécifiez dans la configuration de votre run (`wandb.init(config=)`).
Par exemple, l’extrait de code suivant initialise d’abord un run avec des valeurs de configuration pour `learning_rate` et `batch_size`, puis filtre les runs dans rapports en fonction de la valeur de configuration `learning_rate`.
```python theme={null}
import wandb
config = {
"learning_rate": 0.01,
"batch_size": 32,
}
with wandb.init(project="[PROJECT]", entity="[ENTITY]", config=config) as run:
# Votre code d'entraînement ici
pass
```
Dans votre script ou notebook Python, vous pouvez ensuite filtrer de manière programmatique les runs dont le taux d’apprentissage est supérieur à `0.01`.
```python theme={null}
import wandb_workspaces.reports.v2 as wr
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="Config('learning_rate') > 0.01"
)
```
Vous pouvez également filtrer sur plusieurs valeurs de configuration avec l’opérateur `and` :
```python theme={null}
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="Config('learning_rate') > 0.01 and Config('batch_size') == 32"
)
```
En reprenant l’exemple précédent, vous pouvez créer un rapport à partir de l’ensemble de runs filtré comme suit :
```python theme={null}
report = wr.Report(
entity="[ENTITY]",
project="[PROJECT]",
title="My Report"
)
report.blocks = [
wr.PanelGrid(
runsets=[runset],
panels=[
wr.LinePlot(
x="Step",
y=["accuracy"],
)
]
)
]
report.save()
```
### Filtres de métriques
Filtrez les ensembles de runs selon le tag (`tags`), l'état (`state`), le nom du run (`displayName`) ou le type de job (`jobType`) d'un run.
Les filtres `Metric` utilisent une syntaxe différente de celle des autres filtres. Vous devez passer les valeurs sous forme de liste.
```text theme={null}
Metric('[KEY]') operation [VALUE]
```
Par exemple, prenons l'extrait Python suivant, qui crée trois runs et attribue un nom à chacun d'eux :
```python theme={null}
import wandb
with wandb.init(project="[PROJECT]", entity="[ENTITY]") as run:
for i in range(3):
run.name = f"run{i+1}"
# Votre code d'entraînement ici
pass
```
Lorsque vous créez votre rapport, vous pouvez filtrer les runs en fonction de leur nom d’affichage. Par exemple, pour filtrer les runs dont le nom est `run1`, `run2` et `run3`, vous pouvez utiliser le code suivant :
```python theme={null}
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="Metric('displayName') in ['run1', 'run2', 'run3']"
)
```
Vous pouvez trouver le nom du run sur la page **Aperçu** d’un run dans la W\&B App, ou par code avec `Api.runs().run.name`.
Les exemples suivants montrent comment filtrer un ensemble de runs en fonction de l’état du run (`finished`, `crashed` ou `running`) :
```python theme={null}
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="Metric('state') in ['finished']"
)
```
```python theme={null}
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="Metric('state') not in ['crashed']"
)
```
### Filtres de SummaryMetric
Filtrez un ensemble de runs selon les métriques de synthèse afin de vous concentrer sur les runs qui atteignent des seuils de résultat spécifiques, tels que des valeurs de précision ou de perte. Les métriques de synthèse sont les valeurs que vous ajoutez au journal d’un run avec `wandb.Run.log()`. Après avoir alimenté le journal d’un run, vous pouvez trouver les noms de vos métriques de synthèse dans la W\&B App, dans la section **Summary** de la page **Aperçu** d’un run.
```python theme={null}
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="SummaryMetric('accuracy') > 0.9"
)
```
```python theme={null}
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="Metric('state') in ['finished'] and SummaryMetric('train/train_loss') < 0.5"
)
```
### Filtres de tags
Filtrez un ensemble de runs par tag pour n’afficher que les runs auxquels vous avez attribué un tag particulier. Les tags sont des valeurs que vous ajoutez à un run (par programmation ou avec la W\&B App).
```python theme={null}
runset = wr.Runset(
entity="[ENTITY]",
project="[PROJECT]",
filters="Tags('training') == 'training'"
)
```
## Ajouter des blocs de code
Ajoutez des blocs de code pour partager la configuration, des exemples ou des extraits avec vos résultats. Vous pouvez les ajouter de manière interactive depuis l’interface de l’application ou de manière programmatique avec le SDK W\&B.
Tapez une barre oblique (`/`) dans le rapport pour afficher un menu déroulant. Dans ce menu, choisissez **Code**.
Sélectionnez le nom du langage de programmation dans le bloc de code pour ouvrir un menu déroulant. Dans ce menu, sélectionnez la syntaxe de votre langage de programmation. Vous pouvez choisir parmi JavaScript, Python, CSS, JSON, HTML, Markdown et YAML.
Utilisez la classe `wr.CodeBlock` pour créer un bloc de code de manière programmatique. Indiquez le nom du langage et le code que vous souhaitez afficher dans les paramètres `language` et `code`, respectivement.
L’exemple suivant montre une liste dans un fichier YAML :
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.CodeBlock(
code=["this:", "- is", "- a", "cool:", "- yaml", "- file"], language="yaml"
)
]
report.save()
```
Cela affiche un bloc de code semblable à :
```yaml theme={null}
this:
- is
- a
cool:
- yaml
- file
```
L’exemple suivant montre un bloc de code Python :
```python theme={null}
report = wr.Report(project="report-editing")
report.blocks = [wr.CodeBlock(code=["Hello, World!"], language="python")]
report.save()
```
Cela affiche un bloc de code semblable à :
```md theme={null}
Hello, World!
```
## Ajouter du Markdown
Ajoutez du Markdown pour mettre en forme le texte narratif, les titres et l’emphase en ligne dans votre rapport. Vous pouvez ajouter du Markdown de manière interactive avec l’interface de l’application ou avec le SDK W\&B.
Saisissez une barre oblique (`/`) dans le rapport pour afficher un menu déroulant. Dans ce menu, choisissez **Markdown**.
Utilisez la classe `wr.MarkdownBlock` pour créer un bloc Markdown par code. Fournissez une chaîne au paramètre `text` :
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.MarkdownBlock(text="Markdown cell with *italics* and **bold** and $e=mc^2$")
]
```
Le rendu obtenu ressemble à ceci :
## Ajouter des éléments HTML
Ajoutez à votre rapport des éléments HTML tels que des titres et des listes pour le structurer, de manière interactive avec l’interface de l’application ou le SDK W\&B.
Saisissez une barre oblique (`/`) dans le rapport pour afficher un menu déroulant. Dans ce menu, sélectionnez un type de bloc de texte. Par exemple, pour créer un bloc de titre H2, sélectionnez l’option `Heading 2`.
Attribuez une liste d’un ou plusieurs éléments HTML à l’attribut `blocks` du rapport. L’exemple suivant montre comment créer un H1, un H2 et une liste non ordonnée :
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.H1(text="How Programmatic Reports work"),
wr.H2(text="Heading 2"),
wr.UnorderedList(items=["Bullet 1", "Bullet 2"]),
]
report.save()
```
Le rendu des éléments HTML est le suivant :
## Intégrer des liens de médias enrichis
Intégrez des médias enrichis tels que des tweets, des vidéos et de l’audio pour enrichir votre rapport avec un contexte externe. Vous pouvez intégrer des médias enrichis dans le rapport à l’aide de l’interface de l’application ou du SDK W\&B.
Copiez-collez des URL dans les rapports pour y intégrer des médias enrichis. Les animations suivantes montrent comment copier-coller des URL depuis Twitter, YouTube et SoundCloud.
### Twitter
Copiez-collez l’URL d’un Tweet dans un rapport pour afficher le Tweet dans le rapport.
### YouTube
Copiez-collez l’URL d’une vidéo YouTube pour intégrer une vidéo dans le rapport.
### SoundCloud
Copiez-collez un lien SoundCloud pour intégrer un fichier audio dans un rapport.
Passez une liste d’un ou plusieurs objets médias intégrés à l’attribut `blocks` du rapport. L’exemple suivant montre comment intégrer des médias vidéo et Twitter dans un rapport :
```python theme={null}
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.Video(url="https://www.youtube.com/embed/6riDJMI-Y8U"),
wr.Twitter(
embed_html='\n'
),
]
report.save()
```
## Dupliquer des grilles de panneaux
Dupliquez une grille de panneaux pour réutiliser sa mise en page dans le même rapport ou dans un autre rapport. Sélectionnez une grille de panneaux et la copier-coller pour la dupliquer dans le même rapport, ou la coller dans un autre rapport.
Sélectionnez toute une section de grille de panneaux à l’aide de la poignée de déplacement située dans le coin supérieur droit. Cliquez et faites glisser pour sélectionner une zone dans un rapport, comme des grilles de panneaux, du texte ou des titres.
## Supprimer des grilles de panneaux
Supprimez une grille de panneaux lorsque vous n’avez plus besoin de sa mise en page ou de son contenu dans le rapport. Sélectionnez une grille de panneaux, puis appuyez sur `delete` sur votre clavier pour la supprimer.
Repliez les en-têtes dans un rapport pour masquer le contenu d’un bloc de texte. Lorsque le rapport se charge, seul le contenu des en-têtes dépliés s’affiche. Replier les en-têtes dans les rapports aide à organiser votre contenu et évite de charger plus de données que nécessaire. L’animation suivante illustre la procédure.
## Visualiser les relations sur plusieurs dimensions
Lorsque vous souhaitez faire ressortir les relations entre trois variables ou plus dans un même graphique, un graphique 2D standard peut être limitant. Pour comparer plus de variables qu’un graphique 2D ne peut en afficher, vous pouvez utiliser un dégradé de couleurs comme dimension supplémentaire. Utiliser un dégradé de couleurs pour représenter l’une des variables peut faciliter l’interprétation des tendances.
1. Choisissez une variable à représenter à l’aide d’un dégradé de couleurs, comme les scores de pénalité ou les taux d’apprentissage. Cela permet de mieux comprendre comment la pénalité (couleur) interagit avec la récompense ou les effets secondaires (axe des y) au fil de l’entraînement (axe des x).
2. Mettez en évidence les principales tendances. Survolez un groupe spécifique de runs pour les mettre en évidence dans la visualisation.