使用 Go 语言学会 Tensorflow

 1package main
 2import (
 3    "fmt"
 4    tf "github.com/tensorflow/tensorflow/tensorflow/go"
 5    "github.com/tensorflow/tensorflow/tensorflow/go/op"
 6)
 7func main() {
 8    // 让我们描述我们的需求：创建图
 9    // 我们想要定义两个运行时使用的 placeholder
10    // 第一个 placeholder A 是 [2, 2] 整数张量
11    // 第二个 placeholder x 是 [2, 1] 整数张量
12    // 然后计算 Y = Ax
13    // 创建图的节点：一个空节点，作为图的根节点
14    root := op.NewScope()
15    // 定义两个占位符
16    A := op.Placeholder(root, tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 2)))
17    x := op.Placeholder(root, tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 1)))
18    // 定义可以接受 A & x 作为输入的操作节点
19    product := op.MatMul(root, A, x)
20    // 每次我们将 `Scope` 传入一个操作时，我们都将这个操作置于这个作用域内。
21    // 如你所见，我们有一个通过 NewScope 创建空域：
22    // 这个空域是我们所创建的图的根，我们用 “/”表示它。
23    // 现在我们让 tensorflow 通过我们的定义来构建图。
24    // 实体的图是通过我们用域和操作组合起来定义的“抽象”图生成的。
25    graph, err := root.Finalize()
26    if err != nil {
27        // 处理这个错误没有什么用处
28        // 如果我们对图的定义做错了，我们只能手动修正这些定义。
29        // 它很想一个 SQL 查询过程：如果查询语句错了，我们只能重写它
30        panic(err.Error())
31    }
32    // 至此：我们的图定义语法上就没有问题了。
33    // 我们现在可以将其放入一个 Session 中使用了。
34    var sess *tf.Session
35    sess, err = tf.NewSession(graph, &tf.SessionOptions{})
36    if err != nil {
37        panic(err.Error())
38    }
39    // 为了使用占位符，我们必须创建含有数值的张量传入网络中
40    var matrix, column *tf.Tensor
41    // A = [ [1, 2], [-1, -2] ]
42    if matrix, err = tf.NewTensor([2][2]int64{ {1, 2}, {-1, -2} }); err != nil {
43        panic(err.Error())
44    }
45    // x = [ [10], [100] ]
46    if column, err = tf.NewTensor([2][1]int64{ {10}, {100} }); err != nil {
47        panic(err.Error())
48    }
49    var results []*tf.Tensor
50    if results, err = sess.Run(map[tf.Output]*tf.Tensor{
51        A: matrix,
52        x: column,
53    }, []tf.Output{product}, nil); err != nil {
54        panic(err.Error())
55    }
56    for _, result := range results {
57        fmt.Println(result.Value().([][]int64))
58    }
59}

 1import tensorflow as tf
 2
 3a = tf.placeholder(tf.int32, shape=())
 4
 5b = tf.placeholder(tf.int32, shape=())
 6
 7add = tf.add(a,b)
 8
 9sess = tf.InteractiveSession()
10
11print(sess.run(add, feed_dict={a: 1,b: 2}))

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

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

1// define 2 subscopes of the root subscopes, called "input". In this
2
3// way we expect to have a input/ and a input_1/ scope under the root scope
4
5A := op.Placeholder(root.SubScope("input"), tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 2)))
6
7x := op.Placeholder(root.SubScope("input"), tf.Int64, op.PlaceholderShape(tf.MakeShape(2, 1)))
8
9    fmt.Println(A.Op.Name(), x.Op.Name())

1input/Placeholder input_1/Placeholder

1panic: failed to add operation "MatMul": Value for attr 'T' of int64 is not in the list of allowed values: half, float, double, int32, complex64, complex128

 1REGISTER_OP("MatMul")
 2
 3.Input("a: T")
 4
 5.Input("b: T")
 6
 7.Output("product: T")
 8
 9.Attr("transpose_a: bool = false")
10
11.Attr("transpose_b: bool = false")
12
13.Attr("T: {half, float, double, int32, complex64, complex128}")
14
15.SetShapeFn(shape_inference::MatMulShape)
16
17.Doc(R"doc(
18
19Multiply the matrix "a" by the matrix "b".
20
21The inputs must be two-dimensional matrices and the inner dimension of
22
23"a" (after being transposed if transpose_a is true) must match the
24
25outer dimension of "b" (after being transposed if transposed_b is
26
27true).
28
29*Note*: The default kernel implementation for MatMul on GPUs uses
30
31cublas.
32
33transpose_a: If true, "a" is transposed before multiplication.
34
35transpose_b: If true, "b" is transposed before multiplication.
36
37)doc");

1input/Placeholder input_1/Placeholder
2[[210] [-210]]

  1package main
  2
  3import (
  4
  5"fmt"                                      
  6
  7tf "github.com/tensorflow/tensorflow/tensorflow/go"                                              
  8
  9"github.com/tensorflow/tensorflow/tensorflow/go/op"                                              
 10
 11)
 12
 13func main() {
 14
 15// Let's describe what we want: create the graph                                                 
 16
 17// We want to define two placeholder to fill at runtime                                          
 18
 19// the first placeholder A will be a [2, 2] tensor of integers                                   
 20
 21// the second placeholder x will be a [2, 1] tensor of intergers                                 
 22
 23// Then we want to compute Y = Ax           
 24
 25// Create the first node of the graph: an empty node, the root of our graph                      
 26
 27root := op.NewScope()
 28
 29// Define the 2 placeholders                
 30
 31// define 2 subscopes of the root subscopes, called "input". In this                             
 32
 33// way we expect the have a input/ and a input_1/ scope under the root scope                     
 34
 35A := op.Placeholder(root.SubScope("input"), tf.Int32, op.PlaceholderShape(tf.MakeShape(2, 2)))
 36
 37x := op.Placeholder(root.SubScope("input"), tf.Int32, op.PlaceholderShape(tf.MakeShape(2, 1)))
 38
 39fmt.Println(A.Op.Name(), x.Op.Name())
 40
 41// Define the operation node that accepts A & x as inputs                                        
 42
 43product := op.MatMul(root, A, x)
 44
 45// Every time we passed a `Scope` to an operation, we placed that operation **under**            
 46
 47// that scope.                              
 48
 49// As you can see, we have an empty scope (created with NewScope): the empty scope               
 50
 51// is the root of our graph and thus we denote it with "/".                                      
 52
 53// Now we ask tensorflow to build the graph from our definition.                                 
 54
 55// The concrete graph is created from the "abstract" graph we defined using the combination      
 56
 57// of scope and op.                         
 58
 59graph, err := root.Finalize()
 60
 61if err != nil {
 62
 63// It's useless trying to handle this error in any way:                                  
 64
 65// if we defined the graph wrongly we have to manually fix the definition.               
 66
 67// It's like a SQL query: if the query is not syntactically valid we have to rewrite it  
 68
 69panic(err.Error())
 70
 71}
 72
 73// If here: our graph is syntatically valid.
 74
 75// We can now place it within a Session and execute it.
 76
 77var sess *tf.Session
 78
 79sess, err = tf.NewSession(graph, &tf.SessionOptions{})
 80
 81if err != nil {
 82
 83panic(err.Error())
 84
 85}
 86
 87// In order to use placeholders, we have to create the Tensors containing the values to feed into                                                                                                          
 88
 89// the network                              
 90
 91var matrix, column *tf.Tensor
 92
 93// A = [ [1, 2], [-1, -2] ]                 
 94
 95if matrix, err = tf.NewTensor([2][2]int32{{1, 2}, {-1, -2}}); err != nil {
 96
 97panic(err.Error())
 98
 99}
100
101// x = [ [10], [100] ]                      
102
103if column, err = tf.NewTensor([2][1]int32{{10}, {100}}); err != nil {
104
105panic(err.Error())
106
107}
108
109var results []*tf.Tensor
110
111if results, err = sess.Run(map[tf.Output]*tf.Tensor{
112
113A: matrix,
114
115x: column,
116
117}, []tf.Output{product}, nil); err != nil {
118
119panic(err.Error())
120
121}
122
123for _, result := range results {
124
125fmt.Println(result.Value().([][]int32))
126
127}
128
129}