Tensorflow 介绍和基础操作

介绍

TensorFlow 是⼀个使⽤数据流图进⾏数值计算的开源软件库。
⾃Tensorflow于2015年⾯世伊始, 在中国⽹⺠中的关注度⼀直持续上升, 并且逐步超越其他深 度学习框架, 可以说这就是当今最热⻔的深度学习框架了。
Tensorflow应⽤例子
Google机器翻译
https://www.leiphone.com/news/201611/M8Vco0xHWUELysQX.html
星际争霸
https://www.jiqizhixin.com/articles/2017-08-10-2

数据流图

数据流图用“结点”（nodes）和“线”(edges)的有向图来描述数学计算。
“节点” 一般用来表示施加的数学操作，但也可以表示数据输入（feed in）的起点/输出（push out）的终点，或者是读取/写入持久变量（persistent variable）的终点。
“线”表示“节点”之间的输入/输出关系。这些数据“线”可以输运“size可动态调整”的多维数据数组，即“张量”（tensor）。
张量从图中流过的直观图像是这个工具取名为“Tensorflow”的原因。一旦输入端的所有张量准备好，节点将被分配到各种计算设备完成异步并行地执行运算。

环境搭建

1.java开发的小伙伴可以直接用java开发用具idea然后集成插件Python
2.可以用idea专门为Python设计的软件PyCharm
3.安装一个Anaconda3-5.2.0-Windows-x86_64（深度学习的小伙伴小结一下）

Tensorflow 基础【代码】

直接上代码了（需有编程基础哦）‘

# from __future__ import print_function
import tensorflow as tf

# TensorFlow™ 是⼀个使⽤数据流图进⾏数值计算的开源软件库
# tensorflow 将构建图和执⾏图分成了两个独⽴的步骤
a = tf.constant(32)
print(a)
b = tf.constant(10)
print(b)
c = tf.constant(15)
print(c)
d = tf.add(a, b)
print(d)
# 进⼊图的执⾏,开启session
sess = tf.Session()
print(sess.run(a))
print(sess.run([a, b]))
print(sess.run([a, b, c]))
print(sess.run([a, b, c, d]))

#  tensorflow 称这个过程为 fetch
py_a = sess.run(a)
print(py_a)

# 参数可以是矩阵
mat = tf.constant([[1, 0],[0, 1]])
print(sess.run(mat))

# tensor 还可以有名字, 在定义每个 tensor 的时候添加参数 name 的值就可以.这是⼀个可选参数, 不过在后⾯有 很⼤的意义
my_name_is_hello = tf.constant('Hello', name='Hello')
my_name_is_world = tf.constant('World', name='World')

print('tensor {}: {}'.format(my_name_is_hello.name, sess.run(my_name_is_hello)))
print('tensor {}: {}'.format(my_name_is_world.name, sess.run(my_name_is_world)))

# 加减乘除
d = tf.add_n([a, b, b])
e = tf.subtract(a, b)
f = tf.multiply(a, b)
g = tf.divide(a, b)
h = tf.mod(a, b)

print(sess.run(d))
print(sess.run(e))
print(sess.run(f))
print(sess.run(g))
print(sess.run(h))

# 高阶函数  sin e的X次方

a_float = tf.cast(a, dtype=tf.float32)
b_float = tf.cast(b, dtype=tf.float32)

i = tf.sin(a_float)
j = tf.exp(tf.divide(1.0, a_float))
k = tf.add(i, tf.log(i))

print(sess.run(i))
print(sess.run(j))
print(sess.run(k))


# l = tf.divide(1, tf.add(1, tf.exp(a_float)))
l = tf.sigmoid(a_float)
print(sess.run(l))

sigmoid1 = tf.divide(1.0, tf.add(1.0, tf.exp(-b_float)))

print(sess.run(sigmoid1))


# 可以通过 reshape 改变形状 tensorflow ⽀持矩阵操作, broadcast 机制
mat_a = tf.constant([1, 2, 3, 4])
mat_a = tf.reshape(mat_a, (2, 2))
mat_b = tf.constant([1, 3, 5, 7, 9, 11])
mat_b = tf.reshape(mat_b, (2, 3))
vec_a = tf.constant([1, 2])

mat_c = tf.matmul(mat_a, mat_b)
mat_d = tf.multiply(mat_a, vec_a)

print(sess.run(mat_a))
print(sess.run(mat_b))
print(sess.run(mat_c))
print(sess.run(mat_d))

zeros = tf.zeros((2, 3), dtype=tf.int32)
zeros_like = tf.zeros_like(zeros)
ones_like = tf.ones_like(zeros)
fill = tf.fill((2, 4), 2)
linspace = tf.linspace(1.0, 5.0, 5)
ranger = tf.range(3, 18, delta=3)

print('{}:\n{}\n'.format('zeros', sess.run(zeros)))
print('{}:\n{}\n'.format('zeros_like', sess.run(zeros_like)))
print('{}:\n{}\n'.format('ones_like', sess.run(ones_like)))
print('{}:\n{}\n'.format('fill', sess.run(fill)))
print('{}:\n{}\n'.format('linspace', sess.run(linspace)))
print('{}:\n{}\n'.format('range', sess.run(ranger)))

# random tensors

rand_normal = tf.random_normal((), mean=0.0, stddev=1.0, dtype=tf.float32, seed=None)
truncated_normal = tf.truncated_normal((), mean=0.0, stddev=1.0, dtype=tf.float32, seed=None)
rand_uniform = tf.random_uniform((), minval=0.0, maxval=1.0, dtype=tf.float32, seed=None)

for i in range(5):
    print('time: %d' % i)
    print('rand_normal: %.4f' % sess.run(rand_normal))
    print('truncated_normal: %.4f' % sess.run(truncated_normal))
    print('rand_uniform: %.4f' % sess.run(rand_uniform))





# Variable
var_a = tf.Variable(0, dtype=tf.int32)
var_b = tf.Variable([1, 2], dtype=tf.float32)
var_w = tf.Variable(tf.zeros((1024, 10)))

##开启交互式`session`
sess = tf.InteractiveSession()

##⼀次性初始化所有的变量
init = tf.global_variables_initializer()
###⼀般`session`的⽅法
sess.run(init)
###`InteractiveSession`的⽅法
init.run()

##初始化某些变量
init_ab = tf.variables_initializer([var_a, var_b])
init_ab.run()

## 初始化某个变量
var_w.initializer.run()

W = tf.Variable(10)
sess.run(W.initializer)
print(W)
print(sess.run(W))
print(W.eval())


W.assign(100)
W.initializer.run()
print(W.eval(sess))

# assign 是为 variable 赋值的⼀个 op ,⼤家可以看下⾯的代码来理解 operation 和 assign 的应⽤
assign_op = W.assign(100)
W.initializer.run()
assign_op.eval()
print(W.eval())

# assign_add 和 assign_sub 对应与我们平常理解的 i++ 和 i-- , 也是 variable 的常⽤ op
print("assign_add")

assign_add = W.assign_add(10)
assign_sub = W.assign_sub(2)

W.initializer.run()
print(assign_add.eval())
print(assign_add.eval())
print(assign_sub.eval())
print(W.eval())

# 我们可以给⼀些 tensor 添加⼀个名称域，这样所有的变量名称都有⼀个共同的前缀.
# 我们可以通过 tf.name_scope 或者 tf.variable_scope 来实现

with tf.name_scope('name_scope'):
    var_a = tf.Variable(0, dtype=tf.int32)
    var_b = tf.Variable([1, 2], dtype=tf.float32)
with tf.variable_scope('var_scope'):
        var_c = tf.Variable(0, dtype=tf.int32)
        var_d = tf.Variable([1, 2], dtype=tf.float32)
        print(var_a.name)
        print(var_b.name)
        print(var_c.name)
        print(var_d.name)

# Placeholder 占位符

##定义⼀个占位符 ##`tf.placeholder(dtype, shape=None, name=None)`

# 定义⼀个`float32`型的占位符,它是⼀个⻓为3的向量
a = tf.placeholder(tf.float32, shape=[3])

# 定义⼀个`bool`型的占位符, 它是⼀个`1x2`的矩阵
b = tf.placeholder(tf.bool, shape=[1, 2])

print(sess.run(a, feed_dict={a: [1, 2, 3]}))
print(sess.run([a, b], feed_dict={a: [1, 2, 3], b: [[True, False]]}))


sess.close()