> ## 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.

> Modifiez un rapport de manière interactive dans l’interface de l’application ou par programmation avec le SDK W&B.

# Modifier un rapport

<Note>
  L’API W\&B Report and Workspace est en préversion publique.
</Note>

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 aborde l’ajout de graphiques, d’ensembles de runs, de blocs de code, de contenu markdown, d’éléments HTML et de médias enrichis. Elle traite également du filtrage et du regroupement des ensembles de runs, de l’organisation de la mise en page du rapport et de la visualisation des relations multidimensionnelles.

Le corps d’un rapport se compose de *blocs*. Les blocs contiennent du texte, des images, des visualisations intégrées, des graphiques issus d’expériences et de runs, ainsi que des grilles de panneaux.

Les *grilles de panneaux* sont un type de bloc particulier qui contient des panneaux et des *ensembles de runs*. Un ensemble de runs est une collection de runs journalisés dans un projet W\&B. Les panneaux permettent de visualiser les données des ensembles de runs.

<Tip>
  Pour faire réviser par [ARIA](/fr/products/aria) un rapport dont vous êtes propriétaire, ouvrez le rapport, cliquez sur **Edit with ARIA**, puis décrivez les modifications souhaitées. ARIA enregistre ses modifications directement dans le rapport existant.
</Tip>

<Note>
  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 personnalisée et enregistrée.
</Note>

<Note>
  Pour modifier un rapport par programmation, vous devez installer l’API W\&B Report and Workspace (`wandb-workspaces`) ainsi que le SDK Python W\&B :

  ```bash theme={"system"}
  pip install wandb wandb-workspaces
  ```
</Note>

<h2 id="add-plots">
  Ajouter des graphiques
</h2>

Les graphiques vous permettent de visualiser les données des runs dans un rapport. Chaque grille de panneaux comporte des ensembles de runs et des panneaux. Les ensembles de runs de la grille de panneaux déterminent 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 extraient leurs données d’un autre ensemble de runs.

<Tabs>
  <Tab title="Interface de l’application">
    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, notamment un graphique en courbes, un nuage de points ou un graphique en coordonnées parallèles.

    <Frame>
      <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/demo_report_add_panel_grid.gif?s=5466d6aed179dfea653ffc185ce9029a" alt="Ajouter des graphiques à un rapport" width="1652" height="1498" data-path="products/wandb/_media/demo_report_add_panel_grid.gif" />
    </Frame>
  </Tab>

  <Tab title="API Report and Workspace">
    Ajoutez des graphiques à un rapport par programmation avec le SDK. Transmettez une liste d’un ou plusieurs objets graphiques au paramètre `panels` de la classe `PanelGrid` de l’API publique. Créez chaque objet graphique à l’aide de la classe Python correspondante.

    Les exemples suivants montrent comment créer un graphique en courbes et un nuage de points.

    ```python theme={"system"}
    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 en savoir plus sur les graphiques que vous pouvez ajouter à un rapport par programmation, consultez `wr.panels`.
  </Tab>
</Tabs>

<h2 id="add-run-sets">
  Ajouter des ensembles de runs
</h2>

Ajoutez des ensembles de runs à partir de projets de manière interactive avec l’interface de l’application ou le SDK W\&B.

<Tabs>
  <Tab title="Interface de l’application">
    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éé.

    Lorsque vous importez un panneau dans un rapport, celui-ci hérite des noms de runs du projet. Dans le rapport, vous pouvez, si vous le souhaitez, [renommer un run](/fr/products/wandb/runs#rename-a-run) pour apporter plus 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é affiche lui aussi 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, trouvez le run à renommer. Survolez le nom du run et cliquez sur le menu **action (<Icon icon="ellipsis-vertical" iconType="solid" />)**. 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, en conservant le nom existant ailleurs. Cette option ne permet pas de générer un nouveau nom aléatoire.

    3. Cliquez sur **Publish report**.
  </Tab>

  <Tab title="API Report and Workspace">
    Ajoutez des ensembles de runs à partir de 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 dans le paramètre project, et l’entity propriétaire du projet dans 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 l’objet `wr.PanelGrid()` dans une liste.
    4. Mettez à jour l’attribut blocks de l’instance du rapport avec la liste des instances de grilles de panneaux.

    Dans l’exemple suivant, remplacez `[PROJECT-NAME]` par le nom de votre projet W\&B et `[ENTITY-NAME]` par le nom de votre entity W\&B :

    ```python theme={"system"}
    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 également ajouter des ensembles de runs et des panneaux en un seul appel au SDK :

    ```python theme={"system"}
    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()
    ```
  </Tab>
</Tabs>

<h2 id="freeze-a-run-set">
  Figer un ensemble de runs
</h2>

Un rapport met automatiquement à jour ses ensembles de runs afin d’afficher les données les plus récentes du projet. Figez un ensemble de runs pour conserver son état à un moment donné dans un rapport, de sorte que les runs ultérieurs ne modifient pas ce qu’affiche le rapport.

Pour figer un ensemble de runs lorsque vous consultez un rapport, cliquez sur l’icône en forme de flocon de neige dans sa grille de panneaux, à côté du bouton **Filter**.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/freeze_runset.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=a01866e786fb0ef6244603671bba3a36" alt="Bouton pour figer un ensemble de runs" width="1799" height="552" data-path="products/wandb/_media/freeze_runset.png" />
</Frame>

<h2 id="group-a-run-set-programmatically">
  Regrouper un run set par programmation
</h2>

Regroupez les runs d’un run set par programmation avec l’[API Workspace and Reports](/fr/products/wandb/ref/wandb_workspaces/reports). Le regroupement rassemble les runs apparentés dans les panneaux, ce qui facilite la comparaison des configurations et des résultats.

Vous pouvez regrouper les runs d’un run set par valeurs de configuration, par métadonnées de run ou par métriques de synthèse. Le tableau suivant répertorie les méthodes de regroupement disponibles, ainsi que les clés utilisables pour chacune d’elles :

| Méthode de regroupement | Description | Clés disponibles |
| - | - | - |
| Valeurs de configuration | Regrouper les runs par valeurs de configuration | Valeurs définies dans le paramètre config de `wandb.init(config=)` |
| Métadonnées de run | Regrouper les runs par métadonnées de run | `State`, `Name`, `JobType` |
| Métriques de synthèse | Regrouper les runs par métriques de synthèse | Valeurs que vous journalisez dans un run avec `wandb.Run.log()` |

<h3 id="group-runs-by-config-values">
  Regrouper les runs par valeurs de configuration
</h3>

Regroupez les runs par valeurs de configuration pour comparer des runs dont les configurations sont similaires. Les valeurs de configuration sont les paramètres que vous définissez 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 les runs d’un rapport selon la valeur de configuration `group`. Remplacez `[ENTITY]` et `[PROJECT]` par les noms de votre entity et de votre projet W\&B.

```python theme={"system"}
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 votre notebook, vous pouvez ensuite regrouper les runs selon la valeur de `config.group` :

```python theme={"system"}
runset = wr.Runset(
  project=project,
  entity=entity,
  groupby=["config.group"]  # Regrouper selon la valeur de configuration « group »
)
```

Dans la continuité de l’exemple précédent, vous pouvez créer un rapport contenant le run set groupé :

```python theme={"system"}
report = wr.Report(
  entity=entity,
  project=project,
  title="Grouped Runs Example",
)

report.blocks = [
  wr.PanelGrid(
      runsets=[runset],
          )
      ]

report.save()
```

<h3 id="group-runs-by-run-metadata">
  Regrouper les runs par métadonnées de run
</h3>

Regroupez les runs par métadonnées pour les organiser selon leurs propriétés intrinsèques plutôt que selon des valeurs journalisées. Vous pouvez les regrouper par nom (`Name`), par état (`State`) ou par type de job (`JobType`).

Pour reprendre l’exemple précédent, vous pouvez regrouper vos runs par nom à l’aide de l’extrait de code suivant :

```python theme={"system"}
runset = wr.Runset(
  project=project,
  entity=entity,
  groupby=["Name"]  # Regrouper par nom de run
)
```

<Note>
  Le nom du run est celui que vous indiquez dans le paramètre `wandb.init(name=)`. Si vous n'indiquez pas de nom, W\&B génère un nom aléatoire pour le run.

  Vous trouverez le nom du run sur la page **Aperçu** du run dans l'application W\&B, ou par programmation avec `Api.runs().run.name`.
</Note>

<h3 id="group-runs-by-summary-metrics">
  Grouper les runs par métriques de synthèse
</h3>

Les exemples suivants montrent comment grouper des runs par métriques de synthèse. Les métriques de synthèse sont les valeurs que vous journalisez dans un run avec `wandb.Run.log()`. Une fois un run journalisé, les noms de vos métriques de synthèse figurent dans l’App W\&B, dans la section **Summary** de la page **Overview** du run.

Pour grouper des runs par métriques de synthèse, utilisez la syntaxe `summary.[KEY]`, où `[KEY]` est le nom de la métrique de synthèse selon laquelle vous souhaitez effectuer le groupement.

Par exemple, supposons que vous journalisiez une métrique de synthèse nommée `acc`. Remplacez `[ENTITY]` et `[PROJECT]` par les noms de votre entity et de votre projet W\&B :

```python theme={"system"}
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 selon la métrique de synthèse `summary.acc` :

```python theme={"system"}
runset = wr.Runset(
  project=project,
  entity=entity,
  groupby=["summary.acc"]  # Regrouper par valeurs de synthèse
)
```

<h2 id="filter-a-run-set-programmatically">
  Filtrer un ensemble de runs par programmation
</h2>

Filtrez des ensembles de runs par programmation et ajoutez-les à un rapport avec l’[API Workspace and Reports](/fr/products/wandb/ref/wandb_workspaces/reports). Le filtrage permet de limiter un ensemble de runs aux seuls runs que vous souhaitez afficher, en fonction des valeurs de configuration, des métriques, des tags ou des propriétés des runs.

La syntaxe générale d’une expression de filtre est la suivante :

```text theme={"system"}
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 à laquelle comparer. `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 :

| Filtre | Description | Clés disponibles |
| - | - | - |
| `Config('[KEY]')` | Filtrer par valeurs de configuration | Valeurs spécifiées dans le paramètre `config` de `wandb.init(config=)`. |
| `SummaryMetric('[KEY]')` | Filtrer par métriques de synthèse | Valeurs que vous journalisez dans un run avec `wandb.Run.log()`. |
| `Tags('[KEY]')` | Filtrer par tags | Valeurs de tag que vous ajoutez à votre run (par programmation ou avec la W\&B App). |
| `Metric('[KEY]')` | Filtrer par propriétés du run | `tags`, `state`, `displayName`, `jobType` |

Après avoir défini vos filtres, vous pouvez créer un rapport et transmettre les ensembles de runs filtrés à `wr.PanelGrid(runsets=)`. Consultez les onglets **Report and Workspace API** de cette page pour savoir comment ajouter par programmation différents éléments à un rapport.

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.

<h3 id="config-filters">
  Filtres de configuration
</h3>

Filtrez un run set selon une ou plusieurs valeurs de configuration. Les valeurs de configuration sont les paramètres que vous définissez 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 d’un rapport en fonction de la valeur de configuration `learning_rate`.

```python theme={"system"}
import wandb

config = {
    "learning_rate": 0.01,
    "batch_size": 32,
}

with wandb.init(project="[PROJECT]", entity="[ENTITY]", config=config) as run:
    # Placez votre code d’entraînement ici
    pass
```

Dans votre script Python ou votre notebook, vous pouvez ensuite filtrer par programmation les runs dont le taux d’apprentissage est supérieur à `0.01`.

```python theme={"system"}
import wandb_workspaces.reports.v2 as wr

runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="Config('learning_rate') > 0.01"
)
```

Vous pouvez également filtrer selon plusieurs valeurs de configuration à l’aide de l’opérateur `and` :

```python theme={"system"}
runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="Config('learning_rate') > 0.01 and Config('batch_size') == 32"
)
```

Dans la continuité de l’exemple précédent, vous pouvez créer un rapport contenant le run set filtré de la manière suivante :

```python theme={"system"}
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()
```

<h3 id="metric-filters">
  Filtres de métriques
</h3>

Filtrez les ensembles de runs en fonction du tag d'un run (`tags`), de son état (`state`), de son nom (`displayName`) ou du type de job (`jobType`).

<Note>
  Les filtres `Metric` utilisent une syntaxe différente de celle des autres filtres. Vous devez transmettre les valeurs sous forme de liste.

  ```text theme={"system"}
  Metric('[KEY]') operation [VALUE]
  ```
</Note>

Prenons par exemple l'extrait de code Python suivant, qui crée trois runs et attribue un nom à chacun d'eux :

```python theme={"system"}
import wandb

with wandb.init(project="[PROJECT]", entity="[ENTITY]") as run:
    for i in range(3):
        run.name = f"run{i+1}"
        # Insérez votre code d’entraînement ici
        pass
```

Lorsque vous créez votre rapport, vous pouvez filtrer les runs selon leur nom d’affichage. Par exemple, pour filtrer les runs nommés `run1`, `run2` et `run3`, utilisez le code suivant :

```python theme={"system"}
runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="Metric('displayName') in ['run1', 'run2', 'run3']"
)
```

<Note>
  Vous pouvez trouver le nom du run sur la page **Overview** d’un run dans l’application W\&B, ou par programmation avec `Api.runs().run.name`.
</Note>

Les exemples suivants montrent comment filtrer un ensemble de runs selon l'état du run (`finished`, `crashed` ou `running`) :

```python theme={"system"}
runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="Metric('state') in ['finished']"
)
```

```python theme={"system"}
runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="Metric('state') not in ['crashed']"
)
```

<h3 id="summarymetric-filters">
  Filtres SummaryMetric
</h3>

Filtrez un run set selon les métriques de synthèse pour vous concentrer sur les runs qui atteignent certains seuils de résultat, par exemple des valeurs de précision ou de perte. Les métriques de synthèse sont les valeurs que vous journalisez dans un run avec `wandb.Run.log()`. Une fois un run journalisé, les noms de vos métriques de synthèse figurent dans l’application W\&B, dans la section **Summary** de la page **Overview** du run.

```python theme={"system"}
runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="SummaryMetric('accuracy') > 0.9"
)
```

```python theme={"system"}
runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="Metric('state') in ['finished'] and SummaryMetric('train/train_loss') < 0.5"
)
```

<h3 id="tags-filters">
  Filtres par tags
</h3>

Filtrez un run set par tags pour n'afficher que les runs auxquels vous avez attribué un tag donné. Les tags sont des valeurs que vous ajoutez à un run (par programmation ou via l'application W\&B).

```python theme={"system"}
runset = wr.Runset(
  entity="[ENTITY]",
  project="[PROJECT]",
  filters="Tags('training') == 'training'"
)
```

<h2 id="add-code-blocks">
  Ajouter des blocs de code
</h2>

Ajoutez des blocs de code pour partager une configuration, des exemples ou des extraits de code avec vos résultats. Vous pouvez les ajouter de manière interactive depuis l’interface de l’application ou par programmation avec le SDK W\&B.

<Tabs>
  <Tab title="Interface de l’application">
    Saisissez 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 avez le choix entre JavaScript, Python, CSS, JSON, HTML, Markdown et YAML.
  </Tab>

  <Tab title="API Report and Workspace">
    Utilisez la classe `wr.CodeBlock` pour créer un bloc de code par programmation. Fournissez le nom du langage et le code à afficher, respectivement via les paramètres language et code.

    L’exemple suivant présente une liste dans un fichier YAML :

    ```python theme={"system"}
    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()
    ```

    Vous obtenez un bloc de code semblable à celui-ci :

    ```yaml theme={"system"}
    this:
    - is
    - a
    cool:
    - yaml
    - file
    ```

    L’exemple suivant présente un bloc de code Python :

    ```python theme={"system"}
    report = wr.Report(project="report-editing")


    report.blocks = [wr.CodeBlock(code=["Hello, World!"], language="python")]

    report.save()
    ```

    Vous obtenez un bloc de code semblable à celui-ci :

    ```md theme={"system"}
    Hello, World!
    ```
  </Tab>
</Tabs>

<h2 id="add-markdown">
  Ajouter du markdown
</h2>

Ajoutez du markdown pour mettre en forme le texte narratif, les titres et la mise en valeur du texte dans votre rapport. Vous pouvez ajouter du markdown de manière interactive depuis l’interface de l’application ou par programmation avec le SDK W\&B.

<Tabs>
  <Tab title="Interface de l’application">
    Saisissez une barre oblique (`/`) dans le rapport pour afficher un menu déroulant. Dans ce menu, choisissez **Markdown**.
  </Tab>

  <Tab title="API Report et Workspace">
    Utilisez la classe `wr.MarkdownBlock` pour créer un bloc markdown par programmation. Transmettez une chaîne de caractères au paramètre `text` :

    ```python theme={"system"}
    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$")
    ]
    ```

    Vous obtenez ainsi un bloc markdown dont le rendu ressemble à celui-ci :

    <Frame>
      <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/markdown.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=1edfe90e8a9c76f457b0321bb627da92" alt="Rendu d’un bloc markdown" width="1000" height="178" data-path="products/wandb/_media/markdown.png" />
    </Frame>
  </Tab>
</Tabs>

<h2 id="add-html-elements">
  Ajouter des éléments HTML
</h2>

Ajoutez des éléments HTML, tels que des titres et des listes, pour structurer votre rapport. Vous pouvez les ajouter de manière interactive depuis l’interface de l’application ou par programmation avec le SDK W\&B.

<Note>
  Lorsque vous journalisez une image avec `wandb.Image`, W\&B enregistre le fichier non pas sous son nom d’origine, mais sous un nom généré qui inclut un hachage du contenu, par exemple `media/images/[key]_[step]_[hash].png`. Par conséquent, une balise `<img>` ou une image markdown qui fait référence au nom de fichier d’origine ne peut pas être résolue. Pour intégrer une image journalisée dans un rapport, journalisez d’abord l’image, puis utilisez le chemin de fichier généré comme valeur `src` de l’image.
</Note>

<Tabs>
  <Tab title="Interface de l’application">
    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`.
  </Tab>

  <Tab title="API Report and Workspace">
    Transmettez une liste d’un ou plusieurs éléments HTML à l’attribut `blocks` du rapport. L’exemple suivant montre comment créer un titre H1, un titre H2 et une liste à puces :

    ```python theme={"system"}
    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()
    ```

    Les éléments HTML obtiennent alors le rendu suivant :

    <Frame>
      <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/render_html.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=9cf8a83b2d0cf5666507843b76aa0a58" alt="Rendu des éléments HTML" width="1410" height="426" data-path="products/wandb/_media/render_html.png" />
    </Frame>
  </Tab>
</Tabs>

<h2 id="embed-rich-media-links">
  Intégrer des liens vers des médias enrichis
</h2>

Intégrez des médias enrichis, tels que des tweets, des vidéos et des fichiers audio, pour apporter un contexte externe à votre rapport. Vous pouvez intégrer des médias enrichis depuis l’interface de l’application ou avec le SDK W\&B.

<Tabs>
  <Tab title="Interface de l’application">
    Copiez-collez des URL dans vos rapports pour y intégrer des médias enrichis. Les animations suivantes montrent comment copier-coller des URL depuis Twitter, YouTube et SoundCloud.

    <h3 id="twitter">
      Twitter
    </h3>

    Copiez-collez l’URL d’un tweet dans un rapport pour l’y afficher.

    <Frame>
      <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/twitter.gif?s=c0ddfb25d9943403668c5481b0402729" alt="Intégration de contenu Twitter" width="810" height="760" data-path="products/wandb/_media/twitter.gif" />
    </Frame>

    <h3 id="youtube">
      YouTube
    </h3>

    Copiez-collez l’URL d’une vidéo YouTube pour l’intégrer dans le rapport.

    <Frame>
      <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/youtube.gif?s=a0e2b8230c21f7017dd2c26527ec01c6" alt="Intégration de vidéos YouTube" width="1434" height="780" data-path="products/wandb/_media/youtube.gif" />
    </Frame>

    <h3 id="soundcloud">
      SoundCloud
    </h3>

    Copiez-collez un lien SoundCloud pour intégrer un fichier audio dans un rapport.

    <Frame>
      <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/soundcloud.gif?s=51299fea079487391a1ac3c850524796" alt="Intégration d’audio SoundCloud" width="1018" height="684" data-path="products/wandb/_media/soundcloud.gif" />
    </Frame>
  </Tab>

  <Tab title="API Report et Workspace">
    Transmettez une liste d’un ou plusieurs objets de médias intégrés à l’attribut `blocks` du rapport. L’exemple suivant montre comment intégrer une vidéo et un contenu Twitter dans un rapport :

    ```python theme={"system"}
    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='<blockquote class="twitter-tweet"><p lang="en" dir="ltr">The voice of an angel, truly. <a href="https://twitter.com/hashtag/MassEffect?src=hash&amp;ref_src=twsrc%5Etfw">#MassEffect</a> <a href="https://t.co/nMev97Uw7F">pic.twitter.com/nMev97Uw7F</a></p>&mdash; Mass Effect (@masseffect) <a href="https://twitter.com/masseffect/status/1428748886655569924?ref_src=twsrc%5Etfw">August 20, 2021</a></blockquote>\n'
        ),
    ]
    report.save()
    ```
  </Tab>
</Tabs>

<h2 id="duplicate-panel-grids">
  Dupliquer des grilles de panneaux
</h2>

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, puis copiez-collez-la pour la dupliquer dans le même rapport ou collez-la dans un autre rapport.

Pour mettre en surbrillance une section entière de grille de panneaux, sélectionnez la poignée de glissement dans le coin supérieur droit. Cliquez et faites glisser le pointeur pour mettre en surbrillance et sélectionner une zone d’un rapport, par exemple des grilles de panneaux, du texte ou des titres.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/demo_copy_and_paste_a_panel_grid_section.gif?s=7cd01fc6d400fd1f4609df3b67e15776" alt="Copie de grilles de panneaux" width="1684" height="1226" data-path="products/wandb/_media/demo_copy_and_paste_a_panel_grid_section.gif" />
</Frame>

<h2 id="delete-panel-grids">
  Supprimer des panel grids
</h2>

Supprimez une panel grid lorsque vous n’avez plus besoin de sa mise en page ou de son contenu dans le rapport. Pour ce faire, sélectionnez-la et appuyez sur la touche `delete` de votre clavier.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/delete_panel_grid.gif?s=f4bc3885dabab1feb9f78fc685b27d5c" alt="Suppression de panel grids" width="1425" height="670" data-path="products/wandb/_media/delete_panel_grid.gif" />
</Frame>

<h2 id="collapse-headers-to-organize-reports">
  Réduire les en-têtes pour organiser les rapports
</h2>

Réduisez les en-têtes d’un rapport pour masquer le contenu d’un bloc de texte. Au chargement du rapport, seuls les en-têtes développés affichent leur contenu. Réduire les en-têtes permet de mieux organiser le contenu de vos rapports et d’éviter de charger plus de données que nécessaire. L’animation suivante illustre la procédure.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/collapse_headers.gif?s=7301bab96b6136907b271f33a472e6b9" alt="Réduction des en-têtes dans un rapport" width="1425" height="670" data-path="products/wandb/_media/collapse_headers.gif" />
</Frame>

<h2 id="visualize-relationships-across-multiple-dimensions">
  Visualiser les relations sur plusieurs dimensions
</h2>

Lorsque vous souhaitez faire ressortir les relations entre trois variables ou plus dans un seul graphique, un graphique 2D standard peut s’avérer limité. Pour comparer plus de variables qu’un graphique 2D ne permet d’en afficher, vous pouvez utiliser un dégradé de couleur comme dimension supplémentaire. Représenter l’une des variables par un dégradé de couleur peut rendre les tendances plus faciles à interpréter.

1. Choisissez une variable à représenter par un dégradé de couleur, comme les scores de pénalité ou les taux d’apprentissage. Vous comprendrez ainsi plus clairement comment la pénalité (couleur) interagit avec la récompense ou les effets secondaires (axe Y) au fil de l’entraînement (axe X).
2. Faites ressortir les tendances clés. Survolez un groupe de runs donné pour le mettre en évidence dans la visualisation.