原文：https://pgaleone.eu/tensorflow/go/2017/05/29/understanding-tensorflow-using-go/

Tensorflow 并不是一个严格意义上的机器学习库，它是一个使用图来表示计算的通用计算库。它的核心功能由 C++ 实现，通过封装，能在各种不同的语言下运行。它的 Golang 版和 Python 版不同，Golang 版 Tensorflow 不仅能让你通过 Go 语言使用 Tensorflow，还能让你理解 Tensorflow 的底层实现。

绑定（The bindings）

Go 绑定（The Go bindings）

我建议读者在阅读下面的内容前，先准备好 Go 环境，以及编译、安装好 Tensorflow Go 版（编译、安装过程参考 README.md）。

注：之前的博文中有详细的安装过程，仅供参考。

理解 Tensorflow 架构 （Understand Tensorflow structure）

先回顾一下什么是 Tensorflow 吧！（这是我个人的理解，和官网的有所不同）

TensorFlow™ 是一个采用数据流图(data flow graphs),用于数值计算的开源软件库。节点（Nodes）在图中表示数学操作，图中的线（edges）则表示在节点间相互联系的多维数据数组，即张量（tensor）。

我们可以把 Tensorflow 看做一种类似于 SQL 的描述性语言，首先你得确定你需要什么数据，它会通过底层引擎（数据库）分析你的查询语句，检查你的句法错误和语法错误，将查询语句转换为私有语言表达式，进行优化之后运算得出计算结果。这样，它能保证将正确的结果传达给你。

因此，我们无论使用什么 API 实质上都是在描述一个图。我们将它放在 Session 中作为求值的起点，这样做确定了这个图将会在这个 Session 中运行。

了解这一点，我们可以试着定义一个计算操作的图，并将其放在一个 Session 中进行求值。

API 文档 中明确告知了 tensorflow（简称 tf）包与 op 包中的可用方法列表。

正如我们所看到的，这两个包有定义和计算图形所需的所有内容。

tf 包中包含了各种构建基础结构的函数，例如 Graph（图）。op 包是最重要的包，它包含了由 C++ 实现自动生成的绑定等功能。

现在，假设我们要计算 $A$ 与 $x$ 的矩阵乘法：
$A= begin{pmatrix} 1 & 2 \ -1 & -2 end{pmatrix} , x= begin{pmatrix} 10 \ 100 end{pmatrix}$

我想读者已经熟悉了 tensorflow 图的定义思想，并且知道 placeholder 以及其是如何工作的。

下面的代码是 Tensorflow Python 绑定用户的第一次尝试。让我们把这个文件称为attempt1.go。

package main

import (
	"fmt"
	"github.com/tensorflow/tensorflow/tensorflow/go/op"
	tf "github.com/tensorflow/tensorflow/tensorflow/go"
)

func main() {
	// 第一步：创建图

	// 首先我们需要在 Runtime 定义两个 placeholder 进行占位
	// 第一个 placeholder A 将会被一个 [2, 2] 的 interger 类型张量代替
	// 第二个 placeholder x 将会被一个 [2, 1] 的 interger 类型张量代替

	// 接下来我们要计算 Y = Ax

	// 创建图的第一个节点：让这个空节点作为图的根
	root := op.NewScope()

	// 定义两个 placeholder
	A := op.Placeholder(root, tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 2)))
	x := op.Placeholder(root, tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 1)))



	// 定义接受 A 与 x 输入的 op 节点
	product := op.MatMul(root, A, x)

	// 每次我们传递一个域给一个操作的时候，
	// 我们都要将操作放在在这个域下。
	// 如你所见，现在我们已经有了一个空作用域（由 newScope）创建。这个空作用域
	// 是我们图的根，我们可以用“/”表示它。

	// 现在让 tensorflow 按照我们的定义建立图吧。
	// 依据我们定义的 scope 与 op 结合起来的抽象图，程序会创建相应的常数图。
	graph, err := root.Finalize()
	if err != nil {
		// 如果我们错误地定义了图，我们必须手动修正相关定义，
		// 任何尝试自动处理错误的方法都是无用的。

		// 就像 SQL 查询一样，如果查询不是有效的语法，我们只能重写它。
		panic(err.Error())
	}

	// 如果到这一步，说明我们的图语法上是正确的。
	// 现在我们可以将它放在一个 Session 中并执行它了！

	var sess *tf.Session
	sess, err = tf.NewSession(graph, &tf.SessionOptions{})
	if err != nil {
		panic(err.Error())
	}

	// 为了使用 placeholder，我们需要创建传入网络的值的张量
	var matrix, column *tf.Tensor

	// A = [ [1, 2], [-1, -2] ]
	if matrix, err = tf.NewTensor([2][2]int64{ {1, 2}, {-1, -2} }); err != nil {
		panic(err.Error())
	}
	// x = [ [10], [100] ]
	if column, err = tf.NewTensor([2][1]int64{ {10}, {100} }); err != nil {
		panic(err.Error())
	}

	var results []*tf.Tensor
	if results, err = sess.Run(map[tf.Output]*tf.Tensor{
		A: matrix,
		x: column,
	}, []tf.Output{product}, nil); err != nil {
		panic(err.Error())
	}
	for _, result := range results {
		fmt.Println(result.Value().([][]int64))
	}
}

上面的代码有完整的注释，建议读者阅读上面的每一条注释。

现在， Tensorflow Python 的用户感觉非常棒，认为他的代码能够成功编译与运行。可以验证一下：

go run attempt1.go

然后可以看到下面的运行结果：

panic: failed to add operation "Placeholder": Duplicate node name in graph: 'Placeholder' (Stacktrace: goroutine 1 [running]:
runtime/debug.Stack(0x24, 0x4e4a728, 0x404c160)

等等，为什么会这样呢？问题很明显。上面代码里出现了 2 个重名的 “Placeholder” 操作。

第一课：节点 ID（Lesson 1: node IDs）

import tensorflow as tf
a = tf.placeholder(tf.int32, shape=())
b = tf.placeholder(tf.int32, shape=())
add = tf.add(a,b)
sess = tf.InteractiveSession()
print(sess.run(add, feed_dict={a: 1,b: 2}))

第 2 课：作用域 （Lesson 2: Scoping）

下面是该方法的文档及特性，参考 scope.h：

/// Return a new scope. All ops created within the returned scope will have
/// names of the form <name>/<op_name>[_<suffix].
Scope WithOpName(const string& op_name) const;

我们可以注意到，这个方法会返回一个作用域 Scope 来对节点进行命名，因此一个节点名实际上就是一个作用域 Scope。

Scope 就是从根 /（空图）到 op_name 的完整路径。

为了避免在相同作用域下有重复的节点，WithOpName 方法会在我们尝试添加一个有着相同的 / 到 op_name 路径的节点时，为其加上一个后缀 _<suffix>（<suffix> 是一个计数器）。

了解了这一点，为了解决重复节点名的问题，我们希望在 type Scope 中找到 WithOpName 方法。遗憾的是，目前 Go tf API 中还没有这种方法。

当查看 type Scope 的文档，我们可以看到返回新 Scope 的惟一方法是 SubScope(namespace string)。

引用的文档中的内容：

SubScope 会返回一个 Scope ，该 Scope 将会使添加到图中的所有操作使用“namespace”这个命名空间。如果这个命名空间与范围内的现有命名空间冲突，则添加后缀。

这种加后缀的冲突处理和 C++ 中的 WithOpName 方法不同，C++ 中的 WithOpName 是在操作名后面加suffix，它们都在同样的作用域内（例如 Placeholder 变成 Placeholder_1），而 Go 的 SubScope 是在作用域名称后面加 suffix。

这种不同会致使生成完全不同的图，尽管不同（节点被放置在不同的 Scope），但是从计算上来说，它们是等价的。

尝试修改 placeholder 的定义，让它们定义两个不同的节点，然后打印 Scope 名称。

创建 attempt2.go 文件，将下面几行：

A := op.Placeholder(root, tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 2)))
x := op.Placeholder(root, tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 1)))

改为如下代码：

	// 在根定义域下定义两个自定义域，命名为 input。这样
	// 我们就能在根定义域下拥有 input/ 和 input_1/ 两个定义域了。
	A := op.Placeholder(root.SubScope("input"), tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 2)))
	x := op.Placeholder(root.SubScope("input"), tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 1)))
	fmt.Println(A.Op.Name(), x.Op.Name())

编译、运行： go run attempt2.go，输出结果：

input/Placeholder input_1/Placeholder

提问时间：

• 关于 Tensorflow 的架构我们学到了什么？

节点完全由其定义所在的 Scope 标识。这个 Scope 是我们从图的根节点追溯到指定节点的一条路径。有两种方法来定义执行同一种操作的节点：1、将其定义放在不同的作用域中（Go 风格）2、改变操作名称（我们在 C++ 中可以这么做，Python 版会自动这么做）

至此解决了节点命名重复的问题，但是现在控制台中出现了一个新的问题，如下所示：

panic: failed to add operation "MatMul": Value for attr 'T' of int64 is not in the list of allowed values: bfloat16, half, float, double, int32, complex64, complex128
        ; NodeDef: {{node MatMul}} = MatMul[T=DT_INT64, transpose_a=false, transpose_b=false](input/Placeholder, input_1/Placeholder); Op<name=MatMul; signature=a:T, b:T -> product:T; attr=transpose_a:bool,default=false; attr=transpose_b:bool,default=false; attr=T:type,allowed=[DT_BFLOAT16, DT_HALF, DT_FLOAT, DT_DOUBLE, DT_INT32, DT_COMPLEX64, DT_COMPLEX128]> (Stacktrace: goroutine 1 [running]:
runtime/debug.Stack(0xc42000c0f0, 0x40636bf, 0x4)

为什么 MatMul 节点的定义出错了？我们要做的仅仅是计算两个 tf.int64 矩阵的乘积而已！看问题描述似乎是 MatMul 不能接受 int64 的类型。

Value for attr ‘T’ of int64 is not in the list of allowed values: bfloat16, half, float, double, int32, complex64, complex128;

上面这个列表是什么？为什么能计算 2 个 int32 矩阵的乘积却不能计算 int64 的乘积？

下面将解决这个问题。

第 3 课：Tensorflow 类型系统（Lesson 3: Tensorflow typing system）

深入研究一下 源代码 来看 C++ 是如何定义 MatMul 操作的：

REGISTER_OP("MatMul")
    .Input("a: T")
    .Input("b: T")
    .Output("product: T")
    .Attr("transpose_a: bool = false")
    .Attr("transpose_b: bool = false")
    .Attr("T: {half, float, double, int32, complex64, complex128}")
    .SetShapeFn(shape_inference::MatMulShape)
    .Doc(R"doc(
Multiply the matrix "a" by the matrix "b".
The inputs must be two-dimensional matrices and the inner dimension of
"a" (after being transposed if transpose_a is true) must match the
outer dimension of "b" (after being transposed if transposed_b is
true).
*Note*: The default kernel implementation for MatMul on GPUs uses
cublas.
transpose_a: If true, "a" is transposed before multiplication.
transpose_b: If true, "b" is transposed before multiplication.

上述几行代码为 MatMul 的操作定义了一个接口，由 REGISTER_OP 宏对此操作做出了如下描述：

• 名称: MatMul
• 参数: a，b
• 属性（可选参数）: transpose_a， transpose_b
• 模版 T 支持的类型: half， float， double， int32， complex64， complex128
• 输出类型: 自动识别
• 文档

这个宏没有包含任何 C++ 代码，但是它告诉了我们当在定义一个操作的时候，即使它使用模版定义，我们也需要指定特定类型 T 支持的类型（或属性）列表。

实际上，属性 .Attr("T: {half, float, double, int32, complex64, complex128}") 将 T 的类型限制在了这个类型列表中。

tensorflow 教程 中有提到，当使用模版 T 时，我们需要对所有支持的重载运算在内核中进行注册。内核会使用 CUDA 的方式引用 C/C++ 函数，进行并发执行。

或许 MatMul 的作者可能是出于以下的两个原因，才使支持的类型把 int64 排除在外的：

1. 疏忽：这个是有可能的，毕竟 Tensorflow 的作者也是人！
2. 为了支持不能完全使用 int64 操作的设备，可能内核的这种特定实现并不足以在所有受支持的硬件上运行。

回到我们的问题中，已经很清楚如何解决问题了。我们需要将 MatMul 支持类型的参数传给它。

因此，我们需要创建 attempt3.go 文件，将所有 int64 的地方都改成 int32。

需要注意：Go 封装版 tf 有自己的一套类型，基本与 Go 本身的类型 1:1 相映射。当我们要将值传入图中时，我们必须遵循这种映射关系（例如定义 tf.Int32 类型的 placeholder 时要传入 int32）。从图中取值同理。

*tf.Tensor 类型将会返回一个张量 evaluation，它包含一个 Value() 方法，此方法将返回一个必须转换为正确类型的 interface{}（这是从图的结构了解到的）。

运行 go run attempt3.go，得到如下结果：

input/Placeholder input_1/Placeholder

完全正确！

下面是 attempt3.go 文件的完整代码，你可以编译并运行它。(还请记住，这是一个Gist，如果您看到一些可以改进的地方，您可以提供一些帮助)。

package main

import (
	"fmt"
	"github.com/tensorflow/tensorflow/tensorflow/go/op"
	tf "github.com/tensorflow/tensorflow/tensorflow/go"
)

func main() {
	// 第一步：创建图

	// 首先我们需要在 Runtime 定义两个 placeholder 进行占位
	// 第一个 placeholder A 将会被一个 [2, 2] 的 interger 类型张量代替
	// 第二个 placeholder x 将会被一个 [2, 1] 的 interger 类型张量代替

	// 接下来我们要计算 Y = Ax

	// 创建图的第一个节点：让这个空节点作为图的根
	root := op.NewScope()

	// 在根定义域下定义两个自定义域，命名为 input。这样
	// 我们就能在根定义域下拥有 input/ 和 input_1/ 两个定义域了。
	A := op.Placeholder(root.SubScope("input"), tf.Int32, op.PlaceholderShape(tf.MakeShape(2, 2)))
	x := op.Placeholder(root.SubScope("input"), tf.Int32, op.PlaceholderShape(tf.MakeShape(2, 1)))
	fmt.Println(A.Op.Name(), x.Op.Name())




	// 定义接受 A 与 x 输入的 op 节点
	product := op.MatMul(root, A, x)

	// 每次我们传递一个域给一个操作的时候，
	// 我们都要将操作放在在这个域下。
	// 如你所见，现在我们已经有了一个空作用域（由 newScope）创建。这个空作用域
	// 是我们图的根，我们可以用“/”表示它。

	// 现在让 tensorflow 按照我们的定义建立图吧。
	// 依据我们定义的 scope 与 op 结合起来的抽象图，程序会创建相应的常数图。
	graph, err := root.Finalize()
	if err != nil {
		// 如果我们错误地定义了图，我们必须手动修正相关定义，
		// 任何尝试自动处理错误的方法都是无用的。

		// 就像 SQL 查询一样，如果查询不是有效的语法，我们只能重写它。
		panic(err.Error())
	}

	// 如果到这一步，说明我们的图语法上是正确的。
	// 现在我们可以将它放在一个 Session 中并执行它了！

	var sess *tf.Session
	sess, err = tf.NewSession(graph, &tf.SessionOptions{})
	if err != nil {
		panic(err.Error())
	}

	// 为了使用 placeholder，我们需要创建传入网络的值的张量
	var matrix, column *tf.Tensor

	// A = [ [1, 2], [-1, -2] ]
	if matrix, err = tf.NewTensor([2][2]int32{ {1, 2}, {-1, -2} }); err != nil {
		panic(err.Error())
	}
	// x = [ [10], [100] ]
	if column, err = tf.NewTensor([2][1]int32{ {10}, {100} }); err != nil {
		panic(err.Error())
	}

	var results []*tf.Tensor
	if results, err = sess.Run(map[tf.Output]*tf.Tensor{
		A: matrix,
		x: column,
	}, []tf.Output{product}, nil); err != nil {
		panic(err.Error())
	}
	for _, result := range results {
		fmt.Println(result.Value().([][]int32))
	}
}

提问时间：
关于 Tensorflow 的架构我们学到了什么？每个操作都有自己的一组关联内核。Tensorflow 是一种强类型的描述性语言，它不仅遵循 C++ 类型规则，同时要求在 op 注册时需定义好类型才能实现其功能。

总结

由于个人理解的不同，虽参考了现有的译文，但还是针对一些点使用了自己的翻译，不足之处，还望谅解！