Tensorflow教程（2）Tensorflow的常用函數介紹

以下函數的用法基於Tensorflow1.4版本。

1、tf.constant

tf.constant方法用來定義一個常量，所謂常量，就是“不變化的量”。我們先看下官方Api是如何對constant函數來定義的：

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

其中包括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)

輸出結果：

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

變量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)

輸出結果：

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

可見數值的類型都變為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())

輸出結果：

2.0
[2. 2. 2.]
[[2. 2. 2. 2.]
 [2. 2. 2. 2.]
 [2. 2. 2. 2.]]

此時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)

輸出結果：

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

常量的默認名稱為Const，建議大家創建常量時最好定義一下name，只要是字符串就沒有問題。

當指定verify_shape=True時：

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

輸出結果報錯：

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

錯誤原因是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
)

是不是參數多到令人發指！目前感覺最常用的也就是initial_value、name、dtype，用法和tf.constant類似，這里不用代碼做過多演示。

3、tf.zeros

tf.zeros用來定義一個全部元素都為0的張量，例如一個全為0的矩陣或向量，看一下函數的定義：

 

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

 

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))

輸出結果：

[0.]
[0. 0.]
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

4、tf.ones

和tf.zeros功能相似，tf.ones用來定義一個全部元素都為1的張量，例如一個全為1的矩陣或向量，看一下函數的定義：

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

測試代碼：

#長度為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.]
[1. 1.]
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

5、tf.random_uniform

tf.random_uniform可用來生成一個被隨機數填充的張量，可以是向量或矩陣，函數定義為：

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

參數說明：

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))

輸出結果：

[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

從結果中我們會發現，值d和e在設置相同seed的情況下，隨機數值的相同的，這就意味着，如果最小值、最大值以及種子定義完全相同的話，隨機數值也是相同的。如果想在相同范圍內得到不同的隨機數值，請修改seed

6、tf.add

tf.add方法計算兩個張量之和，先看函數格式：

tf.add(
    x,
    y,
    name=None
)

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))

輸出結果：

數值加法
7
向量加法
[4 6]
矩陣加法
[[4 4]
 [6 6]]

7、tf.subtract

tf.subtract方法計算兩個張量之差，與tf.add結構相同。同樣需要注意的是，傳入的兩個張量的類型必須保持一致。

tf.subtract(
    x,
    y,
    name=None
)

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))

輸出結果：

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]]

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))

輸出結果：

a的值
[[2 2 2] [2 2 2]] b的值 [[3 3 3] [3 3 3] [3 3 3]] matmul后 [[18 18 18] [18 18 18]]

a、b兩個矩陣被函數matmul處理后，依然是一個2X3的矩陣，matmul要求兩個輸入的張量類型必須完全的一致。

9、tf.divide

浮點數除法，兩個輸入的張量類型可以不一致。

tf.divide(
    x,
    y,
    name=None
)

10、tf.mod

兩個張量相除並取余。

tf.mod(
    x,
    y,
    name=None
)

 11、tf.placeholder

之前我們了解了如何用tf.constant定義常量，用tf.Variable定義變量，那加入我想在運算過程中動態的修改傳入的值呢？我們可以考慮使用placeholder，也就是占位符。我們先看一下它的結構：

tf.placeholder(
    dtype,
    shape=None,
    name=None
)

結構很簡單，那我們為什么要用占位符呢？這其實就設計到了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}))

輸出結果：

從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 ]]

d的值等於a乘b，a的值為2.0，b為一個占位符，在運算過程中，通過feed_dict動態的修改了b的值，得到了不同的計算結果。

e的值等於a乘c，a的值為2.0，c為一個2X3的矩陣占位符，運算過程中，使用feed_dict動態的把隨機矩陣rand_value喂到了運算中，計算得到了不同的結果。