Programme Leçon 227 sur 250 · Projet : Production AI Gateway
Projet : Production AI Gateway

Comptabilité des jetons/coûts + Mise en cache

Ta passerelle route les requêtes maintenant, mais chaque appel à un vrai modèle coûte de l'argent et du temps. Les deux leviers principaux que tu contrôles sont cost accounting (pour que personne ne soit choqué par la facture) et caching (pour que tu arrêtes de payer deux fois pour la même réponse). Cette leçon construit les deux, et le caching a une particularité qui le rend vraiment utile : il attrape les questions quasi identiques, pas seulement les répétitions octet par octet.

Commence avec le compteur. Une estimation de jeton déterministe et bon marché est "environ un jeton pour quatre caractères", et le coût est juste les jetons multipliés par un taux par jeton :

def estimate_cost(text, rate):
    tokens = len(text) // 4
    return tokens * rate

Maintenant le cache. Un cache naïf se base sur la chaîne exacte, donc "Reset my password" et "reset my password" ressemblent à des questions différentes et les deux paient le prix total. Tu vas construire une two-tier Cache class:

  • Niveau de hash : normalise le texte (minuscules, supprimer les espaces superflus), calcule le hash et stocke la réponse sous cette clé. Une répétition exacte (après normalisation) est une réussite immédiate.
  • Niveau sémantique : quand le hash échoue, compare le embedding de la requête à chaque embedding stocké par cosine similarity. Si le plus proche est au seuil ou au-dessus (disons 0.9), cela compte aussi comme un hit. C'est ainsi que "password reset steps" touche un "how do I reset my password" mis en cache.

Les deux put et get prennent le texte and un embedding précalculé (un petit vecteur). get retourne un (status, value) tuple où status est "hit" ou "miss":

def get(self, text, embedding):
    key = self._key(text)
    if key in self.by_hash:            # tier 1: exact
        return ("hit", self.by_hash[key])
    best, best_sim = None, -1.0        # tier 2: semantic
    for vec, answer in self.entries:
        sim = cosine(embedding, vec)
        if sim > best_sim:
            best_sim, best = sim, answer
    if best is not None and best_sim >= self.threshold:
        return ("hit", best)
    return ("miss", None)

La similarité cosinus est le produit scalaire divisé par le produit des normes; protège-toi contre un vecteur nul pour ne jamais diviser par zéro. Dans une passerelle réelle, ces embeddings viennent du modèle, mais ici tu les passes directement pour que la logique soit testable hors ligne. Appuie sur Run pour tarifer un prompt, touche le cache exactement, touche-le à nouveau sur une paraphrase, et regarde une requête non liée rater.

À ton tour

Écris estimate_cost(text, rate) retournant une estimation de jetons (~1 jeton pour 4 caractères) fois le rate par jeton. Ensuite, construis une classe Cache à deux niveaux avec put(text, embedding, answer) et get(text, embedding) qui retourne un tuple (status, value). get est un "hit" sur une correspondance de texte exacte (normalisée : en minuscules, espaces supprimés) via un hash, OU quand l'embedding stocké le plus proche a une similarité cosinus >= le seuil (une correspondance sémantique) ; sinon ("miss", None). Une requête distincte avec une faible similarité doit échouer.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.