Compter le nombre de Tokens envoyés à un LLM en Go (partie 1)

Introduction

Il y a quelques semaines, j'avais une discussion avec un directeur financier d'une entreprise partenaire commerciale, concernant la mise en œuvre des capacités watsonx.ai au sein de leur propre solution. Lors de la discussion sur les coûts j'ai prononcé le mot « token » et tout d'un coup c'est la panique ?

Après avoir expliqué ce que sont les jetons, la question s'est posée ; « Comment puis-je compter les jetons que nous envoyons et recevons ? Combien ça nous coûte ? »

La réponse était assez simple. Nous sommes allés au laboratoire d'invites du studio watsonx.ai, avons fait des allers-retours avec quelques invites simples et là nous avons vu le nombre de jetons. J'ai également montré à la personne de très beaux sites Web sur lesquels nous pouvons trouver le nombre de jetons que nous envoyons à un LLM en utilisant des entrées simples.

Plus tard, je me suis dit, pourquoi ne pas créer ma propre application de compteur de jetons (et mon intention est de l'écrire en langage Go car cela fait longtemps que je n'ai pas utilisé Golang !). Eh bien, je pensais que c'était un peu plus compliqué que ça ?

Première tentative - Utilisation de Regex

Ma première pensée a été d'utiliser Regex, je pourrais obtenir des résultats plus ou moins acceptables.

J'ai configuré l'application Go suivante.

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "regexp"
    "strings"

    "github.com/sqweek/dialog"
)

// countTokens approximates the number of tokens in a text based on whitespace and punctuation.
func countTokens(text string) int {
    // A simple regex to split text into words and punctuation
    tokenizer := regexp.MustCompile(`\w+|[^\w\s]`)
    tokens := tokenizer.FindAllString(text, -1)
    return len(tokens)
}

func main() {

    // Open a file dialog box and let the user select a text file
    filePath, err := dialog.File().Filter("Text Files", "txt").Load()
    if err != nil {
        if err.Error() == "Cancelled" {
            fmt.Println("File selection was cancelled.")
            return
        }
        log.Fatalf("Error selecting file: %v", err)
    }

    // Output the selected file name
    fmt.Printf("Selected file: %s\n", filePath)

    // Specify the file to read
    //filePath := "input.txt"

    // Open the file
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Printf("Error opening file: %v\n", err)
        return
    }
    defer file.Close()

    // Read the file line by line
    var content strings.Builder
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        content.WriteString(scanner.Text())
        content.WriteString("\n")
    }

    if err := scanner.Err(); err != nil {
        fmt.Printf("Error reading file: %v\n", err)
        return
    }

    // Get the text content
    text := content.String()

    // Count the tokens
    tokenCount := countTokens(text)

    // Output the result
    fmt.Printf("The file contains approximately %d tokens.\n", tokenCount)
}

Vous comprendrez que je suis un fan des interfaces graphiques et des boîtes de dialogue, j'ai donc implémenté une boîte de dialogue pour sélectionner le fichier texte d'entrée.

Et voici le fichier texte (un texte aléatoire que j'ai trouvé ?).

The popularity of the Rust language continues to explode; yet, many critical codebases remain authored in C, and cannot be realistically rewritten by hand. Automatically translating C to Rust is thus an appealing course of action. Several works have gone down this path, handling an ever-increasing subset of C through a variety of Rust features, such as unsafe. While the prospect of automation is appealing, producing code that relies on unsafe negates the memory safety guarantees offered by Rust, and therefore the main advantages of porting existing codebases to memory-safe languages.
We instead explore a different path, and explore what it would take to translate C to safe Rust; that is, to produce code that is trivially memory safe, because it abides by Rust's type system without caveats. Our work sports several original contributions: a type-directed translation from (a subset of) C to safe Rust; a novel static analysis based on "split trees" that allows expressing C's pointer arithmetic using Rust's slices and splitting operations; an analysis that infers exactly which borrows need to be mutable; and a compilation strategy for C's struct types that is compatible with Rust's distinction between non-owned and owned allocations.
We apply our methodology to existing formally verified C codebases: the HACL* cryptographic library, and binary parsers and serializers from EverParse, and show that the subset of C we support is sufficient to translate both applications to safe Rust. Our evaluation shows that for the few places that do violate Rust's aliasing discipline, automated, surgical rewrites suffice; and that the few strategic copies we insert have a negligible performance impact. Of particular note, the application of our approach to HACL* results in a 80,000 line verified cryptographic library, written in pure Rust, that implements all modern algorithms - the first of its kind.

Après avoir exécuté mon code, j'obtiens le résultat suivant :

The file contains approximately 359 tokens.

Ça a l'air bien, mais bon… ok, mais… contre quel modèle ?? Et aussi il existe différentes manières d'implémenter Regex, donc celle-ci ne compte pas du tout ?!

Deuxième tentative : exécuter sur un modèle spécifique

Ce que j'ai compris, c'est qu'à moins que nous n'utilisions pas le « tokenizer » spécifique pour un LLM donné, la première méthode n'est pas exacte. J'ai donc commencé à chercher comment obtenir des résultats précis par rapport à un modèle tel que gpt 3.5 qui est sur le marché depuis un certain temps maintenant. Après avoir fait quelques recherches sur le net, voici l'application que j'ai imaginée.

package main

import (
 "bufio"
 "bytes"
 "fmt"
 "log"
 "os"
 "os/exec"

 "github.com/joho/godotenv"
 "github.com/sqweek/dialog"
)

func main() {


 // Open a file dialog box and let the user select a text file
 filePath, err := dialog.File().Filter("Text Files", "txt").Load()
 if err != nil {
  if err.Error() == "Cancelled" {
   fmt.Println("File selection was cancelled.")
   return
  }
  log.Fatalf("Error selecting file: %v", err)
 }

 // Output the selected file name
 fmt.Printf("Selected file: %s\n", filePath)

 // Open the file
 file, err := os.Open(filePath)
 if err != nil {
  fmt.Printf("Error opening file: %v\n", err)
  return
 }
 defer file.Close()

 // Read the file content
 var content bytes.Buffer
 scanner := bufio.NewScanner(file)
 for scanner.Scan() {
  content.WriteString(scanner.Text())
  content.WriteString("\n")
 }

 if err := scanner.Err(); err != nil {
  fmt.Printf("Error reading file: %v\n", err)
  return
 }

 // Specify the model
 model := "gpt-3.5-turbo"

 // Execute the Python script
 cmd := exec.Command("python3", "tokenizer.py", model)
 cmd.Stdin = bytes.NewReader(content.Bytes())
 output, err := cmd.Output()
 if err != nil {
  fmt.Printf("Error running tokenizer script: %v\n", err)
  return
 }

 // Print the token count
 fmt.Printf("Token count: %s", output)
}

Comme on peut le voir dans le code ci-dessus, il y a un appel à une application Python que j'ai trouvée sur un site Microsoft qui aide (car elle a été implémentée) un « tiktoken » pour déterminer le nombre de jetons pour gpt ! De plus, le nom du modèle est codé en dur.

import sys
from tiktoken import encoding_for_model

def count_tokens(model, text):
    enc = encoding_for_model(model)
    tokens = enc.encode(text)
    return len(tokens)

if __name__ == "__main__":
    # Read model name and text from stdin
    model = sys.argv[1]  # E.g., "gpt-3.5-turbo"
    text = sys.stdin.read()
    print(count_tokens(model, text))

Cela fonctionne bien. Pour le même texte donné plus tôt, j'obtiens maintenant le décompte de 366 tokens qui est précis, concernant tous les sites web que j'ai trouvés et sur lesquels j'ai réglé le modèle sur GPT 3.5.

Le truc, c'est que je veux écrire, c'est un code entièrement en « Golang »… et je veux pouvoir l'exécuter pour tous les modèles (ou presque tous) que je peux trouver sur Huggingface (comme comme ibm-granite/granite-3.1–8b-instruct) ?

Ce serait la partie 2 de cet article (WIP).

Jusqu'à présent, j'explore les dépôts suivants (super ?) Github ;

• Tokenizer : https://github.com/sugarme/tokenizer
• tokenizers : https://github.com/daulet/tokenizers
• Et enfin et surtout -> go-huggingface: https://github.com/gomlx/go-huggingface?tab=readme-ov-file

Conclusion

Merci d'avoir lu et ouvert aux commentaires.

Et jusqu'à la sortie de la 2ème application, restez connectés… ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!