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

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

一、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矩陣）！

二、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相似，這裏不用代碼作過多演示。

三、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.]]

四、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.]]

五、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

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

七、tf.subtract

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

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

八、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要求兩個輸入的張量類型必須徹底的一致。

九、tf.divide

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

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

十、tf.mod

兩個張量相除並取餘。

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

 十一、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喂到了運算中，計算獲得了不一樣的結果。