Tensorflow简单实践系列（二）：张量

在上一节中，我们安装 TensorFlow 并运行了最简单的应用，这节我们熟悉 TensorFlow 中的张量。

张量是 TensorFlow 的核心数据类型。数学里面也有张量的概念，但是 TensorFlow 的张量其实不一样，更像是一个 n 维数组。

不能在常规 Python 例程中访问张量，因此 TensorFlow API 提供了很多张量的操作函数。

张量的创建

张量是一个 n 维数组。当 $n=0$ 时它就是标量；当 $n=1$ 时它就是向量；当 $n=2$ 时它就是矩阵。

所有的张量都是 Tensor 类的实例。

张量可以包含数字、字符串和布尔类型。但是一个张量包含的的元素必须是相同类型的。

创建常数

constant 函数签名：

constant(value, dtype=None, shape=None, name='Const', verify_shape=False)

代码示例：

 # 创建常数

 t1 = tf.constant('hello world')

 t2 = tf.constant([1, 2, 3])

 t3 = tf.constant([[1, 2], [3, 4]])

 t4 = tf.constant([6, 66, 666], tf.int16, [3], 'very_6', True)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(t1))

     print(sess.run(t2))

     print(sess.run(t3))

     print(sess.run(t4))

b'hello world'

[  ]

[[ ]

 [ ]]

[     ]

zeros/ones/fill

zeros 函数签名：

zeros(shape, dtype=tf.float32, name=None)

ones 函数签名：

ones(shape, dtype=tf.float32, name=None)

fill 函数签名：

fill(dims, value, name=None)

代码示例：

 # 创建零值张量

 t1 = tf.zeros([2])

 # 创建一值张量

 t2 = tf.ones([2, 3])

 # 填值

 t3 = tf.fill([3, 2], 666)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(t1))

     print(sess.run(t2))

     print(sess.run(t3))

[. .]

[[. . .]

 [. . .]]

[[ ]

 [ ]

 [ ]]

创建序列

linspance 函数签名：

linspace(start, stop, num,  name=None)

range 函数签名：

range(start, limit, delta=, dtype=None, name='range')

range(limit, delta=, dtype=None, name='range')

代码示例：

 # 创建序列

 t1 = tf.linspace(0., 1., 10)

 t2 = tf.range(-1., 1., delta=0.1)

 t3 = tf.range(-2., delta=-0.5)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(t1))

     print(sess.run(t2))

     print(sess.run(t3))

[.         0.11111111 0.22222222 0.33333334 0.44444445 0.5555556

 0.6666667  0.7777778  0.8888889  .        ]

[-1.00000000e+00 -8.99999976e-01 -7.99999952e-01 -6.99999928e-01

 -5.99999905e-01 -4.99999911e-01 -3.99999917e-01 -2.99999923e-01

 -1.99999928e-01 -9.99999270e-02  7.45058060e-08  1.00000076e-01

  2.00000077e-01  3.00000072e-01  4.00000066e-01  5.00000060e-01

  6.00000083e-01  7.00000107e-01  8.00000131e-01  9.00000155e-01]

[ .  -0.5 -.  -1.5]

创建随机值：正态分布

很多时候机器学习需要创建随机值。正态分布有两种：random_normal 和 truncated_normal。对于一般意义的正态分布，大约 95.4% 的概率会落在 2 倍标准方差的范围之内。

random_normal 是一般意义的正态分布，有可能有小概率会选择 2 倍标准方差的范围之外。而 truncated_normal 会有截断，保证所有值都落在 2 倍标准方差的范围之内。

函数签名：

random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

代码示例：

 # 创建随机值：正态分布

 t1 = tf.random_normal([10], dtype=tf.float64)

 t2 = tf.random_normal([20], 0, 2, dtype=tf.float64, seed=60)

 t3 = tf.truncated_normal([20], 0, 2, dtype=tf.float32, seed=60)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(t1))

     print(sess.run(t2))

     print(sess.run(t3))

[-0.30217352 -0.01353907  0.11583214  0.7693184  -2.03386255  0.74505956

 -1.57310053  1.16255292  1.87307555  1.1607303 ]

[ 0.43070572  1.78930951  1.90006543 -0.08042026 -2.3744852   1.88272049

  1.56724792  1.37002113 -0.12527277  4.5297854  -0.82256769  0.87545214

  0.85278266 -0.14404349  0.93608167 -2.59733351 -0.33442825  1.19330448

  4.15318877 -3.12805352]

[ 0.74157673 -0.9606577   0.46180212 -3.2753797   0.16152781 -2.189441

 -0.09013904 -2.1726682  -1.2061952   0.5147551  -3.3902223   1.843447

 -0.83136135 -2.4879968   3.2793632   2.9981675  -3.217487   -0.13496129

  1.7222887  -3.1599777 ]

观察第 2 个输出中的 4.15318877，已经超过了 2 倍标准方差（标准方差为 2），这有将近 4.6% 的概率发生。

而对于 truncated_normal 函数，不管输出多少数，也不可能有这样的输出。

创建随机值：均匀分布

random_uniform 创建最大值和最小值之间的均匀分布。

函数签名：

random_uniform(shape, minval=, maxval=None, dtype=tf.float32, seed=None, name=None)

代码示例：

 # 创建随机值：均匀分布

 t1 = tf.random_uniform([20], 0, 10, dtype=tf.int32, seed=66)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(t1))

[0 7 5 3 2 7 7 5 1 7 9 9 0 3 0 1 4 7 3 4]

随机打乱某张量

random_shuffle 可以对张量沿着一维方向，随机打乱顺序。

函数签名：

random_shuffle(tensor, seed=None, name=None)

代码示例：

 # 随机打乱张量（沿第一维方向）

 t1 = tf.constant([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]])

 t2 = tf.random_shuffle(t1, seed=66)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(t1))

     print(sess.run(t2))

[[   ]

 [   ]

 [   ]

 [   ]

 [  ]]

[[   ]

 [   ]

 [   ]

 [  ]

 [   ]]

设置随机种子

前面的随机函数都有一个 seed 参数，我们其实可以直接设置，让所有随机函数都会用同一个随机种子。

set_random_seed(seed)

代码示例：

 # 随机种子

 tf.set_random_seed(66)

创建张量的运算

基本的数学运算

代码示例：

 # 基本的数学运算

 x1 = tf.constant([2, 2, 2])

 x2 = tf.constant([4, 4, 4])

 my_sum1 = tf.add(x1, x2)

 my_diff1 = tf.subtract(x1, x2)

 my_prod1 = tf.multiply(x1, x2)

 my_quot1 = tf.divide(x1, x2)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(my_sum1))

     print(sess.run(my_diff1))

     print(sess.run(my_prod1))

     print(sess.run(my_quot1))

 print('-' * 20)

 # 还可以使用 Python 运算符

 my_sum2 = x1 + x2

 my_diff2 = x1 - x2

 my_prod2 = x1 * x2

 my_quot2 = x1 / x2

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(my_sum2))

     print(sess.run(my_diff2))

     print(sess.run(my_prod2))

     print(sess.run(my_quot2))

 print('-' * 20)

 # 除和整除

 my_quot3 = x1 / x2

 my_quot4 = x1 // x2

 my_quot5 = tf.divide(x1, x2)

 my_quot6 = tf.div(x1, x2)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(my_quot3))

     print(sess.run(my_quot4))

     print(sess.run(my_quot5))

     print(sess.run(my_quot6))

[  ]

[- - -]

[  ]

[0.5 0.5 0.5]

--------------------

[  ]

[- - -]

[  ]

[0.5 0.5 0.5]

--------------------

[0.5 0.5 0.5]

[  ]

[0.5 0.5 0.5]

[  ]

凑整和比较运算

代码示例：

 # 凑整和比较运算

 # 凑整

 t = tf.constant([-1.5, -1.4, 1.4, 1.5])

 r1 = tf.round(t)

 r2 = tf.rint(t)

 r3 = tf.ceil(t)

 r4 = tf.floor(t)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(r1))

     print(sess.run(r2))

     print(sess.run(r3))

     print(sess.run(r4))

 print('-' * 20)

 # 比较

 t1 = tf.constant([1., 2.])

 t2 = tf.constant([1.5, 3.])

 my_max = tf.maximum(t1, t2)

 my_min = tf.minimum(t1, t2)

 t3 = tf.constant([[6., 2.], [4., -6.]])

 min_index = tf.argmin(t3)

 max_index = tf.argmax(t3)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(my_max))

     print(sess.run(my_min))

     print(sess.run(min_index))

     print(sess.run(max_index))

[-2. -1.  1.  2.]

[-2. -1.  1.  2.]

[-1. -1.  2.  2.]

[-2. -2.  1.  1.]

--------------------

[1.5 3. ]

[1. 2.]

[1 1]

[0 0]

指数和对数

机器学习经常要用到指数和对数来计算概率。

 # 指数和对数

 x = tf.constant([0., 1., 2.])

 y = tf.constant([-1., -1., -1.])

 t1 = tf.square(x)

 t2 = tf.squared_difference(x, y)

 t3 = tf.sqrt(x)

 t4 = tf.rsqrt(x)  # tf.sqrt(x)的倒数

 t5 = tf.pow(x, 3)

 t6 = tf.exp(x)

 t7 = tf.expm1(x)  # exp(x)-1

 t8 = tf.log(x)  # ln(x)

 t9 = tf.log1p(x)  # log(x+1)

 t10 = tf.erf(x)  # 误差函数

 t11 = tf.erfc(x)  # 互补误差函数

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(t1))

     print(sess.run(t2))

     print(sess.run(t3))

     print(sess.run(t4))

     print(sess.run(t5))

     print(sess.run(t6))

     print(sess.run(t7))

     print(sess.run(t8))

     print(sess.run(t9))

     print(sess.run(t10))

     print(sess.run(t11))

[. . .]

[. . .]

[.        .        1.4142135]

[       inf .         0.70710677]

[. . .]

[.        2.7182817 7.389056 ]

[.        1.7182819 6.389056 ]

[     -inf .        0.6931472]

[.        0.6931472 1.0986123]

[.        0.8427008 0.9953223]

[.         0.1572992  0.00467773]

向量和矩阵运算

机器学习中有很多向量（一维张量）和矩阵（二维张量）的运算。

代码示例：

 # 向量和矩阵运算

 # 点乘

 t1 = tf.constant([0., 1., 2.])

 t2 = tf.constant([1., 2., 3.])

 dot0 = tf.tensordot(t1, t2, axes=0)

 dot1 = tf.tensordot(t1, t2, axes=1)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(dot0))

     print(sess.run(dot1))

 print('-' * 20)

 # 矩阵乘法

 t3 = tf.constant([[0., 1., 2.]])

 t4 = tf.constant([[1., 2., 3.]])

 dot3 = tf.matmul(t3, tf.transpose(t4))

 # 交叉内积

 cross = tf.cross(t3, t4)

 # 对角矩阵

 t5 = tf.diag([1, 2, 3])

 # 迹

 trace = tf.trace(t5)

 # 单位矩阵

 eye = tf.eye(4)

 # 范数

 t6 = tf.constant([[1., 2.], [3., 4.]])

 norm = tf.norm(t6)

 # 求解Ax = b

 A = tf.constant([[1., 1.], [2., 3.]])

 b = tf.constant([[10.], [23.]])

 x = tf.matrix_solve(A, b)

 # 特征向量

 t7 = tf.constant([[1., 2.], [3., 4.]])

 qr = tf.qr(t7)

 # 矩阵分解

 svd = tf.svd(t7)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(dot3))

     print(sess.run(cross))

     print(sess.run(t5))

     print(sess.run(trace))

     print(sess.run(eye))

     print(sess.run(norm))

     print(sess.run(x))

     print(sess.run(qr))

     print(sess.run(svd))

 print('-' * 20)

 # 自定义运算

 m1 = tf.constant([[1, 2], [3, 4]])

 m2 = tf.constant([[5, 6], [7, 8]])

 e1 = tf.einsum('ij->ji', m1)

 e2 = tf.einsum('ij,jk->ik', m1, m2)

 # 发起一个会话

 with tf.Session() as sess:

     print(sess.run(e1))

     print(sess.run(e2))

[[. . .]

 [. . .]

 [. . .]]

8.0

--------------------

[[.]]

[[-.  . -.]]

[[  ]

 [  ]

 [  ]]

[[. . . .]

 [. . . .]

 [. . . .]

 [. . . .]]

5.477226

[[.]

 [.]]

Qr(q=array([[-0.3162278 , -0.9486833 ],

       [-0.9486833 ,  0.31622773]], dtype=float32), r=array([[-3.1622777 , -4.4271884 ],

       [ .        , -0.63245535]], dtype=float32))

(array([5.4649854 , 0.36596614], dtype=float32), array([[ 0.4045535, -0.9145143],

       [ 0.9145143,  0.4045535]], dtype=float32), array([[ 0.5760484,  0.8174156],

       [ 0.8174156, -0.5760484]], dtype=float32))

--------------------

[[ ]

 [ ]]

[[ ]

 [ ]]

总结

张量是 TensorFlow 中核心的数据类型。本文揭开了 TensorFlow 中张量的神秘面纱，包括张量的创建和张量的运算。

张量类似于 N 维数组。0 维张量就是标量，1 维张量就是向量，2 维张量就是矩阵。

我们只是熟悉了张量基本的创建和运算（很多 API 和我们熟悉的 Numpy 很类似），更多的技巧知识还需要不断在实践中总结和提升。

巴特西

Tensorflow简单实践系列（二）：张量

张量的创建

创建常数

zeros/ones/fill

创建序列

创建随机值：正态分布

创建随机值：均匀分布

随机打乱某张量

设置随机种子

创建张量的运算

基本的数学运算

凑整和比较运算

指数和对数

向量和矩阵运算

总结

最新文章

热门文章