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

# Coût d’un modèle personnalisé

> Définissez et suivez les coûts de modèles personnalisés dans W&B Weave afin de surveiller les dépenses selon les différents fournisseurs et modèles de LLM.

<Note>
  Il s'agit d'un notebook interactif. Vous pouvez l'exécuter localement ou utiliser les liens ci-dessous :

  * [Ouvrir dans Google Colab](https://colab.research.google.com/github/wandb/docs/blob/main/weave/cookbooks/source/custom_model_cost.ipynb)
  * [Voir la source sur GitHub](https://github.com/wandb/docs/blob/main/weave/cookbooks/source/custom_model_cost.ipynb)
</Note>

<div id="set-up-a-custom-cost-model">
  ## Configurer un modèle de coût personnalisé
</div>

Ce guide vous montre comment définir dans Weave un modèle personnalisé qui indique sa propre utilisation des jetons, enregistrer un coût personnalisé par jeton pour ce modèle, puis récupérer les appels avec les informations de coût associées. Utilisez cette approche lorsque vous travaillez avec un modèle qui n’est pas couvert par les données de coût intégrées de Weave et que vous souhaitez suivre les dépenses en parallèle de vos traces.

Weave calcule les coûts en fonction du nombre de jetons consommés et du modèle utilisé.
Weave récupère cette utilisation et ce modèle dans la sortie, puis les associe à l'appel.

Configurez un modèle personnalisé simple qui calcule lui-même son utilisation des jetons et l'enregistre dans Weave.

<div id="set-up-the-environment">
  ### Configurer l'environnement
</div>

Installez et importez tous les packages nécessaires.
Définissez `WANDB_API_KEY` dans votre environnement afin de pouvoir vous connecter avec `wandb.login()` (cette clé doit être fournie à Colab en tant que secret).

Définissez dans `name_of_wandb_project` le projet W\&B dans lequel vous voulez journaliser ces données.

<Note>
  `name_of_wandb_project` peut également être au format `{team_name}/{project_name}` pour indiquer l'équipe dans laquelle journaliser les traces.
</Note>

Récupérez ensuite un client Weave en appelant `weave.init()`.

```python lines theme={null}
%pip install wandb weave datetime --quiet
python
import os

import wandb
from google.colab import userdata

import weave

os.environ["WANDB_API_KEY"] = userdata.get("WANDB_API_KEY")
name_of_wandb_project = "custom-cost-model"

wandb.login()
python
weave_client = weave.init(name_of_wandb_project)
```

<div id="set-up-a-model-with-weave">
  ### Configurer un modèle avec Weave
</div>

Ensuite, définissez une sous-classe Weave `Model` qui effectue son propre comptage des jetons. Le fait de renvoyer les compteurs d’utilisation et le nom du modèle dans le dictionnaire de sortie permet ensuite à Weave d’associer l’appel au coût personnalisé défini dans la section suivante.

```python lines theme={null}
from weave import Model

class YourModel(Model):
    attribute1: str
    attribute2: int

    def simple_token_count(self, text: str) -> int:
        return len(text) // 3

    # Ceci est un op personnalisé que nous définissons
    # Il prend une chaîne en entrée et renvoie un dictionnaire avec les comptages d'utilisation, le nom du modèle et la sortie
    @weave.op()
    def custom_model_generate(self, input_data: str) -> dict:
        # La logique du modèle se trouve ici
        # C'est ici que vous placeriez une fonction de génération personnalisée
        prediction = self.attribute1 + " " + input_data

        # Comptages d'utilisation
        prompt_tokens = self.simple_token_count(input_data)
        completion_tokens = self.simple_token_count(prediction)

        # Nous renvoyons un dictionnaire avec les comptages d'utilisation, le nom du modèle et la sortie
        # Weave associera automatiquement ceci à la trace
        # Cet objet {usage, model, output} correspond à la sortie d'un appel OpenAI
        return {
            "usage": {
                "input_tokens": prompt_tokens,
                "output_tokens": completion_tokens,
                "total_tokens": prompt_tokens + completion_tokens,
            },
            "model": "your_model_name",
            "output": prediction,
        }

    # Dans notre fonction predict, nous appelons notre fonction de génération personnalisée et renvoyons la sortie.
    @weave.op()
    def predict(self, input_data: str) -> dict:
        # C'est ici que vous effectueriez tout post-traitement des données
        outputs = self.custom_model_generate(input_data)
        return outputs["output"]
```

<div id="add-a-custom-cost">
  ### Ajouter un coût personnalisé
</div>

Ajoutez un coût personnalisé. Une fois que vous avez ajouté un coût personnalisé et que vos appels comportent des données d’utilisation, vous pouvez récupérer les appels avec `include_cost` et consulter les coûts dans `summary.weave.costs`.

```python lines theme={null}
model = YourModel(attribute1="Hello", attribute2=1)
model.predict("world")

# Nous ajoutons ensuite un coût personnalisé à notre projet
weave_client.add_cost(
    llm_id="your_model_name", prompt_token_cost=0.1, completion_token_cost=0.2
)

# Nous pouvons ensuite interroger les appels, et avec include_costs=True
# nous recevons les coûts associés aux appels en retour
calls = weave_client.get_calls(filter={"trace_roots_only": True}, include_costs=True)

list(calls)
```

Vous disposez désormais d’un modèle personnalisé qui enregistre sa propre utilisation des jetons, d’un coût personnalisé enregistré pour le `llm_id` de ce modèle, ainsi que d’un moyen de récupérer des appels avec des données de coût par appel associées dans `summary.weave.costs`.