"""
神經網路搭建的八股：
前向傳播就是搭建網路，設計網路結構（forward.py）
def forward(x, regularizer):
    w=
    b=
    y=
    return y

def get_weight(shape, regularizer):
    w=tf.Variable()
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer(w))
    return w

def get_bias(shape):
    b=tf.Variable()
    return b

反向傳播就是訓練網路，優化網路引數（backwaor.py）
def backward():
    x=tf.placehlder()
    y_=tf.placeholder()
    y=forward.forward(x, REGULARIZER)
    global_step=tf.Variable(0, trainable=False)
    loss=

loss可以是：
y與y_的差距=tf.reduce_mean(tf.square(y-y_))
也可以是：
ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
y與y_的差距（cem）=tf.reduce_mean(ce)
加入正則化後：
loss=y與y_的差距+tf.add_n(tf.get_collection('losses'))

指數衰減學習率
learning_rate=tf.train.exponential_decay(
    LEARNING_RATE_BASE,
    global_step,
    資料集總樣本數/BATCH_SIZE,
    LEARNING_RATE_DECAY,
    staircase=True)
train_step=tf.train.GrandientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

滑動平均
ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,gloabl_step)
ema_op=ema.apply(tf.trainable_variables())
with tf.control_dependencies([train_step, ema_op]):
    train_op=tf.no_op(name='train')

with tf.Session() as sess:
    init_op=tf.global_variable_initializer()
    sess.run(init_op)

    for i in range(STEPS):
        sess.run(train_step, feed_dict={x: ,y_: })
        if i % 輪數 == 0:
        print

if __name__ == '__main__':
    backward()
"""
 

generateds.py  生成資料集

#coding:utf-8
#0匯入模組，生成模擬資料集
import numpy as np
import matplotlib.pyplot as plt
seed = 2
#param X 正態分佈資料集 ， 2列
#param Y_ 根據X判斷是否在圓中，是為1，不是為0
#param Y_c 將圓內點變成紅色，圓外點變成藍色
def generateds():
    #基於seed產生隨機數
    rdm = np.random.RandomState(seed)
    #隨機數返回300行2列的矩陣
    X = rdm.randn(300, 2)   #randn表示正態分佈
    #取出每一行分析Y_的取值
    Y_ = [int(x0*x0 + x1*x1 < 2) for [x0, x1] in X]
    #在圓內的點為紅色，圓外的點為藍色
    Y_c = [['red' if y else 'blue'] for y in Y_]
    #對資料集X和標籤Y進行形狀整理，第一個維度根據第二個維度進行計算
    X = np.vstack(X).reshape(-1, 2)
    Y_ =np.vstack(Y_).reshape(-1, 1)   #Y_原來只有一行很多列，現在變成多行一列
    print(X)
    return X, Y_, Y_c

 

forward.py 前向傳播

#coding:utf-8
#0匯入模組，生成模擬資料集
import tensorflow as tf

#定義神經網路的輸入，引數的輸出，定義前向傳播過程
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
#在這裡設計了神經網路結構
#輸出層-》隱藏層-》輸出層，其中隱藏層有11個結點
def forward(x, regularizer):
    w1 = get_weight([2, 11], regularizer)   #2行11列的w，隱藏層有11個結點
    b1 = get_bias([11])                     #每一個w都要有一個偏置
    y1 = tf.nn.relu(tf.matmul(x, w1) + b1)  #得到1行11列向量

    w2 = get_weight([11, 1], regularizer)   #輸出層的權重
    b2 = get_bias([1])                      #輸出層偏置
    y = tf.matmul(y1, w2) + b2              #輸出結果
    return y
 

backward.py 反向傳播

#coding:utf-8
#0匯入模組，生成模擬資料集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import generagteds
import forward

STEPS = 40000
BATCH_SIZE = 30
LEARNING_RATE_BASE = 0.001  #初始的學習率
LEARNING_RATE_DECAY = 0.999 #指數衰減學習率中的衰減率
REGULARIZER = 0.01          #正則化引數
"""
指數衰減學習率
learning_rate = LEARNING_RATE_BASE*(LEARNING_RATE_DECAY)^\
                (global_step/decay_step),\
                其中 decay_step=sample_size/BATCH_SIZE
"""
def backward():
    x = tf.placeholder(tf.float32, shape=[None, 2])
    y_ = tf.placeholder(tf.float32, shape=[None, 1])
    X, Y_, Y_c = generagteds.generateds()
    y = forward.forward(x, REGULARIZER)    #前向傳播後得到的結果
    global_step = tf.Variable(0, trainable=False)  #初始值為0且不可訓練
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        300/BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True
    )

    #定義損失函式
    loss_mse = tf.reduce_mean(tf.square(y-y_))
    loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
    """
    tf.add_to_collection 向當前計算圖中新增張量集合
    tf.get_collection 返回當前計算圖中手動新增的張量集合
    tf.add_n 實現兩個列表對應元素的相加
    """

    #定義反向傳播方法：包含正則化
    train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)

    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()
        sess.run(init_op)
        for i in range(STEPS):
            start = (i % BATCH_SIZE) % 300
            end = start + BATCH_SIZE
            sess.run(train_step, feed_dict={x: X[start:end], y_ : Y_[start:end]})
            if i % 2000 == 0:
                loss_v = sess.run(loss_total,feed_dict={x:X, y_:Y_})
                print("After %d steps, loss is : %f"%(i, loss_v))

        xx, yy = np.mgrid[-3:3:.01, -3:3:.01]           #xx/yy.shape=(600,600)
        grid = np.c_[xx.ravel(), yy.ravel()]            #grid.shape=(360000,2)
        probs = sess.run(y, feed_dict={x:grid})         #y是前向傳播得到的結果
        probs = probs.reshape(xx.shape)                 #probs.shape=(600,600)

    plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))      #scatter表示散點圖，c表示color
    plt.contour(xx, yy, probs, levels=[.5])             #畫出等高線(x,y,f(x,y),)
    plt.show()

if __name__=='__main__':
    backward()

輸出結果：

After 0 steps, loss is : 22.403366
After 2000 steps, loss is : 0.388432
After 4000 steps, loss is : 0.220161
After 6000 steps, loss is : 0.178859
After 8000 steps, loss is : 0.149793
After 10000 steps, loss is : 0.135582
After 12000 steps, loss is : 0.128238
After 14000 steps, loss is : 0.122058
After 16000 steps, loss is : 0.121162
After 18000 steps, loss is : 0.121859
After 20000 steps, loss is : 0.117058
After 22000 steps, loss is : 0.116621
After 24000 steps, loss is : 0.118317
After 26000 steps, loss is : 0.115774
After 28000 steps, loss is : 0.115856
After 30000 steps, loss is : 0.117945
After 32000 steps, loss is : 0.115462
After 34000 steps, loss is : 0.115636
After 36000 steps, loss is : 0.117573
After 38000 steps, loss is : 0.115184