tfgo: TensorFlow 在 Go 中

• tfgo: TensorFlow 在 Go 中
  • 依赖项
  • 安装
  • 快速入门
  • 使用数据流图进行计算机视觉
  • 用 Python 训练，用 Go 提供服务
    • Python 代码
    • Go 代码
  • 为什么？
  • 贡献
  • TensorFlow 安装
    • 手动安装
    • Docker

TensorFlow 的 Go 绑定使用起来很困难：tfgo 让它变得简单！

不再有以下问题：

• 作用域：每个新节点都会有一个新的唯一名称
• 类型转换：属性会自动转换为支持的类型，而不是在运行时抛出错误

此外，它使用了方法链式调用，使得编写优雅的 Go 代码成为可能。

依赖项

1. TensorFlow 2.9.1 库。如何安装 TensorFlow。
2. TensorFlow 绑定 github.com/galeone/tensorflow。为了在 Go 中正确使用 TensorFlow 2.9.1，我们需要使用我创建的一个带有修复的分支。这些绑定可能会太大而无法通过 go mod 代理下载，因此你可以通过执行 go env -w GONOSUMDB="github.com/galeone/tensorflow" 来关闭代理，直接使用系统中安装的 git 拉取代码。这不会改变用户界面——你可以像往常一样使用 Go 模块。

安装

go get github.com/galeone/tfgo

快速入门

TensorFlow Go 绑定的核心数据结构是 op.Scope 结构体。tfgo 允许创建新的 *op.Scope，从而解决了上述的作用域问题。

由于我们正在定义一个图，让我们从它的根（空图）开始。

root := tg.NewRoot()

现在我们可以将节点放入这个图中并连接它们。假设我们要将一个矩阵与一个列向量相乘，然后将另一个列向量加到结果上。

以下是完整的源代码。

package main

import (
        "fmt"
        tg "github.com/galeone/tfgo"
        tf "github.com/galeone/tensorflow/tensorflow/go"
)

func main() {
        root := tg.NewRoot()
        A := tg.NewTensor(root, tg.Const(root, [2][2]int32{{1, 2}, {-1, -2}}))
        x := tg.NewTensor(root, tg.Const(root, [2][1]int64{{10}, {100}}))
        b := tg.NewTensor(root, tg.Const(root, [2][1]int32{{-10}, {10}}))
        Y := A.MatMul(x.Output).Add(b.Output)
        // 请注意，Y 只是指向 A 的指针！

        // 如果我们想在图中创建一个不同的节点，我们必须克隆 Y
        // 或者等价地克隆 A
        Z := A.Clone()
        results := tg.Exec(root, []tf.Output{Y.Output, Z.Output}, nil, &tf.SessionOptions{})
        fmt.Println("Y: ", results[0].Value(), "Z: ", results[1].Value())
        fmt.Println("Y == A", Y == A) // ==> true
        fmt.Println("Z == A", Z == A) // ==> false
}

输出如下：

Y:  [[200] [-200]] Z:  [[200] [-200]]
Y == A true
Z == A false

可用方法列表可在 GoDoc 上找到：http://godoc.org/github.com/galeone/tfgo

使用数据流图进行计算机视觉

TensorFlow 提供了丰富的图像操作方法。tfgo 提供了 image 包，允许使用 Go 绑定以优雅的方式执行计算机视觉任务。

例如，可以读取一张图像，计算其水平和垂直方向上的方向导数，计算梯度并保存结果。

下面的代码实现了这一点，并展示了使用相关和卷积操作所得到的不同结果。

package main

import (
        tg "github.com/galeone/tfgo"
        "github.com/galeone/tfgo/image"
        "github.com/galeone/tfgo/image/filter"
        "github.com/galeone/tfgo/image/padding"
        tf "github.com/galeone/tensorflow/tensorflow/go"
        "os"
)

func main() {
        root := tg.NewRoot()
        grayImg := image.Read(root, "/home/pgaleone/airplane.png", 1)
        grayImg = grayImg.Scale(0, 255)

        // 使用 Sobel 滤波器进行边缘检测：卷积
        Gx := grayImg.Clone().Convolve(filter.SobelX(root), image.Stride{X: 1, Y: 1}, padding.SAME)
        Gy := grayImg.Clone().Convolve(filter.SobelY(root), image.Stride{X: 1, Y: 1}, padding.SAME)
        卷积边缘 := image.NewImage(root.SubScope("edge"), Gx.Square().Add(Gy.Square().Value()).Sqrt().Value()).EncodeJPEG()

        Gx = grayImg.Clone().Correlate(filter.SobelX(root), image.Stride{X: 1, Y: 1}, padding.SAME)
        Gy = grayImg.Clone().Correlate(filter.SobelY(root), image.Stride{X: 1, Y: 1}, padding.SAME)
        相关边缘 := image.NewImage(root.SubScope("edge"), Gx.Square().Add(Gy.Square().Value()).Sqrt().Value()).EncodeJPEG()

        results := tg.Exec(root, []tf.Output{卷积边缘、相关边缘}, nil, &tf.SessionOptions{})

        file, _ := os.Create("convolved.png")
        file.WriteString(results[0].Value().(string))
        file.Close()

        file, _ := os.Create("correlated.png")
        file.WriteString(results[1].Value().(string))
        file.Close()
}

airplane.png

convolved.png

correlated.png

可用方法列表可在 GoDoc 上找到：http://godoc.org/github.com/galeone/tfgo/image

用 Python 训练，用 Go 提供服务

TensorFlow 2 提供了许多简便的方法来将计算图（例如 Keras 模型或使用 @tf.function 装饰的函数）导出为 SavedModel 序列化格式（这是唯一官方支持的格式）。

使用 TensorFlow 2（结合 Keras 或 tf.function）+ tfgo，导出训练好的模型（或通用计算图）并在 Go 中使用它非常简单。

只需查看示例，即可了解如何使用 tfgo 提供训练好的模型的服务。

Python 代码

import tensorflow as tf

model = tf.keras.Sequential(
    [
        tf.keras.layers.Conv2D(
            8,
            (3, 3),
            strides=(2, 2),
            padding="valid",
            input_shape=(28, 28, 1),
            activation=tf.nn.relu,
            name="inputs",
        ),  # 14x14x8
        tf.keras.layers.Conv2D(
            16, (3, 3), strides=(2, 2), padding="valid", activation=tf.nn.relu
        ),  # 7x716
        tf.keras.layers.Flatten(),
        tf.keras.layers.Dense(10, name="logits"),  # 线性
    ]
)

tf.saved_model.save(model, "output/keras")

Go 代码

package main

import (
        "fmt"
        tg "github.com/galeone/tfgo"
        tf "github.com/galeone/tensorflow/tensorflow/go"
)

func main() {
        // 使用 tf.saved_model.save() 导出的模型
        // 自动带有 "serve" 标签，因为 SavedModel 文件格式就是为推理服务设计的。
        // 该标签包含了导出的各种函数。其中始终存在 "serving_default" 签名定义。
        // 这个签名定义的行为与 TF 1.x 图完全一致。获取输入张量和输出张量，
        // 分别用作占位符来提供输入和接收输出。

        // 要查看 SavedModel 中的信息，最好的工具是 TensorFlow Python 包自带的 saved_model_cli。
        
        // 例如：saved_model_cli show --all --dir output/keras
        // 会输出包括以下信息：

        // signature_def['serving_default']:
        // 给定的 SavedModel SignatureDef 包含以下输入：
        //   inputs['inputs_input'] tensor_info:
        //       数据类型: DT_FLOAT
        //       形状: (-1, 28, 28, 1)
        //       名称: serving_default_inputs_input:0
        // 给定的 SavedModel SignatureDef 包含以下输出：
        //   outputs['logits'] tensor_info:
        //       数据类型: DT_FLOAT
        //       形状: (-1, 10)
        //       名称: StatefulPartitionedCall:0
        // 方法名称为: tensorflow/serving/predict

        model := tg.LoadModel("test_models/output/keras", []string{"serve"}, nil)

        fakeInput, _ := tf.NewTensor([1][28][28][1]float32{})
        results := model.Exec([]tf.Output{
                model.Op("StatefulPartitionedCall", 0),
        }, map[tf.Output]*tf.Tensor{
                model.Op("serving_default_inputs_input", 0): fakeInput,
        })

        predictions := results[0]
        fmt.Println(predictions.Value())
}

为什么？

从图表示计算的角度来看，以这种方式描述计算，用一个词来说就是——具有挑战性。

此外，tfgo 将 GPU 计算引入 Go 语言，并允许编写并行代码，而无需关心执行设备（只需将图放置到你希望使用的设备上即可！）。

如何贡献

我非常欢迎贡献！说真的，能有志同道合、愿意共同面对相同挑战的人一起工作，真是太棒了。

如果你想贡献，可以直接深入代码，看看有哪些可以添加或改进的地方。先通过提交 issue 开启讨论，我们一起交流。

请遵循我在 image 包中使用的相同设计原则：覆盖相同的 Tensor 方法、为方法编写文档、测试你的更改，等等。

还有很多像 image 包这样的包可以被添加。也欢迎你创建全新的包：我非常期待这类贡献！

TensorFlow 安装

手动安装

在 macOS 上，你可以使用 brew install libtensorflow 命令进行安装（前提是已安装 Homebrew。Homebrew 是一个包管理器。如果需要帮助安装 Homebrew，请参考此处说明：https://docs.brew.sh/Installation）。

然后从 https://www.tensorflow.org/install/lang_c 下载并安装 C 库：

curl -L "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-linux-x86_64-2.9.1.tar.gz" | sudo tar -C /usr/local -xz
sudo ldconfig

Docker

docker pull tensorflow/tensorflow:2.9.1

或者你也可以使用系统的包管理器。

tfgo 快速上手指南

tfgo 是一个让 Go 语言轻松使用 TensorFlow 的开源库。它通过方法链（Method Chaining）简化了原生 Go 绑定的复杂性，自动处理节点作用域和类型转换，让编写深度学习代码更加优雅。

环境准备

系统要求

• 操作系统: Linux, macOS (Windows 需通过 WSL 或 Docker)
• Go 版本: 建议 Go 1.16+
• TensorFlow 版本: 必须安装 TensorFlow 2.9.1 C 库

前置依赖

1. 安装 TensorFlow C 库

   macOS (使用 Homebrew):

   brew install libtensorflow
   

   Linux (手动安装):

   # 下载并解压 TensorFlow 2.9.1 C 库
   curl -L "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-linux-x86_64-2.9.1.tar.gz" | sudo tar -C /usr/local -xz
   sudo ldconfig
   

   注：国内用户若下载缓慢，可尝试寻找国内镜像源替换上述 URL，或使用本地已下载的包。

2. 配置 Go 模块代理

   由于 tfgo 依赖特定的 TensorFlow Go 绑定 fork 版本，可能需要禁用校验和数据库以直接拉取代码：

   go env -w GONOSUMDB="github.com/galeone/tensorflow"
   

安装步骤

在终端执行以下命令安装 tfgo：

go get github.com/galeone/tfgo

基本使用

tfgo 的核心是 op.Scope。通过 tg.NewRoot() 创建根节点，然后利用方法链构建计算图。

以下示例演示了如何定义矩阵乘法并执行计算：

package main

import (
        "fmt"
        tg "github.com/galeone/tfgo"
        tf "github.com/galeone/tensorflow/tensorflow/go"
)

func main() {
        // 1. 创建计算图根节点
        root := tg.NewRoot()
        
        // 2. 定义常量张量
        // 矩阵 A: 2x2
        A := tg.NewTensor(root, tg.Const(root, [2][2]int32{{1, 2}, {-1, -2}}))
        // 向量 x: 2x1
        x := tg.NewTensor(root, tg.Const(root, [2][1]int64{{10}, {100}}))
        // 向量 b: 2x1
        b := tg.NewTensor(root, tg.Const(root, [2][1]int32{{-10}, {10}}))
        
        // 3. 构建计算图：Y = A * x + b
        // 使用方法链，代码简洁易读
        Y := A.MatMul(x.Output).Add(b.Output)
        
        // 注意：Y 是指向 A 的指针。若需独立节点，请使用 .Clone()
        Z := A.Clone()
        
        // 4. 执行计算图
        results := tg.Exec(root, []tf.Output{Y.Output, Z.Output}, nil, &tf.SessionOptions{})
        
        // 5. 输出结果
        fmt.Println("Y: ", results[0].Value(), "Z: ", results[1].Value())
        fmt.Println("Y == A", Y == A) // 输出 true
        fmt.Println("Z == A", Z == A) // 输出 false
}

运行结果：

Y:  [[200] [-200]] Z:  [[200] [-200]]
Y == A true
Z == A false

典型工作流：Python 训练，Go 部署

tfgo 完美支持加载由 Python (Keras/tf.function) 导出的 SavedModel 模型进行推理：

1. Python 端导出模型:

   import tensorflow as tf
   # ... 定义并训练模型 ...
   tf.saved_model.save(model, "output/keras")
   

2. Go 端加载并推理:

   // 加载带有 "serve" 标签的模型
   model := tg.LoadModel("output/keras", []string{"serve"}, nil)
   
   // 准备输入数据
   fakeInput, _ := tf.NewTensor([1][28][28][1]float32{})
   
   // 执行推理
   results := model.Exec([]tf.Output{
           model.Op("StatefulPartitionedCall", 0),
   }, map[tf.Output]*tf.Tensor{
           model.Op("serving_default_inputs_input", 0): fakeInput,
   })
   
   fmt.Println(results[0].Value())