Tensorflow Programming--Basic

Tensorflow基本操作

1
2
3
4
5
import tensorflow as tf
a = tf.add(3,5)
sess = tf.Session()
print(sess.run(a))
sess.close()

或者这样写更好：

1
2
3
4
import tensorflow as tf
a = tf.add(3,5)
with tf.Session() as sess:
    print(sess.run(a))

Session对象封装了Operation对象的执行环境和Tensor对象的验证。

更复杂的图的例子

1
2
3
4
5
6
7
8
x = 2
y = 3
add_op = tf.add(x,y)
mul_op = tf.mul(x,y)
useless = tf.mul(x,add_op)
pow_op = tf.pow(add_op,mul_op)
with tf.Session() as sess:
    z, not_useless = sess.run([op3,useless])

API: tf.Session.run(fetches, feed_dict=None,options=None,rum_metadata=None)
将所有你想要的值的变量传递给一个列表。
Tensorflow支持多GPU计算，可以将构建的图分成几个大块并在多个GPU或者CPU或者其他设备上进行并行计算。

指定特定GPU的方法：

1
2
3
4
5
6
with tf.device('/gpu:2'):
    a = tf.constant([1.0,2.0,3.0,4.0,5.0,6.0],name='a')
    b = tf.constant([1.0,2.0,3.0,4.0,5.0,6.0],name='b')
    c = tf.matmul(a,b)
    with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
        print(sess.run())

tf.Graph()

向一个图中添加操作，并将图设置为默认：

1
2
3
4
5
6
7
g = tf.Graph()
with g.as_default():
    x = tf.add(3,5)
sess = tf.Session(graph=g)
with tf.Session() as sess:
    sess.run(x)

使用一下语句得到默认的图：

1
g = tf.get_default_graph()

注意不要将默认图和用户自定义的图混合。

使用图的优点

1、节约计算资源，每次运算仅仅只需运行与结果有关的子图
2、可以将图分成小块进行自动微分
3、方便部署在多个设备上
4、很多机器学习算法都能够被可视化为图的结构

Tensorboard简单使用

Tensorboard用于可视化训练过程中的一些数据

1
2
3
4
5
6
7
8
9
import tensorflow as tf
a = tf.constant(2)
b = tf.constant(3)
x = tf.add(a,b)
with tf.Session() as sess:
    # 利用tensorboard记录
    writer = tf.summary.FileWriter('./graphs',sess.graph)
    print(sess.run(x))
writer.close()

注意是在建立图之后，运行Session之前进行summary操作。
采用以下命令查看Tensorboard可视化结果：

$ python [yourprogram].py
$ tensorboard —logdir=’./graph’ —port 6006
然后在相应浏览器地址打开即可看到可视化结果。

为了让可视化结果更清晰，可给操作和节点命名。
如下所示

1
2
3
4
5
6
7
import tensorflow as tf
a = tf.constant(2, name='a')
b = tf.constant(3, name='b')
x = tf.add(a, b, name='add')
writer = tf.summary.FileWriter('./graphs',sess.graph)
with tf.Session() as sess:
    print(sess.run(x))

总之，Tensorboard是一个十分强大的工具，特别是对于分析复杂的网络结构以及观察网络训练过程特别有用。

常用API

1、tf.constant(value, dtype=None, shape=None, name=’Const’,verify_shape=False)
2、tf.zeros(shape, dtype=tf.float32, name=None)
3、tf.zeros_like(input_tensor, dtype=None, name=None, optimize=True)
4、tf.ones(shape, dtype=tf.float32, name=None)
5、tf.ones_like(input_tensor, dtype=None, name=None, optimize=True)
6、tf.fill(dims, value, name=None)
7、tf.linspace(start, stop, num, name=None)
8、tf.range(start, limit=None, delta=1, dtype=None, name=’range’)
9、tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
10、tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None,name=None)
10、tf.random_uniform(shape, minval=0, maxval=None, dtype=tf.float32, seed=None,name=None)
11、tf.random_shuffle(value, seed=None, name=None)
12、tf.random_crop(value, size, seed=None, name=None)
13、tf.multinomial(logits, num_samples, seed=None, name=None)
14、tf.random_gamma(shape, alpha, beta=None, dtype=tf.float32, seed=None, name=None)
15、tf.set_random_seed(seed)

运算操作

Tensorflow数据类型

Tensorflow需要python的原生数据类型，如int，float， string等。

Tensorflow和Numpy中的数据类型比较

1、tf.int3 == np.int32 #true
2、可将numpy数据类型传递给Tensorflow的操作

1
tf.ones([2,2],np.float32) # =>[[1.0,1.0],[1.0,1.0]]

3、对于语句 tf.Session.run(fetches), 如果 fetch是一个Tensor数据，那么输出将会是一个numpy数组。

使用原则

1、不要使用Python原生类型作为张量，因为TensorFlow必须推断Python
类型。
2、使用numpy类型时需要小心，以后numpy和tensorflow可能不兼容。

constants的弊端

Constants是存储在图的定义中的。当constants比较大时，加载图会很耗费资源。
为了解决这个问题, 一个使用原则是：只对原始类型使用constants，其他需要更多内存的数据可以使用variables或者readers表示。

variables

一些例子

1
2
3
4
a = tf.Variable(2, name='scalar')
b = tf.Variable([2,3], name='vector')
c = tf.Variable([[0,1],[2,3]], name='matrix')
W = tf.Variable(tf.zeros([784,10]))

一个简单的问题：为什么tf.constant中constant是小写，而tf.Variable中Variable是大写？因为tf.Variable是一个类，tf.constant是一个操作符。遵循python的命名习惯。

如果tf.Variable有一些运算符：

1
2
3
4
5
x = tf.Variable(...)
x.initializer #init op 
x.value() # read op
x.assign(...) # write op
x.assign_add(...) # and more

variables初始化

最简单的方法是一次初始化所有变量

1
2
3
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

初始化部分变量

1
2
3
init_ab = tf.variables_initializer([a,b], name='init_ab')
with tf.Session() as sess:
    sess.run(init_ab)

初始化单个变量

1
2
3
W = tf.Variable(tf.zeros([784,10]))
with tf.Session() as sess:
    sess.run(W.initializer)

tf.Variable.assign()

1
2
3
4
5
W = tf.Variable(10)
W.assign(100)
with tf.Session() as sess:
    sess.run(W.initializer)
    print(W.eval()) # >>10

因为 W.assign(100) 只是创建了一个赋值操作，这个操作要被运行才能起作用，如下所示。并且我们并不需要初始化变量，因为assign_op已经为我们做了这个操作。实际上，初始化操作是赋值操作将变量的初始值赋给变量本身。

1
2
3
4
5
6
W = tf.Variable(10)
assign_op = W.assign(100)
with tf.Session() as sess:
    sess.run(W.initializer)
    sess.run(assign_op)
print(W.eval())  # >>100

1
2
3
4
5
6
7
my_var = tf.Variable(2, name='my_var')
my_var_times_two = my_var.assign(2 * my_var)
with tf.Session() as sess:
    sess.run(my_var.initializer)
    sess.run(my_var_times_two) # >>4
    sess.run(my_var_times_two) # >>8
    sess.run(my_var_times_two) # >>16

以上例子中，每运行一次，my_var都执行乘2操作。

assign_add() 和 assign_sub()

1
2
3
4
5
my_var = tf.Variable(10)
with tf.Session() as sess:
    sess.run(my_var.initializer)
    sess.run(my_var.assign_add(10)) # >>20
    sess.run(my_var.assign_sub(2)) # >>18

assign_add()和assign_sub()操作都不能帮我们初始化变量，因为这两个操作都需要参数的初始值。

每个session都拥有它自己的变量的拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
W = tf.Variable(10)
sess1 = tf.Session()
sess2 = tf.Session()
sess1.run(W.initializer)
sess2.run(W.initializer)
print(sess1.run(W.assign_add(10))) # >>20
print(sess2.run(W.assign_sub(2))) # >>8
print(sess1.run(W.assign_add(100))) # >>120
print(sess2.run(W.assign_sub(50))) # >>-42
sess1.close()
sess2.close()

用一个变量初始化另一个变量

下面这种方法比较常见，但是不够安全。

1
2
W = tf.Variable(tf.truncated_normal([700,10]))
U = tf.Variable(2 * W)

下面这种方法保证了保证了在用W初始化U之前，W的值已经被初始化,所以更加安全。

1
2
W = tf.Variable(tf.truncated_normal([700,10]))
U = tf.Variable(2 * W.initialized_value())

Session 和 InteractiveSesssion

InteractiveSession 和 Session的唯一区别就是InteractiveSession使其成为默认设置。

1
2
3
4
5
6
7
sess = tf.InteractiveSession()
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a * b
# 我们可以只使用'c.eval（）'而不指定上下文'sess'
print(c.eval())
sess.close()

Control Dependencies

API: tf.Graph.control_dependencies(control_inputs)
用来定义哪个操作先被执行。

1
2
3
4
5
# graph g 有 5个操作：a, b ,c ,d ,e
with g.control_dependencies([a,b,c]):
    # 操作d 和 操作e 只在 a,b,c都执行过了之后再执行。
    d = ...
    e = ...

Placeholder

一个tensorflow写的程序通常有两个部分：
1、构建图 2、使用会话执行图中的操作
也就是说我们可以在不知道需要的计算参数的具体数值的前提下构建图。
我们可以在不知道x和y的具体数值的前提下定义函数 f(x,y) = x*2 +y，x和y只是具体数值的占位符。我们可以构建好计算图之后再对变量赋值进行计算。
API: tf.placeholder(dtype, shape=None, name=None)

1
2
3
4
5
a = tf.placeholder(tf.float32, shape=[3])
b = tf.constant([5,5,5],tf.float32)
c = a + b
with tf.Session() as sess:
    print(sess.run(c)) # 因为a并没有任何具体数值，所以会出错。

我们需要使用dictionary将值提供给占位符。
如下所示：

1
2
3
with tf.Session() as sess:
    print(sess.run(c,{a: [1,2,3]}))
# >> [6,7,8]

也可以给占位符多次赋值，如下所示：

1
2
3
with tf.Session() as sess:
    for a_value in list_of_values_for_a:
        print(sess.run(c, {a: a_value}))

其实我们可以通过feed_dict给任何feedable的张量，占位符只是一些必须被feed的量的一种表示。
可以通过 tf.Graph.is_feedable(tensor)判断张量能否被feed。

Feeding values to TF ops

1
2
3
4
5
a = tf.add(2, 5)
b = tf.mul(a, 3)
with tf.Session() as sess:
    replace_dict={a: 15}
    sess.run(b,feed_dict= replace_dict) # returns 45

Lazy Loading

lazy loading的意思是尽量推迟创建或者初始化对象的时间，直到其需要的时候再创建或者初始化。

非lazy loading

1
2
3
4
5
6
7
8
9
x = tf.Variable(10, name='x')
y = tf.Variable(20, name='y')
z = tf.add(x, y)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter('./my_graph',sess.graph)
    for _ in range(10):
        sess.run(z)
    writer.close()

lazy loading

1
2
3
4
5
6
7
8
x = tf.Variable(10, name='x')
y = tf.Variable(20, name='y')
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter('./my_graph',sess.graph)
    for _ in range(10):
        sess.run(tf.add(x,y))
    writer.close()

lazy loading和非lazy loading得到的结果是一样的。但是它们的区别在哪儿呢？
以上例子中普通的加载方法 add操作只执行一次，而lazy loading的方法add操作要执行10次，当操作更复杂时，lazy loading的弊端就显现出来了。这是tensorflow最常见的一个non-bug bugs。
解决方法：
1、从计算/运行操作单独定义操作
2、使用Python属性来确保函数在第一次被调用时也被加载。？？具体怎么实现
Structuring Your Tensorflow Models

参考

Tensorflow Ops Slides
Tensorflow Ops Notes

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true