Introduction
This is the second part of the work on writing a Go application to determine the number of tokens that a user sends to a LLM based on a chosen text.
In the previous article I mentioned I want to build something written in Golang only, and among the Github repositories I looked at, this one seems to be real good: go-hggingface. The code seems to be very new but it’s “kind-of” working for me.
Implementation
First of, the code accesses Hugginface to get the list of all the “tokenizers” which go with a LLM, so the user should have a HF token. So I put my token in an .env file as shown.
HF_TOKEN="your-huggingface-token"
Then using the example provided in the following page (https://github.com/gomlx/go-huggingface?tab=readme-ov-file) I built my own code around it.
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)
}
In the “var” section for “hfModelIDs” I added some new references such as IBM’s Granite, Meta’s LLama and also a Mistral model.
The Huggingface token is directly sourced and read inside the Go code as well.
I added a dialog box to display the LLMs’ list (which I’ll change eventually), a dialog box to add the text from a file (I love that kind of stuff 😊) and some lines of code to clear and clean the screen 🧽!
The input text is the following;
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.
Test
The code once executed shows a dialog bx where you can select a desired LLM.
If everything goes fine, the next step is to download the “tokenizer” file locally (refer to the Github repo’s explanations) and then a dialog box is shown to chose the text file with the content which is to be evaluated in terms of the number of tokens.
So far, I have asked access to Meta LLama and Google “google/gemma-2–2b-it” models and am awaiting access to be granted.
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"
Conclusion
I think being on the right path to achieve what I intended to get, a Golang programme which is able to determine the number of tokens is a user’s query sent to a LLM.
The only aim of this project is to learn the internal system behind determination of the number of tokens in queries against a variety of LLMs and to discover how they are calculated.
Thanks for reading and open to comments.
And till the final conclusion, stay tuned… 🧪
Top comments (0)