In this article we’re going to walk through loading a pre-trained TensorFlow model and running inference with the Go bindings.
Now, because of the
The TensorFlow team is not currently maintaining the Documentation for installing the Go bindings for TensorFlow.
https://github.com/tensorflow/tensorflow/tree/master/tensorflow/go
The new “official” contributor for the Go bindings (as recommended by the TF itself) is William Muir and his graft repo - https://github.com/wamuir/graft
Setting Up the Environment
Reqs:
Installing the TF:
brew install tensorflow
Installing the Go TF package:
go get -u github.com/wamuir/graft/tensorflow/...
To check if your TF installation works, please follow the “Hello Tensorflow” example from the graft README - https://github.com/wamuir/graft:
package main
import (
tf "github.com/wamuir/graft/tensorflow"
"github.com/wamuir/graft/tensorflow/op"
"fmt"
)
func main() {
s := op.NewScope()
c := op.Const(s, "Hello from TensorFlow version " + tf.Version())
graph, err := s.Finalize()
if err != nil {
panic(err)
}
sess, err := tf.NewSession(graph, nil)
if err != nil {
panic(err)
}
output, err := sess.Run(nil, []tf.Output{c}, nil)
if err != nil {
panic(err)
}
fmt.Println(output[0].Value())
}
The output when you run the program should be similar to this one:
go run main.go
WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
I0000 00:00:1745750228.799498 1712814 mlir_graph_optimization_pass.cc:425] MLIR V1 optimization pass is not enabled
Hello from TF version 2.19.0
In case of any issues please refer to the section “Common Pitfalls and Troubleshooting” at the end of this article.
Preparing the Model
We’re going to use the pre-trained image classifier model mobilenet_v2 - https://www.kaggle.com/models/google/mobilenet-v2/tensorFlow2
Unfortunately the model downloaded from the given source had issues with the provided input layer, so in the blog article repository (see “Sources”) you can find a converter.py script, that exported it from source and provided us with the named input layer called serving_default_x.
You don’t have to do it, it’s already done, but you can take a look at the converter.py to see how you can export a model to a SavedModel format.
Loading and Running the Model in Go
In the attached code you can observe the whole processing operations split into main sections:
Load the model
Load an image
Create input tensors (preprocess the image)
Run the session (run inference)
Fetch outputs (predictions)
Find the best prediction and disply results
Our goal is to detect what’s on that image, we want to know if that’s a squirrel:
package main
import (
"bufio"
"fmt"
"image"
"image/jpeg"
"log"
"os"
"github.com/nfnt/resize"
tf "github.com/wamuir/graft/tensorflow"
)
func main() {
model, err := tf.LoadSavedModel("saved_mobilenet_v2", []string{"serve"}, nil)
if err != nil {
log.Fatal("LoadSavedModel", err)
}
defer func(Session *tf.Session) {
if e := Session.Close(); e != nil {
log.Fatal("Session.Close", e)
}
}(model.Session)
img, err := loadImage("images/1.jpg")
if err != nil {
log.Fatal("loadImage", err)
}
tensor, err := makeTensorFromImage(img)
if err != nil {
log.Fatal("makeTensorFromImage", err)
}
inputOp := model.Graph.Operation("serving_default_x")
if inputOp == nil {
log.Fatal("model.Graph.Operation: serving_default_x not found")
}
outputOp := model.Graph.Operation("StatefulPartitionedCall")
if outputOp == nil {
log.Fatal("model.Graph.Operation: StatefulPartitionedCall not found")
}
outputs, err := model.Session.Run(
map[tf.Output]*tf.Tensor{
inputOp.Output(0): tensor,
},
[]tf.Output{
outputOp.Output(0),
},
nil,
)
if err != nil {
log.Fatal("Session.Run", err)
}
predictions := outputs[0].Value().([][]float32)
bestIdx := 0
bestScore := float32(0.0)
for i, p := range predictions[0] {
if p > bestScore {
bestIdx = i
bestScore = p
}
}
labels, err := loadLabels("ImageNetLabels.txt")
if err != nil {
log.Fatal("loadLabels", err)
}
fmt.Printf("Predicted label: %s (index: %d, confidence: %.4f)\n", labels[bestIdx], bestIdx, bestScore)
}
func loadImage(filename string) (image.Image, error) {
file, err := os.Open(filename)
if err != nil {
return nil, fmt.Errorf("os.Open: %w", err)
}
defer func(file *os.File) {
if e := file.Close(); e != nil {
log.Fatal("file.Close", e)
}
}(file)
img, err := jpeg.Decode(file)
if err != nil {
return nil, fmt.Errorf("jpeg.Decode: %w", err)
}
return img, nil
}
func makeTensorFromImage(img image.Image) (*tf.Tensor, error) {
resized := resize.Resize(224, 224, img, resize.Bilinear)
bounds := resized.Bounds()
batch := make([][][][]float32, 1)
batch[0] = make([][][]float32, bounds.Dy())
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
row := make([][]float32, bounds.Dx())
for x := bounds.Min.X; x < bounds.Max.X; x++ {
r, g, b, _ := resized.At(x, y).RGBA()
row[x] = []float32{
float32(r) / 65535.0,
float32(g) / 65535.0,
float32(b) / 65535.0,
}
}
batch[0][y] = row
}
return tf.NewTensor(batch)
}
func loadLabels(filename string) ([]string, error) {
file, err := os.Open(filename)
if err != nil {
return nil, fmt.Errorf("os.Open: %w", err)
}
defer func(file *os.File) {
if e := file.Close(); e != nil {
log.Fatal("file.Close", e)
}
}(file)
var labels []string
scanner := bufio.NewScanner(file)
for scanner.Scan() {
labels = append(labels, scanner.Text())
}
if err = scanner.Err(); err != nil {
return nil, fmt.Errorf("bufio.Scanner: %w", err)
}
return labels, nil
}
The output is as follows:
go run main.go
2025-04-27 18:56:20.238487: I tensorflow/cc/saved_model/reader.cc:83] Reading SavedModel from: saved_mobilenet_v2
2025-04-27 18:56:20.244913: I tensorflow/cc/saved_model/reader.cc:52] Reading meta graph with tags { serve }
2025-04-27 18:56:20.244945: I tensorflow/cc/saved_model/reader.cc:147] Reading SavedModel debug info (if present) from: saved_mobilenet_v2
WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
I0000 00:00:1745772980.292412 2175877 mlir_graph_optimization_pass.cc:425] MLIR V1 optimization pass is not enabled
2025-04-27 18:56:20.298863: I tensorflow/cc/saved_model/loader.cc:236] Restoring SavedModel bundle.
2025-04-27 18:56:20.505321: I tensorflow/cc/saved_model/loader.cc:220] Running initialization op on SavedModel bundle at path: saved_mobilenet_v2
2025-04-27 18:56:20.562274: I tensorflow/cc/saved_model/loader.cc:471] SavedModel load for tags { serve }; Status: success: OK. Took 323789 microseconds.
Predicted label: fox squirrel (index: 336, confidence: 8.3710)
As you can see, the most common tag is a “fox squirrel”, which is exactly what we wanted to achieve. Personally not sure if this is a fox squirel or any other regular squirrel, but for sure it’s a squirrel.
All the resources like models, images and labels you can find in the article repository.
Common Pitfalls and Troubleshooting
Issues with the TensorFlow library:
go run main.go
../../../go/pkg/mod/github.com/wamuir/graft@v0.10.0/tensorflow/tensor.go:69:26: could not determine what C.TF_FLOAT8_E4M3FN refers to
../../../go/pkg/mod/github.com/wamuir/graft@v0.10.0/tensorflow/tensor.go:68:26: could not determine what C.TF_FLOAT8_E5M2 refers to
../../../go/pkg/mod/github.com/wamuir/graft@v0.10.0/tensorflow/tensor.go:70:26: could not determine what C.TF_INT4 refers to
../../../go/pkg/mod/github.com/wamuir/graft@v0.10.0/tensorflow/tensor.go:71:26: could not determine what C.TF_UINT4 refers to
Even though TensorFlow is installed via Homebrew, it's not properly configured for pkg-config, which is needed for Go to find and link against the TensorFlow C library.
Run brew link --force libtensorflow
Then if needed add also env vars to you bash profile file (I’m using the .zshrc):
export LIBRARY_PATH="/opt/homebrew/lib:$LIBRARY_PATH"
export CPATH="/opt/homebrew/include:$CPATH"
export PKG_CONFIG_PATH="/opt/homebrew/lib/pkgconfig:$PKG_CONFIG_PATH"
Sources
