Programma Lezione 227 di 250 · Progetto: un AI gateway di produzione
Progetto: un AI gateway di produzione

Contabilità di token e costi + cache

Il tuo gateway ora instrada le richieste, ma ogni chiamata a un vero modello costa soldi e tempo. Le due leve più grandi che controlli sono la contabilità dei costi (così nessuno resta scioccato dalla bolletta) e la cache (così smetti di pagare due volte per la stessa risposta). Questa lezione le costruisce entrambe, e la cache ha un tocco che la rende davvero utile: becca le domande quasi doppioni, non solo le ripetizioni byte per byte.

Comincia dal contatore. Una stima dei token economica e deterministica è "circa un token ogni quattro caratteri", e il costo è semplicemente i token per una tariffa a token:

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

Ora la cache. Una cache ingenua usa come chiave la stringa esatta, quindi "Reset my password" e "reset my password" sembrano domande diverse e pagano entrambe il prezzo pieno. Costruirai una classe Cache a due livelli:

  • Livello hash: normalizza il testo (minuscolo, spazi compressi), fanne l'hash, e salva la risposta sotto quella chiave. Una ripetizione esatta (dopo la normalizzazione) è un successo immediato.
  • Livello semantico: quando l'hash dà buco, confronta l'embedding della query con ogni embedding salvato con la similarità del coseno. Se il più vicino raggiunge almeno una soglia (per esempio 0.9), conta anche quello come successo. È così che "password reset steps" trova in cache "how do I reset my password".

Sia put sia get ricevono il testo e un embedding già calcolato (un piccolo vettore). get restituisce una tupla (status, value) dove status è "hit" o "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à del coseno è il prodotto scalare diviso per il prodotto delle norme; proteggiti dal vettore zero così non dividi mai per zero. In un vero gateway quegli embedding vengono dal modello, ma qui li passi direttamente così la logica si può testare offline. Premi Run per dare un prezzo a un prompt, trovare esattamente in cache, ritrovare su una parafrasi, e guardare una query che non c'entra dare buco.

Tocca a te

Scrivi estimate_cost(text, rate) che restituisce una stima dei token (~1 token ogni 4 caratteri) per la tariffa a token rate. Poi costruisci una classe Cache a due livelli con put(text, embedding, answer) e get(text, embedding) che restituisce una tupla (status, value). get è un "hit" con una corrispondenza esatta del testo (normalizzato: minuscolo, spazi compressi) tramite un hash, OPPURE quando l'embedding salvato più vicino ha una similarità del coseno >= la soglia (un successo semantico); altrimenti ("miss", None). Una query distinta con bassa similarità deve dare buco.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.