1.张量

张量是tensorflow中的核心，可以将其简单的理解为多维的数组。

其中0阶的张量就是一个变量，一个单独的值，如：1

1阶的张量就是由于多个标量，所组成的一个一维的数组，N阶的张量就是N维度的数组。

张量被没有真正的保存数据，而是保存了数据计算的一个过程，接下来演示一下两个张量中间的计算。

import tensorflow as tf
import numpy as np

x = tf.constant([2,3],name='x')
y = tf.constant([4,5],name='y')
result = tf.add(x,y,name='add')
print(result)

Tensor(“add:0”, shape=(2,), dtype=int32)

输出的结果并不是一个数据，而是一个张量的结构。这个结构中包含着三个属性：变量名，维度，变量类型。

“add:0”：表示的是result张量是计算节点add输出的第一个结果。shape代表维度，dtype为类型

想要输出具体的结果：

x = tf.constant([2,3],name='x')
y = tf.constant([4,5],name='y')
result = tf.add(x,y,name='add')
sess = tf.Session()
print(result)

array([6, 8])

1.1 固定张量

通过tf.zeros构建全为0的张量，传入数组的shape

sess.run(tf.zeros([2,2]))

array([[ 0., 0.],
[ 0., 0.]], dtype=float32)

通过tf.ones构建全为1的张量，传入数组的shape

sess.run(tf.ones([3,3]))

array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=float32)

通过tf.fill构建全部都是一个值的张量，也要传入数组的shape,和要填充的值

sess.run(tf.fill([2,3],3))

array([[3, 3, 3],
[3, 3, 3]])

1.2 相似的张量

可以用like来模仿，已经构建出来的张量的维度，和numpy中类似。

constant_tensor = tf.constant([[2,3],[3,4]])
sess.run(tf.zeros_like(constant_tensor))

array([[0, 0],
[0, 0]])

sess.run(tf.ones_like(constant_tensor))

array([[1, 1],
[1, 1]])

1.3 序列的张量

tensorflow中页定义有相应的linspace和range函数，用于构建相应的序列的向量。

linear_tensor =tf.linspace(star=0.0,stop=10.0,num=5)
sess.run(linear_tensor)

array([ 0. , 2.5, 5. , 7.5, 10. ], dtype=float32)

其中要注意，传入的数据的类型是整型还是浮点型，整型不能等差切分的时候，会报错。

sequence_tensor = tf.range(0,10,3)
sess.run(sequence_tensor)

array([0, 3, 6, 9])

1.4 随机的张量

1.4.1真随机

构建随机张量的方法有很多，对于不同的场景下，应用的也不一样，逐步开始讲解，不同的随机张量的构建的方法。

构建一个均匀分布的一个随机张量。tf.random_uniform(),其中要传入最大值，和最小值

randunifom_tensor = tf.random_uniform([2,2],minval=0.0,maxval=1.0)
sess.run(randunifom_tensor)

array([[ 0.00671721, 0.94347858],
[ 0.2032578 , 0.44404912]], dtype=float32)

1.4.2 正态分布随机张量

生成一个服从正态分布的随机张量,tf.random_normal

randnormal_tensor = tf.random_normal([2,2],mean=0.0,stddev=1.0)
sess.run(randnormal_tensor)

array([[ 0.57518029, 0.22895758],
[ 0.40178141, 0.02055765]], dtype=float32)

1.4.3 生成指定区间的随机张量

truncnormal_tensor = tf.truncated_normal([2,2],mean=5.0,stddev=3)
sess.run(truncnormal_tensor)

array([[ 0.33884716, 3.44682765],
[ 7.73195887, 6.26586485]], dtype=float32)

1.4.4 随机打乱

shuffle_output = tf.random_shuffle([[1,2],[1,3],[2,4]])
sess.run(shuffle_output)

array([[1, 3],
[1, 2],
[2, 4]])

1.4.5 随机切片获取部分张量

后面的[2,2]表示要切多少维度的出来

crop_tensor = tf.random_crop([[1,2],[1,3],[2,4],[3,4]],[2,2])
sess.run(crop_tensor)

array([[2, 4],
[3, 4]])

这个函数每次执行的结果都不一样

2. 会话

tensorflow中通过会话来执行一定定义好的图的流程运算，一般会话形式：

import tensorflow as tf
sess = tf.Session()
sess.run(..........)
sess.close()

会话打开执行后，一般为了防止资源的泄漏，都需要在执行完成后，关闭会话。

2.1 会话的上下文管理器

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

通过上下文的管理器，就可以在执行完，会话后，就关闭会话

2.2 tf.eval()，tf.InteractiveSession()取值

tensorflow中不会自己生成默认的会话，只有自己手动的生成默认会话，当默认会话呗指定后，就可以用tf.eval()来取得张量的值。

a = tf.constant([3.0,4.0],name='a')
b = tf.constant([4.0,5.0],name='b')
result = tf.add(a,b,name='add')
with tf.Session() as sess:
    print(result.eval())

[ 7. 9.]

也可以通过tf.InteractiveSession()取值

sess = tf.InteractiveSession()
print(result.eval())

[ 7. 9.]

3. 变量与占位符

3.1变量

在tensorflow中变量是算法中应用的参数，通过对参数进行调整，来优化模型。

占位符是tesorflow中的对象，由于有的时候在不知道传入的数的具体数值，所以需要一个占位符来占位置。

传入的变量都需要进行初始化才能用，一般通过tf.global_variables_initializer()进行全局的一个初始化。

varible_name = tf.Variable(tf.zeros([2,3]))
sess = tf.Session()
initialize_op = tf.global_variables_initializer()
sess.run(initialize_op)

3.2 占位符

placeholder

主要通过feed_dict参数获取数据的具体的数值，使用feed_dict的时候要确保传入的参数和给定的palceholder的类型一致。

from tensorflow.python.framework import ops

ops.reset_default_graph()
sess = tf.Session()
x = tf.placeholder(tf.float32,shape=(2,2))
y = tf.identity(x)
rand_array = np.random.rand(2,2)
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter('/tmp/variable_logs',sess.graph)
print(sess.run(y,feed_dict={
    x:rand_array}))

[[ 0.77838486 0.36920077]
[ 0.8936649 0.54854125]]

4.矩阵

4.1 常见矩阵

可以通过numpy创建矩阵，也可以通过列表的嵌套和创建张量的形式，创建矩阵。

import tensorflow as tf
import numpy as np

sess = tf.Session()
#创建3*3的全0矩阵
m1 = tf.zeros([3,3])
print(sess.run(m1))

m2 = tf.ones([3,3])
print(sess.run(m2))

m3 = tf.fill([3,3],6)
print(sess.run(m3))

m4 = tf.constant([1,2,3,4])
print(sess.run(m4))

m5 = tf.truncated_normal([3,3])
print(sess.run(m5))

m6 = tf.random_uniform([3,3])
print(sess.run(m6))

[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
[[6 6 6]
[6 6 6]
[6 6 6]]
[1 2 3 4]
[[-0.95833504 -0.50551957 0.86696702]
[ 1.78476 -0.34451649 -0.01428395]
[-0.92595565 -0.43097624 -0.42828724]]
[[ 0.79463243 0.3379482 0.53706539]
[ 0.83475208 0.01446998 0.97285581]
[ 0.24806726 0.46546197 0.54671335]]

将其他数组转成tf的数据格式tf.convert_to_tensor()

m7 = tf.convert_to_tensor(np.array([[1,2,3],[4,5,6]]))
print(sess.run(m7))

[[1 2 3]
[4 5 6]]

4.2 对角矩阵

支持通过diag()函数从一个1维度的数组创建对角矩阵

sess = tf.Session()
diagonal = [1,1,1,1]
print(sess.run(tf.diag(diagonal)))

[[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]]

也可以通过diag_part获取对角阵的元素

diagonal = tf.constant([[1,0 ,0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1]])
print(sess.run(tf.diag_part(diagonal)))

[1 1 1 1]

4.3 矩阵的基本运算

加减

print(sess.run(m1 + m2))
print(sess.run(m1 - m2))

相乘

print(sess.run(tf.matmul(m1,m2)))

矩阵的转置

print(sess.run(tf.transpose(m6)))

[[ 0.02242279 0.95276403 0.17858338]
[ 0.35303771 0.94850373 0.69271755]
[ 0.53127277 0.34490252 0.5641582 ]]

矩阵行列式

print(sess.run(tf.matrix_determinant(m5)))

逆矩阵

print(sess.run(tf.matrix_inverse(m5)))

矩阵分解

print(sess.run(tf.cholesky(m5)))

特征值与特征向量

print(sess.run(tf.self_adjoint_eig(m5)))

(array([-1.5917685, -0.0519438, 2.638695 ], dtype=float32), array([[ 0.16981925, -0.79775006, 0.57858151],
[ 0.55087334, -0.4099704 , -0.7269547 ],
[ 0.81712914, 0.44217607, 0.36983824]], dtype=float32))

差不多这就是基础了，慢慢好好学好tensorflow，小生加油
​