這幾天開始學tensorflow，先來做一下學習記錄
一.神經網路解決問題步驟：
1.提取問題中實體的特徵向量作為神經網路的輸入。也就是說要對資料集進行特徵工程，然後知道每個樣本的特徵維度，以此來定義輸入神經元的個數。
2.定義神經網路的結構，並定義如何從神經網路的輸入得到輸出。也就是說定義輸入層，隱藏層以及輸出層。
3.通過訓練資料來調整神經網路中的引數取值，這是訓練神經網路的過程。一般來說要定義模型的損失函式，以及引數優化的方法，如交叉熵損失函式和梯度下降法調優等。
4.利用訓練好的模型預測未知的資料。也就是評估模型的好壞。

二.訓練簡單的向前傳播神經網路
一下訓練的神經模型是最簡單的一類，而且是線性的（也就是說沒有用啟用函式去線性話），沒有反向傳播的過程，只是簡單的說明神經網路工作的流程。

import tensorflow as tf

#定義隱藏層引數，每個w變數是一個tensor(可以當成是n*m的陣列，n表示上一層結點個數，m表示本層結點個數)表示上一層與本層的連線權重,這裡先隨機定義權重
w1=tf.Variable(tf.random_normal([2,3]，stddev=1))
w2=tf.Variable(tf.random_normal([3,1]，stddev=1))

#定義存放輸入資料的地方，也就是x向量,這裡shape為前一個傳入訓練的樣本個數，後面出入每個樣本的維度大小
x=tf.placeholder(tf.float32,shape=(None
 
,2),name="input")
#矩陣乘法
a=tf.matmul(x,w1)
y=tf.matmul(a,w2)

with tf.Session() as sess:
    #新版本好像不能用這個函式初始化所有變量了
    init_op=tf.initialize_all_variables()
    sess.run(init_op)
    #feed_dict用於向y中的x傳入引數，這裡傳入3個，則y輸出為一個3*1的tensor
    print（sess.run(y,feed_dict={x:[[0.7,0.9],[1.0,1.5],[2.1,2.3]]}))

至此，一個用x的每個維度乘以兩層權重之後輸出單個值得線性神經網路就定義好了。

三.定義損失函式以及反向傳播演算法
有了上面的基礎，我們可以定義損失函式以及反向傳播演算法去擬合數據了，非線性資料我們可以定義啟用函式去線性化。還有一些細節就是學習率的問題，這次使用的是動態學習率，首先把學習率設定為比較大的值，加速收斂，然後隨著迭代次數的增加，學習率不斷下降，防止錯過區域性最小值。還有一個問題，就是防止過擬合。一般神經網路防止過擬合的策略有兩種，一種是正則化，一種是dropout，我們暫且不作討論後者

損失函式：交叉熵
反向傳播演算法：梯度下降法
啟用函式：relu

# -*- coding: utf-8 -*-
"""
Created on Fri Aug 18 14:02:19 2017

@author: osT
"""

import tensorflow as tf 
import numpy as np

#匯入資料，這裡的資料是每一行代表一個樣本，每一行最後一列表示樣本標籤，0-32一共33個類
data=np.loadtxt('train_data.txt',dtype='float',delimiter=',')

#將樣本標籤轉換成獨熱編碼
def label_change(before_label):
    label_num=len(before_label)
    change_arr=np.zeros((label_num,33))
    for i in range(label_num):
        #該樣本標籤原本為0-32的，本人疏忽下32標記成33
        if before_label[i]==33.0:
            change_arr[i,int(before_label[i]-1)]=1
        else:
            change_arr[i,int(before_label[i])]=1
    return change_arr



#定義神經網路的輸入輸出結點，每個樣本為1*315維，以及輸出分類結果
INPUT_NODE=315
OUTPUT_NODE=33

#定義兩層隱含層的神經網路，一層300個結點，一層100個結點
LAYER1_NODE=300
LAYER2_NODE=100

#定義學習率，學習率衰減速度，正則係數，訓練調整引數的次數以及平滑衰減率
LEARNING_RATE_BASE=0.5
LEARNING_RATE_DECAY=0.99
REGULARIZATION_RATE=0.0001
TRAINING_STEPS=2000
MOVING_AVERAGE_DECAY=0.99


#定義整個神經網路的結構，也就是向前傳播的過程，avg_class為平滑可訓練量的類，不傳入則不使用平滑
def inference(input_tensor,avg_class,w1,b1,w2,b2,w3,b3):
    if avg_class==None:
        #第一層隱含層，輸入與權重矩陣乘後加上常數傳入啟用函式作為輸出
        layer1=tf.nn.relu(tf.matmul(input_tensor,w1)+b1)
        #第二層隱含層，前一層的輸出與權重矩陣乘後加上常數作為輸出
        layer2=tf.nn.relu(tf.matmul(layer1,w2)+b2)
        #返回 第二層隱含層與權重矩陣乘加上常數作為輸出
        return tf.matmul(layer2,w3)+b3
    else:
        #avg_class.average()平滑訓練變數，也就是每一層與上一層的權重
        layer1=tf.nn.relu(tf.matmul(input_tensor,avg_class.average(w1))+avg_class.average(b1))
        layer2=tf.nn.relu(tf.matmul(layer1,avg_class.average(w2))+avg_class.average(b2))
        return tf.matmul(layer2,avg_class.average(w3))+avg_class.average(b3)

def train(data):
    #混洗資料
    np.random.shuffle(data)
    #取錢850個樣本為訓練樣本，後面的全是測試樣本，約250個
    data_train_x=data[:850,:315]
    data_train_y=label_change(data[:850,-1])
    data_test_x=data[850:,:315]
    data_test_y=label_change(data[850:,-1])

    #定義輸出資料的地方，None表示無規定一次輸入多少訓練樣本,y_是樣本標籤存放的地方
    x=tf.placeholder(tf.float32,shape=[None,INPUT_NODE],name='x-input')
    y_=tf.placeholder(tf.float32,shape=[None,OUTPUT_NODE],name='y-input')

    #依次定義每一層與上一層的權重，這裡用隨機數初始化，注意shape的對應關係
    w1=tf.Variable(tf.truncated_normal(shape=[INPUT_NODE,LAYER1_NODE],stddev=0.1))
    b1=tf.Variable(tf.constant(0.1,shape=[LAYER1_NODE]))

    w2=tf.Variable(tf.truncated_normal(shape=[LAYER1_NODE,LAYER2_NODE],stddev=0.1))
    b2=tf.Variable(tf.constant(0.1,shape=[LAYER2_NODE]))

    w3=tf.Variable(tf.truncated_normal(shape=[LAYER2_NODE,OUTPUT_NODE],stddev=0.1))
    b3=tf.Variable(tf.constant(0.1,shape=[OUTPUT_NODE]))

    #輸出向前傳播的結果
    y=inference(x,None,w1,b1,w2,b2,w3,b3)

    #每訓練完一次就會增加的變數
    global_step=tf.Variable(0,trainable=False)

    #定義平滑變數的類，輸入為平滑衰減率和global_stop使得每訓練完一次就會使用平滑過程
    variable_averages=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
    #將平滑應用到所有可訓練的變數，即trainable=True的變數
    variable_averages_op=variable_averages.apply(tf.trainable_variables())

    #輸出平滑後的預測值
    average_y=inference(x,variable_averages,w1,b1,w2,b2,w3,b3)

    #定義交叉熵和損失函式，但為什麼傳入的是label的arg_max(),就是對應分類的下標呢，我們遲點再說
    cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.arg_max(y_,1))
    #計算交叉熵的平均值，也就是本輪訓練對所有訓練樣本的平均值
    cross_entrip_mean=tf.reduce_mean(cross_entropy)

    #定義正則化權重，並將其加上交叉熵作為損失函式
    regularizer=tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    regularization=regularizer(w1)+regularizer(w2)+regularizer(w3)
    loss=cross_entrip_mean+regularization

    #定義動態學習率，隨著訓練的步驟增加不斷遞減
    learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,900,LEARNING_RATE_DECAY)
    #定義向後傳播的演算法，梯度下降發，注意後面的minimize要傳入global_step
    train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
    #管理需要更新的變數，傳入的引數是包含需要訓練的變數的過程
    train_op=tf.group(train_step,variable_averages_op)

    #正確率預測
    correct_prediction=tf.equal(tf.arg_max(average_y,1),tf.arg_max(y_,1))
    accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

    with tf.Session() as sess:
        #初始所有變數
        tf.global_variables_initializer().run()
        #訓練集輸入字典
        validate_feed={x:data_train_x,y_:data_train_y}
        #測試集輸入字典
        test_feed={x:data_test_x,y_:data_test_y}

        for i in range(TRAINING_STEPS):
            if i%1000==0:
                validate_acc=sess.run(accuracy,feed_dict=validate_feed)
                print("After %d training step(s),validation accuracy using average model is %g"%(i,validate_acc))
            #每一輪通過同一訓練集訓練，由於樣本太少，沒辦法了
            sess.run(train_op,feed_dict=validate_feed)
        #用測試集檢視模型的準確率
        test_acc=sess.run(accuracy,feed_dict=test_feed)
        print("After %d training step(s),test accuracy using average model is %g"%(TRAINING_STEPS,test_acc))

train(data)

然後我們來看一下為什麼計算交叉熵時要傳入樣本的下標：
首先我們知道，輸出結點有33個，通過與前面的權重相乘後，則每個結點都會有一個輸出，每個輸出我們暫且認為是對應每個類的概率，該值越大，我們就越認為該樣本為對應的類。logits引數是神經網路的直接輸出，也就是未經softmax函式處理的輸出，labels傳入的是單個值，也就是分類對應的下標，這是由於我們使用的計算交叉熵的函式 tf.nn.sparse_softmax_cross_entropy_with_logits()有關。這個函式對於在只有一個正確分類的模型計算起到加速作用，而這個labels的輸入就是“這一個正確的分類”，對應到輸出的結點，就是其下標了。我們還有一個沒有加速的交叉熵函式：tf.nn.softmax_cross_entropy_with_logis(logis=,labels=)這個時候我們就應該傳入本身的labels標籤了。

最後，我們來總結一下提高模型準確率的方法：
1.使用啟用函式。也就是去線性化，這步幾乎是必須的。
2.增加隱含層。就本例而言，單隱含層300個結點，準確率在89%左右；單隱含層400個結點，準確率在93%左右；而雙隱含層300結點和100結點，準確率在94%左右。但增加隱含層意味著增加訓練時間。
3.使用動態學習率。這不但可以加快訓練的速度，還可以增加神經網路收斂到較低的極小值處的概率，從而增加準確率。
4.使用平滑模型。主要可以增加模型的健壯性，使其泛化能力更強。
5.加入正則化或者使用dropout防止過擬合。

附上訓練集

在下一篇文章中，我將會記錄如何儲存模型，以及取出模型使用的一些細節。