Tensorflow 基础函数详解_tf.constant

tensorflow 常用基础函数

以下函数的用法基于Tensorflow1.4版本

1、tf.constant
tf.constant方法用来定义一个常量，所谓常量，就是“不变化的量”。我们先看下官方Api是如何对constant函数来定义的：

tf.constant(
    value,
    dtype=None,
    shape=None,
    name='Const',
    verify_shape=False
)
1
2
3
4
5
6
7

其中包括5个输入值：
value（必填）：常量值，可以是一个数，也可以是一个向量或矩阵。
dtype（非必填）：用来指定数据类型，例如tf.float32类型或tf.float64。
shape（非必填）：用来指定数据的维度。
name（非必填）：为常量定义名称，默认为Const。
verify_shape（非必填）：默认值为False，如果值为True时，在定义常量时会自动检测value和shape维度是否相同，不同则报错，例如value定义为1，而shape定义为一行两列的矩阵（1,2），那么肯定会报错。
了解了参数的具体含义，我们用代码来验证一下吧！
指定value的值：

#定义一个整数
a = tf.constant(1)
#定义一个向量
b = tf.constant([1,2])
#定义一个2行3列的矩阵
c = tf.constant([[1,2,3],[4,5,6]])
print(a)
print(b)
print(c)
1
2
3
4
5
6
7
8
9

输出结果：

Tensor("Const:0", shape=(), dtype=int32)
Tensor("Const_1:0", shape=(2,), dtype=int32)
Tensor("Const_2:0", shape=(2, 3), dtype=int32)
1
2
3

变量a的shape为空，0个纬度，也就是一个数值；
变量b的shape是（2,），只有一个维度，是一个长度为2向量；
变量c的shape是（2,3），有两个维度，是一个2X3的矩阵。
当指定dtype参数时：

#定义一个整数
a = tf.constant(1,dtype=tf.float32)
#定义一个向量
b = tf.constant([1,2],dtype=tf.float32)
#定义一个2行3列的矩阵
c = tf.constant([[1,2,3],[4,5,6]],dtype=tf.float32)
print(a)
print(b)
print(c)
1
2
3
4
5
6
7
8
9

输出结果：

Tensor("Const:0", shape=(), dtype=float32)
Tensor("Const_1:0", shape=(2,), dtype=float32)
Tensor("Const_2:0", shape=(2, 3), dtype=float32)
1
2
3

可见数值的类型都变为float32类型。
当指定shape参数时：

#定义一个整数
a = tf.constant(2.,shape=())
b = tf.constant(2.,shape=(3,))
c = tf.constant(2.,shape=(3,4))
with tf.Session() as sess:
    print(a.eval())
    print(b.eval())
    print(c.eval())
1
2
3
4
5
6
7
8

输出结果：

2.0
[2. 2. 2.]
[[2. 2. 2. 2.]
 [2. 2. 2. 2.]
 [2. 2. 2. 2.]]
1
2
3
4
5

此时constant会根据shape指定的维度使用value值来进行填充，例如参数a指定维度为0，也就是一个整数；参数b指定维度为1长度为3，也就是一个向量；参数b指定维度为2长度为3X4，也就是定义一个3X4的矩阵，全部都使用value值2.0来进行填充。

当指定name参数时：

#不指定name
a = tf.constant(2.)
#指定name
b = tf.constant(2.,name="b")
print(a)
print(b)
1
2
3
4
5
6

输出结果：

Tensor("Const:0", shape=(), dtype=float32)
Tensor("b:0", shape=(), dtype=float32)
1
2

常量的默认名称为Const，建议大家创建常量时最好定义一下name，只要是字符串就没有问题。
当指定verify_shape=True时：

a = tf.constant(2.,shape=(2,3),verify_shape=True)
1

输出结果报错：

TypeError: Expected Tensor's shape: (2,3), got ().
1

错误原因是value的值和指定的shape维度不同，value是一个数值，而我们指定的shape为2X3的矩阵，所以报错！当我们去掉verify_shape参数时错误即消失。那么问题来了，此时这个常量到底是整数还是一个矩阵呢？当然是矩阵啦（一个被value值填充的2X3矩阵）！
2、tf.Variable
tf.Variable方法用来定义一个变量，所谓变量，就是“变化的量”。我们看一下函数的定义：

 
tf.Variable(
    initial_value=None,
    trainable=True,
    collections=None,
    validate_shape=True,
    caching_device=None,
    name=None,
    variable_def=None,
    dtype=None,
    expected_shape=None,
    import_scope=None,
    constraint=None
)
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

是不是参数多到令人发指！目前感觉最常用的也就是initial_value、name、dtype，用法和tf.constant类似，这里不用代码做过多演示。
3、tf.zeros
tf.zeros用来定义一个全部元素都为0的张量，例如一个全为0的矩阵或向量，看一下函数的定义：

 
tf.zeros(
    shape,
    dtype=tf.float32,
    name=None
)
1
2
3
4
5
6

shape：数据的维度。
dtype：数据得类型。
name：命名。

#长度为1的1维向量
a = tf.zeros([1])
#长度为2的1维向量
b = tf.zeros([2])
#2维矩阵，矩阵大小3X4
c = tf.zeros([3,4])
with tf.Session() as sess:
    print(sess.run(a))
    print(sess.run(b))
    print(sess.run(c))
1
2
3
4
5
6
7
8
9
10

输出结果：

[0.]
[0. 0.]
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
1
2
3
4
5

4、tf.ones
和tf.zeros功能相似，tf.ones用来定义一个全部元素都为1的张量，例如一个全为1的矩阵或向量，看一下函数的定义：

tf.ones(
    shape,
    dtype=tf.float32,
    name=None
)
1
2
3
4
5

测试代码：

#长度为1的1维向量
a = tf.ones([1],name="n1",dtype=tf.float32)
#长度为2的1维向量
b = tf.ones([2])
#2维矩阵，矩阵大小3X4
c = tf.ones([3,4])
with tf.Session() as sess:
    print(sess.run(a))
    print(sess.run(b))
    print(sess.run(c))
1
2
3
4
5
6
7
8
9
10

输出结果：

[1.]
[1. 1.]
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
1
2
3
4
5

5、tf.random_uniform
tf.random_uniform可用来生成一个被随机数填充的张量，可以是向量或矩阵，函数定义为：

tf.random_uniform(
    shape,
    minval=0,
    maxval=None,
    dtype=tf.float32,
    seed=None,
    name=None
)
1
2
3
4
5
6
7
8

参数说明：
shape：定义形状
minval：随机数最小值，默认是0
maxval：随机数最大值，默认是1
dtype：数据得类型，默认是float32类型
seed：随机数种子
name：定义返回值名称

#定义一个由最小值为0，最大值为0.5填充的向量
a = tf.random_uniform([3],0,0.5,name="a")
#定义一个由最小值为-1，最大值为1填充的4X3的矩阵
b = tf.random_uniform([4,3],-1,1,name="b")
#定义一个最小值为10，最大值为100的随机数
c = tf.random_uniform([],10,100,name="c")
#定义seed为1
d = tf.random_uniform([],10,100,seed=1)
e = tf.random_uniform([],10,100,seed=1)
#定义seed为2
f = tf.random_uniform([],10,100,seed=2)

with tf.Session() as sess:
    print(sess.run(a))
    print(sess.run(b))
    print(sess.run(c))
    print(sess.run(d))
    print(sess.run(e))
    print(sess.run(f))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果：

 
[0.37117624 0.28079355 0.12813371]
[[ 0.50496936  0.2632537  -0.30630517]
 [ 0.16871548  0.7529404  -0.6158774 ]
 [-0.9147036   0.35593843 -0.50358105]
 [-0.4618771  -0.26037788  0.7437594 ]]
40.39641
31.513365
31.513365
71.08719
1
2
3
4
5
6
7
8
9
10

从结果中我们会发现，值d和e在设置相同seed的情况下，随机数值的相同的，这就意味着，如果最小值、最大值以及种子定义完全相同的话，随机数值也是相同的。如果想在相同范围内得到不同的随机数值，请修改seed
6、tf.add
tf.add方法计算两个张量之和，先看函数格式：

tf.add(
    x,
    y,
    name=None
)
1
2
3
4
5

x：张量1
y：张量2
name：计算结果命名
注：输入的x，y两个张量的类型必须一致

 
#数值加法
a = tf.constant(3)
b = tf.constant(4)
c = tf.add(a,b)

#向量加法
a1 = tf.constant([1,2])
b1 = tf.constant([3,4])
c1 = tf.add(a1,b1)

#矩阵加法
a2 = tf.constant([[1,1],[2,2]])
b2 = tf.constant([[3,3],[4,4]])
c2 = tf.add(a2,b2)

with tf.Session() as sess:
    print("数值加法")
    print(sess.run(c))
    print("向量加法")
    print(sess.run(c1))
    print("矩阵加法")
    print(sess.run(c2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出结果：

 
数值加法
7
向量加法
[4 6]
矩阵加法
[[4 4]
 [6 6]]
 
1
2
3
4
5
6
7
8
9

7、tf.subtract
tf.subtract方法计算两个张量之差，与tf.add结构相同。同样需要注意的是，传入的两个张量的类型必须保持一致。

tf.subtract(
    x,
    y,
    name=None
)
1
2
3
4
5

8、tf.matmul和tf.multiply
之所以把matmul和multipy放在一起讨论，因为好多人会把这两个函数搞混。
tf.matmul是矩阵乘法，tf.multiply是元素乘法。

#定义一个被数值2填充的2X3矩阵
a = tf.constant(2,shape=(2,3),name="a")
#定义一个被数值3填充的2X3矩阵
b = tf.constant(3,shape=(2,3),name="b")
#定义一个被数
c = tf.constant(5,name="c")
#multiply
d = tf.multiply(a,b)
#multiply
e = tf.multiply(a,c)
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print('a的值')
    print(sess.run(a))
    print('b的值')
    print(sess.run(b))
    print('c的值')
    print(sess.run(c))
    print('matmul(a,b)')
    print(sess.run(d))
    print('matmul(a,c)')
    print(sess.run(e))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出结果：

a的值
[[2 2 2]
 [2 2 2]]
b的值
[[3 3 3]
 [3 3 3]]
c的值
5
matmul(a,b)
[[6 6 6]
 [6 6 6]]
matmul(a,c)
[[10 10 10]
 [10 10 10]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

a、b是两个矩阵，ca和b类型一致，可以multiply，结果依然是一个2X3的矩阵；
a是一个矩阵，c是一个数值，虽类型不同，但依然可以multiply，结果和a的类型保持一致。
所以multiply的两个输入的张量类型可以不一致。

 
#定义一个被数值2填充的2X3矩阵
a = tf.constant(2,shape=(2,3),name="a")
#定义一个被数值3填充的2X3矩阵
b = tf.constant(3,shape=(3,3),name="b")
#multiply
c = tf.matmul(a,b)
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print('a的值')
    print(sess.run(a))
    print('b的值')
    print(sess.run(b))
    print('matmul后')
    print(sess.run(c))
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

 
a的值
[[2 2 2]
 [2 2 2]]
b的值
[[3 3 3]
 [3 3 3]
 [3 3 3]]
matmul后
[[18 18 18]
 [18 18 18]]
1
2
3
4
5
6
7
8
9
10
11

a、b两个矩阵被函数matmul处理后，依然是一个2X3的矩阵，matmul要求两个输入的张量类型必须完全的一致。
9、tf.divide
浮点数除法，两个输入的张量类型可以不一致。

tf.divide(
    x,
    y,
    name=None
)
1
2
3
4
5

10、tf.mod
两个张量相除并取余。

tf.mod(
    x,
    y,
    name=None
)
1
2
3
4
5

11、tf.placeholder
之前我们了解了如何用tf.constant定义常量，用tf.Variable定义变量，那加入我想在运算过程中动态的修改传入的值呢？我们可以考虑使用placeholder，也就是占位符。我们先看一下它的结构：

tf.placeholder(
    dtype,
    shape=None,
    name=None
)
1
2
3
4
5

结构很简单，那我们为什么要用占位符呢？这其实就设计到了Tensorflow的设计理念，作为入门教程的第二篇，我们先不讲其设计理念和计算流图，我们只要记住，在未创建Tensorflow的session会话之前，定义的所有变量、常量其实都还没有进行计算，我们使用placeholder可以先为一个变量预留出一份内存，等Tensorflow启动session会话以后，就可以将数据喂到这个预留的内存中去，实现Tensorflow运算过程中的动态赋值，文字不好理解，直接上代码：

 
import tensorflow as tf
import numpy as np
#定义一个数值
a = tf.constant(2.,name="a")
#定义一个数值类型的placeholder
b = tf.placeholder(tf.float32,[],name="b")
#定义一个矩阵类型的placeholder
c = tf.placeholder(tf.float32,[2,3],name="c")
#d为a*b
d = tf.multiply(a,b)
#e为a*c
e = tf.multiply(a,c)
#一个随机数组
rand_value = np.random.rand(2,3)
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)#初始化变量
    print("从0循环到9，分别乘2")
    for i in range(10):
        print(sess.run(d,feed_dict={b:i}))
    print("传入随机生成的一个数组")
    print(sess.run(e,feed_dict={c:rand_value}))
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出结果：

从0循环到9，分别乘2
0.0
2.0
4.0
6.0
8.0
10.0
12.0
14.0
16.0
18.0
传入随机生成的一个数组
[[0.7041698  1.0414026  1.973911  ]
 [1.952334   0.46541974 1.1905501 ]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

d的值等于a乘b，a的值为2.0，b为一个占位符，在运算过程中，通过feed_dict动态的修改了b的值，得到了不同的计算结果。
e的值等于a乘c，a的值为2.0，c为一个2X3的矩阵占位符，运算过程中，使用feed_dict动态的把随机矩阵rand_value喂到了运算中，计算得到了不同的结果。
1.变量初始化函数：

if tensorflow.__version__ <= 0.1:
sess.run(tf.initialize_all_variables())
else:
sess.run(tf.global_variables_initializer())
1
2
3
4

2. 写日志函数；

if tensorflow.__version__ <= 0.1:
logsWriter = tf.train.SummaryWriter
else:
logsWriter = tf.summary.FileWriter
1
2
3
4