神經網路： 重點在闕值和w，因為y=w1*x1+w2*x2+w3*x3... 啟用函式：在隱藏層，每個輸出點帶入啟用函式，然後再繼續向後，最後輸出的y預測值不需要啟用 損失函式：定義的形式（三種）：均方誤差（西瓜書）、自定義需要的引數、交叉熵（吳恩達裡面定義的有log的損失函式）

優化神經網路方法：1.定義合適的損失函式loss、選擇合適的啟用函式、2.不斷更新學習率（梯度下降的學習率）、3.建立滑動平均值、4.正則化

實現過程： 1.（0,1）範圍初始化所以連線權和闕值。 2.計算出y預測值。 3.BP演算法，在迴圈中迭代，利用梯度下降演算法優化w，使定義的損失函式最小化，同時得到w最優值。 4.輸出連線權和闕值確定最優化的多層前饋神經網路。

#mnist_forward.py   前向傳播
import tensorflow as tf
INPUT_NODE = 784  #畫素點
OUTPUT_NODE = 10  #輸出10個數，一個矩陣代表label
LAYEr1_NODE= 500  #隱藏層的節點個數
def get_weight(shape,regularizer):#定義初始化權重
    w = tf.Variable(tf.truncated_normal(shape,stddev=0.1))
    if (regularizer != None):
        tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))
        return w
def get_bias(shape):#定義初始化闕值
    b = tf.Variable(tf.zeros(shape))
    return b

def forward(x,regularizer):
    w1=get_weight([INPUT_NODE,LAYEr1_NODE],regularizer)
    b1=get_bias([LAYEr1_NODE])
    y1=tf.nn.relu(tf.matmul(x,w1)+b1)

    w2=get_weight([LAYEr1_NODE,OUTPUT_NODE],regularizer)
    b2=get_bias([OUTPUT_NODE])
    y=tf.matmul(y1,w2)+b2
    return y    #是輸出y進行反向傳播，但是不經過啟用函式




#前向傳播先寫出來，一開始初始化了w和b，那麼會得到一個預測值，然後前向傳播結束；
#定義各個引數和bp的演算法和loss損失函式，在迴圈裡面不斷更新w，b和使loss函式最小化
#此時框架已經構架好了，但是沒有匯入x的值




#mnist-backward.py  反向傳播
from tensorflow.examples.tutorials.mnist import  input_data
import os
BATCH_SIZE = 200
LEARNING_RATE_BASE=0.1
LEARNING_RATE_DECAY=0.99
REGULARIZER=0.0001
STEPS= 50000
MOVING_AVERAGE_DECAY=0.99
MODEL_SACE_PATH="./model/"
MODEL_NAME="mnist_model"

def backward(mnist):
    x = tf.placeholder(tf.float32,[None,INPUT_NODE]) #輸入x的資料  佔位
    y_=tf.placeholder(tf.float32,[None,OUTPUT_NODE])
    y = forward(x,REGULARIZER)    #得到預測y
    global_step=tf.Variable(0,trainable=False)

    ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
    cem=tf.reduce_mean(ce)
    loss=cem+tf.add_n(tf.get_collection('losses'))

    learning_rate=tf.train.exponential_decay(    #定義指數衰減學習率
        LEARNING_RATE_BASE,
        global_step,
        mnist.train.num_examples/BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True)
    train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
    ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
    ema_op=ema.apply(tf.trainable_variables())
    with tf.control_dependencies([train_step,ema_op]):
        train_op=tf.no_op(name='train')
    saver= tf.train.Saver()

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

        for i in range(STEPS):
            xs,ys=mnist.train.next_batch(BATCH_SIZE)
            _,loss_value,step=sess.run([train_op,loss,global_step],feed_dict={x:xs,y_:ys})
            if i%1000 ==0:
                print("After %d training step(s). loss on training batch is %g."%(step,loss_value))
                saver.save(sess,os.path.join(MODEL_SACE_PATH,MODEL_NAME),global_step=global_step)

def main():
    mnist=input_data.read_data_sets("./data/",one_hot=True)
    backward(mnist)

if __name__ == '__main__':
    main()