Zählen der Anzahl der an ein LLM in Go gesendeten Token (Teil 2)

Einführung

Dies ist der zweite Teil der Arbeit zum Schreiben einer Go-Anwendung, um die Anzahl der Token zu bestimmen, die ein Benutzer basierend auf einem ausgewählten Text an ein LLM sendet.

Im vorherigen Artikel habe ich erwähnt, dass ich etwas erstellen möchte, das nur in Golang geschrieben ist, und unter den Github-Repositories, die ich mir angesehen habe, scheint dieses wirklich gut zu sein: go-hggingface. Der Code scheint sehr neu zu sein, funktioniert aber bei mir „irgendwie“.

Durchführung

Zuerst greift der Code auf Hugginface zu, um die Liste aller „Tokenizer“ zu erhalten, die zu einem LLM gehören, sodass der Benutzer über einen HF-Token verfügen sollte. Also habe ich mein Token wie gezeigt in eine .env-Datei eingefügt.

HF_TOKEN="your-huggingface-token"

Dann habe ich anhand des Beispiels auf der folgenden Seite (https://github.com/gomlx/go-huggingface?tab=readme-ov-file) meinen eigenen Code darum herum erstellt.

package main

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

 "github.com/gomlx/go-huggingface/hub"
 "github.com/gomlx/go-huggingface/tokenizers"

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

 "fyne.io/fyne/v2"
 "fyne.io/fyne/v2/app"
 "fyne.io/fyne/v2/container"
 "fyne.io/fyne/v2/widget"
 //"github.com/inancgumus/scree"
)

var (
 // Model IDs we use for testing.
 hfModelIDs = []string{
  "ibm-granite/granite-3.1-8b-instruct",
  "meta-llama/Llama-3.3-70B-Instruct",
  "mistralai/Mistral-7B-Instruct-v0.3",
  "google/gemma-2-2b-it",
  "sentence-transformers/all-MiniLM-L6-v2",
  "protectai/deberta-v3-base-zeroshot-v1-onnx",
  "KnightsAnalytics/distilbert-base-uncased-finetuned-sst-2-english",
  "KnightsAnalytics/distilbert-NER",
  "SamLowe/roberta-base-go_emotions-onnx",
 }
)

func runCmd(name string, arg ...string) {
 cmd := exec.Command(name, arg...)
 cmd.Stdout = os.Stdout
 cmd.Run()
}

func ClearTerminal() {
 switch runtime.GOOS {
 case "darwin":
  runCmd("clear")
 case "linux":
  runCmd("clear")
 case "windows":
  runCmd("cmd", "/c", "cls")
 default:
  runCmd("clear")
 }
}

func FileSelectionDialog() string {
 // 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.")
  }
  log.Fatalf("Error selecting file: %v", err)
 }

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

func main() {

 var filePath string

 // read the '.env' file
 err := godotenv.Load()
 if err != nil {
  log.Fatal("Error loading .env file")
 }
 // get the value of the 'HF_TOKEN' environment variable
 hfAuthToken := os.Getenv("HF_TOKEN")
 if hfAuthToken == "" {
  log.Fatal("HF_TOKEN environment variable is not set")
 }

 // to display a list of LLMs to determine the # of tokens later on regarding the given text
 var llm string = ""
 var modelID string = ""
 myApp := app.New()
 myWindow := myApp.NewWindow("Select a LLM in the list")
 items := hfModelIDs
 // Label to display the selected item
 selectedItem := widget.NewLabel("Selected LLM: None")
 // Create a list widget
 list := widget.NewList(
  func() int {
   // Return the number of items in the list
   return len(items)
  },
  func() fyne.CanvasObject {
   // Template for each list item
   return widget.NewLabel("Template")
  },
  func(id widget.ListItemID, obj fyne.CanvasObject) {
   // Update the template with the actual data
   obj.(*widget.Label).SetText(items[id])
  },
 )
 // Handle list item selection
 list.OnSelected = func(id widget.ListItemID) {
  selectedItem.SetText("Selected LLM:" + items[id])
  llm = items[id]
 }

 // Layout with the list and selected item label
 content := container.NewVBox(
  list,
  selectedItem,
 )

 // Set the content of the window
 myWindow.SetContent(content)
 myWindow.Resize(fyne.NewSize(300, 400))
 myWindow.ShowAndRun()
 ClearTerminal()
 fmt.Printf("Selected LLM: %s\n", llm)
 //////

 //List files for the selected model
 for _, modelID := range hfModelIDs {
  if modelID == llm {
   fmt.Printf("\n%s:\n", modelID)
   repo := hub.New(modelID).WithAuth(hfAuthToken)
   for fileName, err := range repo.IterFileNames() {
    if err != nil {
     panic(err)
    }
    fmt.Printf("fileName\t%s\n", fileName)
    fmt.Printf("repo\t%s\n", repo)
    fmt.Printf("modelID\t%s\n", modelID)
   }
  }
 }

 //List tokenizer classes for the selected model
 for _, modelID := range hfModelIDs {
  if modelID == llm {
   fmt.Printf("\n%s:\n", modelID)
   repo := hub.New(modelID).WithAuth(hfAuthToken)
   fmt.Printf("\trepo=%s\n", repo)
   config, err := tokenizers.GetConfig(repo)
   if err != nil {
    panic(err)
   }
   fmt.Printf("\ttokenizer_class=%s\n", config.TokenizerClass)
  }
 }

 // Models URL -> "https://huggingface.co/api/models"
 repo := hub.New(modelID).WithAuth(hfAuthToken)
 tokenizer, err := tokenizers.New(repo)
 if err != nil {
  panic(err)
 }

 // call file selection dialogbox
 filePath = FileSelectionDialog()

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

 // Put the text file content into a buffer and convert it to a string.
 buf := new(bytes.Buffer)
 buf.ReadFrom(filerc)
 sentence := buf.String()

 tokens := tokenizer.Encode(sentence)
 fmt.Println("Sentence:\n", sentence)

 fmt.Printf("Tokens:  \t%v\n", tokens)
}

Im Abschnitt „var“ für „hfModelIDs“ habe ich einige neue Referenzen hinzugefügt, wie IBMs Granite, Metas LLama und auch ein Mistral-Modell.

Der Huggingface-Token wird direkt im Go-Code beschafft und gelesen.

Ich habe ein Dialogfeld hinzugefügt, um die Liste der LLMs anzuzeigen (was ich irgendwann ändern werde), ein Dialogfeld, um den Text aus einer Datei hinzuzufügen (ich liebe solche Dinge?) und einige Codezeilen zum Löschen und Reinigen Sie den Bildschirm ?!

Der Eingabetext ist der folgende;

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.

Testen
Sobald der Code ausgeführt wird, wird ein Dialogfeld angezeigt, in dem Sie ein gewünschtes LLM auswählen können.

Wenn alles gut geht, wird im nächsten Schritt die „Tokenizer“-Datei lokal heruntergeladen (siehe Erläuterungen zum Github-Repo) und dann wird ein Dialogfenster angezeigt, in dem Sie die Textdatei mit dem Inhalt auswählen können, der hinsichtlich der Begriffe ausgewertet werden soll der Anzahl der Token.

Bisher habe ich um Zugriff auf die Modelle Meta LLama und Google „google/gemma-2–2b-it“ gebeten und warte auf die Gewährung des Zugriffs.

google/gemma-2-2b-it:
        repo=google/gemma-2-2b-it
panic: request for metadata from "https://huggingface.co/google/gemma-2-2b-it/resolve/299a8560bedf22ed1c72a8a11e7dce4a7f9f51f8/tokenizer_config.json" failed with the following message: "403 Forbidden"

Abschluss

Ich denke, ich bin auf dem richtigen Weg, um das zu erreichen, was ich mir vorgenommen habe: ein Golang-Programm, das in der Lage ist, die Anzahl der Token zu bestimmen, indem eine Benutzeranfrage an ein LLM gesendet wird.

Das einzige Ziel dieses Projekts besteht darin, das interne System hinter der Bestimmung der Anzahl von Tokens in Abfragen für eine Vielzahl von LLMs kennenzulernen und herauszufinden, wie diese berechnet werden.

Danke fürs Lesen und offen für Kommentare.

Und bis zum endgültigen Abschluss bleiben Sie dran… ?

Das obige ist der detaillierte Inhalt vonZählen der Anzahl der an ein LLM in Go gesendeten Token (Teil 2). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!