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

# Définir le nom d’affichage d’un appel

> Définir ou redéfinir le nom d’affichage d’un appel dans le traçage W&B Weave

Les ops produisent des appels. Un op est une fonction ou une méthode que vous décorez avec `@weave.op`. Par défaut, le nom de l’op correspond au nom de la fonction, et les appels associés portent le même nom d’affichage.

Un nom d’affichage personnalisé permet d’identifier plus facilement les appels dans l’interface Weights & Biases. Il vous permet de distinguer les appels d’un même op, de faire apparaître un contexte dynamique comme des valeurs d’entrée ou des horodatages, ou encore d’harmoniser les noms des appels avec les conventions de votre équipe.

Il existe plusieurs façons de redéfinir le nom d’affichage de tous les appels d’un op donné. Choisissez l’approche adaptée à la portée souhaitée : un appel unique, tous les appels d’un op ou l’op lui-même.

<Tabs>
  <Tab title="Python">
    1. Modifiez le nom d’affichage au moment où vous appelez l’op. L’exemple suivant utilise le dictionnaire `__weave` pour définir le nom d’affichage de l’appel, qui prévaut sur celui de l’op :

    ```python lines theme={"system"}
    result = my_function("World", __weave={"display_name": "My Custom Display Name"})
    ```

    2. Modifiez le nom d’affichage appel par appel. L’exemple suivant utilise la méthode [`Op.call`](/fr/products/wandb/weave/reference/python-sdk/trace/op#function-call) pour renvoyer un objet `call`. Vous pouvez ensuite utiliser cet objet pour définir le nom d’affichage avec [`call.set_display_name`](/fr/products/wandb/weave/reference/python-sdk/trace/weave_client#method-set_display_name) :

    ```python lines theme={"system"}
    result, call = my_function.call("World")
    call.set_display_name("My Custom Display Name")
    ```

    3. Modifiez le nom d’affichage de tous les appels d’un op donné. L’exemple suivant définit le nouveau nom d’affichage directement dans le décorateur de fonction `@weave.op`, afin qu’il s’applique à tous les appels de l’op :

    ```python lines theme={"system"}
    @weave.op(call_display_name="My Custom Display Name")
    def my_function(name: str):
        return f"Hello, {name}!"
    ```

    `call_display_name` peut également être une fonction qui prend en entrée un objet `call` et renvoie une chaîne de caractères. Weave transmet automatiquement l’objet `call` lors de l’exécution de la fonction. Vous pouvez vous en servir pour générer dynamiquement des noms à partir du nom de la fonction, des entrées de l’appel, de certains champs, etc. C’est utile lorsque vous souhaitez que le nom de chaque appel reflète le contexte d’exécution.

    Un cas d’usage courant consiste à ajouter un horodatage au nom de la fonction.

    ```python lines theme={"system"}
    from datetime import datetime

    @weave.op(call_display_name=lambda call: f"{call.func_name}__{datetime.now()}")
    def func():
        return ...
    ```

    Vous pouvez également journaliser des métadonnées personnalisées à l’aide de `.attributes`.

    ```python lines theme={"system"}
    def custom_attribute_name(call):
        model = call.attributes["model"]
        revision = call.attributes["revision"]
        now = call.attributes["date"]

        return f"{model}__{revision}__{now}"

    @weave.op(call_display_name=custom_attribute_name)
    def func():
        return ...

    with weave.attributes(
        {
            "model": "finetuned-llama-3.1-8b",
            "revision": "v0.1.2",
            "date": "2024-08-01",
        }
    ):
        func()  # le nom d'affichage sera "finetuned-llama-3.1-8b__v0.1.2__2024-08-01"

        with weave.attributes(
            {
                "model": "finetuned-gpt-4o",
                "revision": "v0.1.3",
                "date": "2024-08-02",
            }
        ):
            func()  # le nom d'affichage sera "finetuned-gpt-4o__v0.1.3__2024-08-02"
    ```

    4. Modifiez le nom d’affichage de l’op lui-même. Les appels associés à un op portent le même nom d’affichage : renommer l’op est donc le moyen le plus direct de renommer tous les appels qu’il produit. Si vous redéfinissez le nom de l’op lui-même, le nom d’affichage de l’appel change également. Vous pouvez procéder de deux manières :

       * Définissez la propriété `name` de l’op avant de journaliser des appels :
         ```python lines theme={"system"}
         my_function.name = "My Custom Op Name"
         ```

       * Définissez l’option `name` dans le décorateur de l’op :
         ```python lines theme={"system"}
         @weave.op(name="My Custom Op Name")
         ```
  </Tab>

  <Tab title="TypeScript">
    Pour redéfinir le nom par défaut d’un appel, utilisez l’option `callDisplayName` lors de l’appel à `weave.op()`.

    ```typescript twoslash lines {2} theme={"system"}
    // @noErrors
    const extractDinosOp = weave.op(extractDinos, {
    callDisplayName: (input: string) => `Your New Display Name`
    });
    ```
  </Tab>
</Tabs>

Si vous devez renommer un appel déjà journalisé, vous pouvez également [mettre à jour le nom d’affichage d’un appel](/fr/products/wandb/weave/guides/tracking/update-call) après son exécution.