TensorFlow入门记录第二天

TensorFlow常量，变量，占位符和矩阵基础运算

TensorFlow里用张量来定义所有的数据类型，看做是一个n维的矩阵，所有的数据类型，包括矩阵等都可以看做是特殊的张量

1.常量（固定值的张量）
常见常用的声明方式有这几种

#声明一个常量
num1 = tf.constant(1)
#声明一个向量
num2 = tf.constant([1,2,3,4,5,6,7])
#声明一个3*3 值为1的矩阵
num3 = tf.constant([[1,1,1],[1,1,1],[1,1,1]])
#声明一个3*3 值全为5的矩阵
num4 = tf.constant(5,shape=[3,3])
#声明一个4*4 值全为6的矩阵
num5 = tf.fill([4,4],6)
#声明一个3*3 值全为0的矩阵
num6 = tf.zeros([3,3],tf.int32)
#声明一个4*4 值全为1的矩阵
num7 = tf.ones([4,4],tf.int32)

定义时可以直接赋值，也可以通过一些函数去给整体赋值，比如：tf.fill()函数用值填充指定大小的矩阵，用shape填充指定大小的矩阵，用tf.zeros(),tf.ones()创建一个值全为0或1的矩阵。

还有一些常用的初始化函数，用来创建不同分布的随机张量

1. tf.random_normal()
   用于生成一个服从正态分布的随机数组

2. tf.truncated_normal()
   用于生成一个服从截断的正态分布的随机数组，就是当随机值偏离均值2个
   标准差以上时，会重新生成这个数

3. tf.random_uniform()
   用于生成一个服从均匀分布的随机数组

4. tf.random_gamma()
   用于生成一个服从伽马分布的随机数组

#参数：1.输出生成的形状，这里为2*2数组     2.指定均值默认为0.0     3.指定标准差默认为1.0
#      4.指定数据类型默认为tf.float32 5.指定随机数种子默认为None 6.指定变量名默认为None
random_num1 = tf.random_normal([2,2],0.0,1.0,tf.float32,None,None)

#参数类型同上
random_num2 = tf.truncated_normal([2,2],0.0,1.0,tf.float32,None,None)

#参数： 1.输出生成的形状，这里为2*2数组  2.指定最小值默认为0  3.指定最大值默认为None 4.后三个同上
random_num3 = tf.random_uniform([2,2],0,None,tf.float32,None,None)

#参数： 1.输出生成的形状，这里为2*2数组  2.alpha分布参数  3.bate分布参数默认为None   4.后三个同上
random_num4 = tf.random_gamma([2,2],3,None,tf.float32,None,None)

2.变量（需要在会话中更新的量）

Tensorflow中的变量是用Variable类来创建的，使用时用 initial_value 参数指定初始化函数， name 参数指定自定义的变量名。

变量可以用常量或者常量的一些函数去定义，同时也可以用一个变量去定义另一个变量。与常量不同的是变量的定义指定了它初始化的方法，在没有运行之前要使用对变量进行显式初始化，TensorFlow中用统一的初始化方法tf.global_variables_initializer()去进行初始化。变量也可以在运行图中用 tf.Variable.initializer 进行初始化。最后保存变量用Saver类来保存。

#使用常量的初始化函数定义变量
num1 = tf.Variable(tf.random_normal([2,2],stddev=1))
num2 = tf.Variable(tf.ones([3,3],tf.float32))

rand = tf.random_uniform([4,4],0,10)
num3 = tf.Variable(rand)

#使用变量定义变量
num4 = tf.Variable(num1.initialized_value())

#直接定义
num5 = tf.Variable([1])

还需要在会话之前对所有变量进行显式初始化

all = tf.global_variables_initializer()
with tf.compat.v1.Session() as sess:
    sess.run(all)
#或者
with tf.compat.v1.Session() as sess:
    sess.run(tf.global_variables_initializer())    

也可以单独对变量初始化

with tf.compat.v1.Session() as sess:
    sess.run(num1.initializer)
    sess.run(num2.initializer)
    sess.run(num3.initializer)
    sess.run(num4.initializer)
    sess.run(num5.initializer)

3.占位符（提供数据给计算图）
占位符使用 tf.placeholder(dtype,shape=None,name=None) 方法定义，用于声明一个张量的数据格式，但还没有确定具体的值，要等到正式运行时才会赋值。这是TensorFlow中一种解决大量训练数据的问题的机制，它可以不用定义时赋值，随着训练的开始，再给占位符传送数据。

tf.placeholder()的数据维度 可以根据给定的数据计算得到，给出确定的维度，也可以不给出。在会话中运行时，在需要用到占位符时通过 feed_dict 参数传入它的值，feed_dict也可以同时设置多个占位符的值，但要注意在用feed_dict设置tensor的时候赋值的类型必须要和占位符的定义类型相同。在使用变量赋值占位符的时候别忘了要先显式初始化变量。

#定义一个string类型的占位符
x = tf.placeholder(tf.string)
#定义一个2*2的矩阵，并赋值为[1,2][3,4]
y = tf.constant([[1,2],[3,4]],tf.int32)
#定义一个2*2的矩阵，类型为int32的占位符，也可以不用设置而shape的维度
z = tf.placeholder(tf.int32,shape=[2,2])

with tf.Session() as sess:
    y = sess.run(y)
    #给占位符x赋值为Test String
    output = sess.run(x, feed_dict={x: 'Test String'})
    #给占位符z赋值为y
    output_1 = sess.run(z,feed_dict={z:y})

4.TensorFlow矩阵基础运算

#分别定义3个矩阵，分别赋值
a = tf.constant([[1,1,1],[2,2,2]],tf.int32)
b = tf.constant([[2,2,2],[3,3,3]],tf.int32)
c = tf.constant([[3,3],[4,4],[5,5]],tf.int32)

#分别做 加减乘除 操作，也可以直接使用a+b a-b a*b a/b
out_1 = tf.add(a,b)
out_2 = tf.subtract(a,b)
out_3 = tf.multiply(a,b)
out_4 = tf.divide(a,b)

#做矩阵乘法
out_5 = tf.matmul(a,c)

这里要注意的是tf.multiply()是两个矩阵对应元素相乘且两个矩阵的数据类型要相同，而tf.matmul()则是线性代数中的两个矩阵相乘，而且tf.matmul()还有其他的参数。

tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)

参数:
a: 一个类型为 float16, float32, float64, int32, complex64, complex128 且张量秩 > 1 的张量。
b: 一个类型跟张量a相同的张量。
transpose_a: 如果为真, a则在进行乘法计算前进行转置。
transpose_b: 如果为真, b则在进行乘法计算前进行转置。
adjoint_a: 如果为真, a则在进行乘法计算前进行共轭和转置。
adjoint_b: 如果为真, b则在进行乘法计算前进行共轭和转置。
a_is_sparse: 如果为真, a会被处理为稀疏矩阵。
b_is_sparse: 如果为真, b会被处理为稀疏矩阵。
name: 操作的名字（可选参数）
返回值： 一个跟张量a和张量b类型一样的张量且最内部矩阵是a和b中的相应矩阵的乘积。
注意：
（1）输入必须是矩阵（或者是张量秩 >２的张量，表示成批的矩阵），并且其在转置之后有相匹配的矩阵尺寸。
（2）两个矩阵必须都是同样的类型，支持的类型如下：float16, float32, float64, int32, complex64, complex128。