tensorflow

Tensorflow

一、使用圖（graphs）來表示計算任務

二、使用會話（session）的上下文（context）中執行任務

三、使用tensor表示數據，張量是幾階的能夠經過張量右邊的方括號數來判斷。例如 t = [ [ [    ] ] ]，顯然這個爲3階。

0階張量稱爲標量，表示單獨的一個數[1]

1階張量稱爲向量， 表示一個一維數組[1, 2, 3]

2階張量稱爲矩陣，表示一個二維數組[[1, 2, 3],[4, 5, 6],[7, 8, 9]]

四、經過變量（variable）維護狀態

五、用feed和fetch可爲任意的操做賦值或從中獲取數據

圖中的節點叫op（operation），一個op得到0個或多個Tensor，產生0個或多個Tensor，tensor看做一個n維的數組或列表。圖必須在會話裏被啓動。

 

1、會話

變量初始化後，仍是沒有被激活，須要再在 sess 裏, sess.run(init) , 激活 init 這一步.

直接 print(state) 不起做用！！必定要把 sess 的指針指向 state 再進行 print 才能獲得想要的結果！

 1 import tensorflow as tf
 2 
 3 #建立一個常量
 4 m1 = tf.constant([[3,3]])#一行兩列
 5 m2 = tf.constant([[2],[3]])#兩行一列
 6 
 7 #矩陣乘法
 8 product = tf.matmul(m1,m2)
 9 print(product)
10 
11 #定義一個會話，啓動默認圖
12 sess = tf.Session()
13 result = sess.run(product)# 調用run方法執行圖，這個觸發了三個op(操做)，兩個常量的創建，矩陣的乘法
14 print(result)
15 sess.close()
16 
17 #無需關閉會話 # with as的這種結構會自動關閉會話
18 with tf.Session() as sess:
19     result = sess.run(product)
20     print(result)

輸出：

運行會獲得顯示結果，其中MatMul爲節點名，0表明第0個輸出；shape是維度，（1，1）表明一行一列的張量，長度爲1；dtype指數據類型爲整型。

Tensor("MatMul:0", shape=(1, 1), dtype=int32)
[[15]]
[[15]]

 

2、變量

  上文常量使用tf.constant()表示，變量是用tf.Variable()表示，要初始化！！！init=tf.global_variables_initializer()

 1 import tensorflow as tf
 2 
 3 x=tf.Variable([1,2])    # 定義一個變量，這裏是張量的加減法，因此一維數組便可
 4 a=tf.constant([3,3])    # 定義一個常量
 5 
 6 sub=tf.subtract(x,a)    # 增長一個減法op
 7 add=tf.add(x,sub)       # 增長一個加法op
 8 
 9 init=tf.global_variables_initializer()   # 在tensorflow中使用變量要初始化，此條語句也能夠初始化多個變量，這句代碼提示沒有(),多加練習
10 #沒有第13行會FailedPreconditionError: Attempting to use uninitialized value Variable_1 試圖使用未初始化的值Variable_1
11 with tf.Session() as sess:
12     sess.run(init)                       # 變量初始化，也要放在會話中，才能執行
13     print(sess.run(sub))
14     print(sess.run(add))

[-2 -1]

[-1 1]

上述代碼展現了變量的定義和初始化，但尚未體現變量的本質，下面一段代碼實現變量a進行5次+1的操做

值得一提的是，在打印常量和變量時，不能像python中的直接print(a)，而是也須要放在sess.run()中。

 1 a=tf.Variable(0,name='counter')        # 建立一個變量初始化爲0，並命名爲counter。（此段代碼中命名無做用）
 2 new_value = tf.add(a,1)                # 建立一個加法op，做用是使state加1
 3 update=tf.assign(a,new_value)          # 此句話是賦值op，在tensorflow中，賦值也須要對應的op
 4 init=tf.global_variables_initializer() # 變量初始化
 5 with tf.Session() as sess:
 6     sess.run(init)
 7     print(sess.run(a))
 8     for i in range(5):                
 9         sess.run(update)
10         print(sess.run(a))

0

1

2

3

4

5

注意：初始化時，pycharm會代碼提示 tf.global_variables_initializer，但每每會把括號漏掉，需注意

            經常使用的op如今除了加減乘除，還多了個assign()的賦值op

 

3、Fetch

sess.run([fetch1,fetch2]) 進行多個op，注意格式

 1 import tensorflow as tf
 2 
 3 input1 = tf.constant(3.0)
 4 input2 = tf.constant(2.0)
 5 input3 = tf.constant(5.0)
 6 
 7 add = tf.add(input2,input3)
 8 mul = tf.multiply(input1,add)
 9 
10 with tf.Session() as sess:
11     result = sess.run([mul,add])       # 執行了兩個op，要注意格式
12     print(result)

[21.0,7.0]

這裏須要提一下tf.matmul()是用於矩陣乘法，tf.multiply是用於點乘。正如上面這段代碼的multiply

4、佔位 feed的數據格式以字典的形式傳入

先不輸入具體數值，先佔位，在會話中調用op時，再輸入具體值

1 import tensorflow as tf
2 
3 input1 = tf.placeholder(tf.float32)      # 使用placeholder()佔位，須要提供類型
4 input2 = tf.placeholder(tf.float32)
5 output = tf.multiply(input1,input2)
6 
7 with tf.Session() as sess:
8     print(sess.run(output,feed_dict={input1:8.0,input2:2.0}))  # 以字典形式輸入feed_dict

 

16.0

 

小案例

import tensorflow as tf
import numpy as np
#使用numpy生成100個隨機點
x_data = np.random.rand(100)
y_data=x_data * 0.1 +0.2

#構造一個線性模型
b = tf.Variable(1.5)#隨機取一個數，最後結果接近0.2
k = tf.Variable(3.2)#隨機取一個數，最後結果接近0.1

#二次代價函數（損失函數）
loss  =  tf.reduce_mean(tf.square(y_data-y))
#定義一個梯度降低法來訓練的優化器
optimizer = tf.train.GrandientDescentOptimizer(0.2)
#最小化代價函數
train = optimizer.minimize(loss)

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    for step in range(300):
        sess.run(train)
    if step%20==0
    print(step,sess.run([k,b]

 

 

4、Tensorflow解決非線性迴歸問題

使用反斜傳播算法對神經網絡（全鏈接）的權值進行訓練，使用梯度降低法（交叉熵）對損失函數進行優化

非線性迴歸

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

#使用numpy在[-0.5,0.5]生成200個數（200行1列）---樣本
x_data = np.linspace(-0.5,0.5,200)[:,np.newaxis]#增長一個維度
noise = np.random.normal(0,0.02,x_data.shape)
y_data = np.square(x_data) + noise

#定義兩個佔位符
x = tf.placeholder(tf.float32,[None,1])
y = tf.placeholder(tf.float32,[None,1])

#定義神經網絡的中間層
weights_L1  = tf.Variable(tf.random_normal([1,10]))#一行十列
biases_L1 = tf.Variable(tf.zeros([1,10]))#定義只有一個神經元在輸入層
Wx_plus_b_L1 =  tf.matmul(x,weights_L1)  +  biases_L1
#矩陣相乘（輸入和中間層權重）
L1 = tf.nn.tanh(Wx_plus_b_L1)#tanh爲激活函數

#定義神經網絡的輸出層
weights_L2  = tf.Variable(tf.random_normal([10,1]))
biases_L2 = tf.Variable(tf.zeros([1,1]))#定義只有一個神經元在輸入層
Wx_plus_b_L2 =  tf.matmul(L1,weights_L2)  +  biases_L2
#矩陣相乘（輸入和中間層權重）
prediction = tf.nn.tanh(Wx_plus_b_L2)#tanh爲激活函數


#定義損失函數
loss = tf.reduce_mean(tf.square(y - prediction))
#計算張量tensor沿着某一維度的平均值，用於降維

#使用梯度降低法（0.35爲學習率）
train_step = tf.train.GradientDescentOptimizer(0.35).minimize(loss)#loss的值和bias和weight有關，不停地回調他們
#其中 minimize() 實際上包含了兩個步驟，即 compute_gradients 和 apply_gradients，
#前者用於計算梯度，後者用於使用計算獲得的梯度來更新對應的variable。下面對這兩個函數作具體介紹。
print(sess.run(train_step))
with tf.Session() as sess:
    #初始化變量
    sess.run(tf.global_variables_initializer())
    for _ in range(1000):
        sess.run(train_step,feed_dict={x:x_data,y:y_data})
        #得到預測值
        prediction_value = sess.run(prediction,feed_dict={x:x_data})
        #畫圖
        plt.figure()
        plt.scatter(x_data,y_data)#散點出樣本分佈
        plt.plot(x_data,prediction_value,'r-',lw=5)#紅色實線，線寬爲5
        plt.show()         

 

 

5、Tensorflow解決簡單分類問題

MNIST數據集

有兩部分：60000行的訓練數據集和10000行的測試數據集

每一張圖片包含28*28個像素，咱們把這個數組展開成一個向量，長度是28*28=784.在MNIST數據集在mnist.yrain.images是一個形狀爲[60000,784]的張量，第一個維度數字用來索引每張圖片中的像素點。圖片中某個像素的強度值介於0-1之間。

數據集標籤是介於0-9的數字，把標籤轉換成獨熱向量，除了某一位是1，其餘維度都是0.標籤0表示成([1,0,0,0,0,0,0,0,0,0]),所以，mnist.train.label是個[60000,10]的數字矩陣。

神經網絡構成：

784個輸入神經元===>10個輸出神經元

Softmax函數

咱們的模型測出來有十個機率，和爲1。sorfmax迴歸函數用來給不一樣的對象分配機率。

將n維向量映射到另外一個n維向量。採用指數函數，拉大了向量中大小份量的差距

手寫數字識別基於非線性迴歸

 1 import tensorflow as tf
 2 import tensorflow.example.tutorials.mnist import input_data
 3 
 4 #載入數據集
 5 print("--"*36)
 6 mnist = input_data.read_data_set("MNIST_data",one_hot=True)
 7 #one_hot是一位是1
 8 
 9 #每一個批次的大小（以矩陣的形式放進去訓練）
10 batch_size = 50
11 #計算有多少個批次
12 n_batch = mnist.train.num_examples//batch_size #整除
13 
14 #定義兩個佔位符
15 x = tf.placeholder(tf.float32,[None,28*28])#None的賦值與批次有關
16 y = tf.placeholder(tf.float32,[None,10])#標籤：10個數字
17 
18 #建立有關簡單的神經網絡（隱藏層爲10個神經元）
19 w = tf.Variable(tf.zero([784,10]))
20 b = tf.Variable(tf.zero([10]))
21 prediction = tf.nn.softmax(tf.matmul(x,w)+b)#softmax：輸出值轉換成機率
22 
23 #損失函數
24 loss = tf.reduce_mean(tf.square(y-prediction))
25 
26 #梯度降低法
27 train_step = tf.train.GradientDesentOptimizer(0.4)minimize(loss)
28 
29 #比較equal()函數內參數是否一致，一致返回「true」
30 #argmax函數返回一維張量中最大值所在位置
31 correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
32 #求準確率cast()將布爾型轉換成浮點型（true轉換成1.0，false轉換成0）
33 
34 accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
35 
36 with tf.Session() as sess:
37     sess.run(tf.global_variables_initializer())
38     for iter in range(25):
39         for batch in range(n_batch):
40             #next_batch()第二次執行獲取第二個批次的數據
41             batch_xs,batch_ys = mnist.train.next_batch(batch_size)
42             sess.run(train_step,feed={x:batch_x,y:batch_y})
43         ac=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
44         print("--"*36)
45         print(">>>Iter:" +str(iter)+ ",>>>Testing Accuracy"" +str(ac))

能夠經過修改批次大小/優化方式/學習率/損失函數類型/訓練次數等來提升訓練準確度

 

6、損失函數、優化器、過擬合

（一）損失函數

損失函數（loss function），量化了分類器輸出的結果（預測值）和咱們指望的結果（標籤）之間的差距，這和分類器結構自己一樣重要。改良損失函數可使得分類器的結果最優。

1. Labels ：標籤，在分類或者分割等問題中的標準答案。能夠是1,2,3,4,5,6 。
2. Labels_onehot ： Onehot形式的標籤，即若是有3類那麼第一類表示爲[1,0,0]，第二類爲[0,1,0]，第三類爲[0,0,1]。這種形式的標籤更加的常見。
3. Network.out : 網絡最後一層的輸出，注意是沒有通過softmax的網絡的輸出，一般是softmax函數的輸入值。
4. Network.probs : 網絡輸出的機率結果，一般爲網絡最後一層輸出通過softmax函數以後的結果，Network.probs=tf.nn.softmax(Network.out)
5. Network.pred : 網絡的預測結果，在onehot的形式中選擇機率最大的一類做爲最終的預測結果，Network.pred=tf.argmax(Network.probs, axis=n)。
6. Tensor : 一個張量，能夠簡單的理解爲是tensorflow中的一個數組。
7. tf.reduce_sum(Tensor) : 降維加和，好比一個數組是333大小的，那麼通過這個操做以後會變爲一個數字，即全部元素的加和。
8. tf.reduce_mean(Tensor)：降維平均，和上面的reduce_sum同樣，將高維的數組變爲一個數，該數是數組中全部元素的均值。

A、內置的損失函數（對數似然損失函數）

1.Tensor=tf.nn.softmax_cross_entropy_with_logits(logits= Network.out, labels= Labels_onehot)

面是softmax交叉熵loss，參數爲網絡最後一層的輸出和onehot形式的標籤。切記輸入必定不要通過softmax，由於在函數中內置了softmax操做，若是再作就是重複使用了。在計算loss的時候，輸出Tensor要加上tf.reduce_mean(Tensor)或者tf.reduce_sum(Tensor)，做爲tensorflow優化器（optimizer）的輸入。

2.    Tensor=tf.nn.sparse_softmax_cross_entropy_with_logits (logits=Network.out, labels= Labels)
這個函數和上面的區別就是labels參數應該是沒有通過onehot的標籤，其他的都是同樣的。另外加了sparse的loss還有一個特性就是標籤能夠出現-1，若是標籤是-1表明這個數據再也不進行梯度回傳。

3.    Tensor=tf.nn. sigmoid_cross_entropy_with_logits (logits= Network.out, labels= Labels_onehot)
sigmoid交叉熵loss，與softmax不一樣的是，該函數首先進行sigmoid操做以後計算交叉熵的損失函數，其他的特性與tf.nn.softmax_cross_entropy_with_logits一致。

4.    Tensor=tf.nn.weighted_cross_entropy_with_logits (logits=Network.out, labels=Labels_onehot, pos_weight=decimal_number)
這個loss不同凡響的地方就是加入了一個權重的係數，其他的地方與tf.nn. sigmoid_cross_entropy_with_logits這個損失函數是一致的，加入的pos_weight函數能夠適當的增大或者縮小正樣本的loss，能夠必定程度上解決正負樣本數量差距過大的問題。
對於普通的sigmoid來講計算的形式以下：
targets * -log(sigmoid(logits)) + (1 - targets) * -log(1 - sigmoid(logits))
加入了pos_weight以後的計算形式以下：
targets * -log(sigmoid(logits)) * pos_weight + (1 - targets) * -log(1 - sigmoid(logits))

B、自定義損失函數

常見的函數

1. 四則運算：tf.add(Tensor1,Tensor2)，tf.sub(Tensor1,Tensor2)， tf.mul(Tensor1,Tensor2)，tf.div（Tensor1,Tensor2）這裏的操做也能夠被正常的加減乘除的負號所取代。這裏想要指出的是乘法和除法的規則和numpy庫是同樣的，是matlab中的點乘而不是矩陣的乘法，矩陣的乘法是tf.matmul(Tensor1, Tensor2)
2. 基礎運算： 取模運算(tf.mod())，絕對值(tf.abs())，平方(tf.square())，四捨五入取整(tf.round())，取平方根(tf.sqrt()) ，天然對數的冪(tf.exp()) ，取對數(tf.log()) ，冪(tf.pow()) ，正弦運算(tf.sin())。以上的這些數學運算以及不少沒有被說起的運算在tensorflow中均可以本身被求導，因此你們不用擔憂還須要本身寫反向傳播的問題，只要你的操做是由tensorflow封裝的基礎操做實現的，那麼反向傳播就能夠自動的實現。
3. 條件判斷，經過條件判斷語句咱們就能夠實現分段的損失函數，利用tf.where(condition, tensor_x, tensor_y) 若是說條件condition是True那麼就會返回tensor_x，若是是False則返回tensor_y。注：舊版本的tensorflow能夠用tf.select實現這個操做。
4. 比較操做，爲了得到condition這個參數，咱們能夠用tf.greater( tensor_x, tensor_y)若是說tensor_x大於tensor_y則返回True。
5. tf.reduce_sum()，tf.reduce_mean()這兩個操做是重要的loss操做，由於loss是一個數字，而一般計算獲得的是一個高維的矩陣，所以用降維加法和降維取平均，能夠將一個高維的矩陣變爲一個數字。

 

（二）優化器

1. tf.train.GradientDescentOptimizer          
2. tf.train.AdadeltaOptimizer                            
3. tf.train.AdagradOptimizer
4. tf.train.AdagradDAOptimizer
5. tf.train.MomentumOptimizer                       
6. tf.train.AdamOptimizer
7. tf.train.FtrlOptimizer
8. tf.train.ProximalGradientDescentOptimizer
9. tf.train.ProximalAdagradOptimizer
10. tf.train.RMSPropOptimizer

 

若是數據是稀疏的，用自適用方法，Adagrad，Adadelta，RMSprop，Adam。

RMSprop，Adadelta，Adam在不少狀況下是類似的

Adam就算在RMSprop的基礎上加了bias-correction和momentum，

隨着梯度變稀疏，Adam比RMSprop效果好。

總體來說，Adam是最好的選擇。

不少論文用SGD，沒有momentum等。SGD雖然能達到極小值，可是時間長，可能被困住鞍點

若是是複雜的神經網絡，要一種自適應的算法。

 

（三）過擬合

1. 增長數據集
2. 正則化方法：在代價函數後添加一個正則項（減少網絡一種複雜程度的方式）
3. Dropout：在每次迭代，隨機使得部分神經元工做，部分神經元不工做

都是經過限制權限的大小。
L1：讓參數變得更稀疏，即便更多的參數變爲0，相似特徵提取。
L2：弱參數平方後變的更小，模型優化中幾乎能夠忽略，好比0.0001的平方。
根據須要能夠結合L1和L2一塊兒使用。

#L1，L2demo
w = tf.constant([[1.0,2.],[-2.,4.]])
with tf.Session() as sess:
    print(sess.run(tf.contrib.layers.l1_regularizer(0.5)(w)))
    print(sess.run(tf.contrib.layers.l2_regularizer(0.5)(w)))
    print(sess.run(tf.contrib.layers.l1_l2_regularizer(scale_l1=0.5,scale_l2=0.5)(w)))
out:
4.5      #1+2+2+4=9  9*0.5=4.5
6.25    #1+4+4+16=25 25/2=12.5  12.5*0.5=6.25   
10.75  #9*0.5+12.5*0.5=10.75

L3_drop=tf.nn.dropout(L3,keep_prob)#keep_prob表明百分之多少的神經元在工做

後續工做用L3_drop代替L3

 

（四）激活函數

tensorflow-->python-->ops-->nn.py在這個文件裏面

經常使用的激活函數有sigmoid、tanh、relu

tf.nn.激活函數(變量名)

1.sigmoid映射到(0,1)區間

2.log_sigmoid映射到了(負無窮，0)

3.tanh映射到(-1,1)

4.relu最受歡迎，relu函數的定義:f(x)=max(x,0)

5.relu6取值區間被限定在了[0,6]之間，min(max(features,0),6)

 

7、tensorflow可視化
log_dir = ''    # 輸出日誌保存的路徑

1. 標量Scalars
2. 圖片Images
3. 音頻Audio
4. 計算圖Graph
5. 數據分佈Distribution
6. 直方圖Histograms
7. 嵌入向量Embeddings

（1）首先確定是先創建一個graph,你想從這個graph中獲取某些數據的信息

（2）肯定要在graph中的哪些節點放置summary operations以記錄信息
使用tf.summary.scalar記錄標量
使用tf.summary.histogram記錄數據的直方圖
使用tf.summary.distribution記錄數據的分佈圖
使用tf.summary.image記錄圖像數據

函數（'名稱'，變量名）

（3）operations並不會去真的執行計算，除非你告訴他們須要去run,或者它被其餘的須要run的operation所依賴。而咱們上一步建立的這些summary operations其實並不被其餘節點依賴，所以，咱們須要特意去運行全部的summary節點。可是呢，一份程序下來可能有超多這樣的summary 節點，要手動一個一個去啓動天然是及其繁瑣的，所以咱們可使用tf.summary.merge_all去將全部summary節點合併成一個節點，只要運行這個節點，就能產生全部咱們以前設置的summary data。

（4）使用tf.summary.FileWriter將運行後輸出的數據都保存到本地磁盤中

（5）運行整個程序，並在命令行輸入運行tensorboard的指令，以後打開web端可查看可視化的結果

運行整個程序，在程序中定義的summary node就會將要記錄的信息所有保存在指定的logdir路徑中了，訓練的記錄會存一份文件，測試的記錄會存一份文件。進入命令行，運行如下代碼，等號後面加上summary日誌保存的路徑（在程序第一步中就事先自定義了）

tensorboard --logdir=

有一條信息出來，打開網址就能夠看到可視化信息

Starting TensorBoard 41 on port 6006
(You can navigate to http://127.0.1.1:6006)

模型的保存

 1 # 以前是各類構建模型graph的操做(矩陣相乘，sigmoid等等....)
 2 
 3 saver = tf.train.Saver() # 生成saver
 4
 5 with tf.Session() as sess:
 6     sess.run(tf.global_variables_initializer()) # 先對模型初始化
 7 
 8     # 而後將數據丟入模型進行訓練blablabla
 9 
10     # 訓練完之後，使用saver.save 來保存
11     saver.save(sess, "save_path/file_name") #file_name若是不存在的話，會自動建立

模型的載入

1 saver = tf.train.Saver()
2 
3 with tf.Session() as sess:
4     #參數能夠進行初始化，也可不進行初始化。即便初始化了，初始化的值也會被restore的值給覆蓋
5     sess.run(tf.global_variables_initializer())     
6     saver.restore(sess, "save_path/file_name") #會將已經保存的變量值resotre到 變量中。

 

8、卷積神經網絡

（一）數據結構

mnist原始圖片輸入，原始圖片的尺寸爲28×28，導入後會自動展開爲28×28=784的list

tensor : shape=[784]

卷積層輸入input_image: shape=[batch, height, width, channels]

bacth : 取樣數
height, width : 圖片的尺寸
channels : 圖片的深度；若是是灰度圖像，則爲1，rgb圖像，則爲3

卷積核filter: shape=[height, width, in_channels, out_channels]

height, width: 圖片的尺寸
in_channels: 圖片的深度
out_channels: 卷積核的數量

（二）函數

卷積函數[tf.nn.conv2d(x, filter, strides=[1,1,1,1], padding=’SAME’)]

def conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None,
           data_format=None, name=None):

x: 卷積層輸入 shape=[batch, height, width, channels]

filter: 卷積核 shape=[height, width, in_channels, out_channels]

stride: 卷積步長 shape=[batch_stride, height_stride, width_stride, channels_stride]

padding: 控有SAME和VALID兩種選項，表示是否要保留圖像邊上那一圈不徹底卷積的部分。若是是SAME，則保留。

use_cudnn_on_gpu ：是否使用cudnn加速。默認是True

• stride表示卷積核filter對應了input_image各維度下移動的步長；第一個參數對應input_image的batch方向上的移動步長，第2、三參數對應高寬方向上的步長，決定了卷積後圖像的尺寸，最後一個參數對應channels方向上的步長
• padding=’SAME’表示給圖像邊界加上padding，讓filter卷積後的圖像尺寸與原圖相同；’VALID’表示卷積後imgaeHeight_aterFiltered=imageHeight_inital-filterHeight+strideHeight，寬同理

池化函數tf.nn.max_pool(x, k_size=[1,2,2,1], strides=[1,2,2,1], padding=’SAME’)

ave_pool是平均池化

def max_pool(value, ksize, strides, padding, data_format="NHWC", name=None):

x: 池化輸入input_image: shape=[batch, height, width, channels]
ksize: 池化窗口的尺寸
strides: 池化步長
padding: 處理邊界策略

卷積核filter初始化weight_variable(shape)

    def weight_variable(shape):
    initial=tf.truncated_normal(shape, mean=0.0, stddev=0.1)
    return tf.Variable(inital)

偏置初始化bias_variable(shape)

    def bias_variable(shape):
    initial=tf.constant(0,1,shape=shape)
    return tf.Vatiable(initial)

手寫字體的識別

 1     import tensorflow as tf
 2     from tensorflow.examples.tutorials.mnist import input_data
 3 
 4     #獲取mnist訓練集
 5     mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 
 6 
 7     #交互式session
 8     sess = tf.InteractiveSession()
 9 
10     #已將32×32的圖片展開成行向量，None表明該維度上數量不肯定，程序中指的是取樣的圖像數量不肯定
11     x=tf.placeholder(tf.float32, shape=[None,784])
12     #圖片的標籤
13     y_label=tf.placeholder(tf.float32, shape=[None,10])  
14     -------------------------------------------------------------------------
15     #第一層網絡
16     #reshape()將按照設定的shape=[-1,28,28,1]對x:shape=[None,784]的結構進行從新構建
17     #參數-1表明該維度上數量不肯定，由系統自動計算
18     x_image = tf.reshape(x, shape=[-1,28,28,1]) 
19     #32個卷積核，卷積核大小5×5
20     W_conv1 = weight_variable([5,5,1,32])
21     #32個前置，對應32個卷積核輸出
22     b_conv1 = bias_varibale([32]) 
23 
24     #卷積操做 
25     layer_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 
26     #池化操做
27     layer_pool1 = tf.nn.max_pool(layer_conv1) 
28     -------------------------------------------------------------------------
29     #第二層網絡
30     #64個卷積核，卷積核大小5×5，32個channel
31     W_conv2 = weight_variable([5,5,32,64]) 
32     #64個前置，對應64個卷積核輸出
33     b_conv2 = bias_varibale([64]) 
34 
35     #卷積操做 
36     layer_conv2 = tf.nn.relu(conv2d(layer_pool1, W_conv2) + b_conv2) 
37     #池化操做
38     layer_pool2 = tf.nn.max_pool(layer_conv2) 
39     -------------------------------------------------------------------------
40     #full-connected網絡
41     #圖片尺寸變化28×28-->14×14-->7×7
42     #該層設定1024個神經元
43     layer_pool2_flat = tf.reshape(layer_pool2,[-1,7*7*64])
44 
45     W_fc1 = weight_variable([7*7*64,1024])
46     b_fc1 = bias_variable([1024])
47 
48     h_fc1 = tf.nn.relu(tf.matmul(layer_pool2_flat, W_fc1) + b_fc1)
49     -------------------------------------------------------------------------
50     #droput網絡
51     keep_prob = tf.placeholder(tf.float32)
52     h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
53     -------------------------------------------------------------------------
54     #輸出層
55     W_fc2 = weight_variable([1024,10])
56     b_fc2 = bias_variable([10])
57 
58     y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)
59     -------------------------------------------------------------------------
60     #loss-function
61     cross_entropy = -tf.reduce_sum(y_lable*tf.log(y_conv))
62     #梯度降低
63     train = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy) 
64     #tf.argmax(x,1)表示從x的第二維度選取最大值
65     correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_lable,1)) 
66     accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
67     sess.run(tf.global_variables_initializer())
68     -------------------------------------------------------------------------
69     #訓練train
70     #訓練3000次
71     for i in range(3000) 
72       #每次選取50訓練集
73       batch = mnist.train.next_batch(50) 
74 
75       if i%100 == 0:
76         train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_labe: batch[1], keep_prob: 1.0})
77         print ("step %d, training accuracy %g"%(i, train_accuracy))
78 
79       train.run(feed_dict={x: batch[0], y_label: batch[1], keep_prob: 0.5})
80       print ("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_label: mnist.test.labels, keep_prob: 1.0}))

 

9、矩陣生成

1.矩陣生成（全0矩陣，全1矩陣，隨機矩陣，常數矩陣）

tf.ones(shape,type=tf.float32,name=None) 
tf.zeros([2, 3], int32)

產生尺寸爲shape的張量，全1/0

tf.ones_like(tensor,dype=None,name=None) 
tf.zeros_like(tensor,dype=None,name=None) 
新建一個與給定的tensor類型大小一致的tensor，其全部元素爲1/0

tf.fill(shape,value,name=None) 
建立一個形狀大小爲shape的tensor，其初始值爲value

tf.constant(value,dtype=None,shape=None,name=’Const’) 
建立一個常量tensor，按照給出value來賦值，能夠用shape來指定其形狀。value能夠是一個數，也能夠是一個list。 
若是是一個數，那麼這個常亮中全部值的按該數來賦值。 
若是是list,那麼len(value)必定要小於等於shape展開後的長度。賦值時，先將value中的值逐個存入。不夠的部分，則所有存入value的最後一個值。

tf.random_normal(shape,mean=0.0,stddev=1.0,dtype=tf.float32,seed=None,name=None) 
tf.truncated_normal(shape, mean=0.0, stddev=1.0,dtype=tf.float32,seed=None, name=None) 
tf.random_uniform(shape,minval=0,maxval=None,dtype=tf.float32,seed=None,name=None) 
這幾個都是用於生成隨機數tensor的。尺寸是shape 
random_normal: 正太分佈隨機數，均值mean,標準差stddev 
truncated_normal:截斷正態分佈隨機數，均值mean,標準差stddev,不過只保留[mean-2*stddev,mean+2*stddev]範圍內的隨機數 
random_uniform:均勻分佈隨機數，範圍爲[minval,maxval]

tf.get_variable

get_variable(name, shape=None, dtype=dtypes.float32, initializer=None,
                 regularizer=None, trainable=True, collections=None,
                 caching_device=None, partitioner=None, validate_shape=True,
                 custom_getter=None):

name: 這個不用說了，變量的名字 
shape: 變量的形狀，[]表示一個數，[3]表示長爲3的向量，[2,3]表示矩陣或者張量(tensor) 
dtype: 變量的數據格式，主要有tf.int32, tf.float32, tf.float64等等 
initializer: 初始化工具，有tf.zero_initializer, tf.ones_initializer, tf.constant_initializer, tf.random_uniform_initializer, tf.random_normal_initializer, tf.truncated_normal_initializer等

2.矩陣變換

tf.shape(Tensor) 
Returns the shape of a tensor.返回張量的形狀。可是注意，tf.shape函數自己也是返回一個張量。而在tf中，張量是須要用sess.run(Tensor)來獲得具體的值的。

labels = [1,2,3]
shape = tf.shape(labels)
print(shape)
sess = tf.InteractiveSession()
print(sess.run(shape))
# >>>Tensor("Shape:0", shape=(1,), dtype=int32)
# >>>[3]

tf.expand_dims(Tensor, dim) 
爲張量+1維。官網的例子：’t’ is a tensor of shape [2] 
shape(expand_dims(t, 0)) ==> [1, 2] 
shape(expand_dims(t, 1)) ==> [2, 1] 
shape(expand_dims(t, -1)) ==> [2, 1]

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
sess = tf.InteractiveSession()
labels = [[1,2,3],[2,2,2]]
x = tf.expand_dims(labels, 0)
print(sess.run(x))
x = tf.expand_dims(labels, -1)
print(sess.run(x))
x = tf.expand_dims(labels, 1)
print(sess.run(x))

[[[1 2 3]
  [2 2 2]]]


[[[1]
  [2]
  [3]]

 [[2]
  [2]
  [2]]]


[[[1 2 3]]

 [[2 2 2]]]

tf.pack

tf.pack(values, axis=0, name=」pack」) 
Packs a list of rank-R tensors into one rank-(R+1) tensor 
將一個R維張量列表沿着axis軸組合成一個R+1維的張量

  # 'x' is [1, 4]
  # 'y' is [2, 5]
  # 'z' is [3, 6]
  pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
  pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]

tf.concat(concat_dim, values, name=」concat」) 
Concatenates tensors along one dimension. 
將張量沿着指定維數拼接起來。我的感受跟前面的pack用法相似

t1 = [[1, 2, 3], [4, 5, 6]]
t2 = [[7, 8, 9], [10, 11, 12]]
tf.concat(0, [t1, t2]) 
#==> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
tf.concat(1, [t1, t2]) 
#==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

tf.sparse_to_dense

稀疏矩陣轉密集矩陣

def sparse_to_dense(sparse_indices,
                    output_shape,
                    sparse_values,
                    default_value=0,
                    validate_indices=True,
                    name=None):

sparse_indices: 元素的座標[[0,0],[1,2]] 表示(0,0)，和(1,2)處有值 
output_shape: 獲得的密集矩陣的shape 
sparse_values: sparse_indices座標表示的點的值，能夠是0D或者1D張量。若0D，則全部稀疏值都同樣。如果1D，則len(sparse_values)應該等於len(sparse_indices) 
default_values: 缺省點的默認值

tf.random_shuffle(value,seed=None,name=None) 
沿着value的第一維進行隨機從新排列

sess = tf.InteractiveSession()
a=[[1,2],[3,4],[5,6]]
x = tf.random_shuffle(a)
print(sess.run(x))
#===>[[3 4],[5 6],[1 2]

tf.argmax(input=tensor,dimention=axis) 
找到給定的張量tensor中在指定軸axis上的最大值/最小值的位置。

argmin找最小值

tf.equal(x, y, name=None): 
判斷兩個tensor是否每一個元素都相等。返回一個格式爲bool的tensor

tf.cast(x, dtype, name=None) 將x的數據格式轉化成dtype.例如，原來x的數據格式是bool，那麼將其轉化成float之後，就可以將其轉化成0和1的序列。反之也能夠