tensorflow函数介绍(1)

tensorflow中的tensor表示一种数据结构，而flow则表现为一种计算模型，两者合起来就是通过计算图的形式来进行计算表述，其每个计算都是计算图上的一个节点，节点间的边表示了计算之间的依赖关系。一般的tensorflow程序分为两个阶段，在第一阶段定义计算图需要的变量，第二个阶段定义计算模型，最后通过执行计算来得到运行结果。

import tensorflow as tf

1、常数及矩阵

m1=tf.constant([[3.,3.]])     #产生两行一列的矩阵（创建一个常量tensor）
m2=tf.constant([[3.],[3.]])   #产生两列一行的矩阵
result=tf.matmul(m1,m2)    #矩阵相乘
sess=tf.Session()
sess.run(result)      #运行选中节点并返回值
sess.close()    #关闭会话
#其中sess=tf.session()和sess=tf.InteractiveSession()区别在于后者便于交互式，后者倾向于运算前提交整个计算图
tf.ones(shape=[2,2])     #维度为shape的全为1的矩阵
tf.zeros(shape=[3,3])    #维度为shape的全为0的矩阵
tf.constant([3.0, 3.0])    #产生常量列表，可sess.run()
tf.random_normal(shape=[2,2],stddev=2)    #产生正态分布随机数，stddev为标准差
tf.random_uniform(shape=[2,2],minval=0,maxval=None)   #产生均匀分布随机数，最小为...,最大为...
tf.fill([2,3],9)    #对矩阵内容以9来填充
x=tf.constant([[1.,2.],[3.,4.]])
sess.run(tf.reduce_mean(x))    #reduce_mean 返回均值，若tf.reduce_mean(x,0)则返回第一行的均值，参数0改为1则返回第二行均值 
x=tf.Variable([1.0, 2.0]) #创建变量列表（定义一个变量），不可直接sess.run() 
test=np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]]) 
tf.argmax(test,0)  #返回每一列最大项所在位置
tf.argmax(test,1)  #返回每一行最大项所在位置
tf.cast(a,tf.float32)  #将变量a转换为指定格式（tf.float32）
tf.group(a1,a2)
tf.shape(a)   #返回a的维度
tf.reshape(a,[5,1])  #将a的维度转为[5,1]
#若a=[[[1, 1, 1],[2, 2, 2]],[[3, 3, 3],[4, 4, 4]],[[5, 5, 5],[6, 6, 6]]]
tf.reshape(a,[-1,9])  #则返回[[1, 1, 1, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 6, 6, 6]]
tf.reshaoe(a,[2,-1])  #则返回[[1, 1, 1, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 6, 6, 6]]    这里和上面的-1含义不需要我们指定维度的大小，函数会自动计算，但列表里只能有1个-1
tf.equal(a,b)   #判断a和b是否相同，相同则返回True,否则返回False
tf.sqrt(x)       # 对x开根号
tf.square(x)     # x的平方
a=tf.constant([1,2,3])
b=tf.constant([4,5,6])
c=tf.stack([a,b],axis=0)   #将a和b按照0轴合并
d=tf.unstack(c,axis=0)    #将c按照0轴进行拆分
A=np.array([[1,2,3],[4,5,6]])
tf.transpose(A,[1,0])   #将A的0维和1维进行交换，也相当于转置
B=np.array([[[1,2,3],[4,5,6]]])
tf.transpose(B, [2,1,0])    #将B的0维、1维、1维进行替换，替换顺序从原来的[0,1,2]转换成[2,1,0]，在该例中也就是第一维和第三维进行转换
tf.decode_raw(image,tf.uint8)    #将tf.decode_raw可以将字符串转换成uint8的张量，其中tf.uint8为无符号整型，tf.int8为有符号整型

2、变量

#或者这样定义变量

w=np.array([[1,1,1],[2,2,2],[3,3,3]])       
x=tf.Variable(initial_value=w)       #先通过np定义，后导入tf                                  
init=tf.global_variables_initializer()     #变量定义完后，显式地执行所有变量初始化操作才可进行下一步
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(x))
w_2 = tf.get_variable(name="w_1",initializer=2)   #定义变量w_1,初始化为2

sess.run(x.initializer)    #变量定义后也可以选择单个变量初始化，然而若需要初始化的变量过多，则选择上面的init=tf.global_variables_initializer()来进行初始化
sess.run(x)   #继上再sess.run()
tf.get_variable(shape=[2,2],name='xiaoli')   #判断是否存在该变量名，若存在则调用该变量，若不存在则创建名为name的变量
bias = tf.get_variable("bias", shape=[2,2],initializer=tf.zeros_initializer())     #变量初始化填补，以1来填充
tf.Variable(tf.random_normal(shape=[5,5],stddev=1),name='zhangsan')  #创建初始变量
tf.Variable(tf.ones(3,3),name='cccc')  
tf.Variable(tf.constant([1,2,3]),name='cccc')
a=tf.Variable(0,dtype=tf.float32)
tf.assign(a,2)   #将2赋值给a
b=tf.assign_add(a,2)   #将a的值加上2并将结果赋值给b
a=tf.Variable(tf.constant([1,2],shape=[1,2]),dtype=tf.int32)   #在Variable步骤初始化a并设置a的维度
a=tf.Variable([1])
a.dtype()  #返回tensor的数据类型
a.name    #返回a的名称
a.graph   #返回该tensor所在的图
a.op   #返回产生该tensor的op
a.get_shape()  #返回该tensor的shape
a.set_shape()   #更新tensor的shape
a.device    #设置计算该tensor的设备
a=tf.get_variable(name='a',shape=[1,2],initializer=tf.constant_initializer([1,2]))
tf.get_variable_scope().reuse_variables()     #该操作使得tf.get_variable()变量可以重复构建
a=tf.get_variable(name='a',shape=[1,2],initializer=tf.constant_initializer([1,2]))    

3、占位符

x=tf.placeholder(tf.float32,shape=[5,5])        #先占位置
y=tf.matmul(x,x)
with tf.Session() as sess:
    a=np.random.rand(5,5)           
    print(sess.run(y,feed_dict={x:a}))      #后通过sess.run()里的feed_dict进行填充

4、加减法和乘法

例1：

x=tf.Variable(tf.ones(shape=[3,3]))
y=tf.Variable(tf.ones(shape=[3,3]))
z=tf.matmul(x,y)                 #乘法
z=tf.add(x,y)             #加法
z=tf.subtract(x,y)             #减法
init=tf.global_variables_initializer()     
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(z))

例2：

a=tf.placeholder(tf.int16)
b=tf.placeholder(tf.int16)
c=tf.add(a,b)
with tf.Session() as sess:
    print(sess.run(c,feed_dict={a:2,b:3}))

 5、tensor的连接及操作

a=[[1,1,1,1],[2,2,2,2],[3,3,3,3],[4,4,4,4]]
b1=tf.shape(a)
b2=tf.size(a)
b3=tf.reshape(a,[2,-1])
with tf.Session() as sess:
    print(sess.run(b1))           #获取维度
    print(sess.run(b2))          #获取size
    print(sess.run(b3))       #将原数据进行维度转换

t1 = [[1, 2, 3], [4, 5, 6]]
t2 = [[7, 8, 9], [10, 11, 12]]
with tf.Session() as sess:
    print(sess.run(tf.concat([t1,t2],0)))    #将t1和t2按照行合并，参数设置为0
    print(sess.run(tf.concat([t1,t2],1)))    #将t1和t2按照列合并，参数设置为1

  6、出现重复变量后的variable_scope()和name_scope()区别

(1)这里分别以name_scope()和variable_scope()的两个例子为例：

with tf.name_scope('name1'):
    var1=tf.Variable(name='var1',initial_value=[2],dtype=tf.float32)
    var2=tf.Variable(name='var1',initial_value=[2.2],dtype=tf.float32)
    var3=tf.Variable(name='var1',initial_value=[2.3],dtype=tf.float32)
with tf.Session() as sess:
    init=tf.global_variables_initializer()
    sess.run(init)
    print(var1.name)         #输出name1/var1:0
    print(sess.run(var1))   #输出[ 2.]
    print(var2.name)    #输出name1/var1_1:0
    print(sess.run(var2))   #输出[ 2.20000005]
    print(var3.name)    #输出name1/var1_2:0
    print(sess.run(var3))   #输出[ 2.29999995]

从上述结果可以发现，通过tf.name_scope()区域下，虽然变量重复定义，但其实生成了不同的变量名

with tf.variable_scope('bar') as scope:
    initializer=tf.constant_initializer(value=3) 
    var3=tf.get_variable(name='var3',shape=[1],initializer=initializer)
    scope.reuse_variables()
    var4=tf.get_variable(name='var3')
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(var3.name)   #输出bar/var3:0
    print(sess.run(var3))    #输出[ 3.]
    print(var4.name)   #输出bar/var3:0
    print(sess.run(var4))   #输出[ 3.]

 对于重复命名的变量，通过scope.reuse_variables()来处理

  (2)重复命名的变量的又一个例子(这次通过在variable_scope里增加参数reuse=True来重复提取变量)

import tensorflow as tf
with tf.variable_scope('layer1') as scope:
    weights=tf.get_variable('weight',[2,2],initializer=tf.constant_initializer(1.))
    x=tf.constant([1.,2.,1.,2.],shape=[2,2])
    layer1=tf.nn.relu(tf.matmul(x,weights))
with tf.variable_scope('layer1',reuse=True):
    weights=tf.get_variable('weight')        #tf.get_variable用于判断是否存在相同命名的变量，有则返回该变量，相反的tf.Variable用于每次都能创建新的变量
    x=tf.constant([3.,3.,3.,3.],shape=[2,2])
    layer2=tf.nn.relu(tf.matmul(x,weights))
sess=tf.Session()
init=tf.global_variables_initializer()
sess.run(init)
sess.run(layer1)
sess.run(layer2)

 7、group和tuple的使用

w = tf.Variable(1)
mul = tf.multiply(w, 2)
add = tf.add(w, 2)
group = tf.group(mul, add)   #group返回的是operation
tuple = tf.tuple([mul, add])   #tuple返回的是tensor(张量)
sess=tf.Session()
sess.run(w.initializer)
sess.run(group)   #不输出值
sess.run(tuple)     #返回的是mul和add的计算结果

 8、session.run和tensor.eval区别

参考来源：http://blog.csdn.net/zcf1784266476/article/details/70259676

假若有一个tensor，那么t.eval()等价于tf.get_default_session().run(t)

相比于t.eval，sess.run()可以一次获得多个tensor中的值，以如下为例：

t = tf.constant(42.0)
u = tf.constant(37.0)
tu = tf.multiply(t, u)
ut = tf.multiply(u, t)
init=tf.global_variables_initializer()
with sess.as_default():
    sess.run(init)
    print(tu.eval())  # runs one step
    print(ut.eval()) # runs one step
    print(sess.run([tu, ut]))

 9、tf.reduce_mean()和tf.expand_dims()

tf.trainable_variables()    ＃返回所有当前计算图中，在获取变量时未被标记trainable=False的变量集合
#设x为[[1.,2.],[3.,4.]]
tf.reduce_mean(x)   #返回2.5
tf.reduce_mean(x,0)   #返回[2.,3.]，计算每列的均值
tf.reduce_mean(x,1)   #返回[1.5,3.5]，计算每行的均值

# 't' is a tensor of shape [2]
tf.shape(tf.expand_dims(t, 0)) ==> [1, 2]
tf.shape(tf.expand_dims(t, 1)) ==> [2, 1]
tf.shape(tf.expand_dims(t, -1)) ==> [2, 1]
# 't2' is a tensor of shape [2, 3, 5]
tf.shape(tf.expand_dims(t2, 0)) ==> [1, 2, 3, 5]
tf.shape(tf.expand_dims(t2, 2)) ==> [2, 3, 1, 5]
tf.shape(tf.expand_dims(t2, 3)) ==> [2, 3, 5, 1]

 10、tf.train.global_step

 首先构建变量来放global_step的值，trainable要设置为False，这样传播的时候就不会修改global_step的值。

 tf.train.global_step()用来获取当前sess的global_step值。

建立global_step的过程如下：

global_step=tf.Variable(0,trainable=False,name='global_step')
global_step=tf.get_variable('global_step',[],initializer=tf.constant_initializer(0),trainable=False)

若是使用minimize，则将global_step作为参数传入minimize

global_step = tf.Variable(0,trainable=False)
increment_op = tf.assign_add(global_step,tf.constant(1))
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)
for step in range(0,10):
　　....
    print(sess.run(increment_op))    #返回1 2 3 4 5 6 7 8 9 10

increase = tf.Variable(0, trainable=False, name='global_step')
for _ in range(10):
    increase=tf.assign_add(increase,tf.constant(1))
    sess = tf.Session()
    init=tf.global_variables_initializer()
    sess.run(init)
    print('global_step: %s' % tf.train.global_step(sess, increase))

 11、tf.slice() 取切片

import numpy as np
x=np.arange(24).reshape([2,3,4])  
begin_x=[1,0,0]
size_x=[1,2,3]            #分别表示从begin_x开始，在各维度取多少个元素
out=tf.slice(x,begin_x,size_x)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(out))