【TensorFlow】张量对象，变量空间variable_scope，矩阵基本操作

TensorFlow

TensorFlow为深度神经网络（DNN）开发的功能强大的开源软件库。

安装：win10安装CPU-【tensorflow2.0.0】+Anaconda(python3.7)

其中报错：解决Anaconda出现CondaHTTPError: HTTP 000 CONNECTION FAILED for url问题

使用：在jupyter中使用Tensorflow
windows，Pycharm，Spyder
尝试了很久，我只能在Pycharm使用，至少有一个能用了，不那么崩溃。

1 程序结构

将一个TensorFlow程序分为两个阶段：
第一个阶段是定义计算图中的运算，程序的这部分内容放在Session前面；
第二阶段是运算的执行，程序的这部分内容由Session来完成。

一个TensorFlow小程序

import tensorflow as tf

# 定义。创建想要计算的图：一个常量字符串
message = tf.constant("Welcome~")

# 执行。with关键字创建会话，在会话中执行以上计算图
with tf.Session() as sess:
    print(sess.run(message)) # b'Welcome~'
    print(sess.run(message).decode()) # Welcome~

'''
sess = tf.Session()
print(sess.run(message).decode())
sess.close()
'''

tf.Session()定义一个会话对象sess。计算图的执行则使用 sess.run() 语句，sess.run求取message中所定义的tensor值；计算图执行结果输入到print函数，并使用decode方法改进。“b”（表示字节，byte）。

• 计算图：是包含节点和边的网络。每个节点可以有零个或多个输入，但只有一个输出。网络中的节点表示对象（张量和运算操作），边表示运算操作之间流动的张量。使用会话对象来实现计算图的执行。
• 张量（tensor）对象：常量、变量和占位符。
• 会话对象：封装了评估张量和操作对象的环境。不同张量对象的值仅在会话对象中被初始化、访问和保存。在此之前张量对象只被抽象定义，在会话中才被赋予实际的意义。每个会话都需要使用 close()来明确关闭，而with格式可以在运行结束时隐式关闭会话。

一个向量加法

import tensorflow as tf

v_1 = tf.constant([1, 2, 3, 4])
v_2 = tf.constant([2, 1, 5, 3])
v_add = tf.add(v_1, v_2)

with tf.Session() as sess:
    print(sess.run(v_add))

print(tf.Session().run(tf.add(tf.constant([1, 2, 3, 4]), tf.constant([2, 1, 5, 3]))))

2 张量

张量，可理解为一个n维矩阵，所有类型的数据，包括标量、矢量和矩阵等都是特殊类型的张量。
所有常量、变量和占位符将在代码的计算图部分中定义。如果在定义部分使用print语句，只会得到有关张量类型的信息，而不是它的值。为了得到相关的值，需要创建会话图并对需要提取的张量显式使用运行命令。

TensorFlow 支持以下三种类型的张量：

1. 常量
2. 变量：变量在使用前需要被显示初始化。常量存储在计算图的定义中，每次加载图时都会加载相关变量（占用内存）。另一方面，变量又是分开存储的。它们可以存储在参数服务器上。变量通常在神经网络中表示权重和偏置。
3. 占位符：用于将值输入TensorFlow图中。它们可以和 feed_dict 一起使用来输入数据。在训练神经网络时，它们通常用于提供新的训练样本。在会话中运行计算图时，可以为占位符赋值。这样在构建一个计算图时不需要真正地输入数据。占位符不包含任何数据，因此不需要初始化。

2.1 常量

import tensorflow as tf

t1 = tf.constant(4) # 标准常量
t2 = tf.constant([4,3,2]) # 常向量

zero_t = tf.zeros([2,3], tf.int32) # 零元素矩阵
zero_t2 = tf.zeros_like(t2) # 与现有张量形状相同的张量常量
ones_t = tf.ones([2,3], tf.int32)

# 范围序列。从初值到终值等差排布的序列
range_t = tf.linspace(2.0,5.0,5)  # [2.   2.75 3.5  4.25 5.  ]
range_t2 = tf.range(10) # [0 1 2 3 4 5 6 7 8 9]

# 具有不同分布的随机张量
random_t1 = tf.random_normal([2,3], mean=2.0, stddev=4,
                             seed=12) # 正态分布随机数组
random_t2 = tf.truncated_normal([1,5], stddev=2, seed=12) # 截尾正态分布随机数组
random_t3 = tf.random_uniform([2,3], maxval=4, seed=12) # 伽马分布随机数组
tf.set_random_seed(54)
random_t4 = tf.random_crop(random_t1, [2,2], seed=12)
random_t5 = tf.random_shuffle(random_t4)

with tf.Session() as sess:
    print(sess.run(random_t4))
    print(sess.run(random_t5))

tf中张量与常规向量不同的是执行"print(t)"输出的是t的形状和数据类型等属性信息，获取t的值需要调用sess.run(t)方法。

方法：

• tf.constant()：创建一个常数张量，传入list或者数值来填充。
• tf.zeros([M,N],tf.dtype) ：创建一个所有元素为零的张量。形如[M，N]的零元素矩阵，数据类型（dtype）可以是int32、float32等。tf.ones()：创建一个所有元素都设为 1 的张量。
• tf.zeros_like(t2)：创建与现有 Numpy 数组或张量常量具有相同形状的张量常量。
• tf.linspace(start,stop,num)：在一定范围内生成一个从初值到终值等差排布的序列，相应的值为 (stop-start)/(num-1)。
• tf.range(start,limit,delta)：从开始（默认值=0）生成一个数字序列，增量为 delta（默认值=1），直到终值（但不包括终值）。
• tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)：从服从指定正太分布的数值中取出指定个数的值。参数shape: 输出张量的形状，必选。mean: 正态分布的均值，默认为0。stddev: 正态分布的标准差，默认为1.0。dtype: 输出的类型，默认为tf.float32。seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样。name: 操作的名称。
• tf.random_crop()：将给定的张量随机裁剪为指定的大小。
• tf.random_shuffle() ：沿着它的第一维随机排列张量。
• tf.set_random_seed() ：为所有随机产生的张量设置种子。
• tf.fill(dims, value, name)：产生一个值为给定数字的数组。

TensorFlow随机数生成函数：

• tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)：正态分布
• tf.truncated_normal() ：截尾正态分布随机数组。如果随机出来的值偏离平均值超过2个标准差，那么这个数就会被重新随机。
• tf.random_uniform(shape, minval, maxval, dtype=tf.float32, seed=None, name=None) ：平均分布。
• tf.random_gamma()：伽马分布随机数组。

2.2 变量

对于神经网络，参数是一个重要的组成部分。在TensorFlow中，变量的作用就是保护网络中的参数，网络中参数的更新就是相应变量的重新赋值。
变量的用途不仅仅是用来作为神经网络的参数。变量声明函数中的trainable参数可以区分变量是否能被训练（优化），能够被训练的变量通常会作为神经网络的参数。

import tensorflow as tf

# 使用常量初始化变量
rand_t = tf.random_uniform([50,50], 0, 10, seed=0) # 常量。随机分布数组
t1 = tf.Variable(rand_t) # 变量
weights = tf.Variable(tf.random_normal([100,100],stddev=2))

# 指定一个变量来初始化另一个变量
w2 = tf.Variable(weights.initialized_value(), name='w2')

# 在计算图的定义中通过声明初始化操作对象来实现
intial_op = tf.global_variables_initializer() # 定义为出初始化全部变量的操作
# sess.run(intial_op)

# 在运行图中初始化
bias = tf.Variable(tf.zeros([100,100])) # 偏置项（神经网络中使用）
with tf.Session() as sess:
    sess.run(bias.initializer) # 变量初始化

# 对变量分配值
q1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
q2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))
tf.assign(q1, q2, validate_shape=False) # 将q2参数的值赋给q1

变量的定义还包括应该初始化的常量/随机值。一个变量在被使用之前，这个变量的初始化过程都需要被明确调用。初始化过程在运行会话时完成，

方法：

• tf.Variable()：通过变量类创建变量，需要初始值。一个变量在构建之后，类型不能再更改。但是维度可以在程序运行中，通过设置参数validate_shape=False来改变。name参数指定变量名称。
• initialized_value()：Variable类有这个方法，对变量进行初始化。用于创建一个依赖于其他变量的变量。
• global_variables_initializer()：变量初始化方式，它可以添加一个op到graph里，这个op可以初始化所有变量。在launch图后，运行这个op。同样，**initialize_all_variables()**函数有相同功能，版本更早一些。
• tf.Variable.initializer：在运行图中单独使用来初始化每个变量。initializer是Variable类的一个属性。
• tf.assign(ref, value, validate_shape, use_locking, name)：用于对变量分配值。

2.2.1 管理变量的变量空间variable_scope()

import tensorflow as tf

# 在名为one的变量空间内创建名字为"a"的变量
with tf.variable_scope("one"):
    a = tf.get_variable("a", [1], initializer=tf.constant_initializer(1.0))

# 生成上下文管理器，获取已经声明的变量
with tf.variable_scope("one", reuse=True):
    a2 = tf.get_variable("a", [1])
    print(a.name, a2.name) # one/a:0 one/a:0

“:0”的输出表示这个变量是生成这个变量运算的第一个结果。

方法：

• get_variable()：用于创建或获取变量。通过initializer参数提供初始化方式。name属性是必选参数，因为函数会根据这个名字来创建/获取变量。在相同的变量空间不能使用get_variable()创建name属性相同的两个变量。
• variable_scope()：用于创建变量空间。在变量空间内创建的变量都会带上这个变量空间的名称作为前缀。参数resue默认为False，get_variable()创建新变量，不可以name同名。resue=True，生成上下文管理器，直接获取name属性相同的已经创建的变量，变量不存在报错。

TensorFlow变量初始化函数：

• tf.constant_initializer(const)：常量初始化函数
• tf.random_normal_initializer()：正态分布初始化函数
• tf.truncated_normal_initializer(mean = 0.0, stddev = 1.0, seed = None, dtype = dtypes.float32)：截取的正态分布初始化函数
• tf.random_uniform_initializer(minval = 0, maxval = None, seed = None, dtype = dtypes.float32)：均匀分布初始化函数
• tf.zeros_initializer()：全0常量初始化函数
• tf.ones_initializer()：全1常量初始化函数
• tf.uniform_unit_scaling_initializer(factor = 1.0, seed = None, dtype = dtypes.float32)：将变量初始化为满足平均分布但不影响输出数量级的随机数值。

2.2.2 变量空间嵌套

import tensorflow as tf

# 在变量空间外部创建变量a
a = tf.get_variable("a", [1], initializer=tf.constant_initializer(1.0))
print(a.name) # a:0

# 生成上下文管理器，获取已经声明的变量
with tf.variable_scope("one"):
    a2 = tf.get_variable("a", [1], initializer=tf.constant_initializer(1.0))
    print(a2.name)  # one/a:0
    print(tf.get_variable_scope().reuse) # False

# 变量空间嵌套
with tf.variable_scope("one"):
    with tf.variable_scope("two"):
        a3 = tf.get_variable("a", [1])
        print(a3.name) # one/two/a:0

    b = tf.get_variable("b", [1])
    print(b.name) # one/b:0

with tf.variable_scope("", reuse=True):
    a4 = tf.get_variable("one/two/a", [1])
    print(a4==a3) # True

tf.get_variable_scope().reuse获取reuse参数的取值。

2.2.3 tf.name_scope()

import tensorflow as tf

with tf.name_scope("one"):
    a = tf.get_variable("a", [1])
    print(a.name)  # a:0

    b = tf.Variable([1], name="b")
    print(b.name) # one/b:0

name_scope()和variable_scope()功能类似，没有reuse参数。在创建变量时，使用get_variable()不添加变量空间名前缀。Variable()会添加变量空间名前缀。而variable_scope()中创建的所有变量都带有变量空间名前缀。

name_scope()用于可视化计算图时，方便以节点的形式查看数据。

2.3 占位符

import tensorflow as tf

x = tf.placeholder("float")
y = 2*x
data = tf.random_uniform([4, 5], 10)

with tf.Session() as sess:
    x_data = sess.run(data)
    print(sess.run(y, feed_dict={x:x_data}))

为x定义一个占位符并计算y=2*x，使用feed_dict输入一个随机的4×5矩阵。

方法：

• tf.placeholder(dtype,shape=None,name=None)：声明一个占位符，需要指定占位符的类型。

使用tf.convert_to_tensor()可以将给定的值转换为张量类型，并将其与 TensorFlow 函数和运算符一起使用。
TensorFlow序列不可迭代。

3 矩阵基本操作

import tensorflow as tf

# 一个交互式对话
sess = tf.InteractiveSession()

# 定义一个5*5单位矩阵
I_matrix = tf.eye(5)
print(I_matrix)

# 定义初始化变量到10*10单位矩阵
X = tf.Variable(tf.eye(10))
X.initializer.run() # 变量初始化
print(X.eval()) # 主对角矩阵

# 创建一个5*10随机矩阵
A = tf.Variable(tf.random_normal([5,10]))
A.initializer.run()

# 矩阵乘法
product = tf.matmul(A, X)
print(product.eval())

# 创建只有0/1的5*10随机矩阵
b = tf.Variable(tf.random_uniform([5,10], 0, 2, dtype=tf.int32))
b.initializer.run()
print(b.eval())

# 更换矩阵类型
b_new = tf.cast(b, dtype=tf.float32)

# 矩阵加减法
t_sum = tf.add(product, b_new)
t_sub = product-b_new
print(t_sum.eval(),'\n',t_sub.eval())

a = tf.Variable(tf.random_normal([4,5], stddev=2))
b = tf.Variable(tf.random_normal([4,5], stddev=2))

# 按元素相乘
A = a*b

# 乘一个标量
B = tf.scalar_mul(2, A)

# 按元素相除
C = tf.div(a,b) # 返回的张量的类型与第一个参数类型一致

# 按元素余数相除
D = tf.mod(a,b)

init_op = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init_op)
    writer = tf.summary.FileWriter('graphs', sess.graph)
    a,b,A_R,B_R,C_R,D_R = sess.run([a,b,A,B,C,D])
    print("a:\n",a,"\nb:\n",b,"\na*b:\n",A_R,
          "\n2*a*b:\n",B_R,"\na/b:\n",C_R,"\na%b:\n",D_R)
writer.close()