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

# Coûts de modèles personnalisés

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

<Note>
  Ceci est un notebook interactif. Vous pouvez l’exécuter en local 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>

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

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 auxquels sont jointes les informations de coût. Utilisez cette approche lorsque vous travaillez avec un modèle que les données de coût intégrées de Weave ne couvrent pas 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 extrait ces informations d’utilisation et de modèle de la sortie et les associe à l’appel.

Configurez un modèle personnalisé simple qui calcule sa propre utilisation des jetons et l’enregistre dans Weave.

<h3 id="set-up-the-environment">
  Configurer l’environnement
</h3>

Installez et importez tous les paquets nécessaires.
Définissez `WANDB_API_KEY` dans votre environnement afin de pouvoir vous connecter avec `wandb.login()` (cette valeur doit être fournie au Colab sous forme de secret).

Indiquez dans `name_of_wandb_project` le projet W\&B dans lequel vous souhaitez journaliser les données.

<Note>
  `name_of_wandb_project` peut également prendre la forme `{team_name}/{project_name}` afin de spécifier l’équipe dans laquelle journaliser les traces.
</Note>

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

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

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

Définissez ensuite une sous-classe de `Model` Weave qui effectue elle-même le décompte de ses jetons. C’est en renvoyant les compteurs d’utilisation et le nom du modèle dans le dictionnaire de sortie que Weave pourra ensuite associer l’appel au coût personnalisé défini dans la section suivante.

```python lines theme={"system"}
from weave import Model

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

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

    # Voici l’op personnalisé que nous définissons
    # Il prend une chaîne en entrée et renvoie un dict contenant les compteurs d’utilisation, le nom du modèle et la sortie
    @weave.op()
    def custom_model_generate(self, input_data: str) -> dict:
        # Placez ici la logique du modèle
        # C’est ici que se trouverait votre fonction de génération personnalisée
        prediction = self.attribute1 + " " + input_data

        # Compteurs d’utilisation
        prompt_tokens = self.simple_token_count(input_data)
        completion_tokens = self.simple_token_count(prediction)

        # Nous renvoyons un dictionnaire contenant les compteurs d’utilisation, le nom du modèle et la sortie
        # Weave l’associe automatiquement à 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 le post-traitement éventuel des données
        outputs = self.custom_model_generate(input_data)
        return outputs["output"]
```

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

Ajoutez un coût personnalisé. Une fois le coût personnalisé ajouté et dès que vos appels enregistrent une utilisation, vous pouvez récupérer les appels avec `include_cost` et consulter les coûts dans `summary.weave.costs`.

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

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

# Vous pouvez ensuite interroger les appels : avec include_costs=True,
# les coûts sont renvoyés joints aux appels
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é associé au `llm_id` de ce modèle et d'un moyen de récupérer les appels, auxquels sont jointes les données de coût par appel sous `summary.weave.costs`.