【tensorflow筆記視頻課】的筆記大集合

這篇文章記錄我所看的視頻課【tensorflow筆記】的代碼，這些代碼並非課上講的代碼，而是我本身聽了課以後根據本身的想法敲寫的，因此不是100%還原老師的代碼。

1.前向傳播

一個很簡單很簡單的前向傳播例子

import numpy as np
import tensorflow as tf

#生成輸入數據
x_data=np.random.rand(100)
y_data=0.2*x_data+0.1

#前向傳播
k=0.5
b=0.3
x=tf.placeholder(tf.float32)
y=k*x+b

#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(y,feed_dict={x:x_data}))

2.反向傳播

一個很簡單很簡單的反向傳播的例子

import numpy as np
import tensorflow as tf

#生成輸入數據
x_data=np.random.rand(100)
y_data=0.2*x_data+0.1

#前向傳播
k=tf.Variable(0.5)
b=tf.Variable(0.3)
y=tf.Variable(0)
y=k*x_data+b

#反向傳播
error=y-y_data
loss=tf.reduce_mean(tf.square(error))
optimizer=tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for i in range(200):
        sess.run(optimizer)
        if i%20==0:
            print(sess.run([k,b,loss]))

下面也是反向傳播，但這個代碼比上面那個有難度提高,由於咱們開始使用權重矩陣

import numpy as np
import tensorflow as tf

#輸入數據
x_data= np.random.rand(32,2)
y_data=[[x1+x2+(rmd.rand()/10.0-0.05)] for (x1,x2) in x_data]
"""這行代碼與下句等同
y=[]
for [x1,x2] in x:
    y.append([x1+x2+(np.random.rand()/10-0.05)])
"""

#前向傳播
x=tf.placeholder(tf.float32,shape=(None,2))
y=tf.placeholder(tf.float32,shape=(None,1))
w1= tf.Variable(tf.random_normal([2, 1]))#正態分佈
z= tf.matmul(x, w1)#點積

#反向傳播
loss=tf.reduce_mean(tf.square(z-y))
optimizer=tf.train.GradientDescentOptimizer(0.002).minimize(loss)

#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for i in range(20000):
        sess.run(optimizer,feed_dict={x:x_data,y:y_data})
        if i%5000==0:
            print(f"第{i}次訓練結果：")
            print(sess.run(w1))
    print("最終結果：\n",sess.run(w1))

3.損失函數

損失函數不少，你能夠本身寫，也能夠用經典的損失函數（線性迴歸、sigmoid、softmax）

經典的線性迴歸上面兩個代碼咱們已經用了，此次寫一下本身定義的損失函數：

import tensorflow as tf

w=tf.Variable(5.)
loss=tf.square(w+1)
optimizer=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
inti=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(inti)
    for i  in range(50):
        sess.run(optimizer)
        print(sess.run([w,loss]))

能夠看到，loss是本身定義的函數，而不是經典的三大金剛。loss能夠隨便定義，你想要的啥就寫啥，這裏方便理解因此寫了個最簡單的loss=（w+1）^2，在實際問題中確定不會這麼簡單。

4.學習率

這個就不寫代碼了，就是在使用各類優化器的時候要設定學習率，就是反向傳播一次更新的程度大小。

學習率的設置也有講究，小了更新慢，大了會爆炸，因此咱們說一下怎麼設置學習率：

在實際編碼時，咱們一般使用【指數衰減學習率】：

這是指數衰減學習率的公式，你能夠不太懂它的含義，只要你會敲代碼就能夠

代碼以下：

globe_step=tf.Variable(0，trainable=False) #計數器，用來記錄當前運行了幾輪batch_size，該參數不參與訓練，因此trainable=False

learning_rate=tf.train.exponential_decay(

LEARNING_RATE_BASE, #學習率初始值

globe_step, #計數器

LEARNING_RATE_STEP, #學習率更新週期，值爲總樣本數÷batch_size樣本數

LEARNING_RATE_DECAY, #學習率衰減率

staircase=True #True表示以不連續的間隔衰減學習速率，最後曲線是鋸齒狀

                                                       False表示以連續的間隔衰減學習速率，最後曲線是光滑狀
)

在訓練時，要求在tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step)的minimize裏寫上global_step

實際應用以下：

import tensorflow as tf

#設置learning_rate
global_step=tf.Variable(0，trainable=False)
LEARNING_RATE_BASE=0.1
LEARNING_RATE_STEP=1
LEARNING_RATE_DECAY=0.99
learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,LEARNING_RATE_STEP,LEARNING_RATE_DECAY,staircase=True)

#設置訓練數據
w=tf.Variable(5.)
#設置損失函數
loss=tf.square(w+1)
#設置優化器
optimize=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step)
#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for i  in range(40):
        sess.run(optimize)
        learning_rate_val=sess.run(learning_rate)
        global_step_val=sess.run(global_step)
        w_val=sess.run(w)
        loss_val=sess.run(loss)
        print(f"通過{i}步，當前global_step爲{ global_step_val}，w爲{w_val}，learning_rate爲{learning_rate_val}，loss爲{loss_val}")

必定多多留意獨特之處！

5.正則化

咱們用正則化來緩解泛化效果差的問題，就是給權重一個矩陣，加在loss上。

如圖所示，正則化後的loss，是原來的loss再加上正則化項，正則化項就是正則化參數*loss（w），這個，跟吳恩達講的如出一轍。

正則化項的表示代碼爲tf.contrib.layers.l2_regularizer（lambda）(w)，其中lambda是正則化參數，w是權重

tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(lambda)(w))  #把正則化項放入一個名爲"losses"的集合器裏面，咱們打算用這個losses來表示整個正則化項了。

loss=cem+tf.add_n(tf.get_collection("losses"))  #cem是原來的loss，如今把正則化項和以前的最原始的loss加在一塊兒，就獲得了正則化後的loss

ok，你可能看不懂，問「爲何要這麼麻煩？直接把正則化項加進cem不就好了嗎？」是的，我也不懂爲何，但就是這樣的一環套一環，你還就真得按照這個代碼去操做，否則你作不出來。

下面看代碼：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
#設置batch（臨時樣本）
step=30
#產生輸入數據
x_data=np.random.randn(300,2)
#產生輸入數據集的標籤（正確答案）
y_data=[int(x0*x0+x1*x1<2) for (x0,x1) in x_data]
#遍歷y_data中的每一個元素，1賦值red，其他賦值blue，這樣可視化顯示時容易區分
y_s=[["red" if y else "blue"] for y in y_data]
#數據變形，按行堆疊成一個新數組
x_data=np.vstack(x_data).reshape(-1,2)#numpy中，shape裏寫-1，至關於tensorflow裏寫None
y_data=np.vstack(y_data).reshape(-1,1)
print(x_data)
print(y_data)
print(y_s)
#用plt.scatter畫出數據集x_data各行中第0列元素和第一列元素的點即各行的（x0,x1），用各行y_s對應的值表示顏色
plt.scatter(x_data[:,0],x_data[:,1],c=np.squeeze(y_s))
plt.show()

#定義神經網絡的輸入、參數和輸出，定義前向傳播
def get_weight(shape,regularizer):
    w=tf.Variable(tf.random_normal(shape),dtype=tf.float32)
    tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w
def get_bias(shape):
    b=tf.Variable(tf.constant(0.01,shape=shape))
    return b
#輸入層輸入
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))
#輸入層到隱藏層
w1=get_weight([2,11],0.01)
b1=get_bias([11])
y1=tf.nn.relu(tf.matmul(x,w1)+b1)
#隱藏層到輸出層
w2=get_weight([11,1],0.01)
b2=get_bias([1])
y=tf.matmul(y1,w2)+b2#輸出層不激活（僅限這個代碼不激活）

#定義損失函數
loss_mse=tf.reduce_mean(tf.square(y-y_))
loss=loss_mse + tf.add_n(tf.get_collection("losses"))

#定義反向傳播
optimizer=tf.train.AdamOptimizer(0.0001).minimize(loss)

#初始化
init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for i  in range(40000):
        start=(i*step)%300
        end=start+step
        sess.run(optimizer,feed_dict={x:x_data[start:end],y_:y_data[start:end]})
        if i%2000==0:
            loss_mse_val=sess.run(loss_mse,feed_dict={x:x_data,y_:y_data})
            print(f"通過{i}步，loss現爲：{loss_mse_val}")

    # xx在-3到3之間以步長爲0.01，yy在-3到3之間以步長0.01,生成二維網格座標點
    xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
    # 將xx , yy拉直，併合併成一個2列的矩陣，獲得一個網格座標點的集合
    grid = np.c_[xx.ravel(), yy.ravel()]
    # 將網格座標點喂入神經網絡 ，probs爲輸出
    probs = sess.run(y, feed_dict={x: grid})
    # probs的shape調整成xx的樣子
    probs = probs.reshape(xx.shape)
    print("w1:\n", sess.run(w1))
    print("b1:\n", sess.run(b1))
    print("w2:\n", sess.run(w2))
    print("b2:\n", sess.run(b2))

plt.scatter(x_data[:, 0], x_data[:, 1], c=np.squeeze(y_s))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()

6.